Enum Format

#[repr(u8)]
pub(crate) enum Format {
    BincodeLegacy = 0,
    Bincode = 1,
    Msgpack = 2,
    MsgpackCompact = 3,
}

A marker byte for the serialization format.

Variants

BincodeLegacy = 0

Bincode without format marker. This does not actually appear in the data.

Bincode = 1

Bincode with format marker.

Msgpack = 2

Msgpack with named structs.

MsgpackCompact = 3

Msgpack with tuple structs.

Implementations

impl Format

pub(crate) fn from_env() -> Result<Option<Self>, String>

Look for a NOIR_SERIALIZATION_FORMAT env var to turn on formatted serialization.

The reason we use an env var is because:

1. It has to be picked up in methods like Program::serialize_program_base64 where no config is available.
2. At the moment this is mostly for testing, to be able to commit code that can produce different formats, but only activate it once a version of bb that can handle it is released.

Trait Implementations

impl Clone for Format

fn clone(&self) -> Format

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Format

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

Formats the value using the given formatter.

impl From<Format> for u8

fn from(enum_value: Format) -> Self

Converts to this type from the input type.

impl FromStr for Format

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Format, <Self as FromStr>::Err>

Parses a string s to return a value of this type.

impl PartialEq for Format

fn eq(&self, other: &Format) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&str> for Format

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Format, <Self as TryFrom<&str>>::Error>

Performs the conversion.

impl TryFrom<u8> for Format

type Error = TryFromPrimitiveError<Format>

The type returned in the event of a conversion error.

fn try_from(number: u8) -> Result<Self, TryFromPrimitiveError<Self>>

Performs the conversion.

impl TryFromPrimitive for Format

const NAME: &'static str = "Format"

type Primitive = u8

type Error = TryFromPrimitiveError<Format>

fn try_from_primitive( number: Self::Primitive, ) -> Result<Self, TryFromPrimitiveError<Self>>

impl Copy for Format

impl Eq for Format

impl StructuralPartialEq for Format