Module sbor::prelude

Each module should have its own prelude, which:

• Adds preludes of upstream crates
• Exports types with specific-enough names which mean they can safely be used downstream.

The idea is that we can just include the current crate’s prelude and avoid messing around with tons of includes. This makes refactors easier, and makes integration into the node less painful.

Feel free to add more types to the prelude

Re-exports

• pub use crate::encoded_wrappers::RawPayload as SborRawPayload;
• pub use crate::encoded_wrappers::RawValue as SborRawValue;
• pub use crate::path::SborPath;
• pub use crate::path::SborPathBuf;
• pub use crate::representations;
• pub use crate::value::CustomValue as SborCustomValue;
• pub use crate::value::Value as SborValue;
• pub use crate::versioned::CloneIntoLatest;
• pub use crate::versioned::HasLatestVersion;
• pub use crate::versioned::UpdateResult;
• pub use crate::basic_decode;
• pub use crate::basic_encode;
• pub use crate::BasicCategorize;
• pub use crate::BasicDecode;
• pub use crate::BasicDescribe;
• pub use crate::BasicEncode;
• pub use crate::BasicSbor;
• pub use crate::Categorize;
• pub use crate::Decode;
• pub use crate::Encode;
• pub use crate::SborEnum;
• pub use crate::SborTuple;
• pub use crate::DecodeError;
• pub use crate::EncodeError;
• pub use crate::schema::prelude::*;
• pub use crate::value_kind::*;

Modules

• btree_map
• btree_set
• fmt
  Utilities for formatting and printing Strings.
• hash_map
• hash_set
• index_map
  The methods and macros provided directly in this index_map module (new, with_capacity) work in both std and no-std modes - unlike the corresponding methods on IndexMap itself.
• index_set
  The methods and macros provided directly in this index_set module (new, with_capacity) work in both std and no-std modes - unlike the corresponding methods on IndexSet itself.
• non_iter_map
• vec
  A contiguous growable array type with heap-allocated contents, written Vec<T>.

Macros

• btreemap
• btreeset
• format
  Creates a String using interpolation of runtime expressions.
• hashmap
• hashset
• indexmap
• indexset
• vec
  Creates a Vec containing the arguments.

Structs

• BTreeMap
  An ordered map based on a B-Tree.
• BTreeSet
  An ordered set based on a B-Tree.
• BorrowError
  An error returned by RefCell::try_borrow.
• BorrowMutError
  An error returned by RefCell::try_borrow_mut.
• Box
  A pointer type that uniquely owns a heap allocation of type T.
• Cell
  A mutable memory location.
• ContextDisplayable
• ContextSerializable
• LinkedList
  A doubly-linked list with owned nodes.
• NonIterMap
  A thin wrapper around a HashMap, which guarantees that a HashMap usage will not result in a non-deterministic execution (simply by disallowing the iteration over its elements).
• OnceCell
  A cell which can be written to only once.
• PhantomData
  Zero-sized type used to mark things that “act like” they own a T.
• Rc
  A single-threaded reference-counting pointer. ‘Rc’ stands for ‘Reference Counted’.
• Ref
  Wraps a borrowed reference to a value in a RefCell box. A wrapper type for an immutably borrowed value from a RefCell<T>.
• RefCell
  A mutable memory location with dynamically checked borrow rules
• RefMut
  A wrapper type for a mutably borrowed value from a RefCell<T>.
• SborFixedEnumVariant
• String
  A UTF-8–encoded, growable string.
• UnsafeCell
  The core primitive for interior mutability in Rust.
• Vec
  A contiguous growable array type, written as Vec<T>, short for ‘vector’.
• VecDeque
  A double-ended queue implemented with a growable ring buffer.
• LazyCellExperimental
  A value which is initialized on the first access.
• SyncUnsafeCellExperimental
  UnsafeCell, but Sync.

Enums

• Cow
  A clone-on-write smart pointer.
• Option
  The Option type. See the module level documentation for more.
• Result
  Result is a type that represents either success (Ok) or failure (Err).

Traits

• AsMut
  Used to do a cheap mutable-to-mutable reference conversion.
• AsRef
  Used to do a cheap reference-to-reference conversion.
• Clone
  A common trait for the ability to explicitly duplicate an object.
• ContextualDisplay
  This trait is used where context is required to correctly display a value.
• ContextualSerialize
  This trait is used where context is required to correctly serialize a value.
