Struct BySpendableType 

pub struct BySpendableType<T> {
    pub p2pk65: T,
    pub p2pk33: T,
    pub p2pkh: T,
    pub p2ms: T,
    pub p2sh: T,
    pub p2wpkh: T,
    pub p2wsh: T,
    pub p2tr: T,
    pub p2a: T,
    pub unknown: T,
    pub empty: T,
}

Fields

p2pk65: T

p2pk33: T

p2pkh: T

p2ms: T

p2sh: T

p2wpkh: T

p2wsh: T

p2tr: T

p2a: T

unknown: T

empty: T

Implementations

impl BySpendableType<CohortName>

pub const fn names() -> &'static BySpendableType<CohortName>

impl<T> BySpendableType<T>

pub fn new<F>(create: F) -> BySpendableType<T>

where F: FnMut(Filter, &'static str) -> T,

pub fn try_new<F, E>(create: F) -> Result<BySpendableType<T>, E>

where F: FnMut(Filter, &'static str) -> Result<T, E>,

pub fn get_mut(&mut self, output_type: OutputType) -> &mut T

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

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>

pub fn par_iter_mut(&mut self) -> impl ParallelIterator<Item = &mut T>

where T: Send + Sync,

pub fn iter_typed(&self) -> impl Iterator<Item = (OutputType, &T)>

pub fn iter_typed_mut(&mut self) -> impl Iterator<Item = (OutputType, &mut T)>

Trait Implementations

impl<T> Add for BySpendableType<T>

where T: Add<Output = T>,

type Output = BySpendableType<T>

The resulting type after applying the + operator.

fn add(self, rhs: BySpendableType<T>) -> <BySpendableType<T> as Add>::Output

Performs the + operation.

impl<T> AddAssign for BySpendableType<T>

where T: AddAssign,

fn add_assign(&mut self, rhs: BySpendableType<T>)

Performs the += operation.

impl<T> Clone for BySpendableType<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for BySpendableType<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for BySpendableType<T>

where T: Default,

fn default() -> BySpendableType<T>

Returns the “default value” for a type.

impl<T> Serialize for BySpendableType<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Traversable for BySpendableType<T>

where T: Traversable + Send + Sync,

fn to_tree_node(&self) -> TreeNode

fn iter_any_exportable(&self) -> impl Iterator<Item = &dyn AnyExportableVec>