Enum Base 

pub enum Base {
    Void,
    Bool,
    Char8,
    Char16,
    Char32,
    I8,
    I16,
    I32,
    I64,
    I128,
    U8,
    U16,
    U32,
    U64,
    U128,
    F8,
    F16,
    F32,
    F64,
    F128,
}

Base type.

Variants

Void

Void type.

Bool

Boolean type.

Char8

Character types.

Char16

Char32

I8

Signed integer types.

I16

I32

I64

I128

U8

Unsigned integer types.

U16

U32

U64

U128

F8

Floating-point types.

F16

F32

F64

F128

Implementations

impl Base

pub fn size(&self) -> u64

Returns the size of the base type in bytes.

Trait Implementations

impl Archive for Base

type Archived = ArchivedBase

The archived representation of this type.

type Resolver = BaseResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve( &self, resolver: <Self as Archive>::Resolver, out: Place<<Self as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Debug for Base

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Base

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<Base, __D> for Archived<Base>

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Base, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Serialize for Base

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S: Fallible + ?Sized> Serialize<__S> for Base

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.