protobin

Types

BytePos

pub type BytePos =
  Int

Config

</>

pub type Config {
  Config(ignore_groups: Bool)
}

Constructors

```
Config(ignore_groups: Bool)
```
Arguments

ignore_groups

Whether or not to ignore groups and allow parsing to succeed if one is encountered. If ignored, all nested fields will be treated as if they were not nested.

Defaults to False.

DecodeResult

</>

pub type DecodeResult(t) =
  Result(t, ParseError)

ParseError

</>

pub type ParseError {
  UnknownWireType(Int, pos: Int)
  InvalidVarInt(leftover_bits: BitArray, acc: BitArray, pos: Int)
  InvalidFixed(size: Int, bits: BitArray, pos: Int)
  InvalidLen(len: Int, value_bits: BitArray, pos: Int)
  UnableToDecode(List(decode.DecodeError))
  UnexpectedGroup(wire_type: @internal WireType, pos: Int)
}

Constructors

```
UnknownWireType(Int, pos: Int)
```

InvalidVarInt(leftover_bits: BitArray, acc: BitArray, pos: Int)

InvalidFixed(size: Int, bits: BitArray, pos: Int)

InvalidLen(len: Int, value_bits: BitArray, pos: Int)

UnableToDecode(List(decode.DecodeError))

UnexpectedGroup(wire_type: @internal WireType, pos: Int)

Parsed

</>

pub type Parsed(t) {
  Parsed(value: t, rest: BitArray, pos: Int)
}

Constructors

Parsed(value: t, rest: BitArray, pos: Int)

ValueParser

</>

pub type ValueParser =
  fn(BitArray, Int) -> Result(Parsed(BitArray), ParseError)

ValueResult

</>

pub type ValueResult =
  Result(Parsed(BitArray), ParseError)

Values

decode_bool

</>

pub fn decode_bool() -> decode.Decoder(Bool)

decode_fixed

</>

pub fn decode_fixed(size: Int) -> decode.Decoder(Int)

decode_multiple

</>

pub fn decode_multiple(
  of decoder: decode.Decoder(t),
  using parser: fn(BitArray, Int) -> Result(
    Parsed(BitArray),
    ParseError,
  ),
) -> decode.Decoder(List(t))

Decode a repeated field that may be either packed or expanded.

If it is impossible for a field to be packed (ie because it is encoded as a LEN) and therefore there is no ValueParser for it, then use the stdlib’s decode.list() instead.

decode_protobuf

</>

pub fn decode_protobuf(
  using decoder: fn() -> decode.Decoder(t),
  named name: String,
  default default: t,
) -> decode.Decoder(t)

decode_string

</>

pub fn decode_string() -> decode.Decoder(String)

decode_uint

</>

pub fn decode_uint() -> decode.Decoder(Int)

parse

</>

pub fn parse(
  from bits: BitArray,
  using decoder: decode.Decoder(t),
) -> Result(Parsed(t), ParseError)

parse_varint

</>

pub fn parse_varint(
  bits: BitArray,
  pos: Int,
) -> Result(Parsed(BitArray), ParseError)

Reads the bits from a varint and parses them a BitArray. The returned bits can be parsed as a uint.

For a decoder that does this, use decoders.uint().

The continuation bits are not included, so the value’s bit size will be a multiple of 7.

parse_with_config

</>

pub fn parse_with_config(
  from bits: BitArray,
  using decoder: decode.Decoder(t),
  config config: Config,
) -> Result(Parsed(t), ParseError)

read_fixed

</>

pub fn read_fixed(
  size: Int,
) -> fn(BitArray, Int) -> Result(Parsed(BitArray), ParseError)

Size is in bits, usually either 32 or 64.

Size must be a multiple of 8, or the returned position will be incorrect.

read_varint

</>

pub fn read_varint(
  bits: BitArray,
  pos: Int,
) -> Result(Parsed(BitArray), ParseError)

Reads the bits from a varint and returns all of them. They cannot be parsed as a uint.

Specifically, the continuation bits are included, so the value’s bit size will be a multiple of 8.

Constructors

Arguments

Constructors

Constructors