Module Bin_prot
module Common : sig
type pos = int
Position within buffers
val create_buf : int -> buf
create_buf n creates a buffer of size n.
val assert_pos : pos -> unit
assert_pos pos
Raises
Invalid_argument if position pos is negative.
val check_pos : buf -> pos -> unit
check_pos buf pos
Raises
Buffer_short if position pos exceeds
the length of buffer buf.
val check_next : buf -> pos -> unit
check_next buf pos
Raises
Buffer_short if the next position after
pos exceeds the length of buffer buf.
val safe_get_pos : buf -> pos_ref -> pos
safe_get_pos buf pos_ref
Returns the position referenced by
pos_ref within buffer buf.
Raises
Buffer_short if the position
exceeds the length of the buffer.
val blit_string_buf : ?src_pos:int -> string -> ?dst_pos:int -> buf -> len:int -> unit
blit_string_buf ?src_pos src ?dst_pos dst ~len blits len
bytes of the source string src starting at position src_pos
to buffer dst starting at position dst_pos.
Raises
Invalid_argument if the designated ranges are invalid.
val blit_buf_string : ?src_pos:int -> buf -> ?dst_pos:int -> string -> len:int -> unit
blit_buf_string ?src_pos src ?dst_pos dst ~len blits len
bytes of the source buffer src starting at position src_pos
to string dst starting at position dst_pos.
Raises
Invalid_argument if the designated ranges are invalid.
val blit_buf : ?src_pos:int -> src:buf -> ?dst_pos:int -> dst:buf -> int -> unit
blit_buf ?src_pos ~src ?dst_pos ~dst len blits len bytes of the
source buffer src starting at position src_pos to destination
buffer dst starting at position dst_pos.
Raises
Invalid_argument if the designated ranges are invalid.
exception Buffer_short
Buffer too short for read/write operation
exception No_variant_match
Used internally for backtracking
module ReadError : sig
type t =
| Neg_int8 (* Negative integer was positive or zero *)
| Int_code (* Unknown integer code while reading integer *)
| Int_overflow (* Overflow reading integer *)
| Nat0_code (* Unknown integer code while reading natural number *)
| Nat0_overflow (* Overflow reading natural number *)
| Int32_code (* Unknown integer code while reading 32bit integer *)
| Int64_code (* Unknown integer code while reading 64bit integer *)
| Nativeint_code (* Unknown integer code while reading native integer *)
| Unit_code (* Illegal unit value *)
| Bool_code (* Illegal boolean value *)
| Option_code (* Illegal option code *)
| String_too_long (* String too long *)
| Variant_tag (* Untagged integer encoding for variant tag *)
| Array_too_long (* Array too long *)
| Hashtbl_too_long (* Hashtable too long *)
| Sum_tag of string (* Illegal sum tag for given type *)
| Variant of string (* Illegal variant for given type *)
| Poly_rec_bound of string (* Attempt to read data bound through polymorphic record fields *)
| Variant_wrong_type of string (* Unexpected attempt to read variant with given non-variant type *)
| Silly_type of string (*
Silly_type type_name indicates unhandled but silly case
where a type of the sort type 'a type_name = 'a is used
with a polymorphic variant as type parameter and included
in another polymorphic variant type. *)| Empty_type of string (* Attempt to read data that corresponds to an empty type. *)
val to_string : t -> string
to_string err
Returns string representation of read error
err.
end
exception Read_error of ReadError.t * pos
ReadError (err, err_pos)
exception Poly_rec_write of string
PolyRecWrite type gets raised when the user attempts to write or
estimate the size of a value of a type that is bound through a
polymorphic record field in type definition type.
exception Empty_type of string
EmptyType gets raised when the user attempts to write or estimate
the size of a value of an empty type, which would not make sense.
val raise_read_error : ReadError.t -> pos -> 'a
raise_read_error err pos
val raise_variant_wrong_type : string -> pos -> 'a
raise_variant_wrong_type name pos
val raise_concurrent_modification : string -> 'a
raise_concurrent_modification loc
Raises
Failure if a binary writer
detects a concurrent change to the underlying data structure.
val array_bound_error : unit -> 'a
array_bound_error ()
type vec = vec64
type mat = mat64
val variant_of_int : int -> TODO: a
val unsafe_blit_buf : src_pos:int -> src:buf -> dst_pos:int -> dst:buf -> len:int -> unit
val unsafe_blit_string_buf : src_pos:int -> string -> dst_pos:int -> buf -> len:int -> unit
val unsafe_blit_buf_string : src_pos:int -> buf -> dst_pos:int -> string -> len:int -> unit
val unsafe_blit_float_array_buf : src_pos:int -> float array -> dst_pos:int -> buf -> len:int -> unit
val unsafe_blit_buf_float_array : src_pos:int -> buf -> dst_pos:int -> float array -> len:int -> unit
end
module Nat0 : sig
type t = int
val of_int : int -> t
of_int n converts integer n to a natural number.
Raises
Failure if n is negative.
val unsafe_of_int : int -> t
end
module Read : sig
type 'a reader = Common.buf -> pos_ref:Common.pos_ref -> 'a
type ('a, 'b) reader1 = 'a reader -> 'b reader
type ('a, 'b, 'c) reader2 = 'a reader -> ('b, 'c) reader1
type ('a, 'b, 'c, 'd) reader3 = 'a reader -> ('b, 'c, 'd) reader2
val bin_read_unit : unit reader
val bin_read_bool : bool reader
val bin_read_string : string reader
val bin_read_char : char reader
val bin_read_int : int reader
val bin_read_nat0 : Nat0.t reader
val bin_read_float : float reader
val bin_read_int32 : int32 reader
val bin_read_int64 : int64 reader
val bin_read_nativeint : nativeint reader
val bin_read_lazy : ('a, 'a lazy_t) reader1
val bin_read_option : ('a, 'a option) reader1
val bin_read_pair : ('a, 'b, ('a * 'b)) reader2
val bin_read_triple : ('a, 'b, 'c, ('a * 'b * 'c)) reader3
val bin_read_list : ('a, 'a list) reader1
val bin_read_array : ('a, 'a array) reader1
val bin_read_float32_vec : Common.vec32 reader
val bin_read_float64_vec : Common.vec64 reader
val bin_read_vec : Common.vec reader
val bin_read_float32_mat : Common.mat32 reader
val bin_read_float64_mat : Common.mat64 reader
val bin_read_mat : Common.mat reader
val bin_read_bigstring : Common.buf reader
val bin_read_float_array : float array reader
val bin_read_variant_int : int reader
val bin_read_variant_tag : TODO: a reader
val bin_read_int_8bit : int reader
val bin_read_int_16bit : int reader
val bin_read_int_32bit : int reader
val bin_read_int_64bit : int reader
val bin_read_int64_bits : int64 reader
val bin_read_network16_int : int reader
val bin_read_network32_int : int reader
val bin_read_network32_int32 : int32 reader
val bin_read_network64_int : int reader
val bin_read_network64_int64 : int64 reader
end
module Size : sig
type 'a sizer = 'a -> int
type ('a, 'b) sizer1 = 'a sizer -> 'b sizer
type ('a, 'b, 'c) sizer2 = 'a sizer -> ('b, 'c) sizer1
type ('a, 'b, 'c, 'd) sizer3 = 'a sizer -> ('b, 'c, 'd) sizer2
val bin_size_unit : unit sizer
val bin_size_bool : bool sizer
val bin_size_string : string sizer
val bin_size_char : char sizer
val bin_size_int : int sizer
val bin_size_float : float sizer
val bin_size_int32 : int32 sizer
val bin_size_int64 : int64 sizer
val bin_size_nativeint : nativeint sizer
val bin_size_nat0 : Nat0.t sizer
val bin_size_lazy_t : ('a, 'a lazy_t) sizer1
val bin_size_lazy : ('a, 'a lazy_t) sizer1
val bin_size_option : ('a, 'a option) sizer1
val bin_size_pair : ('a, 'b, ('a * 'b)) sizer2
val bin_size_triple : ('a, 'b, 'c, ('a * 'b * 'c)) sizer3
val bin_size_list : ('a, 'a list) sizer1
val bin_size_array : ('a, 'a array) sizer1
val bin_size_float32_vec : Common.vec32 sizer
val bin_size_float64_vec : Common.vec64 sizer
val bin_size_vec : Common.vec sizer
val bin_size_float32_mat : Common.mat32 sizer
val bin_size_float64_mat : Common.mat64 sizer
val bin_size_mat : Common.mat sizer
val bin_size_bigstring : Common.buf sizer
val bin_size_float_array : float array sizer
val bin_size_variant_tag : TODO: a sizer
val bin_size_int_8bit : int sizer
val bin_size_int_16bit : int sizer
val bin_size_int_32bit : int sizer
val bin_size_int_64bit : int sizer
val bin_size_int64_bits : int64 sizer
val bin_size_network16_int : int sizer
val bin_size_network32_int : int sizer
val bin_size_network32_int32 : int32 sizer
val bin_size_network64_int : int sizer
val bin_size_network64_int64 : int64 sizer
val bin_size_array_no_length : ('a, 'a array) sizer1
end
module Write : sig
type 'a writer = Common.buf -> pos:Common.pos -> 'a -> Common.pos
type ('a, 'b) writer1 = 'a writer -> 'b writer
type ('a, 'b, 'c) writer2 = 'a writer -> ('b, 'c) writer1
type ('a, 'b, 'c, 'd) writer3 = 'a writer -> ('b, 'c, 'd) writer2
val bin_write_unit : unit writer
val bin_write_bool : bool writer
val bin_write_string : string writer
val bin_write_char : char writer
val bin_write_int : int writer
val bin_write_nat0 : Nat0.t writer
val bin_write_float : float writer
val bin_write_int32 : int32 writer
val bin_write_int64 : int64 writer
val bin_write_nativeint : nativeint writer
val bin_write_lazy : ('a, 'a lazy_t) writer1
val bin_write_option : ('a, 'a option) writer1
val bin_write_pair : ('a, 'b, ('a * 'b)) writer2
val bin_write_triple : ('a, 'b, 'c, ('a * 'b * 'c)) writer3
val bin_write_list : ('a, 'a list) writer1
val bin_write_array : ('a, 'a array) writer1
val bin_write_float32_vec : Common.vec32 writer
val bin_write_float64_vec : Common.vec64 writer
val bin_write_vec : Common.vec writer
val bin_write_float32_mat : Common.mat32 writer
val bin_write_float64_mat : Common.mat64 writer
val bin_write_mat : Common.mat writer
val bin_write_bigstring : Common.buf writer
val bin_write_float_array : float array writer
val bin_write_variant_tag : TODO: a writer
val bin_write_int_8bit : int writer
val bin_write_int_16bit : int writer
val bin_write_int_32bit : int writer
val bin_write_int_64bit : int writer
val bin_write_int64_bits : int64 writer
val bin_write_network16_int : int writer
val bin_write_network32_int : int writer
val bin_write_network32_int32 : int32 writer
val bin_write_network64_int : int writer
val bin_write_network64_int64 : int64 writer
val bin_write_array_no_length : ('a, 'a array) writer1
end
module Type_class : sig
type 'a writer = {
size : 'a Size.sizer;
write : 'a Write.writer;
}
type 'a reader = {
read : 'a Read.reader;
vtag_read : int -> 'a Read.reader;
}
type 'a t = {
writer : 'a writer;
reader : 'a reader;
}
type 'a writer0 = 'a writer
type 'a reader0 = 'a reader
type 'a t0 = 'a t
module S1 : sig
type ('a, 'b) writer = 'a writer0 -> 'b writer0
type ('a, 'b) reader = 'a reader0 -> 'b reader0
type ('a, 'b) t = 'a t0 -> 'b t0
end
module S2 : sig
type ('a, 'b, 'c) writer = 'a writer0 -> ('b, 'c) S1.writer
type ('a, 'b, 'c) reader = 'a reader0 -> ('b, 'c) S1.reader
type ('a, 'b, 'c) t = 'a t0 -> ('b, 'c) S1.t
end
module S3 : sig
type ('a, 'b, 'c, 'd) writer = 'a writer0 -> ('b, 'c, 'd) S2.writer
type ('a, 'b, 'c, 'd) reader = 'a reader0 -> ('b, 'c, 'd) S2.reader
type ('a, 'b, 'c, 'd) t = 'a t0 -> ('b, 'c, 'd) S2.t
end
val bin_writer_unit : unit writer
val bin_reader_unit : unit reader
val bin_unit : unit t
val bin_writer_bool : bool writer
val bin_reader_bool : bool reader
val bin_bool : bool t
val bin_writer_string : string writer
val bin_reader_string : string reader
val bin_string : string t
val bin_writer_char : char writer
val bin_reader_char : char reader
val bin_char : char t
val bin_writer_int : int writer
val bin_reader_int : int reader
val bin_int : int t
val bin_writer_float : float writer
val bin_reader_float : float reader
val bin_float : float t
val bin_writer_int32 : int32 writer
val bin_reader_int32 : int32 reader
val bin_int32 : int32 t
val bin_writer_int64 : int64 writer
val bin_reader_int64 : int64 reader
val bin_int64 : int64 t
val bin_writer_nativeint : nativeint writer
val bin_reader_nativeint : nativeint reader
val bin_nativeint : nativeint t
val bin_writer_nat0 : Nat0.t writer
val bin_reader_nat0 : Nat0.t reader
val bin_nat0 : Nat0.t t
val bin_writer_lazy : ('a, 'a lazy_t) S1.writer
val bin_reader_lazy : ('a, 'a lazy_t) S1.reader
val bin_lazy : ('a, 'a lazy_t) S1.t
val bin_writer_option : ('a, 'a option) S1.writer
val bin_reader_option : ('a, 'a option) S1.reader
val bin_option : ('a, 'a option) S1.t
val bin_writer_pair : ('a, 'b, ('a * 'b)) S2.writer
val bin_reader_pair : ('a, 'b, ('a * 'b)) S2.reader
val bin_pair : ('a, 'b, ('a * 'b)) S2.t
val bin_writer_triple : ('a, 'b, 'c, ('a * 'b * 'c)) S3.writer
val bin_reader_triple : ('a, 'b, 'c, ('a * 'b * 'c)) S3.reader
val bin_triple : ('a, 'b, 'c, ('a * 'b * 'c)) S3.t
val bin_writer_list : ('a, 'a list) S1.writer
val bin_reader_list : ('a, 'a list) S1.reader
val bin_list : ('a, 'a list) S1.t
val bin_writer_array : ('a, 'a array) S1.writer
val bin_reader_array : ('a, 'a array) S1.reader
val bin_array : ('a, 'a array) S1.t
val bin_writer_float32_vec : Common.vec32 writer
val bin_reader_float32_vec : Common.vec32 reader
val bin_float32_vec : Common.vec32 t
val bin_writer_float64_vec : Common.vec64 writer
val bin_reader_float64_vec : Common.vec64 reader
val bin_float64_vec : Common.vec64 t
val bin_writer_vec : Common.vec writer
val bin_reader_vec : Common.vec reader
val bin_vec : Common.vec t
val bin_writer_float32_mat : Common.mat32 writer
val bin_reader_float32_mat : Common.mat32 reader
val bin_float32_mat : Common.mat32 t
val bin_writer_float64_mat : Common.mat64 writer
val bin_reader_float64_mat : Common.mat64 reader
val bin_float64_mat : Common.mat64 t
val bin_writer_mat : Common.mat writer
val bin_reader_mat : Common.mat reader
val bin_mat : Common.mat t
val bin_writer_bigstring : Common.buf writer
val bin_reader_bigstring : Common.buf reader
val bin_bigstring : Common.buf t
val bin_writer_float_array : float array writer
val bin_reader_float_array : float array reader
val bin_float_array : float array t
val bin_writer_variant_tag : TODO: a writer
val bin_reader_variant_tag : TODO: a reader
val bin_variant_tag : TODO: a t
val bin_writer_int_8bit : int writer
val bin_reader_int_8bit : int reader
val bin_int_8bit : int t
val bin_writer_int_16bit : int writer
val bin_reader_int_16bit : int reader
val bin_int_16bit : int t
val bin_writer_int_32bit : int writer
val bin_reader_int_32bit : int reader
val bin_int_32bit : int t
val bin_writer_int_64bit : int writer
val bin_reader_int_64bit : int reader
val bin_int_64bit : int t
val bin_writer_int64_bits : int64 writer
val bin_reader_int64_bits : int64 reader
val bin_int64_bits : int64 t
val bin_writer_network16_int : int writer
val bin_reader_network16_int : int reader
val bin_network16_int : int t
val bin_writer_network32_int : int writer
val bin_reader_network32_int : int reader
val bin_network32_int : int t
val bin_writer_network32_int32 : int32 writer
val bin_reader_network32_int32 : int32 reader
val bin_network32_int32 : int32 t
val bin_writer_network64_int : int writer
val bin_reader_network64_int : int reader
val bin_network64_int : int t
val bin_writer_network64_int64 : int64 writer
val bin_reader_network64_int64 : int64 reader
val bin_network64_int64 : int64 t
val bin_writer_array_no_length : ('a, 'a array) S1.writer
val cnv_writer : 'a -> 'b -> 'b writer -> 'a writer
val cnv_reader : 'b -> 'a -> 'b reader -> 'a reader
val cnv : 'a -> 'b -> 'b -> 'a -> 'b t -> 'a t
end
module Binable : sig
module type S = sig
type t
val bin_size_t : t Size.sizer
val bin_write_t : t Write.writer
val bin_read_t : t Read.reader
val __bin_read_t__ : int -> t Read.reader
val bin_writer_t : t Type_class.writer
val bin_reader_t : t Type_class.reader
val bin_t : t Type_class.t
end
module type S1 = sig
type 'a t
val bin_size_t : ('a, 'a t) Size.sizer1
val bin_write_t : ('a, 'a t) Write.writer1
val bin_read_t : ('a, 'a t) Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Read.reader1
val bin_writer_t : ('a, 'a t) Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Type_class.S1.reader
val bin_t : ('a, 'a t) Type_class.S1.t
end
module type S2 = sig
type ('a, 'b) t
val bin_size_t : ('a, 'b, ('a, 'b) t) Size.sizer2
val bin_write_t : ('a, 'b, ('a, 'b) t) Write.writer2
val bin_read_t : ('a, 'b, ('a, 'b) t) Read.reader2
val __bin_read_t__ : ('a, 'b, int -> ('a, 'b) t) Read.reader2
val bin_writer_t : ('a, 'b, ('a, 'b) t) Type_class.S2.writer
val bin_reader_t : ('a, 'b, ('a, 'b) t) Type_class.S2.reader
val bin_t : ('a, 'b, ('a, 'b) t) Type_class.S2.t
end
end
module Std : sig
type 'a sizer = 'a -> int
type ('a, 'b) sizer1 = 'a sizer -> 'b sizer
type ('a, 'b, 'c) sizer2 = 'a sizer -> ('b, 'c) sizer1
type ('a, 'b, 'c, 'd) sizer3 = 'a sizer -> ('b, 'c, 'd) sizer2
val bin_size_unit : unit sizer
val bin_size_bool : bool sizer
val bin_size_string : string sizer
val bin_size_char : char sizer
val bin_size_int : int sizer
val bin_size_float : float sizer
val bin_size_int32 : int32 sizer
val bin_size_int64 : int64 sizer
val bin_size_nativeint : nativeint sizer
val bin_size_nat0 : Nat0.t sizer
val bin_size_lazy_t : ('a, 'a lazy_t) sizer1
val bin_size_lazy : ('a, 'a lazy_t) sizer1
val bin_size_option : ('a, 'a option) sizer1
val bin_size_pair : ('a, 'b, ('a * 'b)) sizer2
val bin_size_triple : ('a, 'b, 'c, ('a * 'b * 'c)) sizer3
val bin_size_list : ('a, 'a list) sizer1
val bin_size_array : ('a, 'a array) sizer1
val bin_size_float32_vec : Common.vec32 sizer
val bin_size_float64_vec : Common.vec64 sizer
val bin_size_vec : Common.vec sizer
val bin_size_float32_mat : Common.mat32 sizer
val bin_size_float64_mat : Common.mat64 sizer
val bin_size_mat : Common.mat sizer
val bin_size_bigstring : Common.buf sizer
val bin_size_float_array : float array sizer
val bin_size_variant_tag : TODO: a sizer
val bin_size_int_8bit : int sizer
val bin_size_int_16bit : int sizer
val bin_size_int_32bit : int sizer
val bin_size_int_64bit : int sizer
val bin_size_int64_bits : int64 sizer
val bin_size_network16_int : int sizer
val bin_size_network32_int : int sizer
val bin_size_network32_int32 : int32 sizer
val bin_size_network64_int : int sizer
val bin_size_network64_int64 : int64 sizer
val bin_size_array_no_length : ('a, 'a array) sizer1
val bin_unit : unit Type_class.t
val bin_writer_unit : unit Type_class.writer
val bin_write_unit : unit Write.writer
val bin_reader_unit : unit Type_class.reader
val bin_read_unit : unit Read.reader
val bin_bool : bool Type_class.t
val bin_writer_bool : bool Type_class.writer
val bin_write_bool : bool Write.writer
val bin_reader_bool : bool Type_class.reader
val bin_read_bool : bool Read.reader
val bin_string : string Type_class.t
val bin_writer_string : string Type_class.writer
val bin_write_string : string Write.writer
val bin_reader_string : string Type_class.reader
val bin_read_string : string Read.reader
val bin_char : char Type_class.t
val bin_writer_char : char Type_class.writer
val bin_write_char : char Write.writer
val bin_reader_char : char Type_class.reader
val bin_read_char : char Read.reader
val bin_int : int Type_class.t
val bin_writer_int : int Type_class.writer
val bin_write_int : int Write.writer
val bin_reader_int : int Type_class.reader
val bin_read_int : int Read.reader
val bin_float : float Type_class.t
val bin_writer_float : float Type_class.writer
val bin_write_float : float Write.writer
val bin_reader_float : float Type_class.reader
val bin_read_float : float Read.reader
val bin_int32 : int32 Type_class.t
val bin_writer_int32 : int32 Type_class.writer
val bin_write_int32 : int32 Write.writer
val bin_reader_int32 : int32 Type_class.reader
val bin_read_int32 : int32 Read.reader
val bin_int64 : int64 Type_class.t
val bin_writer_int64 : int64 Type_class.writer
val bin_write_int64 : int64 Write.writer
val bin_reader_int64 : int64 Type_class.reader
val bin_read_int64 : int64 Read.reader
val bin_nativeint : nativeint Type_class.t
val bin_writer_nativeint : nativeint Type_class.writer
val bin_write_nativeint : nativeint Write.writer
val bin_reader_nativeint : nativeint Type_class.reader
val bin_read_nativeint : nativeint Read.reader
val bin_lazy_t : ('a, 'a lazy_t) Type_class.S1.t
val bin_writer_lazy_t : ('a, 'a lazy_t) Type_class.S1.writer
val bin_write_lazy_t : ('a, 'a lazy_t) Write.writer1
val bin_reader_lazy_t : ('a, 'a lazy_t) Type_class.S1.reader
val bin_read_lazy_t : ('a, 'a lazy_t) Read.reader1
val bin_lazy : ('a, 'a lazy_t) Type_class.S1.t
val bin_writer_lazy : ('a, 'a lazy_t) Type_class.S1.writer
val bin_write_lazy : ('a, 'a lazy_t) Write.writer1
val bin_reader_lazy : ('a, 'a lazy_t) Type_class.S1.reader
val bin_read_lazy : ('a, 'a lazy_t) Read.reader1
val bin_option : ('a, 'a option) Type_class.S1.t
val bin_writer_option : ('a, 'a option) Type_class.S1.writer
val bin_write_option : ('a, 'a option) Write.writer1
val bin_reader_option : ('a, 'a option) Type_class.S1.reader
val bin_read_option : ('a, 'a option) Read.reader1
val bin_list : ('a, 'a list) Type_class.S1.t
val bin_writer_list : ('a, 'a list) Type_class.S1.writer
val bin_write_list : ('a, 'a list) Write.writer1
val bin_reader_list : ('a, 'a list) Type_class.S1.reader
val bin_read_list : ('a, 'a list) Read.reader1
val bin_array : ('a, 'a array) Type_class.S1.t
val bin_writer_array : ('a, 'a array) Type_class.S1.writer
val bin_write_array : ('a, 'a array) Write.writer1
val bin_reader_array : ('a, 'a array) Type_class.S1.reader
val bin_read_array : ('a, 'a array) Read.reader1
val bin_bigstring : Common.buf Type_class.t
val bin_writer_bigstring : Common.buf Type_class.writer
val bin_write_bigstring : Common.buf Write.writer
val bin_reader_bigstring : Common.buf Type_class.reader
val bin_read_bigstring : Common.buf Read.reader
val bin_mat : Common.mat Type_class.t
val bin_writer_mat : Common.mat Type_class.writer
val bin_write_mat : Common.mat Write.writer
val bin_reader_mat : Common.mat Type_class.reader
val bin_read_mat : Common.mat Read.reader
val bin_float32_mat : Common.mat32 Type_class.t
val bin_writer_float32_mat : Common.mat32 Type_class.writer
val bin_write_float32_mat : Common.mat32 Write.writer
val bin_reader_float32_mat : Common.mat32 Type_class.reader
val bin_read_float32_mat : Common.mat32 Read.reader
val bin_float64_mat : Common.mat64 Type_class.t
val bin_writer_float64_mat : Common.mat64 Type_class.writer
val bin_write_float64_mat : Common.mat64 Write.writer
val bin_reader_float64_mat : Common.mat64 Type_class.reader
val bin_read_float64_mat : Common.mat64 Read.reader
val bin_vec : Common.vec Type_class.t
val bin_writer_vec : Common.vec Type_class.writer
val bin_write_vec : Common.vec Write.writer
val bin_reader_vec : Common.vec Type_class.reader
val bin_read_vec : Common.vec Read.reader
val bin_float32_vec : Common.vec32 Type_class.t
val bin_writer_float32_vec : Common.vec32 Type_class.writer
val bin_write_float32_vec : Common.vec32 Write.writer
val bin_reader_float32_vec : Common.vec32 Type_class.reader
val bin_read_float32_vec : Common.vec32 Read.reader
val bin_float64_vec : Common.vec64 Type_class.t
val bin_writer_float64_vec : Common.vec64 Type_class.writer
val bin_write_float64_vec : Common.vec64 Write.writer
val bin_reader_float64_vec : Common.vec64 Type_class.reader
val bin_read_float64_vec : Common.vec64 Read.reader
end
module Utils : sig
val bin_dump : ?header:bool -> 'a Type_class.writer -> 'a -> Common.buf
bin_dump ?header writer v uses writer to first compute the size of
v in the binary protocol, then allocates a buffer of exactly this
size, and then writes out the value. If header is true, the
size of the resulting binary string will be prefixed as a signed
64bit integer.
Returns the buffer containing the written out value.
header default =
false
Raises
Failure if the size of the value changes during writing,
and any other exceptions that the binary writer in writer can raise.
val bin_read_stream : ?max_size:int -> read:Common.buf -> pos:int -> len:int -> unit -> 'a Type_class.reader -> 'a
bin_read_stream ?max_size ~read reader reads binary protocol data
from a stream as generated by the read function, which places
data of a given length into a given buffer. Requires a header.
The reader type class will be used for conversion to OCaml-values.
max_size = nothing
Raises
Failure if the size of the value disagrees with the one
specified in the header, and any other exceptions that the binary
reader associated with reader can raise.
Raises
Failure if the size reported in the data header is longer than
max_size.
module type Make_binable_spec = sig
module Binable : Binable.S
type t
val to_binable : t -> Binable.t
val of_binable : Binable.t -> t
end
module type Make_binable1_spec = sig
module Binable : Binable.S1
type 'a t
val to_binable : 'a t -> 'a Binable.t
val of_binable : 'a Binable.t -> 'a t
end
module type Make_binable2_spec = sig
module Binable : Binable.S2
type ('a, 'b) t
val to_binable : ('a, 'b) t -> ('a, 'b) Binable.t
val of_binable : ('a, 'b) Binable.t -> ('a, 'b) t
end
module type Make_iterable_binable_spec = sig
type t
type el
type acc
val module_name : string option
val length : t -> int
val iter : t -> f:el -> unit -> unit
val init : int -> acc
val insert : acc -> el -> int -> acc
val finish : acc -> t
val bin_size_el : el Size.sizer
val bin_write_el : el Write.writer
val bin_read_el : el Read.reader
end
module type Make_iterable_binable1_spec = sig
type 'a t
type 'a el
type 'a acc
val module_name : string option
val length : 'a t -> int
val iter : 'a t -> f:'a el -> unit -> unit
val init : int -> 'a acc
val insert : 'a acc -> 'a el -> int -> 'a acc
val finish : 'a acc -> 'a t
val bin_size_el : ('a, 'a el) Size.sizer1
val bin_write_el : ('a, 'a el) Write.writer1
val bin_read_el : ('a, 'a el) Read.reader1
end
module type Make_iterable_binable2_spec = sig
type ('a, 'b) t
type ('a, 'b) el
type ('a, 'b) acc
val module_name : string option
val length : ('a, 'b) t -> int
val iter : ('a, 'b) t -> f:('a, 'b) el -> unit -> unit
val init : int -> ('a, 'b) acc
val insert : ('a, 'b) acc -> ('a, 'b) el -> int -> ('a, 'b) acc
val finish : ('a, 'b) acc -> ('a, 'b) t
val bin_size_el : ('a, 'b, ('a, 'b) el) Size.sizer2
val bin_write_el : ('a, 'b, ('a, 'b) el) Write.writer2
val bin_read_el : ('a, 'b, ('a, 'b) el) Read.reader2
end
end