Crate amplify

Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros.

Minimum supported rust compiler version (MSRV): 1.46 (stable channel)

Re-exports

pub extern crate alloc;

pub use crate::strategy::Holder;

pub use ascii;

Modules

confinement

Confinement puts a constraint on the number of elements within a collection.

flags

Types for building flag-based APIs and functionality

hex

Hex encoding and decoding

num

Custom-sized numeric types

strategy

This is a trick for rust compiler helping to distinguish types implementing mutually-exclusive traits (required until negative trait impls will be there) Implemented after concept by Martin Habovštiak martin.habovstiak@gmail.com

Macros

bmap

Macro for creating alloc::collections::BTreeMap in the same manner as vec! is used for Vec:

bset

Macro for creating alloc::collections::BTreeSet in the same manner as vec! is used for Vec:

confined_blobDeprecated

Helper macro to construct confined blob

confined_bmapDeprecated

Helper macro to construct confined BTreeMap of a given type

confined_bsetDeprecated

Helper macro to construct confined BTreeSet of a given type

confined_mapDeprecated

Helper macro to construct confined HashMap of a given type

confined_sDeprecated

Helper macro to construct confined string

confined_setDeprecated

Helper macro to construct confined HashSet of a given type

confined_vecDeprecated

Helper macro to construct confined vector of a given type

default

Shorthand for Default::default()

dumb

Shorthand for Dumb::dumb()

empty

This macro allows more semantically-clear code (which can be used especially with structure initialization), indicating that instead of type value we are generating empty collection types

list

Macro for creating alloc::collections::LinkedList in the same manner as vec! is used for Vec:

map

Macro for creating std::collections::HashMap in the same manner as vec! is used for Vec:

medium_blob

Helper macro to construct confined blob of a MediumBlob type

medium_bmap

Helper macro to construct confined BTreeMap of a MediumOrdMap type

medium_bset

Helper macro to construct confined BTreeSet of a MediumOrdSet type

medium_map

Helper macro to construct confined HashMap of a MediumHashMap type

medium_s

Helper macro to construct confined string of a MediumString type

medium_set

Helper macro to construct confined HashSet of a MediumHashSet type

medium_vec

Helper macro to construct confined vector of a MediumVec type

none

This macro allows more semantically-clear code (which can be used especially with structure initialization), indicating that instead of type value we are generating no value at all (empty collection or data structure filled with information indicating absence of data)

s

Macro for quick & simple &str -> String conversion:

set

Macro for creating std::collections::HashSet in the same manner as vec! is used for Vec:

small_blob

Helper macro to construct confined blob of a SmallBlob type

small_bmap

Helper macro to construct confined BTreeMap of a SmallOrdMap type

small_bset

Helper macro to construct confined BTreeSet of a SmallOrdSet type

small_map

Helper macro to construct confined HashMap of a SmallHashMap type

small_s

Helper macro to construct confined string of a SmallString type

small_set

Helper macro to construct confined HashSet of a SmallHashSet type

small_vec

Helper macro to construct confined vector of a SmallVec type

tiny_blob

Helper macro to construct confined blob of a TinyBlob type

tiny_bmap

Helper macro to construct confined BTreeMap of a TinyOrdMap type

tiny_bset

Helper macro to construct confined BTreeSet of a TinyOrdSet type

tiny_map

Helper macro to construct confined HashMap of a TinyHashMap type

tiny_s

Helper macro to construct confined string of a TinyString type

tiny_set

Helper macro to construct confined HashSet of a TinyHashSet type

tiny_vec

Helper macro to construct confined vector of a TinyVec type

zero

This macro allows more semantically-clear code (which can be used especially with structure initialization), indicating that instead of type value we are generating zero values (int types or byte slices filled with zeros)

Structs

Array

Wrapper type for all fixed arrays implementing many important traits, so types based on it can simply derive their implementations.

ConfinedIo

Errors with io::ErrorKind::UnexpectedEof on io::Read and io::Write operations if the LIM is reached.

FlagRef

Keeps a reference to a specific feature flag within FlagVec vector

FlagVec

Bit flag vector. Can hold up to 2^16-1 flags and guaranteed to have length up to 255 bytes.

FromSliceError

Error when slice size mismatches array length.

IoError

Copyable & cloneable I/O error type represented by the error kind function.

WriteCounter

A simple way to count bytes written through io::Write.

Enums

MultiError

Traits

AsAny

Trait AsAny allows simple conversion of any type into a generic “thick” pointer &dyn Any (see Any), that can be later converted back to the original type with a graceful failing for all other conversions. For simple conversions it is recommended to use #[derive(AsAny)] macro from amplify_derive crate (see amplify_derive::AsAny).

ByteArray

Trait which does a blanket implementation for all types wrapping Arrays

Dumb

Used as an alternative to default for test and prototyping purposes, when a type can’t have a default value, but you need to generate some dumb data.

IntoMultiError

JoinSplit

Trait for splittable streams and other types, which can be separated into some two types (JoinSplit::A, JoinSplit::B), like a reader and writer streams.

RawArrayDeprecated

Trait which does a blanket implementation for all types wrapping Arrays

Wrapper

Trait defining wrapped types (“newtypes” in rust terminology). Wrapped types are used for allowing implemeting foreign traits to foreign types: https://doc.rust-lang.org/stable/rust-by-example/generics/new_types.html

WrapperMut

Trait allowing mutable reference borrowing for the wrapped inner type.

Type Aliases

Bytes

Wrapper type for all array-based bytes implementing many important traits, so types based on it can simply derive their implementations.

Bytes4

Wrapper type for all array-based 32-bit types implementing many important traits, so types based on it can simply derive their implementations.

Bytes16

Wrapper type for all array-based 128-bit types implementing many important traits, so types based on it can simply derive their implementations.

Bytes20

Wrapper type for all array-based 160-bit types implementing many important traits, so types based on it can simply derive their implementations.

Bytes32

Wrapper type for all array-based 256-bit types implementing many important traits, so types based on it can simply derive their implementations.

Bytes64

Wrapper type for all array-based 512-bit types implementing many important traits, so types based on it can simply derive their implementations.

Bytes32StrRev

Wrapper type for all array-based 256-bit types implementing many important traits, so types based on it can simply derive their implementations.

FlagNo

A single feature flag, represented by it’s number inside feature vector

Derive Macros

AsAny

Trait amplify::AsAny allows simple conversion of any type into a generic “thick” pointer &dyn Any (see [::core::any::Any]), that can be later converted back to the original type with a graceful failing for all other conversions. AsAny derive macro allows to implement this trait for arbitrary time without much hussle:

Display

Usage

Error

Error derive macro works to the full extend only when other derive macros are used. With #[derive(Display)] and [display(doc_comments)] it uses doc comments for generating error descriptions; with #[derive(From)] it may automatically implement transofrations from other error types.

From

Implements From trait for the whole entity and/or its separate fields. Works well with #[derive(Error)] and, in many cases may require [Default] implementation (for details, pls see Examples below)

Getters

Derives getter methods for structures. The return type and naming of the methods depends on the provided attribute arguments.

Wrapper

Creates rust new type wrapping existing type. Can be used in structures containing multiple named or unnamed fields; in this case the field you’d like to wrap should be marked with #[wrap] attribute; otherwise the first field is assumed to be the wrapped one.

WrapperMut

Derives WrapperMut and allows deriving other traits accessing the wrapped type which require mutable access to the inner type. Requires that the type already implements amplify::Wrapper.