package shexp

  1. Overview
  2. Docs

Bigstring IO helpers

include module type of struct include Shexp_bigstring.Std.Bigstring end
type t = (char, Stdlib.Bigarray.int8_unsigned_elt, Stdlib.Bigarray.c_layout) Stdlib.Bigarray.Array1.t
val create : int -> t
val length : t -> int
val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit
val blit_string_t : src:string -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit
val blit_t_bytes : src:t -> src_pos:int -> dst:Stdlib.Bytes.t -> dst_pos:int -> len:int -> unit
val sub_string : t -> pos:int -> len:int -> string
val index : t -> pos:int -> len:int -> char:char -> int option
val rindex : t -> pos:int -> len:int -> char:char -> int option
val pos_len_ok : pos:int -> len:int -> length:int -> bool

Efficiently checks that the range denoted by (pos, len) is in the range 0..length. length is assumed to be >= 0.

val check_pos_len_exn : pos:int -> len:int -> length:int -> unit

Raises if (pos, len) denotes a range outside of 0..length.

val with_temporary : size:int -> f:(t -> 'a) -> 'a

Allocate a bigstring and pass it to f. The memory allocated for the bigstring is released as soon as f returns. As such, the bigstring shouldn't be used after f returns.

This is more efficient than waiting on the garbage collector to release the external memory.

type ('a, 'b) fold_temporary_result = ('a, 'b) Shexp_bigstring.Bigstring.fold_temporary_result =
  1. | Resize of {
    1. new_size : int;
    2. state : 'a;
    }
  2. | Continue of {
    1. state : 'a;
    }
    (*

    Same as Resize with the same size

    *)
  3. | Return of 'b
val fold_temporary : size:int -> init:'a -> f:(t -> 'a -> ('a, 'b) fold_temporary_result) -> 'b

Same as with_temporary, but allow to resize the bigstring if needed.

If f returns Resize { new_size; state }, the bigstring will be resized to the given new size and f will be called with the new bigstring and state. The contents of the bigstring up to the min of the old and new sizes is preserved.

val write : Unix.file_descr -> t -> pos:int -> len:int -> int
val read : Unix.file_descr -> t -> pos:int -> len:int -> int
val read_all : Unix.file_descr -> string
val write_all : Unix.file_descr -> string -> unit
val read_exactly : Unix.file_descr -> int -> string
type read_all_interruptible_result = {
  1. interrupted : bool;
  2. collected : string;
}
val read_all_interruptible : ?delay:float -> Unix.file_descr -> stop:(unit -> bool) -> read_all_interruptible_result

Same as read_all except that stop is called every delay seconds until it returns true. In this case returns prematurely the data collected so far.

val fold_lines : Unix.file_descr -> init:'a -> f:('a -> string -> 'a) -> 'a
val fold_chunks : Unix.file_descr -> sep:char -> init:'a -> f:('a -> string -> 'a) -> 'a
OCaml

Innovation. Community. Security.