module Buffer: BatBuffer
typet =
Stdlib.Buffer.t
The abstract type of buffers.
val create : int -> t
create n
returns a fresh buffer, initially empty.
The n
parameter is the initial size of the internal string
that holds the buffer contents. That string is automatically
reallocated when more than n
characters are stored in the buffer,
but shrinks back to n
characters when reset
is called.
For best performance, n
should be of the same order of magnitude
as the number of characters that are expected to be stored in
the buffer (for instance, 80 for a buffer that holds one output
line). Nothing bad will happen if the buffer grows beyond that
limit, however. In doubt, take n = 16
for instance.
If n
is not between 1 and Sys.max_string_length
, it will
be clipped to that interval.
val contents : t -> string
Return a copy of the current contents of the buffer. The buffer itself is unchanged.
val to_bytes : t -> Stdlib.Bytes.t
Return a copy of the current contents of the buffer. The buffer itself is unchanged.
val sub : t -> int -> int -> string
Buffer.sub b off len
returns a copy of len
bytes from the
current contents of the buffer b
, starting at offset off
.
Raise Invalid_argument
if srcoff
and len
do not designate a valid
range of b
.
val blit : t -> int -> Stdlib.Bytes.t -> int -> int -> unit
Buffer.blit src srcoff dst dstoff len
copies len
characters from
the current contents of the buffer src
, starting at offset srcoff
to string dst
, starting at character dstoff
.
Invalid_argument
if srcoff
and len
do not designate a valid
substring of src
, or if dstoff
and len
do not designate a valid
substring of dst
.val nth : t -> int -> char
get the n-th character of the buffer.
Invalid_argument
if
index out of boundsval length : t -> int
Return the number of characters currently contained in the buffer.
val clear : t -> unit
Empty the buffer.
val reset : t -> unit
Empty the buffer and deallocate the internal string holding the
buffer contents, replacing it with the initial internal string
of length n
that was allocated by Buffer.create
n
.
For long-lived buffers that may have grown a lot, reset
allows
faster reclamation of the space used by the buffer.
val add_char : t -> char -> unit
add_char b c
appends the character c
at the end of the buffer b
.
val add_string : t -> string -> unit
add_string b s
appends the string s
at the end of the buffer b
.
val add_bytes : t -> Stdlib.Bytes.t -> unit
add_bytes b s
appends the string s
at the end of the buffer b
.
val add_substring : t -> string -> int -> int -> unit
add_substring b s ofs len
takes len
characters from offset
ofs
in string s
and appends them at the end of the buffer b
.
val add_subbytes : t -> Stdlib.Bytes.t -> int -> int -> unit
add_subbytes b s ofs len
takes len
characters from offset
ofs
in byte sequence s
and appends them at the end of the buffer b
.
val add_substitute : t -> (string -> string) -> string -> 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:
_
characters,$
character is a $
that immediately follows a backslash
character; it then stands for a plain $
.Not_found
if the closing character of a parenthesized variable
cannot be found.val add_buffer : t -> t -> unit
add_buffer b1 b2
appends the current contents of buffer b2
at the end of buffer b1
. b2
is not modified.
val add_input : t -> BatInnerIO.input -> int -> unit
add_input b ic n
reads exactly n
character from the input ic
and stores them at the end of buffer b
.
End_of_file
if
the channel contains fewer than n
characters.val add_channel : t -> BatInnerIO.input -> int -> unit
val output_buffer : t -> string BatInnerIO.output
output_buffer b
creates an output channel that writes to that
buffer, and when closed, returns the contents of the buffer.
val truncate : t -> int -> unit
truncate b len
truncates the length of b
to len
Note: the internal byte sequence is not shortened.
Raises Invalid_argument
if len < 0
or len > length b
.
val add_utf_8_uchar : t -> Stdlib.Uchar.t -> unit
add_utf_8_uchar b u
appends the
UTF-8 encoding of u
at the end of buffer b
.
val add_utf_16le_uchar : t -> Stdlib.Uchar.t -> unit
add_utf_16le_uchar b u
appends the
UTF-16LE encoding of u
at the end of buffer b
.
val add_utf_16be_uchar : t -> Stdlib.Uchar.t -> unit
add_utf_16be_uchar b u
appends the
UTF-16BE encoding of u
at the end of buffer b
.
val enum : t -> char BatEnum.t
Returns an enumeration of the characters of a buffer.
Contents of the enumeration is unspecified if the buffer is modified after the enumeration is returned.
val of_enum : char BatEnum.t -> t
Creates a buffer from a character enumeration.
val print : 'a BatInnerIO.output -> t -> unit
val to_seq : t -> char Stdlib.Seq.t
Iterate on the buffer, in increasing order. Modification of the buffer during iteration is undefined behavior.
val to_seqi : t -> (int * char) Stdlib.Seq.t
Iterate on the buffer, in increasing order, yielding indices along chars. Modification of the buffer during iteration is undefined behavior.
val add_seq : t -> char Stdlib.Seq.t -> unit
Add chars to the buffer
val of_seq : char Stdlib.Seq.t -> t
Create a buffer from the generator
The functions in this section append binary encodings of integers to buffers.
Little-endian (resp. big-endian) encoding means that least
(resp. most) significant bytes are stored first. Big-endian is
also known as network byte order. Native-endian encoding is
either little-endian or big-endian depending on Sys.big_endian
.
32-bit and 64-bit integers are represented by the int32
and
int64
types, which can be interpreted either as signed or
unsigned numbers.
8-bit and 16-bit integers are represented by the int
type,
which has more bits than the binary encoding. Functions that
encode these values truncate their inputs to their least
significant bytes.
val add_uint8 : t -> int -> unit
add_uint8 b i
appends a binary unsigned 8-bit integer i
to
b
.
val add_int8 : t -> int -> unit
add_int8 b i
appends a binary signed 8-bit integer i
to
b
.
val add_uint16_ne : t -> int -> unit
add_uint16_ne b i
appends a binary native-endian unsigned 16-bit
integer i
to b
.
val add_uint16_be : t -> int -> unit
add_uint16_be b i
appends a binary big-endian unsigned 16-bit
integer i
to b
.
val add_uint16_le : t -> int -> unit
add_uint16_le b i
appends a binary little-endian unsigned 16-bit
integer i
to b
.
val add_int16_ne : t -> int -> unit
add_int16_ne b i
appends a binary native-endian signed 16-bit
integer i
to b
.
val add_int16_be : t -> int -> unit
add_int16_be b i
appends a binary big-endian signed 16-bit
integer i
to b
.
val add_int16_le : t -> int -> unit
add_int16_le b i
appends a binary little-endian signed 16-bit
integer i
to b
.
val add_int32_ne : t -> int32 -> unit
add_int32_ne b i
appends a binary native-endian 32-bit integer
i
to b
.
val add_int32_be : t -> int32 -> unit
add_int32_be b i
appends a binary big-endian 32-bit integer
i
to b
.
val add_int32_le : t -> int32 -> unit
add_int32_le b i
appends a binary little-endian 32-bit integer
i
to b
.
val add_int64_ne : t -> int64 -> unit
add_int64_ne b i
appends a binary native-endian 64-bit integer
i
to b
.
val add_int64_be : t -> int64 -> unit
add_int64_be b i
appends a binary big-endian 64-bit integer
i
to b
.
val add_int64_le : t -> int64 -> unit
add_int64_ne b i
appends a binary little-endian 64-bit integer
i
to b
.