• Copy
  Types whose values can be duplicated simply by copying bits.
• Debug
  ? formatting.
• Default
  A trait for giving a type a useful default value.
• Display
  Format trait for an empty format, {}.
• DoubleEndedIterator
  An iterator able to yield elements from both ends.
• Drop
  Custom code within the destructor.
• Eq
  Trait for comparisons corresponding to equivalence relations.
• ExactSizeIterator
  An iterator that knows its exact length.
• Extend
  Extend a collection with the contents of an iterator.
• Fn
  The version of the call operator that takes an immutable receiver.
• FnMut
  The version of the call operator that takes a mutable receiver.
• FnOnce
  The version of the call operator that takes a by-value receiver.
• From
  Used to do value-to-value conversions while consuming the input value. It is the reciprocal of Into.
• FromIterator
  Conversion from an Iterator.
• FromStr
  Parse a value from a string
• Into
  A value-to-value conversion that consumes the input value. The opposite of From.
• IntoIterator
  Conversion into an Iterator.
• Iterator
  A trait for dealing with iterators.
• Ord
  Trait for types that form a total order.
• PartialEq
  Trait for comparisons using the equality operator.
• PartialOrd
  Trait for types that form a partial order.
• Send
  Types that can be transferred across thread boundaries.
• Sized
  Types with a constant size known at compile time.
• Sync
  Types for which it is safe to share references between threads.
• ToOwned
  A generalization of Clone to borrowed data.
• ToString
  A trait for converting a value to a String.
• TryFrom
  Simple and safe type conversions that may fail in a controlled way under some circumstances. It is the reciprocal of TryInto.
• TryInto
  An attempted conversion that consumes self, which may or may not be expensive.
• Unpin
  Types that do not require any pinning guarantees.

Functions

• combine
  Combines a u8 with a u8 slice.
• copy_u8_array
  Copies a slice to a fixed-sized array.
• drop
  Disposes of a value.
• hash_map_new
  Creates an empty map with capacity 0 and default Hasher
• hash_map_with_capacity
  Creates an empty map with given capacity and default Hasher
• hash_set_new
  Creates an empty set with capacity 0 and default Hasher
• hash_set_with_capacity
  Creates an empty set with given capacity and default Hasher
• index_map_new
  This is safe for std and no-std use cases (unlike IndexMap::new which disappears when std is not in the toolchain - see this article for deep technical reasons)
• index_map_with_capacity
  This is safe for std and no-std use cases (unlike IndexMap::with_capacity which disappears when std is not in the toolchain - see this article for deep technical reasons)
• index_set_new
  This is safe for std and no-std use cases (unlike IndexSet::new which disappears when std is not in the toolchain - see this article for deep technical reasons)
• index_set_with_capacity
  This is safe for std and no-std use cases (unlike IndexSet::with_capacity which disappears when std is not in the toolchain - see this article for deep technical reasons)

Type Aliases

• HashMap
• HashSet
• IndexMap
• IndexSet

Derive Macros

• BasicCategorize
  Derive code that returns the value kind - specifically for Basic SBOR.
• BasicDecode
  Derive code that decodes this data structure from a byte array - specifically for Basic SBOR.
• BasicDescribe
  Derive code that describes the type - specifically for Basic SBOR.
• BasicEncode
  Derive code that encodes this data structure - specifically for Basic SBOR.
• BasicSbor
  A shortcut for BasicCategorize, BasicEncode, BasicDecode, and BasicDescribe derives.
• Categorize
  Derive code that returns the value kind.
• Clone
  Derive macro generating an impl of the trait Clone.
• Copy
  Derive macro generating an impl of the trait Copy.
• Debug
  Derive macro generating an impl of the trait Debug.
• Decode
  Derive code that decodes this data structure from a byte array.
• Default
  Derive macro generating an impl of the trait Default.
• Encode
  Derive code that encodes this data structure
• Eq
  Derive macro generating an impl of the trait Eq.
• Ord
  Derive macro generating an impl of the trait Ord. The behavior of this macro is described in detail here.
• PartialEq
  Derive macro generating an impl of the trait PartialEq. The behavior of this macro is described in detail here.
• PartialOrd
  Derive macro generating an impl of the trait PartialOrd. The behavior of this macro is described in detail here.
• Sbor
  A shortcut for Categorize, Encode, Decode, and Describe derives.