Module Core.Iobuf_debug.Make

Make builds a module that is like Iobuf, except that the module also has some controls for whether the various Iobuf functions do invariant checking and/or show debug messages. Initially, the bool ref's are true.

The performance of the functions in the module resulting from Make can be much worse than that of a plain Iobuf, even with all the controls set to false.

Parameters

Signature

We use module type of struct include Iobuf end rather than module type of Iobuf so that the debugging functions work on normal Iobufs.

include module type of sig ... end
type seek = Iobuf_intf.seek
val sexp_of_seek : seek ‑> Base.Sexp.t
type no_seek = Iobuf_intf.no_seek
val sexp_of_no_seek : no_seek ‑> Base.Sexp.t
type ('data_perm_read_write, 'seek_permission) t = ('data_perm_read_write, 'seek_permission) Core__Iobuf.t
val create : len:int ‑> ('a, 'b) t
val of_bigstring : ?⁠pos:int ‑> ?⁠len:int ‑> Core__.Import.Bigstring.t ‑> ([< Core__.Import.read_write ], 'a) t
val of_string : string ‑> ('a, 'b) t
val sub_shared : ?⁠pos:int ‑> ?⁠len:int ‑> ('d, 'a) t ‑> ('d, 'b) t
val set_bounds_and_buffer : src:([> Core__.Import.write ] as a, 'b) t ‑> dst:('a, seek) t ‑> unit
val set_bounds_and_buffer_sub : pos:int ‑> len:int ‑> src:([> Core__.Import.write ] as a, 'b) t ‑> dst:('a, seek) t ‑> unit
val read_only : ([> Core__.Import.read ], 's) t ‑> (Core__.Import.read, 's) t
val no_seek : ('r, 'a) t ‑> ('r, no_seek) t
val capacity : ('a, 'b) t ‑> int
val length : ('a, 'b) t ‑> int
val is_empty : ('a, 'b) t ‑> bool
val narrow : ('a, seek) t ‑> unit
val narrow_lo : ('a, seek) t ‑> unit
val narrow_hi : ('a, seek) t ‑> unit
module type Bound : sig ... end
val advance : ('a, seek) t ‑> int ‑> unit
val unsafe_advance : ('a, seek) t ‑> int ‑> unit
val resize : ('a, seek) t ‑> len:int ‑> unit
val unsafe_resize : ('a, seek) t ‑> len:int ‑> unit
val rewind : ('a, seek) t ‑> unit
val reset : ('a, seek) t ‑> unit
val flip_lo : ('a, seek) t ‑> unit
val bounded_flip_lo : ('a, seek) t ‑> Lo_bound.t ‑> unit
val compact : (Core__.Import.read_write, seek) t ‑> unit
val bounded_compact : (Core__.Import.read_write, seek) t ‑> Lo_bound.t ‑> Hi_bound.t ‑> unit
val flip_hi : ('a, seek) t ‑> unit
val bounded_flip_hi : ('a, seek) t ‑> Hi_bound.t ‑> unit
val protect_window_and_bounds : ('rw, no_seek) t ‑> f:(('rw, seek) t ‑> 'a) ‑> 'a
val to_string : ?⁠len:int ‑> ([> Core__.Import.read ], 'a) t ‑> string
val to_string_hum : ?⁠max_lines:int ‑> ('a, 'b) t ‑> string
val crc32 : ([> Core__.Import.read ], 'a) t ‑> Core__.Import.Int63.t
val bin_prot_length_prefix_bytes : int
val fill_bin_prot : ([> Core__.Import.write ], seek) t ‑> 'a Bin_prot.Type_class.writer ‑> 'a ‑> unit Core__.Import.Or_error.t
val consume_bin_prot : ([> Core__.Import.read ], seek) t ‑> 'a Bin_prot.Type_class.reader ‑> 'a Core__.Import.Or_error.t
type ok_or_eof = Core__Iobuf.ok_or_eof =
| Ok
| Eof
val compare_ok_or_eof : ok_or_eof ‑> ok_or_eof ‑> int
val sexp_of_ok_or_eof : ok_or_eof ‑> Base.Sexp.t
val read_assume_fd_is_nonblocking : ([> Core__.Import.write ], seek) t ‑> Iobuf_intf.Unix.File_descr.t ‑> Core__.Syscall_result.Unit.t
val pread_assume_fd_is_nonblocking : ([> Core__.Import.write ], seek) t ‑> Iobuf_intf.Unix.File_descr.t ‑> offset:int ‑> unit
val recvfrom_assume_fd_is_nonblocking : ([> Core__.Import.write ], seek) t ‑> Iobuf_intf.Unix.File_descr.t ‑> Iobuf_intf.Unix.sockaddr
val output : ([> Core__.Import.read ], seek) t ‑> Core__.Import.Out_channel.t ‑> unit
val write : ([> Core__.Import.read ], seek) t ‑> Iobuf_intf.Unix.File_descr.t ‑> unit
val write_assume_fd_is_nonblocking : ([> Core__.Import.read ], seek) t ‑> Iobuf_intf.Unix.File_descr.t ‑> unit
val pwrite_assume_fd_is_nonblocking : ([> Core__.Import.read ], seek) t ‑> Iobuf_intf.Unix.File_descr.t ‑> offset:int ‑> unit
val check_invariant : bool Core__.Import.ref
val show_messages : bool Core__.Import.ref