Struct scale_info::Field

source · [−]

pub struct Field<T: Form = MetaForm> { /* private fields */ }

Expand description

A field of a struct-like data type.

Name is optional so it can represent both named and unnamed fields.

This can be a named field of a struct type or an enum struct variant, or an unnamed field of a tuple struct.

Type name

The type_name field contains a string which is the name of the type of the field as it appears in the source code. The exact contents and format of the type name are not specified, but in practice will be the name of any valid type for a field e.g.

Concrete types e.g "u32", "bool", "Foo" etc.
Type parameters e.g "T", "U"
Generic types e.g "Vec<u32>", "Vec<T>"
Associated types e.g. "T::MyType", "<T as MyTrait>::MyType"
Type aliases e.g. "MyTypeAlias", "MyTypeAlias<T>"
Other built in Rust types e.g. arrays, references etc.

Note that the type name doesn’t correspond to the underlying type of the field, unless using a concrete type directly. Any given type may be referred to by multiple field type names, when using generic type parameters and type aliases.

This is intended for informational and diagnostic purposes only. Although it is possible to infer certain properties e.g. whether a type name is a type alias, there are no guarantees provided, and the type name representation may change.

Struct scale_info::Field

Type name

Implementations

impl Field

pub fn builder() -> FieldBuilder

