Struct borsh::schema::BorshSchemaContainer

pub struct BorshSchemaContainer { /* private fields */ }

All schema information needed to deserialize a single type.

Implementations

impl BorshSchemaContainer

pub fn max_serialized_size(&self) -> Result<usize, Error>

Returns the largest possible size of a serialised object based solely on its type.

Even when if returned upper bound is correct, the theoretical value may be much larger than any practical length. For example, maximum encoded length of String is 4 GiB while in practice one may encounter strings of at most dozen of characters.

Example

use borsh::schema::BorshSchemaContainer;

let schema = BorshSchemaContainer::for_type::<()>();
assert_eq!(Ok(0), schema.max_serialized_size());

let schema = BorshSchemaContainer::for_type::<usize>();
assert_eq!(Ok(8), schema.max_serialized_size());

// 4 bytes of length and u32::MAX for the longest possible string.
let schema = BorshSchemaContainer::for_type::<String>();
assert_eq!(Ok(4 + 4294967295), schema.max_serialized_size());

let schema = BorshSchemaContainer::for_type::<Vec<String>>();
assert_eq!(Err(borsh::schema::SchemaMaxSerializedSizeError::Overflow),
           schema.max_serialized_size());

impl BorshSchemaContainer

pub fn validate(&self) -> Result<(), Error>

Validates container for violation of any well-known rules with respect to borsh serialization.

Example

use borsh::schema::BorshSchemaContainer;

let schema = BorshSchemaContainer::for_type::<usize>();
assert_eq!(Ok(()), schema.validate());

impl BorshSchemaContainer

pub fn new( declaration: Declaration, definitions: BTreeMap<Declaration, Definition> ) -> Self

pub fn for_type<T: BorshSchema + ?Sized>() -> Self

generate BorshSchemaContainer for type T

pub fn declaration(&self) -> &Declaration

pub fn definitions(&self) -> impl Iterator<Item = (&Declaration, &Definition)>

pub fn get_definition<Q>(&self, declaration: &Q) -> Option<&Definition>

where Declaration: Borrow<Q>, Q: Ord + ?Sized,

pub fn get_mut_definition<Q>( &mut self, declaration: &Q ) -> Option<&mut Definition>

where Declaration: Borrow<Q>, Q: Ord + ?Sized,

pub fn insert_definition( &mut self, declaration: Declaration, definition: Definition ) -> Option<Definition>

pub fn remove_definition<Q>(&mut self, declaration: &Q) -> Option<Definition>

where Declaration: Borrow<Q>, Q: Ord + ?Sized,

Trait Implementations

impl BorshDeserialize for BorshSchemaContainer

where Declaration: BorshDeserialize, BTreeMap<Declaration, Definition>: BorshDeserialize,

fn deserialize_reader<R: Read>(reader: &mut R) -> IOResult<Self>

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

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>

Deserialize this instance from a slice of bytes.

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

impl BorshSchema for BorshSchemaContainer

where Declaration: BorshSchema, BTreeMap<Declaration, Definition>: BorshSchema,

fn declaration() -> Declaration

Get the name of the type without brackets.

fn add_definitions_recursively( definitions: &mut BTreeMap<Declaration, Definition> )

Recursively, using DFS, add type definitions required for this type. Type definition partially explains how to serialize/deserialize a type.

impl BorshSerialize for BorshSchemaContainer

where Declaration: BorshSerialize, BTreeMap<Declaration, Definition>: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> IOResult<()>

impl Clone for BorshSchemaContainer

fn clone(&self) -> BorshSchemaContainer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BorshSchemaContainer

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

Formats the value using the given formatter.

impl PartialEq for BorshSchemaContainer

fn eq(&self, other: &BorshSchemaContainer) -> 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 Eq for BorshSchemaContainer

impl StructuralPartialEq for BorshSchemaContainer