Trait sp_runtime::traits::Bounded

pub trait Bounded {
    fn min_value() -> Self;
    fn max_value() -> Self;
}

Numbers which have upper and lower bounds

Required methods

fn min_value() -> Self

returns the smallest finite number this type can represent

fn max_value() -> Self

returns the largest finite number this type can represent

Implementations on Foreign Types

impl Bounded for f32

pub fn min_value() -> f32

pub fn max_value() -> f32

impl Bounded for i64

pub fn min_value() -> i64

pub fn max_value() -> i64

impl Bounded for usize

pub fn min_value() -> usize

pub fn max_value() -> usize

impl Bounded for u32

pub fn min_value() -> u32

pub fn max_value() -> u32

impl<N, O, P, Q, R, S, T> Bounded for (N, O, P, Q, R, S, T) where
    T: Bounded,
    S: Bounded,
    R: Bounded,
    N: Bounded,
    P: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (N, O, P, Q, R, S, T)

pub fn max_value() -> (N, O, P, Q, R, S, T)

impl Bounded for i32

pub fn min_value() -> i32

pub fn max_value() -> i32

impl<T> Bounded for (T,) where
    T: Bounded, 

pub fn min_value() -> (T,)

pub fn max_value() -> (T,)

impl<F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    T: Bounded,
    I: Bounded,
    L: Bounded,
    F: Bounded,
    S: Bounded,
    R: Bounded,
    N: Bounded,
    M: Bounded,
    H: Bounded,
    K: Bounded,
    P: Bounded,
    G: Bounded,
    J: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