pub fn new( name: Option<&'static str>, ty: MetaType, type_name: Option<&'static str>, docs: &[&'static str]) -> Self

impl<T> Field<T> where T: Form,

pub fn name(&self) -> Option<&T::String>

pub fn ty(&self) -> &T::Type

pub fn type_name(&self) -> Option<&T::String>

pub fn docs(&self) -> &[T::String]

Trait Implementations

impl<T: Clone + Form> Clone for Field<T> where T::String: Clone, T::Type: Clone, T::String: Clone, T::String: Clone,

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

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

impl<T: Debug + Form> Debug for Field<T> where T::String: Debug, T::Type: Debug, T::String: Debug, T::String: Debug,

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

impl<T: Form> Decode for Field<T> where Option<T::String>: Decode, Option<T::String>: Decode, T::Type: Decode, T::Type: Decode, Option<T::String>: Decode, Option<T::String>: Decode, Vec<T::String>: Decode, Vec<T::String>: Decode,

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>

impl<'de, T: Form> Deserialize<'de> for Field<T> where T::Type: DeserializeOwned, T::String: DeserializeOwned,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where __D: Deserializer<'de>,

impl<T: Form> Encode for Field<T> where Option<T::String>: Encode, Option<T::String>: Encode, T::Type: Encode, T::Type: Encode, Option<T::String>: Encode, Option<T::String>: Encode, Vec<T::String>: Encode, Vec<T::String>: Encode,

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

fn size_hint(&self) -> usize

fn encode(&self) -> Vec<u8, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where A: Allocator,

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

fn encoded_size(&self) -> usize

impl IntoPortable for Field

type Output = Field<PortableForm>

fn into_portable(self, registry: &mut Registry) -> Self::Output

impl<T: Ord + Form> Ord for Field<T> where T::String: Ord, T::Type: Ord, T::String: Ord, T::String: Ord,

fn cmp(&self, other: &Field<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

fn clamp(self, min: Self, max: Self) -> Self

impl<T: PartialEq + Form> PartialEq<Field<T>> for Field<T> where T::String: PartialEq, T::Type: PartialEq, T::String: PartialEq, T::String: PartialEq,

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

fn ne(&self, other: &Field<T>) -> bool

impl<T: PartialOrd + Form> PartialOrd<Field<T>> for Field<T> where T::String: PartialOrd, T::Type: PartialOrd, T::String: PartialOrd, T::String: PartialOrd,

fn partial_cmp(&self, other: &Field<T>) -> Option<Ordering>

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

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

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

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

impl<T: Form> Serialize for Field<T> where T::Type: Serialize, T::String: Serialize,

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

impl<T: Form> EncodeLike<Field<T>> for Field<T> where Option<T::String>: Encode, Option<T::String>: Encode, T::Type: Encode, T::Type: Encode, Option<T::String>: Encode, Option<T::String>: Encode, Vec<T::String>: Encode, Vec<T::String>: Encode,

impl<T: Eq + Form> Eq for Field<T> where T::String: Eq, T::Type: Eq, T::String: Eq, T::String: Eq,

impl<T: Form> StructuralEq for Field<T>

impl<T: Form> StructuralPartialEq for Field<T>

Auto Trait Implementations

impl<T> RefUnwindSafe for Field<T> where <T as Form>::String: RefUnwindSafe, <T as Form>::Type: RefUnwindSafe,

impl<T> Send for Field<T> where <T as Form>::String: Send, <T as Form>::Type: Send,

impl<T> Sync for Field<T> where <T as Form>::String: Sync, <T as Form>::Type: Sync,

impl<T> Unpin for Field<T> where <T as Form>::String: Unpin, <T as Form>::Type: Unpin,

impl<T> UnwindSafe for Field<T> where <T as Form>::String: UnwindSafe, <T as Form>::Type: 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> 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> 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,

pub fn new(
name: Option<&'static str>,
ty: MetaType,
type_name: Option<&'static str>,
docs: &[&'static str ]
) -> Self

impl<T> Field<T> where
T: Form,

pub fn docs(&self) -> &[T::String ]

impl<T: Clone + Form> Clone for Field<T> where
T::String: Clone,
T::Type: Clone,
T::String: Clone,
T::String: Clone,

impl<T: Debug + Form> Debug for Field<T> where
T::String: Debug,
T::Type: Debug,
T::String: Debug,
T::String: Debug,

impl<T: Form> Decode for Field<T> where
Option<T::String>: Decode,
Option<T::String>: Decode,
T::Type: Decode,
T::Type: Decode,
Option<T::String>: Decode,
Option<T::String>: Decode,
Vec<T::String>: Decode,
Vec<T::String>: Decode,

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

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

impl<'de, T: Form> Deserialize<'de> for Field<T> where
T::Type: DeserializeOwned,
T::String: DeserializeOwned,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
__D: Deserializer<'de>,

impl<T: Form> Encode for Field<T> where
Option<T::String>: Encode,
Option<T::String>: Encode,
T::Type: Encode,
T::Type: Encode,
Option<T::String>: Encode,
Option<T::String>: Encode,
Vec<T::String>: Encode,
Vec<T::String>: Encode,

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

fn encode(&self) -> Vec<u8, Global>ⓘ
Notable traits for Vec<u8, A>
`impl<A> Write for Vec<u8, A> where A: Allocator,`

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

impl<T: Ord + Form> Ord for Field<T> where
T::String: Ord,
T::Type: Ord,
T::String: Ord,
T::String: Ord,

impl<T: PartialEq + Form> PartialEq<Field<T>> for Field<T> where
T::String: PartialEq,
T::Type: PartialEq,
T::String: PartialEq,
T::String: PartialEq,

impl<T: PartialOrd + Form> PartialOrd<Field<T>> for Field<T> where
T::String: PartialOrd,
T::Type: PartialOrd,
T::String: PartialOrd,
T::String: PartialOrd,

impl<T: Form> Serialize for Field<T> where
T::Type: Serialize,
T::String: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,

impl<T: Form> EncodeLike<Field<T>> for Field<T> where
Option<T::String>: Encode,
Option<T::String>: Encode,
T::Type: Encode,
T::Type: Encode,
Option<T::String>: Encode,
Option<T::String>: Encode,
Vec<T::String>: Encode,
Vec<T::String>: Encode,

impl<T: Eq + Form> Eq for Field<T> where
T::String: Eq,
T::Type: Eq,
T::String: Eq,
T::String: Eq,

impl<T> RefUnwindSafe for Field<T> where
<T as Form>::String: RefUnwindSafe,
<T as Form>::Type: RefUnwindSafe,

impl<T> Send for Field<T> where
<T as Form>::String: Send,
<T as Form>::Type: Send,

impl<T> Sync for Field<T> where
<T as Form>::String: Sync,
<T as Form>::Type: Sync,

impl<T> Unpin for Field<T> where
<T as Form>::String: Unpin,
<T as Form>::Type: Unpin,

impl<T> UnwindSafe for Field<T> where
<T as Form>::String: UnwindSafe,
<T as Form>::Type: 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 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>

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, U> Into<U> for T where
U: From<T>,

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

pub fn to_keyed_vec(&self, prepend_key: &[u8 ]) -> Vec<u8, Global>ⓘ
Notable traits for Vec<u8, A>
`impl<A> Write for Vec<u8, A> where A: Allocator,`

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 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,

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

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

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

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

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

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

fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,

fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,

fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,