Struct delegation::delegation_hierarchy::DelegationNode

pub struct DelegationNode<DelegationNodeId, MaxChildren: Get<u32>, DelegationDetails, AccountId, Balance> {
    pub hierarchy_root_id: DelegationNodeId,
    pub parent: Option<DelegationNodeId>,
    pub children: BoundedBTreeSet<DelegationNodeId, MaxChildren>,
    pub details: DelegationDetails,
    pub deposit: Deposit<AccountId, Balance>,
}

A node in a delegation hierarchy.

For quicker lookups of the hierarchy details, all nodes maintain a direct link to the hierarchy root node. Furthermore, all nodes have a parent except the root nodes, which point to themselves for the hierarchy root node link.

Fields

hierarchy_root_id: DelegationNodeId

The ID of the delegation hierarchy the node is part of.

parent: Option<DelegationNodeId>

The ID of the parent. For all but root nodes this is not None.

children: BoundedBTreeSet<DelegationNodeId, MaxChildren>

The set of IDs of all the children nodes.

details: DelegationDetails

The additional information attached to the delegation node.

deposit: Deposit<AccountId, Balance>

The deposit that was taken to incentivise fair use of the on chain storage.

Implementations

impl<DelegationNodeId: Ord, MaxChildren: Get<u32>, DelegationDetails, AccountId, Balance> DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>

pub fn new_root_node( id: DelegationNodeId, details: DelegationDetails, deposit_owner: AccountId, deposit_amount: Balance ) -> Self

Creates a new delegation root node with the given ID and delegation details.

pub fn new_node( hierarchy_root_id: DelegationNodeId, parent: DelegationNodeId, details: DelegationDetails, deposit_owner: AccountId, deposit_amount: Balance ) -> Self

Creates a new delegation node under the given hierarchy ID, with the given parent and delegation details.

pub fn try_add_child( &mut self, child_id: DelegationNodeId ) -> Result<(), DelegationNodeId>

Adds a node by its ID to the current node’s children.

Trait Implementations

impl<DelegationNodeId: Clone, MaxChildren: Clone + Get<u32>, DelegationDetails: Clone, AccountId: Clone, Balance: Clone> Clone for DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>

fn clone( &self ) -> DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<DelegationNodeId: Debug, MaxChildren: Debug + Get<u32>, DelegationDetails: Debug, AccountId: Debug, Balance: Debug> Debug for DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>

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

Formats the value using the given formatter.

impl<DelegationNodeId, MaxChildren: Get<u32>, DelegationDetails, AccountId, Balance> Decode for DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>where DelegationNodeId: Decode, Option<DelegationNodeId>: Decode, BoundedBTreeSet<DelegationNodeId, MaxChildren>: Decode, DelegationDetails: Decode, Deposit<AccountId, Balance>: Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<DelegationNodeId, MaxChildren: Get<u32>, DelegationDetails, AccountId, Balance> Encode for DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>where DelegationNodeId: Encode, Option<DelegationNodeId>: Encode, BoundedBTreeSet<DelegationNodeId, MaxChildren>: Encode, DelegationDetails: Encode, Deposit<AccountId, Balance>: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<DelegationNodeId, MaxChildren: Get<u32>, DelegationDetails, AccountId, Balance> MaxEncodedLen for DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>where DelegationNodeId: MaxEncodedLen, Option<DelegationNodeId>: MaxEncodedLen, BoundedBTreeSet<DelegationNodeId, MaxChildren>: MaxEncodedLen, DelegationDetails: MaxEncodedLen, Deposit<AccountId, Balance>: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<DelegationNodeId: PartialEq, MaxChildren: PartialEq + Get<u32>, DelegationDetails: PartialEq, AccountId: PartialEq, Balance: PartialEq> PartialEq<DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>> for DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>

fn eq( &self, other: &DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance> ) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance> TypeInfo for DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>where DelegationNodeId: TypeInfo + 'static, Option<DelegationNodeId>: TypeInfo + 'static, BoundedBTreeSet<DelegationNodeId, MaxChildren>: TypeInfo + 'static, DelegationDetails: TypeInfo + 'static, Deposit<AccountId, Balance>: TypeInfo + 'static, MaxChildren: Get<u32> + TypeInfo + 'static, AccountId: TypeInfo + 'static, Balance: TypeInfo + 'static,

type Identity = DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<DelegationNodeId, MaxChildren: Get<u32>, DelegationDetails, AccountId, Balance> EncodeLike<DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>> for DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>where DelegationNodeId: Encode, Option<DelegationNodeId>: Encode, BoundedBTreeSet<DelegationNodeId, MaxChildren>: Encode, DelegationDetails: Encode, Deposit<AccountId, Balance>: Encode,

impl<DelegationNodeId: Eq, MaxChildren: Eq + Get<u32>, DelegationDetails: Eq, AccountId: Eq, Balance: Eq> Eq for DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>

impl<DelegationNodeId, MaxChildren: Get<u32>, DelegationDetails, AccountId, Balance> StructuralEq for DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>

impl<DelegationNodeId, MaxChildren: Get<u32>, DelegationDetails, AccountId, Balance> StructuralPartialEq for DelegationNode<DelegationNodeId, MaxChildren, DelegationDetails, AccountId, Balance>