plebeia

Functional storage using Merkle Patricia tree
Legend:
Library
Module
Module type
Parameter
Class
Class type
Library plebeia.test_utils
Module Test_utils
include module type of struct include Plebeia.Debug end
val string_of_node : Plebeia.Node_type.node -> int -> string

Dump a node

val simple_string_of_node : Plebeia.Node_type.node -> string

Dump a node, but not recursively

val dot_of_node : Plebeia.Node_type.node -> string

Obtain Graphviz dot file representation of the tree

val dot_of_cursor : Plebeia.Cursor.cursor -> string

Obtain Graphviz dot file representation of the cursor

val save_cursor_to_dot : string -> Plebeia.Cursor.cursor -> unit
val save_node_to_dot : string -> Plebeia.Node_type.node -> unit

Graphviz visualization

include module type of struct include Plebeia.Utils end
module Exn : sig ... end
module Format : sig ... end
module String : sig ... end
module List : sig ... end
module Array : sig ... end
module Open : sig ... end
include module type of Open
val from_Some : 'a option -> 'a
val from_Ok : ( 'a, 'b ) Stdlib.result -> 'a
val from_Ok_lwt : ( 'a, 'b ) Stdlib.result Lwt.t -> 'a Lwt.t
val to_file : file:string -> string -> unit

Create a file with the given string

val (^/) : string -> string -> string

Filename.concat

val with_time : ( unit -> 'a ) -> 'a * Mtime.span

Time the function in seconds

val with_time_lwt : ( unit -> 'a Lwt.t ) -> ('a * Mtime.span) Lwt.t

with_time for lwt

val failwithf : ( 'a, Format.formatter, unit, 'b ) Stdlib.format4 -> 'a

failwith with printf interface

val (@) : 'a list -> 'a list -> 'a list

Tail recursive list concat

val reachable_words : 'a -> int

Return the words occupied by the object. Only for debugging. This costs a lot

val reachable_mbs : 'a -> float
val min : 'a -> 'a -> 'a
val max : 'a -> 'a -> 'a
module Int : sig ... end
module RS = Stdlib.Random.State
val temp_file : string -> string -> string
val with_tempdir : ( string -> 'a ) -> 'b
val context_confs : Plebeia.Context.config list
val with_context_conf : ( Plebeia.Context.config -> 'a ) -> (Plebeia.Context.config * 'b) list
val with_context_conf_lwt : ( Plebeia.Context.config -> 'a Lwt.t ) -> (Plebeia.Context.config * 'b) list Lwt.t
val resize_step_bytes : int
val with_context : ( Plebeia.Context.t -> 'a ) -> (Plebeia.Context.config * 'b) list Lwt.t
val with_context_lwt : ( Plebeia.Context.t -> 'a Lwt.t ) -> (Plebeia.Context.config * 'b) list Lwt.t
val with_memory_only_context : ( Plebeia.Context.t -> 'a ) -> (Plebeia.Context.config * 'b) list Lwt.t
val with_vc : ?prefix:string -> ( Plebeia.Vc.t -> 'a Lwt.t ) -> (Plebeia.Context.config * 'b) list Lwt.t
val with_cursor : ( Plebeia.Cursor.t -> 'a ) -> (Plebeia.Context.config * 'b) list Lwt.t
val with_memory_only_cursor : ( Plebeia.Cursor.t -> 'a ) -> (Plebeia.Context.config * 'b) list Lwt.t
val regression_by_hash : string -> int -> 'a -> unit
val path_of_string : string -> Plebeia.Segment.t
val ok_or_fail : ( 'a, Plebeia.Error.t ) Stdlib.result -> 'b
val must_fail : ( 'a, 'b ) Stdlib.result -> unit
val path : string -> Plebeia.Segment.t
val value : string -> Plebeia.Value.t
val normalize : clear_hash:bool -> Plebeia.Node.node -> Plebeia.Node.node
val normalize_view : clear_hash:bool -> Plebeia.Node.view -> Plebeia.Node.view
val equal_nodes : ignore_hash:bool -> Plebeia.Node.node -> Plebeia.Node.node -> bool
val all_children : Plebeia.Context.t -> Plebeia.Node_type.node -> (Plebeia.Segment.t * [> `Directory of Plebeia.Node.node | `File ]) list
val xassert : bool -> unit
val reraise_after : ( 'a -> 'b ) -> 'c -> ( exn -> 'd ) -> 'e
val reraise_after_lwt : ( 'a -> 'b Lwt.t ) -> 'a0 -> ( exn -> 'c ) -> 'b0 Lwt.t
val with_random : ( RS.t -> 'a ) -> 'b
val with_random_lwt : ( RS.t -> 'a Lwt.t ) -> 'a Lwt.t
val forget_random_nodes : RS.t -> float -> Plebeia.Node.node -> Plebeia.Node.node
val choose_random_node : float -> RS.t -> Plebeia.Context.t -> Plebeia.Node_type.node -> Plebeia.Segment.Segs.t
val copy_file : string -> string -> unit Lwt.t
val count_nodes : Plebeia.Context.t -> Plebeia.Node_type.t -> int
val gen_node : Plebeia.Context.t -> Stdlib.Random.State.t -> ?min_nodes:int -> int -> Plebeia.Node_type.t
val validate_node : Plebeia.Context.t -> Plebeia.Node_type.node -> unit
val check_cursor_is_top : Plebeia.Cursor.cursor -> unit
val random_segs_to_bud_or_leaf : RS.t -> Plebeia.Cursor.cursor -> Plebeia.Segment.t list option
val dump_cursor : Plebeia.Cursor.cursor -> unit
val compare_trees : Dumb.cursor -> Plebeia.Cursor.cursor -> unit
val gen_segments : (int * int) -> int -> Plebeia.Segment.t list Plebeia.Gen.t
val prepare_tree : Stdlib.Random.State.t -> Plebeia.Cursor.t -> path_bits:int -> nfiles:int -> vbytes:int -> Plebeia.Cursor.t * Plebeia.Segment.t list
val random_terminal : Plebeia.Context.t -> Plebeia.Node_type.node -> Stdlib.Random.State.t -> Plebeia__Segment.segment list * Plebeia.Node_type.node
val ignore_lwt : 'a Lwt.t -> unit Lwt.t
val run_lwt : 'a Lwt.t -> 'a
val run_ignore_lwt : 'a Lwt.t -> unit
val exec_lwt : ( unit -> 'a Lwt.t ) -> unit -> 'b
val for_lwt : int -> int -> ( int -> unit Lwt.t ) -> unit Lwt.t
module SegmentSet : sig ... end
module SegmentListSet : sig ... end
val get_empty_buds : Plebeia.Cursor.t -> Plebeia.Path.t list
module NameStringSegment : sig ... end
module Dumb : sig ... end
module Do_random : sig ... end
module Fs_simulation : sig ... end