Struct ProtoSchema

pub(crate) struct ProtoSchema<F> {
    field: PhantomData<F>,
}

Fields

field: PhantomData<F>

Trait Implementations

impl<F> ProtoCodec<(OpcodeLocation, AssertionPayload<F>), AssertMessage> for ProtoSchema<F>

where F: AcirField,

fn encode(value: &(OpcodeLocation, AssertionPayload<F>)) -> AssertMessage

Convert domain type T to protobuf representation R.

fn decode( value: &AssertMessage, ) -> Result<(OpcodeLocation, AssertionPayload<F>)>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<AssertionPayload<F>, AssertionPayload> for ProtoSchema<F>

where F: AcirField,

fn encode(value: &AssertionPayload<F>) -> AssertionPayload

Convert domain type T to protobuf representation R.

fn decode(value: &AssertionPayload) -> Result<AssertionPayload<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<BinaryFieldOp, BinaryFieldOpKind> for ProtoSchema<F>

fn encode(value: &BinaryFieldOp) -> BinaryFieldOpKind

Convert domain type T to protobuf representation R.

fn decode(value: &BinaryFieldOpKind) -> Result<BinaryFieldOp>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_enum(value: &T) -> i32

where R: Into<i32>,

Encode an enum to the i32 value that prost represents it with.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn decode_enum(value: i32) -> Result<T, Report>

where R: TryFrom<i32, Error = UnknownEnumValue>,

Decode the numeric representation of an enum into the domain type. Return an error if the value cannot be recognized.

