Struct Base128Fmt 

pub struct Base128Fmt<const MINIMAL: bool = true>;

Trait Implementations

impl<const MINIMAL: bool> ByteLen<u64> for Base128Fmt<MINIMAL>

exec fn length(&self, v: &UInt) -> len : usize

fn exec_inv(&self) -> bool

impl<const MINIMAL: bool> Clone for Base128Fmt<MINIMAL>

fn clone(&self) -> Base128Fmt<MINIMAL>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const MINIMAL: bool> Consistency for Base128Fmt<MINIMAL>

open(crate) spec fn consistent(&self, v: Self::Val) -> bool

type Val = u64

The type of values whose consistency is being checked.

impl DerOrd<u64> for Base128Fmt<true>

proof fn lemma_der_serialize_len(&self, value: u64)

open spec fn der_remaining(&self, value: u64, state: Base128DerState) -> Seq<u8>

{ self.spec_serialize(value).skip(state.pos as int) }

open spec fn der_state_valid(&self, value: u64, state: Base128DerState) -> bool

{
    &&& state.pos <= state.len
    &&& state.len <= state.bytes@.len()
    &&& state.len == self.spec_serialize(value).len()
    &&& state.bytes@.take(state.len as int) == self.spec_serialize(value)

}

exec fn der_start(&self, i: &u64) -> state : Base128DerState

exec fn der_next(&self, i: &u64, state: &mut Base128DerState) -> next : Option<u8>

fn der_leq(&self, left: &T, right: &T) -> bool

impl DerState for Base128Fmt<true>

type State = Base128DerState

impl<const MINIMAL: bool> EquivSerializers for Base128Fmt<MINIMAL>

proof fn lemma_serialize_equiv_on_empty(&self, v: Self::SVal)

fn equiv_inv(&self) -> bool

impl<const MINIMAL: bool> EquivSerializersGeneral for Base128Fmt<MINIMAL>

proof fn lemma_serialize_equiv(&self, v: Self::SVal, obuf: Seq<u8>)

fn equiv_general_inv(&self) -> bool

impl<const MINIMAL: bool> GoodSerializer for Base128Fmt<MINIMAL>

proof fn lemma_serialize_len(&self, v: Self::SVal)

fn serialize_inv(&self) -> bool

impl<const MINIMAL: bool> NoLookAhead for Base128Fmt<MINIMAL>

proof fn lemma_no_lookahead(&self, i1: Seq<u8>, i2: Seq<u8>)

fn no_lookahead_inv(&self) -> bool

fn corollary_non_extensible(&self, i1: Seq<u8>, i2: Seq<u8>)

impl NonMalleable for Base128Fmt<true>

proof fn lemma_parse_non_malleable(&self, buf1: Seq<u8>, buf2: Seq<u8>)

fn nonmal_inv(&self) -> bool

impl<const MINIMAL: bool> NonTailFmt for Base128Fmt<MINIMAL>

proof fn lemma_serialize_dps_prepend(&self, v: Self::SValue, obuf: Seq<u8>)

proof fn lemma_serialize_dps_len(&self, v: Self::SValue, obuf: Seq<u8>)

fn serialize_dps_inv(&self) -> bool

impl<const MINIMAL: bool> Parser<&[u8]> for Base128Fmt<MINIMAL>

exec fn parse(&self, ibuf: &&[u8]) -> PResult<Self::PT>

type PT = u64

Executable value returned by this parser.

fn exec_inv(&self) -> bool

impl<const MINIMAL: bool> Prepare<u64> for Base128Fmt<MINIMAL>

exec fn prepare(&self, v: &UInt) -> checked : Result<usize, PreSerializeError>

fn exec_inv(&self) -> bool

impl<const MINIMAL: bool> Productive for Base128Fmt<MINIMAL>

proof fn lemma_productive(&self, s: Seq<u8>)

fn productive_inv(&self) -> bool

impl<const MINIMAL: bool> SPRoundTripDps for Base128Fmt<MINIMAL>

proof fn theorem_serialize_dps_parse_roundtrip(&self, v: Self::T, obuf: Seq<u8>)

fn unambiguous(&self) -> bool

impl<const MINIMAL: bool> SafeParser for Base128Fmt<MINIMAL>

proof fn lemma_parse_safe(&self, ibuf: Seq<u8>)

fn safe_inv(&self) -> bool

impl<Output: OutputBuf, const MINIMAL: bool> Serializer<Output, u64> for Base128Fmt<MINIMAL>

exec fn serialize_into(&self, v: &UInt, obuf: &mut Output)

fn exec_inv(&self) -> bool

impl SoundParser for Base128Fmt<true>

proof fn lemma_parse_sound_consumption(&self, ibuf: Seq<u8>)

proof fn lemma_parse_sound_value(&self, ibuf: Seq<u8>)

fn sound_inv(&self) -> bool

impl<const MINIMAL: bool> SpecByteLen for Base128Fmt<MINIMAL>

open(crate) spec fn byte_len(&self, v: Self::T) -> nat

type T = u64

The type of values whose byte length is being computed.

impl<const MINIMAL: bool> SpecParser for Base128Fmt<MINIMAL>

open(crate) spec fn spec_parse(&self, ibuf: Seq<u8>) -> Option<(int, Self::PVal)>

type PVal = u64

The type of parsed values.

impl<const MINIMAL: bool> SpecSerializer for Base128Fmt<MINIMAL>

open(crate) spec fn spec_serialize(&self, v: Self::SVal) -> Seq<u8>

type SVal = u64

The type of values to be serialized.

impl<const MINIMAL: bool> SpecSerializerDps for Base128Fmt<MINIMAL>

open(crate) spec fn spec_serialize_dps(&self, v: Self::SValue, obuf: Seq<u8>) -> Seq<u8>

type SValue = u64

The type of values to be serialized.

impl<const MINIMAL: bool> Copy for Base128Fmt<MINIMAL>