Struct TieredMulti

pub struct TieredMulti<T>(/* private fields */);

Represents notes of different denominations.

Attention: care has to be taken when constructing this to avoid overflow when calculating the total amount represented. As it is prudent to limit both the maximum note amount and maximum note count per transaction this shouldn’t be a problem in practice though.

Implementations

impl<T> TieredMulti<T>

pub fn new(map: BTreeMap<Amount, Vec<T>>) -> Self

Returns a new TieredMulti with the given BTreeMap map

pub fn total_amount(&self) -> Amount

Returns the total value of all notes in msat as Amount

pub fn count_items(&self) -> usize

Returns the number of items in all vectors

pub fn count_tiers(&self) -> usize

Returns the number of tiers

pub fn iter_tiers(&self) -> impl Iterator<Item = &Amount>

Returns an iterator over the keys

pub fn summary(&self) -> TieredCounts

Returns the summary of number of items in each tier

pub fn is_empty(&self) -> bool

Verifies whether all vectors in all tiers are empty

pub fn structural_eq<O>(&self, other: &TieredMulti<O>) -> bool

Verifies whether the structure of self and other is identical

pub fn iter(&self) -> impl Iterator<Item = (&Amount, &Vec<T>)>

Returns an borrowing iterator

pub fn iter_items(&self) -> impl DoubleEndedIterator<Item = (Amount, &T)>

Returns an iterator over every (Amount, &T)

Note: The order of the elements is important: from the lowest tier to the highest, then in order of elements in the Vec

pub fn into_iter_items(self) -> impl DoubleEndedIterator<Item = (Amount, T)>

Returns an consuming iterator over every (Amount, T)

Note: The order of the elements is important: from the lowest tier to the highest, then in order of elements in the Vec

pub fn longest_tier_except(&self, except: &Amount) -> usize

Returns the length of the longest vector of all tiers, ignoring the except tier

pub fn all_tiers_exist_in<K>( &self, keys: &Tiered<K>, ) -> Result<(), InvalidAmountTierError>

Verifies that all keys in self are present in the keys of the given parameter Tiered

pub fn get(&self, amt: Amount) -> Option<&Vec<T>>

Returns an Option with a reference to the vector of the given Amount

pub fn push(&mut self, amt: Amount, val: T)

Trait Implementations

impl<T: Clone> Clone for TieredMulti<T>

fn clone(&self) -> TieredMulti<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for TieredMulti<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C> Decodable for TieredMulti<C>

where C: Decodable + 'static,

fn consensus_decode_from_finite_reader<D: Read>( d: &mut D, modules: &ModuleDecoderRegistry, ) -> Result<Self, DecodeError>

Decode Self from a size-limited reader.

fn consensus_decode<R: Read>( r: &mut R, modules: &ModuleDecoderRegistry, ) -> Result<Self, DecodeError>

Decode an object with a well-defined format.

fn consensus_decode_hex( hex: &str, modules: &ModuleDecoderRegistry, ) -> Result<Self, DecodeError>

Decode an object from hex

fn consensus_decode_vec( bytes: Vec<u8>, modules: &ModuleDecoderRegistry, ) -> Result<Self, DecodeError>

impl<C> Default for TieredMulti<C>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for TieredMulti<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> Encodable for TieredMulti<C>

where C: Encodable + 'static,

fn consensus_encode<W: Write>(&self, writer: &mut W) -> Result<usize, Error>

Encode an object with a well-defined format. Returns the number of bytes written on success.

fn consensus_encode_to_vec(&self) -> Vec<u8>

Self::consensus_encode to newly allocated Vec<u8>

fn consensus_encode_to_hex(&self) -> String

Encode and convert to hex string representation

fn consensus_encode_to_len(&self) -> usize

Encode without storing the encoding, return the size

fn consensus_hash<H>(&self) -> H

where H: Hash, H::Engine: Write,

Generate a SHA256 hash of the consensus encoding using the default hash engine for H.

impl<C> Extend<(Amount, C)> for TieredMulti<C>

fn extend<T: IntoIterator<Item = (Amount, C)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<C> FromIterator<(Amount, C)> for TieredMulti<C>

fn from_iter<T: IntoIterator<Item = (Amount, C)>>(iter: T) -> Self

Creates a value from an iterator.

impl<T: Hash> Hash for TieredMulti<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<C> IntoIterator for TieredMulti<C>

where C: 'static + Send,

type Item = (Amount, C)

The type of the elements being iterated over.

type IntoIter = Box<dyn Iterator<Item = (Amount, C)> + Send>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for TieredMulti<T>

fn eq(&self, other: &TieredMulti<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for TieredMulti<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for TieredMulti<T>

impl<T> StructuralPartialEq for TieredMulti<T>