pub fn max_value() -> (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<K, L, M, N, O, P, Q, R, S, T> Bounded for (K, L, M, N, O, P, Q, R, S, T) where
    T: Bounded,
    L: Bounded,
    S: Bounded,
    R: Bounded,
    N: Bounded,
    M: Bounded,
    K: Bounded,
    P: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (K, L, M, N, O, P, Q, R, S, T)

pub fn max_value() -> (K, L, M, N, O, P, Q, R, S, T)

impl Bounded for ()

pub fn min_value()

pub fn max_value()

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    C: Bounded,
    T: Bounded,
    I: Bounded,
    L: Bounded,
    E: Bounded,
    F: Bounded,
    S: Bounded,
    D: Bounded,
    R: Bounded,
    N: Bounded,
    B: Bounded,
    M: Bounded,
    H: Bounded,
    K: Bounded,
    P: Bounded,
    G: Bounded,
    J: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

pub fn max_value() -> (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl Bounded for i16

pub fn min_value() -> i16

pub fn max_value() -> i16

impl Bounded for f64

pub fn min_value() -> f64

pub fn max_value() -> f64

impl<H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    T: Bounded,
    I: Bounded,
    L: Bounded,
    S: Bounded,
    R: Bounded,
    N: Bounded,
    M: Bounded,
    H: Bounded,
    K: Bounded,
    P: Bounded,
    J: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (H, I, J, K, L, M, N, O, P, Q, R, S, T)

pub fn max_value() -> (H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<T> Bounded for Wrapping<T> where
    T: Bounded, 

pub fn min_value() -> Wrapping<T>

pub fn max_value() -> Wrapping<T>

impl<O, P, Q, R, S, T> Bounded for (O, P, Q, R, S, T) where
    T: Bounded,
    S: Bounded,
    R: Bounded,
    P: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (O, P, Q, R, S, T)

pub fn max_value() -> (O, P, Q, R, S, T)

impl<L, M, N, O, P, Q, R, S, T> Bounded for (L, M, N, O, P, Q, R, S, T) where
    T: Bounded,
    L: Bounded,
    S: Bounded,
    R: Bounded,
    N: Bounded,
    M: Bounded,
    P: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (L, M, N, O, P, Q, R, S, T)

pub fn max_value() -> (L, M, N, O, P, Q, R, S, T)

impl<M, N, O, P, Q, R, S, T> Bounded for (M, N, O, P, Q, R, S, T) where
    T: Bounded,
    S: Bounded,
    R: Bounded,
    N: Bounded,
    M: Bounded,
    P: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (M, N, O, P, Q, R, S, T)

pub fn max_value() -> (M, N, O, P, Q, R, S, T)

impl Bounded for u64

pub fn min_value() -> u64

pub fn max_value() -> u64

impl Bounded for isize

pub fn min_value() -> isize

pub fn max_value() -> isize

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    C: Bounded,
    T: Bounded,
    I: Bounded,
    L: Bounded,
    E: Bounded,
    F: Bounded,
    S: Bounded,
    D: Bounded,
    R: Bounded,
    N: Bounded,
    B: Bounded,
    M: Bounded,
    A: Bounded,
    H: Bounded,
    K: Bounded,
    P: Bounded,
    G: Bounded,
    J: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value(
) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

pub fn max_value(
) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<Q, R, S, T> Bounded for (Q, R, S, T) where
    T: Bounded,
    S: Bounded,
    R: Bounded,
    Q: Bounded, 

pub fn min_value() -> (Q, R, S, T)

pub fn max_value() -> (Q, R, S, T)

impl Bounded for u128

pub fn min_value() -> u128

pub fn max_value() -> u128

impl Bounded for i128

pub fn min_value() -> i128

pub fn max_value() -> i128

impl Bounded for u8

pub fn min_value() -> u8

pub fn max_value() -> u8

impl<E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    T: Bounded,
    I: Bounded,
    L: Bounded,
    E: Bounded,
    F: Bounded,
    S: Bounded,
    R: Bounded,
    N: Bounded,
    M: Bounded,
    H: Bounded,
    K: Bounded,
    P: Bounded,
    G: Bounded,
    J: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

pub fn max_value() -> (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (I, J, K, L, M, N, O, P, Q, R, S, T) where
    T: Bounded,
    I: Bounded,
    L: Bounded,
    S: Bounded,
    R: Bounded,
    N: Bounded,
    M: Bounded,
    K: Bounded,
    P: Bounded,
    J: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (I, J, K, L, M, N, O, P, Q, R, S, T)

pub fn max_value() -> (I, J, K, L, M, N, O, P, Q, R, S, T)

impl Bounded for u16

pub fn min_value() -> u16

pub fn max_value() -> u16

impl<R, S, T> Bounded for (R, S, T) where
    T: Bounded,
    S: Bounded,
    R: Bounded, 

pub fn min_value() -> (R, S, T)

pub fn max_value() -> (R, S, T)

impl<D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    T: Bounded,
    I: Bounded,
    L: Bounded,
    E: Bounded,
    F: Bounded,
    S: Bounded,
    D: Bounded,
    R: Bounded,
    N: Bounded,
    M: Bounded,
    H: Bounded,
    K: Bounded,
    P: Bounded,
    G: Bounded,
    J: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

pub fn max_value() -> (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<P, Q, R, S, T> Bounded for (P, Q, R, S, T) where
    T: Bounded,
    S: Bounded,
    R: Bounded,
    P: Bounded,
    Q: Bounded, 

pub fn min_value() -> (P, Q, R, S, T)

pub fn max_value() -> (P, Q, R, S, T)

impl<S, T> Bounded for (S, T) where
    T: Bounded,
    S: Bounded, 

pub fn min_value() -> (S, T)

pub fn max_value() -> (S, T)

impl<J, K, L, M, N, O, P, Q, R, S, T> Bounded for (J, K, L, M, N, O, P, Q, R, S, T) where
    T: Bounded,
    L: Bounded,
    S: Bounded,
    R: Bounded,
    N: Bounded,
    M: Bounded,
    K: Bounded,
    P: Bounded,
    J: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (J, K, L, M, N, O, P, Q, R, S, T)

pub fn max_value() -> (J, K, L, M, N, O, P, Q, R, S, T)

impl<G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    T: Bounded,
    I: Bounded,
    L: Bounded,
    S: Bounded,
    R: Bounded,
    N: Bounded,
    M: Bounded,
    H: Bounded,
    K: Bounded,
    P: Bounded,
    G: Bounded,
    J: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

pub fn max_value() -> (G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl<C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Bounded for (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    C: Bounded,
    T: Bounded,
    I: Bounded,
    L: Bounded,
    E: Bounded,
    F: Bounded,
    S: Bounded,
    D: Bounded,
    R: Bounded,
    N: Bounded,
    M: Bounded,
    H: Bounded,
    K: Bounded,
    P: Bounded,
    G: Bounded,
    J: Bounded,
    Q: Bounded,
    O: Bounded, 

pub fn min_value() -> (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

pub fn max_value() -> (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

impl Bounded for i8

pub fn min_value() -> i8

pub fn max_value() -> i8

Implementors

impl Bounded for FixedI64

impl Bounded for FixedI128

impl Bounded for FixedU128

impl Bounded for PerU16

impl Bounded for Perbill

impl Bounded for Percent

impl Bounded for Permill

impl Bounded for Perquintill

impl Bounded for Rational128