Module `Opaque.String`

include Bin_prot.Binable.S

type t

include Bin_prot.Binable.S_only_functions with type t := t

type t

val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader: This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t

val length : t -> int

For performance's concern, we require caller of to_opaque and of_opaque_exn to pass in the buf as the intermediate buffer for bin_prot conversion. These two functions will write bytes into the buffer, but will not resize the buffer. So the caller should prepare big enough buffer for their need.

For of_opaque_exn t, the minimum buffer size should be length t.

For to_opaque the necessary buffer size can be computed using size from Type_class.writer or you can catch the exception Bin_prot.Common.Buffer_short (although the latter is not very reliable because some custom bin_io implementations raise a different exception).

Additional caveat: if the opaque blob is malformed/partial then of_opaque_exn can read past the end of the blob, which can result in:

confusing/non-deterministic error messages (referring to the contents of buf rather than the contents of the blob)
degraded performance (having to read through the buffer just to fail at the end)

val to_opaque : buf:Bin_prot.Common.buf -> 'a -> 'a Bin_prot.Type_class.writer -> t
val of_opaque_exn : buf:Bin_prot.Common.buf -> t -> 'a Bin_prot.Type_class.reader -> 'a