Struct pallet_im_online::BoundedOpaqueNetworkState[−][src]

pub struct BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where
    PeerIdEncodingLimit: Get<u32>,
    MultiAddrEncodingLimit: Get<u32>,
    AddressesLimit: Get<u32>,  {
    pub peer_id: WeakBoundedVec<u8, PeerIdEncodingLimit>,
    pub external_addresses: WeakBoundedVec<WeakBoundedVec<u8, MultiAddrEncodingLimit>, AddressesLimit>,
}

Expand description

A type that is the same as OpaqueNetworkState but with Vec replaced with WeakBoundedVec<Limit> where Limit is the respective size limit PeerIdEncodingLimit represents the size limit of the encoding of PeerId MultiAddrEncodingLimit represents the size limit of the encoding of MultiAddr AddressesLimit represents the size limit of the vector of peers connected

Fields

peer_id: WeakBoundedVec<u8, PeerIdEncodingLimit>

PeerId of the local node in SCALE encoded.

external_addresses: WeakBoundedVec<WeakBoundedVec<u8, MultiAddrEncodingLimit>, AddressesLimit>

List of addresses the node knows it can be reached as.

Struct pallet_im_online::BoundedOpaqueNetworkState[−][src]

Fields

Trait Implementations

impl<PeerIdEncodingLimit: Clone, MultiAddrEncodingLimit: Clone, AddressesLimit: Clone> Clone for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where PeerIdEncodingLimit: Get<u32>, MultiAddrEncodingLimit: Get<u32>, AddressesLimit: Get<u32>,

fn clone( &self) -> BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit>

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

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

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

fn encoded_fixed_size() -> Option<usize>

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

fn size_hint(&self) -> usize

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

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

fn encoded_size(&self) -> usize

fn max_encoded_len() -> usize

fn eq( &self, other: &BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit>) -> bool

fn ne( &self, other: &BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit>) -> bool

type Identity = Self

fn type_info() -> Type

impl<PeerIdEncodingLimit: Eq, MultiAddrEncodingLimit: Eq, AddressesLimit: Eq> Eq for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where PeerIdEncodingLimit: Get<u32>, MultiAddrEncodingLimit: Get<u32>, AddressesLimit: Get<u32>,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> StructuralEq for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where PeerIdEncodingLimit: Get<u32>, MultiAddrEncodingLimit: Get<u32>, AddressesLimit: Get<u32>,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> StructuralPartialEq for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where PeerIdEncodingLimit: Get<u32>, MultiAddrEncodingLimit: Get<u32>, AddressesLimit: Get<u32>,

Auto Trait Implementations

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> RefUnwindSafe for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where AddressesLimit: RefUnwindSafe, MultiAddrEncodingLimit: RefUnwindSafe, PeerIdEncodingLimit: RefUnwindSafe,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> Send for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where AddressesLimit: Send, MultiAddrEncodingLimit: Send, PeerIdEncodingLimit: Send,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> Sync for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where AddressesLimit: Sync, MultiAddrEncodingLimit: Sync, PeerIdEncodingLimit: Sync,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> Unpin for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where AddressesLimit: Unpin, MultiAddrEncodingLimit: Unpin, PeerIdEncodingLimit: Unpin,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> UnwindSafe for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where AddressesLimit: UnwindSafe, MultiAddrEncodingLimit: UnwindSafe, PeerIdEncodingLimit: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> CheckedConversion for T

fn checked_from<T>(t: T) -> Option<Self> where Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T> where Self: TryInto<T>,

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> DecodeAll for T where T: Decode,

pub fn decode_all(input: &[u8]) -> Result<T, Error>

impl<T> DecodeLimit for T where T: Decode,

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>( limit: u32, input: &mut I) -> Result<T, Error> where I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>

impl<T> Downcast for T where T: Any,

pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

