Crate cookie_factory

source ·
Expand description

serialization library built with a combinator design similar to nom.

Serializers are built up from single purpose serializers, like slice to write a raw byte slice, or be_u16 to write a u16 integer in big endian form.

Those small serializers can then be assembled by using combinators. As an example, all(["abcd", "efgh", "ijkl"].iter().map(string))(output) will write "abcdefghijkl" to output.

Modules§

  • async_bufwriter
  • bytes
    bytes and numbers related serialization functions
  • combinator
    basic serializers
  • gen
    legacy serializers, kept for backwards compatibility from previous cookie factory versions
  • lib
    lib module necessary to reexport what we need from std in no_std mode
  • multi
    serializers working on a list of elements (vectors, iterators, etc)
  • sequence
    serializers working a sequence of objects (pairs, tuples, etc)

Macros§

  • do_gen
    Applies sub-generators in a sequence.
  • gen_align
    gen_align!(I, u8) => I -> Result<I,E> Align the output buffer to the next multiple of specified value.
  • gen_at_offset
    gen_at_offset!(usize, I -> Result<I,E>) => I -> Result<I,E> Combinator to call generator at an absolute offset.
  • gen_at_rel_offset
    gen_at_offset!(usize, I -> Result<I,E>) => I -> Result<I,E> Combinator to call generator at a relative offset.
  • gen_be_f32
    gen_be_f32!(I, f32) => I -> Result<I,E> Write a 4 byte float.
  • gen_be_f64
    gen_be_f64!(I, f64) => I -> Result<I,E> Write a 8 byte float.
  • gen_be_i8
    gen_be_i8!(I, i8) => I -> Result<I,E> Write a signed 1 byte integer.
  • gen_be_i16
    gen_be_i16!(I, i16) => I -> Result<I,E> Write a signed 2 byte integer.
  • gen_be_i24
    gen_be_i24!(I, i24) => I -> Result<I,E> Write a signed 3 byte integer.
  • gen_be_i32
    gen_be_i32!(I, i32) => I -> Result<I,E> Write a signed 4 byte integer.
  • gen_be_i64
    gen_be_i64!(I, i64) => I -> Result<I,E> Write a signed 8 byte integer.
  • gen_be_u8
    gen_be_u8!(I, u8) => I -> Result<I,E> Write an unsigned 1 byte integer.
  • gen_be_u16
    gen_be_u16!(I, u8) => I -> Result<I,E> Write an unsigned 2 bytes integer (using big-endian order).
  • gen_be_u24
    gen_be_u24!(I, u8) => I -> Result<I,E> Write an unsigned 3 bytes integer (using big-endian order).
  • gen_be_u32
    gen_be_u32!(I, u8) => I -> Result<I,E> Write an unsigned 4 bytes integer (using big-endian order).
  • gen_be_u64
    gen_be_u64!(I, u8) => I -> Result<I,E> Write an unsigned 8 bytes integer (using big-endian order).
  • gen_call
    Used to wrap common expressions and function as macros
  • gen_cond
    gen_cond!(bool, I -> Result<I,E>) => I -> Result<I,E> Conditional combinator
  • gen_copy
    gen_copy!(I, &[u8], u8) => I -> Result<I,E> Writes a slice, copying only the specified number of bytes to the output buffer.
  • gen_if_else
    gen_if_else!(bool, I -> Result<I,E>, I -> Result<I,E>) => I -> Result<I,E> Conditional combinator, with alternate generator.
  • gen_le_f32
    gen_le_f32!(I, f32) => I -> Result<I,E> Write a 4 byte float.
  • gen_le_f64
    gen_le_f64!(I, f64) => I -> Result<I,E> Write a 8 byte float.
  • gen_le_i8
    gen_le_i8!(I, i8) => I -> Result<I,E> Write a signed 1 byte integer.
  • gen_le_i16
    gen_le_i16!(I, i16) => I -> Result<I,E> Write a signed 2 byte integer.
  • gen_le_i24
    gen_le_i24!(I, i24) => I -> Result<I,E> Write a signed 3 byte integer.
  • gen_le_i32
    gen_le_i32!(I, i32) => I -> Result<I,E> Write a signed 4 byte integer.
  • gen_le_i64
    gen_le_i64!(I, i64) => I -> Result<I,E> Write a signed 8 byte integer.
  • gen_le_u8
    gen_le_u8!(I, u8) => I -> Result<I,E> Write an unsigned 1 byte integer.
  • gen_le_u16
    gen_le_u16!(I, u8) => I -> Result<I,E> Write an unsigned 2 bytes integer (using little-endian order).
  • gen_le_u24
    gen_le_u24!(I, u8) => I -> Result<I,E> Write an unsigned 3 bytes integer (using little-endian order).
  • gen_le_u32
    gen_le_u32!(I, u8) => I -> Result<I,E> Write an unsigned 4 bytes integer (using little-endian order).
  • gen_le_u64
    gen_le_u64!(I, u8) => I -> Result<I,E> Write an unsigned 8 bytes integer (using little-endian order).
  • gen_length_slice
  • gen_many
    gen_many!(I, Iterable<V>, Fn(I,V)) => I -> Result<I,E> Applies the generator $f to every element of $l, passing arguments by value.
  • gen_many_byref
    gen_many_byref!(I, Iterable<V>, Fn(I,V)) => I -> Result<I,E> Applies the generator $f to every element of $l, where arguments of $l are references
  • gen_many_ref
    gen_many_ref!(I, Iterable<V>, Fn(I,V)) => I -> Result<I,E> Applies the generator $f to every element of $l, passing arguments by reference.
  • gen_skip
    gen_skip!(I, u8) => I -> Result<I,E> Skip the specified number of bytes.
  • gen_slice
    gen_slice!(I, &[u8]) => I -> Result<I,E> Writes a slice, copying it entirely to the output buffer.

Structs§

  • WriteContext
    Context around a Write impl that is passed through serializing functions

Enums§

Traits§

  • BackToTheBuffer
    Trait for Write types that allow skipping and reserving a slice, then writing some data, then write something in the slice we reserved using the return for our data write.
  • Seek
    Trait for Seek types that want to automatically implement BackToTheBuffer
  • SerializeFn
    Trait for serializing functions
  • Skip
    Trait for Write types that allow skipping over the data

Functions§

  • gen
    Runs the given serializer f with the Write impl w and returns the result
  • gen_simple
    Runs the given serializer f with the Write impl w and returns the updated w

Type Aliases§

  • GenResult
    Holds the result of serializing functions