Enum Ty 

pub enum Ty<L: LinkingScheme> {
    Enum(Enum<L>),
    Struct(Struct<L>),
    Tuple(Tuple<L>),
    Option {
        value: L::TypeLink,
    },
    Integer(IntegerType, IntegerDisplay),
    ByteArray {
        len: usize,
        display: ByteDisplay,
    },
    Float32,
    Float64,
    String,
    Boolean,
    Skip {
        len: usize,
    },
    ByteVec {
        display: ByteDisplay,
    },
    Array {
        len: usize,
        value: L::TypeLink,
    },
    Vec {
        value: L::TypeLink,
    },
    Map {
        key: L::TypeLink,
        value: L::TypeLink,
    },
}

Variants

Enum(Enum<L>)

Struct(Struct<L>)

Tuple(Tuple<L>)

Option

Fields

value: L::TypeLink

Integer(IntegerType, IntegerDisplay)

ByteArray

Fields

len: usize

display: ByteDisplay

Float32

Float64

String

Boolean

Skip

Fields

len: usize

ByteVec

Fields

display: ByteDisplay

Array

Fields

len: usize

value: L::TypeLink

Vec

Fields

value: L::TypeLink

Map

Fields

key: L::TypeLink

value: L::TypeLink

Implementations

impl<L: LinkingScheme> Ty<L>

pub fn visit<V: TypeVisitor<L, M>, M>( &self, schema: &impl TypeResolver<LinkingScheme = L, Metadata = M>, visitor: &mut V, arg: V::Arg, ) -> V::ReturnType

impl<L: LinkingScheme> Ty<L>

pub fn is_skip(&self) -> bool

Returns true if the type is a skip type

impl Ty<IndexLinking>

pub fn fill_next_placholder(&mut self, child: Link)

Fills the next available placeholder in the type with the given link, panicking if no placeholder is available.

impl<L: LinkingScheme> Ty<L>

pub fn is_primitive(&self) -> bool

pub fn parent_byte_references(&self) -> Vec<(usize, usize)>

Trait Implementations

impl<L> BorshDeserialize for Ty<L>

where L: BorshDeserialize + LinkingScheme, L::TypeLink: BorshDeserialize,

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl<L> BorshSerialize for Ty<L>

where L: BorshSerialize + LinkingScheme, L::TypeLink: BorshSerialize,

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl<L: Clone + LinkingScheme> Clone for Ty<L>

where L::TypeLink: Clone,

fn clone(&self) -> Ty<L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: Debug + LinkingScheme> Debug for Ty<L>

where L::TypeLink: Debug,

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

Formats the value using the given formatter.

impl<L> EnumExt for Ty<L>

where L: BorshDeserialize + LinkingScheme, L::TypeLink: BorshDeserialize,

fn deserialize_variant<__R: Read>( reader: &mut __R, variant_tag: u8, ) -> Result<Self, Error>

Deserialises given variant of an enum from the reader.

impl<L: LinkingScheme> From<Container<L>> for Ty<L>

fn from(value: Container<L>) -> Self

Converts to this type from the input type.

impl<L: LinkingScheme> From<Primitive> for Ty<L>

fn from(val: Primitive) -> Self

Converts to this type from the input type.

impl<L: PartialEq + LinkingScheme> PartialEq for Ty<L>

where L::TypeLink: PartialEq,

fn eq(&self, other: &Ty<L>) -> 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<L: LinkingScheme> TryFrom<Ty<L>> for Container<L>

type Error = ErrNotAContainer

The type returned in the event of a conversion error.

fn try_from(value: Ty<L>) -> Result<Self, Self::Error>

Performs the conversion.

impl<L: LinkingScheme> TryFrom<Ty<L>> for Primitive

type Error = ErrNotAPrimitive

The type returned in the event of a conversion error.

fn try_from(value: Ty<L>) -> Result<Self, Self::Error>

Performs the conversion.

impl<L: Eq + LinkingScheme> Eq for Ty<L>

where L::TypeLink: Eq,

impl<L: LinkingScheme> StructuralPartialEq for Ty<L>