Struct chain_path_derivation::HardDerivation

source ·

pub struct HardDerivation(Derivation);

Expand description

wrapper to guarantee the given derivation is a soft derivation

Tuple Fields§

§0: Derivation

Implementations§

source §

impl HardDerivation

source

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

construct a hard derivation from the given derivation without checking the derivation is actually a hard 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 hard derivation from the given Derivation. If the value is not a hard derivation it will return an error

Example

let derivation = Derivation::new(0x8000_0001);
let derivation = HardDerivation::new(derivation)?;

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

source

pub const fn max_value() -> Self

returns the max derivation index value

let max = HardDerivation::max_value();
assert_eq!(max, HardDerivation::new_unchecked(Derivation::new(0xFFFF_FFFF)));

source

pub const fn min_value() -> Self

returns the min derivation index value

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

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!(
    HardDerivation::new_unchecked(Derivation::new(0x8000_0005)).overflowing_add(2),
    (HardDerivation::new_unchecked(Derivation::new(0x8000_0007)), false)
);
assert_eq!(
    HardDerivation::max_value().overflowing_add(1),
    (HardDerivation::new_unchecked(Derivation::new(0x8000_0000)), 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!(
    HardDerivation::new_unchecked(Derivation::new(0x8000_0100)).saturating_add(1),
    HardDerivation::new_unchecked(Derivation::new(0x8000_0101))
);
assert_eq!(
    HardDerivation::max_value().saturating_add(2048),
    HardDerivation::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!(
    HardDerivation::new_unchecked(Derivation::new(0x8000_0100)).checked_add(1),
    Some(HardDerivation::new_unchecked(Derivation::new(0x8000_0101)))
);
assert_eq!(
    HardDerivation::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!(
    HardDerivation::new_unchecked(Derivation::new(0x8000_0100)).wrapping_add(1),
    HardDerivation::new_unchecked(Derivation::new(0x8000_0101))
);
assert_eq!(
    HardDerivation::max_value().wrapping_add(1),
    HardDerivation::new_unchecked(Derivation::new(0x8000_0000)),
);

source