Trait Bounds 

pub trait Bounds: PartialOrd {
    type Size: Copy + Sized + Display;

    const MIN: Self::Size;
    const MAX: Self::Size;

    // Required method
    fn validate_bounds(
        &self,
        lower_bound: Self::Size,
        upper_bound: Self::Size,
    ) -> Result<(), OutOfBounds>;
}

Required Associated Constants

const MIN: Self::Size

const MAX: Self::Size

Required Associated Types

type Size: Copy + Sized + Display

Required Methods

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Bounds for f32

const MIN: Self::Size = {transmute(0xff7fffff): <f32 as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0x7f7fffff): <f32 as rules::range::Bounds>::Size}

type Size = f32

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl Bounds for f64

const MIN: Self::Size = {transmute(0xffefffffffffffff): <f64 as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0x7fefffffffffffff): <f64 as rules::range::Bounds>::Size}

type Size = f64

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl Bounds for i8

const MIN: Self::Size = {transmute(0x80): <i8 as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0x7f): <i8 as rules::range::Bounds>::Size}

type Size = i8

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl Bounds for i16

const MIN: Self::Size = {transmute(0x8000): <i16 as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0x7fff): <i16 as rules::range::Bounds>::Size}

type Size = i16

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl Bounds for i32

const MIN: Self::Size = {transmute(0x80000000): <i32 as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0x7fffffff): <i32 as rules::range::Bounds>::Size}

type Size = i32

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl Bounds for i64

const MIN: Self::Size = {transmute(0x8000000000000000): <i64 as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0x7fffffffffffffff): <i64 as rules::range::Bounds>::Size}

type Size = i64

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl Bounds for i128

const MIN: Self::Size = {transmute(0x80000000000000000000000000000000): <i128 as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0x7fffffffffffffffffffffffffffffff): <i128 as rules::range::Bounds>::Size}

type Size = i128

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl Bounds for isize

const MIN: Self::Size = {transmute(0x8000000000000000): <isize as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0x7fffffffffffffff): <isize as rules::range::Bounds>::Size}

type Size = isize

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl Bounds for u8

const MIN: Self::Size = {transmute(0x00): <u8 as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0xff): <u8 as rules::range::Bounds>::Size}

type Size = u8

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl Bounds for u16

const MIN: Self::Size = {transmute(0x0000): <u16 as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0xffff): <u16 as rules::range::Bounds>::Size}

type Size = u16

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl Bounds for u32

const MIN: Self::Size = {transmute(0x00000000): <u32 as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0xffffffff): <u32 as rules::range::Bounds>::Size}

type Size = u32

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl Bounds for u64

const MIN: Self::Size = {transmute(0x0000000000000000): <u64 as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0xffffffffffffffff): <u64 as rules::range::Bounds>::Size}

type Size = u64

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl Bounds for u128

const MIN: Self::Size = {transmute(0x00000000000000000000000000000000): <u128 as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0xffffffffffffffffffffffffffffffff): <u128 as rules::range::Bounds>::Size}

type Size = u128

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl Bounds for usize

const MIN: Self::Size = {transmute(0x0000000000000000): <usize as rules::range::Bounds>::Size}

const MAX: Self::Size = {transmute(0xffffffffffffffff): <usize as rules::range::Bounds>::Size}

type Size = usize

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

impl<T: Bounds> Bounds for Option<T>

const MIN: Self::Size = T::MIN

const MAX: Self::Size = T::MAX

type Size = <T as Bounds>::Size

fn validate_bounds( &self, lower_bound: Self::Size, upper_bound: Self::Size, ) -> Result<(), OutOfBounds>

Implementors