pub fn as_any(&self) -> &(dyn Any + 'static)

pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

impl<T> DowncastSync for T where T: Any + Send + Sync,

pub fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send + 'static>

impl<T> DynClone for T where T: Clone,

pub fn __clone_box(&self, Private) -> *mut ()

impl<Q, K> Equivalent<K> for Q where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

pub fn equivalent(&self, key: &K) -> bool

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T> Hashable for T where T: Codec,

pub fn blake2_128(&self) -> [u8; 16]

pub fn blake2_256(&self) -> [u8; 32]

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

pub fn twox_128(&self) -> [u8; 16]

pub fn twox_256(&self) -> [u8; 32]

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

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

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

impl<PeerIdEncodingLimit: Clone, MultiAddrEncodingLimit: Clone, AddressesLimit: Clone> Clone for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where
PeerIdEncodingLimit: Get<u32>,
MultiAddrEncodingLimit: Get<u32>,
AddressesLimit: Get<u32>,

fn clone(
&self
) -> BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit>

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

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

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

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

fn eq(
&self,
other: &BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit>
) -> bool

fn ne(
&self,
other: &BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit>
) -> bool

impl<PeerIdEncodingLimit: Eq, MultiAddrEncodingLimit: Eq, AddressesLimit: Eq> Eq for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where
PeerIdEncodingLimit: Get<u32>,
MultiAddrEncodingLimit: Get<u32>,
AddressesLimit: Get<u32>,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> StructuralEq for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where
PeerIdEncodingLimit: Get<u32>,
MultiAddrEncodingLimit: Get<u32>,
AddressesLimit: Get<u32>,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> StructuralPartialEq for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where
PeerIdEncodingLimit: Get<u32>,
MultiAddrEncodingLimit: Get<u32>,
AddressesLimit: Get<u32>,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> RefUnwindSafe for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where
AddressesLimit: RefUnwindSafe,
MultiAddrEncodingLimit: RefUnwindSafe,
PeerIdEncodingLimit: RefUnwindSafe,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> Send for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where
AddressesLimit: Send,
MultiAddrEncodingLimit: Send,
PeerIdEncodingLimit: Send,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> Sync for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where
AddressesLimit: Sync,
MultiAddrEncodingLimit: Sync,
PeerIdEncodingLimit: Sync,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> Unpin for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where
AddressesLimit: Unpin,
MultiAddrEncodingLimit: Unpin,
PeerIdEncodingLimit: Unpin,

impl<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> UnwindSafe for BoundedOpaqueNetworkState<PeerIdEncodingLimit, MultiAddrEncodingLimit, AddressesLimit> where
AddressesLimit: UnwindSafe,
MultiAddrEncodingLimit: UnwindSafe,
PeerIdEncodingLimit: UnwindSafe,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

fn checked_from<T>(t: T) -> Option<Self> where
Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T> where
Self: TryInto<T>,

fn conv<T>(self) -> T where
Self: Into<T>,

fn conv<T>(self) -> T where
Self: Into<T>,

impl<T> DecodeAll for T where
T: Decode,

pub fn decode_all(input: &[u8 ]) -> Result<T, Error>

impl<T> DecodeLimit for T where
T: Decode,

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>(
limit: u32,
input: &mut I
) -> Result<T, Error> where
I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

impl<T> Downcast for T where
T: Any,

impl<T> DowncastSync for T where
T: Any + Send + Sync,

impl<T> DynClone for T where
T: Clone,

impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,

fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,

impl<T> Hashable for T where
T: Codec,

pub fn blake2_128(&self) -> [u8 ; 16]

pub fn blake2_256(&self) -> [u8 ; 32]

pub fn twox_128(&self) -> [u8 ; 16]

pub fn twox_256(&self) -> [u8 ; 32]

impl<T, U> Into<U> for T where
U: From<T>,

impl<T, Outer> IsWrappedBy<Outer> for T where
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,

impl<T> KeyedVec for T where
T: Codec,

pub fn to_keyed_vec(&self, prepend_key: &[u8 ]) -> Vec<u8, Global>

impl<T> Pipe for T where
T: ?Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,

fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,

fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,

fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,

fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,

fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,

fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn saturated_from<T>(t: T) -> Self where
Self: UniqueSaturatedFrom<T>,

fn saturated_into<T>(self) -> T where
Self: UniqueSaturatedInto<T>,

impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,