package shexp

You can search for identifiers within the package.

in-package search v0.2.0

shexp.bigstring
- Shexp_bigstring
  - Bigstring
  - Std
shexp.bigstring-io
- Shexp_bigstring_io
  - Bigstring
  - Std
shexp.process
- Shexp_process
  - Background_command
  - Context
    
    Working_dir
  - Debugger
  - Exit_status
  - Infix
  - Let_syntax
    
    Let_syntax
    
    Open_on_rhs
  - List
  - Logged
  - Prim
    
    Args
  - Std
    
    Process
    
    Background_command
    
    Context
    
    Working_dir
    
    Debugger
    
    Infix
    
    Let_syntax
    
    Let_syntax
    
    Open_on_rhs
    
    List
    
    Logged
    
    Prim
    
    Args
    
    Traced
    
    With_debug
    
    Dbg
  - Std_io
  - Traced
  - With_debug
    
    Dbg
shexp.sexp
- Shexp_sexp
  - Sexp
  - Std

Legend:
Library
Module
Module type
Parameter
Class
Class type

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 =

| Resize of {
1. new_size : int;
2. state : 'a;
}
| Continue of {
1. state : 'a;
}
(*
Same as Resize with the same size
*)
| 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 = {

interrupted : bool;
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