Module Pbrt.Encoder

Encoding protobufs.

Types

type t

A (mutable) encoder.

This encoder can be re-used, see clear.

Error

type error =
  1. | Overflow of string
val error_to_string : error -> string
exception Failure of error

Creator

val create : ?size:int -> unit -> t

Create a new encoder.

val clear : t -> unit

Clear the content of the internal buffer(s), but does not release memory. This makes the encoder ready to encode another message.

  • parameter size

    initial size in bytes

  • since 2.1
val reset : t -> unit

Clears the content and resets internal storage to its initial memory consumption.

This is more costly than clear but can be useful after a very large message was encoded.

  • since 2.1

Convertion

val to_bytes : t -> bytes

Extract the content of the encoder to bytes.

val to_string : t -> string

Extract the content of the encoder to a string. Call this after encoding a message into the encoder.

val write_chunks : (bytes -> int -> int -> unit) -> t -> unit

write_chunks w e calls the write function w (e.g output oc for some output channel oc) on every chunk inside e. The number of chunks is an implementation detail.

  • since 2.1

Encoding Functions

These combinators are used by generated code (or user combinators) to encode a OCaml value into the wire representation of protobufs.

val key : int -> payload_kind -> t -> unit

key k pk e writes a key and a payload kind to e.

val nested : ('a -> t -> unit) -> 'a -> t -> unit

nested f x e applies f x to an encoder for a message nested in e.

val map_entry : encode_key:('a -> t -> unit) -> encode_value:('b -> t -> unit) -> (('a * payload_kind) * ('b * payload_kind)) -> t -> unit
val empty_nested : t -> unit

nested f e encodes a zero length empty message

val int_as_varint : int -> t -> unit

int_as_varint i e encodes i in e with Varint encoding

val int_as_zigzag : int -> t -> unit

int_as_zigzag i e encodes i in e with Varint zigzag encoding

val int32_as_varint : int32 -> t -> unit

int32_as_varint i e encodes i in e with Varint encoding

val int32_as_zigzag : int32 -> t -> unit

int32_as_varint i e encodes i in e with Varint zigzag encoding

val int64_as_varint : int64 -> t -> unit

int64_as_varint i e encodes i in e with Varint encoding

val int64_as_zigzag : int64 -> t -> unit

int64_as_varint i e encodes i in e with Varint zigzag encoding

val int32_as_bits32 : int32 -> t -> unit

int32_as_varint i e encodes i in e with Bits32 encoding

val int64_as_bits64 : int64 -> t -> unit

int64_as_varint i e encodes i in e with Bits64 encoding

val uint32_as_varint : [ `unsigned of int32 ] -> t -> unit
val uint32_as_zigzag : [ `unsigned of int32 ] -> t -> unit
val uint64_as_varint : [ `unsigned of int64 ] -> t -> unit
val uint64_as_zigzag : [ `unsigned of int64 ] -> t -> unit
val uint32_as_bits32 : [ `unsigned of int32 ] -> t -> unit
val uint64_as_bits64 : [ `unsigned of int64 ] -> t -> unit
val bool : bool -> t -> unit

encode b e encodes b in e with Varint encoding

val float_as_bits32 : float -> t -> unit

float_as_bits32 f e encodes f in e with Bits32 encoding

val float_as_bits64 : float -> t -> unit

float_as_bits64 f e encodes f in e with Bits64 encoding

val int_as_bits32 : int -> t -> unit

int_as_bits32 i e encodes i in e with Bits32 encoding TODO : add error handling

val int_as_bits64 : int -> t -> unit

int_as_bits64 i e encodes i in e with Bits64 encoding

val string : string -> t -> unit

string s e encodes s in e

val bytes : bytes -> t -> unit

string s e encodes s in e

val wrapper_double_value : float option -> t -> unit
val wrapper_float_value : float option -> t -> unit
val wrapper_int64_value : int64 option -> t -> unit
val wrapper_int32_value : int32 option -> t -> unit
val wrapper_bool_value : bool option -> t -> unit
val wrapper_string_value : string option -> t -> unit
val wrapper_bytes_value : bytes option -> t -> unit