fn decode_enum_wrap(value: i32, msg: &'static str) -> Result<T, Report>

where R: TryFrom<i32, Error = UnknownEnumValue>,

Decode the numeric representation of an enum, attaching the field name to any errors.

impl<F> ProtoCodec<BinaryIntOp, BinaryIntOpKind> for ProtoSchema<F>

fn encode(value: &BinaryIntOp) -> BinaryIntOpKind

Convert domain type T to protobuf representation R.

fn decode(value: &BinaryIntOpKind) -> Result<BinaryIntOp>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_enum(value: &T) -> i32

where R: Into<i32>,

Encode an enum to the i32 value that prost represents it with.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn decode_enum(value: i32) -> Result<T, Report>

where R: TryFrom<i32, Error = UnknownEnumValue>,

Decode the numeric representation of an enum into the domain type. Return an error if the value cannot be recognized.

fn decode_enum_wrap(value: i32, msg: &'static str) -> Result<T, Report>

where R: TryFrom<i32, Error = UnknownEnumValue>,

Decode the numeric representation of an enum, attaching the field name to any errors.

impl<F> ProtoCodec<BitSize, BitSize> for ProtoSchema<F>

fn encode(value: &BitSize) -> BitSize

Convert domain type T to protobuf representation R.

fn decode(value: &BitSize) -> Result<BitSize>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<BlackBoxFuncCall<F>, BlackBoxFuncCall> for ProtoSchema<F>

where F: AcirField,

fn encode(value: &BlackBoxFuncCall<F>) -> BlackBoxFuncCall

Convert domain type T to protobuf representation R.

fn decode(value: &BlackBoxFuncCall) -> Result<BlackBoxFuncCall<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<BlackBoxOp, BlackBoxOp> for ProtoSchema<F>

fn encode(value: &BlackBoxOp) -> BlackBoxOp

Convert domain type T to protobuf representation R.

fn decode(value: &BlackBoxOp) -> Result<BlackBoxOp>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<BlockType, BlockType> for ProtoSchema<F>

fn encode(value: &BlockType) -> BlockType

Convert domain type T to protobuf representation R.

fn decode(value: &BlockType) -> Result<BlockType>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F: AcirField> ProtoCodec<BrilligBytecode<F>, BrilligBytecode> for ProtoSchema<F>

fn encode(value: &BrilligBytecode<F>) -> BrilligBytecode

Convert domain type T to protobuf representation R.

fn decode(value: &BrilligBytecode) -> Result<BrilligBytecode<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<BrilligInputs<F>, BrilligInputs> for ProtoSchema<F>

where F: AcirField,

fn encode(value: &BrilligInputs<F>) -> BrilligInputs

Convert domain type T to protobuf representation R.

fn decode(value: &BrilligInputs) -> Result<BrilligInputs<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<BrilligOutputs, BrilligOutputs> for ProtoSchema<F>

fn encode(value: &BrilligOutputs) -> BrilligOutputs

Convert domain type T to protobuf representation R.

fn decode(value: &BrilligOutputs) -> Result<BrilligOutputs>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F: AcirField> ProtoCodec<Circuit<F>, Circuit> for ProtoSchema<F>

fn encode(value: &Circuit<F>) -> Circuit

Convert domain type T to protobuf representation R.

fn decode(value: &Circuit) -> Result<Circuit<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<ConstantOrWitnessEnum<F>, ConstantOrWitnessEnum> for ProtoSchema<F>

where F: AcirField,

fn encode(value: &ConstantOrWitnessEnum<F>) -> ConstantOrWitnessEnum

Convert domain type T to protobuf representation R.

fn decode(value: &ConstantOrWitnessEnum) -> Result<ConstantOrWitnessEnum<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<Expression<F>, Expression> for ProtoSchema<F>

where F: AcirField,

fn encode(value: &Expression<F>) -> Expression

Convert domain type T to protobuf representation R.

fn decode(value: &Expression) -> Result<Expression<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<ExpressionOrMemory<F>, ExpressionOrMemory> for ProtoSchema<F>

where F: AcirField,

fn encode(value: &ExpressionOrMemory<F>) -> ExpressionOrMemory

Convert domain type T to protobuf representation R.

fn decode(value: &ExpressionOrMemory) -> Result<ExpressionOrMemory<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<ExpressionWidth, ExpressionWidth> for ProtoSchema<F>

fn encode(value: &ExpressionWidth) -> ExpressionWidth

Convert domain type T to protobuf representation R.

fn decode(value: &ExpressionWidth) -> Result<ExpressionWidth>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F: AcirField> ProtoCodec<F, Field> for ProtoSchema<F>

fn encode(value: &F) -> Field

Convert domain type T to protobuf representation R.

fn decode(value: &Field) -> Result<F>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<FunctionInput<F>, FunctionInput> for ProtoSchema<F>

where F: AcirField,

fn encode(value: &FunctionInput<F>) -> FunctionInput

Convert domain type T to protobuf representation R.

fn decode(value: &FunctionInput) -> Result<FunctionInput<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<HeapArray, HeapArray> for ProtoSchema<F>

fn encode(value: &HeapArray) -> HeapArray

Convert domain type T to protobuf representation R.

fn decode(value: &HeapArray) -> Result<HeapArray>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<HeapValueType, HeapValueType> for ProtoSchema<F>

fn encode(value: &HeapValueType) -> HeapValueType

Convert domain type T to protobuf representation R.

fn decode(value: &HeapValueType) -> Result<HeapValueType>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<HeapVector, HeapVector> for ProtoSchema<F>

fn encode(value: &HeapVector) -> HeapVector

Convert domain type T to protobuf representation R.

fn decode(value: &HeapVector) -> Result<HeapVector>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<IntegerBitSize, IntegerBitSize> for ProtoSchema<F>

fn encode(value: &IntegerBitSize) -> IntegerBitSize

Convert domain type T to protobuf representation R.

fn decode(value: &IntegerBitSize) -> Result<IntegerBitSize>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_enum(value: &T) -> i32

where R: Into<i32>,

Encode an enum to the i32 value that prost represents it with.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn decode_enum(value: i32) -> Result<T, Report>

where R: TryFrom<i32, Error = UnknownEnumValue>,

Decode the numeric representation of an enum into the domain type. Return an error if the value cannot be recognized.

fn decode_enum_wrap(value: i32, msg: &'static str) -> Result<T, Report>

where R: TryFrom<i32, Error = UnknownEnumValue>,

Decode the numeric representation of an enum, attaching the field name to any errors.

impl<F> ProtoCodec<MemOp<F>, MemOp> for ProtoSchema<F>

where F: AcirField,

fn encode(value: &MemOp<F>) -> MemOp

Convert domain type T to protobuf representation R.

fn decode(value: &MemOp) -> Result<MemOp<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<MemoryAddress, MemoryAddress> for ProtoSchema<F>

fn encode(value: &MemoryAddress) -> MemoryAddress

Convert domain type T to protobuf representation R.

fn decode(value: &MemoryAddress) -> Result<MemoryAddress>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F: AcirField> ProtoCodec<BrilligOpcode<F>, BrilligOpcode> for ProtoSchema<F>

fn encode(value: &Opcode<F>) -> BrilligOpcode

Convert domain type T to protobuf representation R.

fn decode(value: &BrilligOpcode) -> Result<Opcode<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<Opcode<F>, Opcode> for ProtoSchema<F>

where F: AcirField,

fn encode(value: &Opcode<F>) -> Opcode

Convert domain type T to protobuf representation R.

fn decode(value: &Opcode) -> Result<Opcode<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<OpcodeLocation, OpcodeLocation> for ProtoSchema<F>

fn encode(value: &OpcodeLocation) -> OpcodeLocation

Convert domain type T to protobuf representation R.

fn decode(value: &OpcodeLocation) -> Result<OpcodeLocation>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F: AcirField> ProtoCodec<Program<F>, Program> for ProtoSchema<F>

fn encode(value: &Program<F>) -> Program

Convert domain type T to protobuf representation R.

fn decode(value: &Program) -> Result<Program<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<ValueOrArray, ValueOrArray> for ProtoSchema<F>

fn encode(value: &ValueOrArray) -> ValueOrArray

Convert domain type T to protobuf representation R.

fn decode(value: &ValueOrArray) -> Result<ValueOrArray>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<Witness, Witness> for ProtoSchema<F>

fn encode(value: &Witness) -> Witness

Convert domain type T to protobuf representation R.

fn decode(value: &Witness) -> Result<Witness>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<WitnessMap<F>, WitnessMap> for ProtoSchema<F>

where F: AcirField,

fn encode(value: &WitnessMap<F>) -> WitnessMap

Convert domain type T to protobuf representation R.

fn decode(value: &WitnessMap) -> Result<WitnessMap<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<WitnessStack<F>, WitnessStack> for ProtoSchema<F>

where F: AcirField,

fn encode(value: &WitnessStack<F>) -> WitnessStack

Convert domain type T to protobuf representation R.

fn decode(value: &WitnessStack) -> Result<WitnessStack<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> ProtoCodec<usize, u64> for ProtoSchema<F>

fn encode(value: &usize) -> u64

Convert domain type T to protobuf representation R.

fn decode(value: &u64) -> Result<usize>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_enum(value: &T) -> i32

where R: Into<i32>,

Encode an enum to the i32 value that prost represents it with.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn decode_enum(value: i32) -> Result<T, Report>

where R: TryFrom<i32, Error = UnknownEnumValue>,

Decode the numeric representation of an enum into the domain type. Return an error if the value cannot be recognized.

fn decode_enum_wrap(value: i32, msg: &'static str) -> Result<T, Report>

where R: TryFrom<i32, Error = UnknownEnumValue>,

Decode the numeric representation of an enum, attaching the field name to any errors.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.