Core_kernel__Bigbuffer (core_kernel.Core_kernel_

This module implements string buffers that automatically expand as necessary. It provides accumulative concatenation of strings in quasi-linear time (instead of quadratic time when strings are concatenated pairwise).

This implementation uses Bigstrings instead of strings. This removes the 16MB limit on buffer size (on 32-bit machines), and improves I/O-performance when reading/writing from/to channels.

include Base.Buffer.S

type t

val sexp_of_t : t ‑> Base.Sexp.t

val create : int ‑> t

val contents : t ‑> string

val contents_bytes : t ‑> bytes

val blit : (t, bytes) Base.Blit_intf.blit

val blito : (t, bytes) Base.Blit_intf.blito

val unsafe_blit : (t, bytes) Base.Blit_intf.blit

val sub : (t, bytes) Base.Blit_intf.sub

val subo : (t, bytes) Base.Blit_intf.subo

val nth : t ‑> int ‑> char

val length : t ‑> int

val clear : t ‑> unit

val reset : t ‑> unit

val add_char : t ‑> char ‑> unit

val add_string : t ‑> string ‑> unit

val add_substring : t ‑> string ‑> pos:int ‑> len:int ‑> unit

val add_bytes : t ‑> bytes ‑> unit

val add_subbytes : t ‑> bytes ‑> pos:int ‑> len:int ‑> unit

val add_buffer : t ‑> t ‑> unit

val big_contents : t ‑> Core_kernel.Bigstring.t

Return a copy of the current contents of the buffer as a bigstring. The buffer itself is unchanged.

val volatile_contents : t ‑> Core_kernel.Bigstring.t

Return the actual underlying bigstring used by this bigbuffer. No copying is involved. To be safe, use and finish with the returned value before calling any other function in this module on the same Bigbuffer.t.

val add_bigstring : t ‑> Core_kernel.Bigstring.t ‑> Core_kernel__.Import.unit

add_bigstring b s appends the bigstring s at the end of the buffer b.

val add_substitute : t ‑> (Core_kernel__.Import.string ‑> Core_kernel__.Import.string) ‑> Core_kernel__.Import.string ‑> Core_kernel__.Import.unit

add_substitute b f s appends the string pattern s at the end of the buffer b with substitution. The substitution process looks for variables into the pattern and substitutes each variable name by its value, as obtained by applying the mapping f to the variable name. Inside the string pattern, a variable name immediately follows a non-escaped $ character and is one of the following:

a non empty sequence of alphanumeric or _ characters,
an arbitrary sequence of characters enclosed by a pair of matching parentheses or curly brackets. An escaped $ character is a $ that immediately follows a backslash character; it then stands for a plain $. Raise Not_found if the closing character of a parenthesized variable cannot be found.