Struct chain_path_derivation::SoftDerivation

source ·

pub struct SoftDerivation(Derivation);

Expand description

wrapper to guarantee the given derivation is a soft derivation

Tuple Fields§

§0: Derivation

Implementations§

source §

impl SoftDerivation

source

pub const fn new_unchecked(derivation: Derivation) -> Self

construct a soft derivation from the given derivation without checking the derivation is actually a soft derivation.

this function does not perform any verification and if the value is not correct it will create a cascade of issues, be careful when utilizing this function.

source

pub fn new(derivation: Derivation) -> Result<Self, DerivationError>

build a soft derivation from the given Derivation. If the value is not a soft derivation it will return an error

Example

let derivation = Derivation::new(42);
let derivation = SoftDerivation::new(derivation)?;

println!("derivation: {}", derivation);

source

pub const fn max_value() -> Self

returns the max derivation index value

let max = SoftDerivation::max_value();
assert_eq!(max, SoftDerivation::new_unchecked(Derivation::new(0x7FFF_FFFF)));

source

pub const fn min_value() -> Self

returns the min derivation index value

let min = SoftDerivation::min_value();
assert_eq!(min, SoftDerivation::new_unchecked(Derivation::new(0)));

source

pub fn overflowing_add(self, rhs: u32) -> (Self, bool)

calculate self + rhs

Returns the tuple of the addition along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

Examples

Basic usage:

assert_eq!(
    SoftDerivation::new_unchecked(Derivation::new(5)).overflowing_add(2),
    (SoftDerivation::new_unchecked(Derivation::new(7)), false)
);
assert_eq!(
    SoftDerivation::max_value().overflowing_add(1),
    (SoftDerivation::new_unchecked(Derivation::new(0)), true)
);

source

pub fn saturating_add(self, rhs: u32) -> Self

saturating integer addition. Computes self + rhs, saturating at the numeric bounds instead of overflowing.

Examples

Basic usage:

assert_eq!(
    SoftDerivation::new_unchecked(Derivation::new(100)).saturating_add(1),
    SoftDerivation::new_unchecked(Derivation::new(101))
);
assert_eq!(
    SoftDerivation::max_value().saturating_add(2048),
    SoftDerivation::max_value(),
);

source

pub fn checked_add(self, rhs: u32) -> Option<Self>

checked integer addition. Computes self + rhs, returning None if overflow would occurred.

Examples

Basic usage:

assert_eq!(
    SoftDerivation::new_unchecked(Derivation::new(100)).checked_add(1),
    Some(SoftDerivation::new_unchecked(Derivation::new(101)))
);
assert_eq!(
    SoftDerivation::max_value().checked_add(2048),
    None,
);

source

pub fn wrapping_add(self, rhs: u32) -> Self

Wrapping (modular) addition. Computes self + rhs, wrapping around the boundary of the type.

Examples

Basic usage:

assert_eq!(
    SoftDerivation::new_unchecked(Derivation::new(100)).wrapping_add(1),
    SoftDerivation::new_unchecked(Derivation::new(101))
);
assert_eq!(
    SoftDerivation::max_value().wrapping_add(1),
    SoftDerivation::new_unchecked(Derivation::new(0)),
);

source