package core
- Overview
- No Docs
You can search for identifiers within the package.
in-package search v0.2.0
Install
dune-project
Dependency
Authors
Maintainers
Sources
md5=743a141234e04210e295980f7a78a6d9
sha512=61b415f4fb12c78d30649fff1aabe3a475eea926ce6edb7774031f4dc7f37ea51f5d9337ead6ec73cd93da5fd1ed0f2738c210c71ebc8fe9d7f6135a06bd176f
doc/core/Core/Bigstring/index.html
Module Core.BigstringSource
String type based on Bigarray, for use in I/O and C-bindings.
Types and exceptions
Type of bigstrings
include Ppx_compare_lib.Comparable.S with type t := t
include Ppx_quickcheck_runtime.Quickcheckable.S with type t := t
Type of bigstrings which support hashing. Note that mutation invalidates previous hashes.
include module type of Base_bigstring
with type t := t
and type t_frozen := t_frozen
Types and exceptions
val hash_fold_t_frozen :
Ppx_hash_lib.Std.Hash.state ->
t_frozen ->
Ppx_hash_lib.Std.Hash.stateinclude Base.Equal.S with type t := t
Creation and string conversion
init n ~f creates a bigstring t of length n, with t.{i} = f i.
of_string ?pos ?len str
of_bytes ?pos ?len str
to_string ?pos ?len bstr
to_bytes ?pos ?len bstr
concat ?sep list returns the concatenation of list with sep in between each.
Checking
check_args ~loc ~pos ~len bstr checks the position and length arguments pos and len for bigstrings bstr.
get_opt_len bstr ~pos opt_len
Accessors
unsafe_get t pos returns the character at pos, without bounds checks.
unsafe_set t pos sets the character at pos, without bounds checks.
Blitting
blit ~src ?src_pos ?src_len ~dst ?dst_pos () blits src_len characters from src starting at position src_pos to dst at position dst_pos.
include Base.Blit.S with type t := t
memset t ~pos ~len c fills t with c within the range [pos, pos + len).
unsafe_memset t ~pos ~len c fills t with c within the range [pos, pos + len), without bounds checks.
Memcmp
memcmp t1 ~pos1 t2 ~pos2 ~len is like compare t1 t2 except performs the comparison on the subregions of t1 and t2 defined by pos1, pos2, and len.
val memcmp_bytes :
t ->
pos1:Base.int ->
Base.Bytes.t ->
pos2:Base.int ->
len:Base.int ->
Base.intmemcmp_bytes, for efficient memcmp between Bigstring and Bytes data.
val memcmp_string :
t ->
pos1:Base.int ->
Base.string ->
pos2:Base.int ->
len:Base.int ->
Base.intmemcmp_string, for efficient memcmp between Bigstring and string data.
Search
find ?pos ?len char t returns Some i for the smallest i >= pos such that t.{i} = char, or None if there is no such i.
Same as find, but does no bounds checking, and returns a negative value instead of None if char is not found.
val memmem :
haystack:t ->
needle:t ->
?haystack_pos:Base.int ->
?haystack_len:Base.int ->
?needle_pos:Base.int ->
?needle_len:Base.int ->
Base.unit ->
Base.int Base.optionSearch for the position of (a substring of) needle in (a substring of) haystack.
val unsafe_memmem :
haystack:t ->
needle:t ->
haystack_pos:Base.int ->
haystack_len:Base.int ->
needle_pos:Base.int ->
needle_len:Base.int ->
Base.intAs unsafe_find for memmem.
Accessors for parsing binary values, analogous to Binary_packing
These are in Bigstring rather than a separate module because:
1. Existing Binary_packing requires copies and does not work with bigstrings. 2. The accessors rely on the implementation of bigstring, and hence should change should the implementation of bigstring move away from Bigarray. 3. Bigstring already has some external C functions, so it didn't require many changes to the jbuild ^_^.
In a departure from Binary_packing, the naming conventions are chosen to be close to C99 stdint types, as it's a more standard description and it is somewhat useful in making compact macros for the implementations. The accessor names contain endian-ness to allow for branch-free implementations
<accessor> ::= <unsafe><operation><type><endian> <unsafe> ::= unsafe_ | '' <operation> ::= get_ | set_ <type> ::= int8 | uint8 | int16 | uint16 | int32 | uint32 | int64 | uint64 <endian> ::= _le | _be | ''
The unsafe_ prefix indicates that these functions do no bounds checking and silently truncate out-of-range numeric arguments.
16-bit methods
32-bit methods
Similar to the usage in binary_packing, the below methods are treating the value being read (or written), as an ocaml immediate integer, as such it is actually 63 bits. If the user is confident that the range of values used in practice will not require 64-bit precision (i.e. Less than Max_Long), then we can avoid allocation and use an immediate. If the user is wrong, an exception will be thrown (for get).
64-bit signed values
64-bit unsigned values
32-bit methods with full precision
64-bit methods with full precision
String methods
These are alternatives to to_string that follow the conventions of the int accessors, and in particular avoid optional arguments.
Creation and string conversion
create length
sub_shared ?pos ?len bstr
Reading/writing bin-prot
These functions write the "size-prefixed" bin-prot format that is used by, e.g., async's Writer.write_bin_prot, Reader.read_bin_prot and Unpack_buffer.Unpack_one.create_bin_prot.
val write_bin_prot :
t ->
?pos:Base.Int.t ->
'a Bin_prot.Type_class.writer ->
'a ->
Base.Int.twrite_bin_prot t writer a writes a to t starting at pos, and returns the index in t immediately after the last byte written. It raises if pos < 0 or if a doesn't fit in t.
val write_bin_prot_known_size :
t ->
?pos:Base.Int.t ->
'a Bin_prot.Write.writer ->
size:Base.Int.t ->
'a ->
Base.Int.tSame as write_bin_prot, with the difference that size is pre-computed by the caller. size is assumed to be the result of calling the bin prot sizer on the value being written.
val read_bin_prot :
t ->
?pos:Base.Int.t ->
?len:Base.Int.t ->
'a Bin_prot.Type_class.reader ->
('a * Base.Int.t) Or_error.tThe read_bin_prot* functions read from the region of t starting at pos of length len. They return the index in t immediately after the last byte read. They raise if pos and len don't describe a region of t.
val read_bin_prot_verbose_errors :
t ->
?pos:Base.Int.t ->
?len:Base.Int.t ->
'a Bin_prot.Type_class.reader ->
[ `Invalid_data of Error.t | `Not_enough_data | `Ok of 'a * Base.Int.t ]Destruction
unsafe_destroy bstr destroys the bigstring by deallocating its associated data or, if memory-mapped, unmapping the corresponding file, and setting all dimensions to zero. This effectively frees the associated memory or address-space resources instantaneously. This feature helps reclaim the resources sooner than they are automatically reclaimed by the GC.
This operation is safe unless you have passed the bigstring to another thread that is performing operations on it at the same time. Access to the bigstring after this operation will yield array bounds exceptions.
unsafe_destroy_and_resize bstr ~len reallocates the memory backing bstr and returns a new bigstring that starts at position 0 and has length len. If len is greater than length bstr then the newly allocated memory will not be initialized.
Similar to unsafe_destroy, this operation is safe unless you have passed the bigstring to another thread that is performing operations on it at the same time. Access to bstr after this operation will yield array bounds exceptions.
val get_tail_padded_fixed_string :
padding:Base.Char.t ->
t ->
pos:Base.Int.t ->
len:Base.Int.t ->
Base.Unit.t ->
Base.String.tSimilar to Binary_packing.unpack_tail_padded_fixed_string and .pack_tail_padded_fixed_string.
val get_tail_padded_fixed_string_local :
padding:Base.Char.t ->
t ->
pos:Base.Int.t ->
len:Base.Int.t ->
Base.Unit.t ->
Base.String.tval set_tail_padded_fixed_string :
padding:Base.Char.t ->
t ->
pos:Base.Int.t ->
len:Base.Int.t ->
Base.String.t ->
Base.Unit.tval get_head_padded_fixed_string :
padding:Base.Char.t ->
t ->
pos:Base.Int.t ->
len:Base.Int.t ->
Base.Unit.t ->
Base.String.tval get_head_padded_fixed_string_local :
padding:Base.Char.t ->
t ->
pos:Base.Int.t ->
len:Base.Int.t ->
Base.Unit.t ->
Base.String.tval set_head_padded_fixed_string :
padding:Base.Char.t ->
t ->
pos:Base.Int.t ->
len:Base.Int.t ->
Base.String.t ->
Base.Unit.t