Module `Make.Tree`Source

Sourceval path_t : path Irmin.Type.t

Sourceval step_t : step Irmin.Type.t

Sourceval metadata_t : metadata Irmin.Type.t

Sourceval contents_t : contents Irmin.Type.t

Sourceval contents_key_t : contents_key Irmin.Type.t

Sourceval node_t : node Irmin.Type.t

Sourceval hash_t : hash Irmin.Type.t

Sourceval t : tree Irmin.Type.t

Sourceval empty : unit -> tree

Sourceval singleton : path -> ?metadata:metadata -> contents -> tree

Sourceval of_contents : ?metadata:metadata -> contents -> tree

Sourceval of_node : node -> tree

Sourcetype elt = [

| `Contents of contents * metadata
| `Node of node

]

Sourceval v : elt -> tree

Source

val kinded_hash_t : 
  [ `Contents of hash * metadata | `Node of hash ] Irmin.Type.t

Sourceval pruned : [ `Contents of hash * metadata | `Node of hash ] -> tree

Sourceval kind : tree -> path -> [ `Contents | `Node ] option Lwt.t

Sourceval is_empty : tree -> bool

Source

val diff : 
  tree ->
  tree ->
  (path * (contents * metadata) Irmin.Diff.t) list Lwt.t

Sourceexception Dangling_hash of {

context : string;
hash : hash;

}

Sourceexception Pruned_hash of {

context : string;
hash : hash;

}

Sourceexception Portable_value of {

context : string;

}

Sourcetype error = [

| `Dangling_hash of hash
| `Portable_value
| `Pruned_hash of hash

]

Sourcetype !'a or_error = ('a, error) result

Sourcemodule Contents : sig ... end

Sourceval mem : tree -> path -> bool Lwt.t

Sourceval find_all : tree -> path -> (contents * metadata) option Lwt.t

Sourceval length : tree -> ?cache:bool -> path -> int Lwt.t

Sourceval find : tree -> path -> contents option Lwt.t

Sourceval get_all : tree -> path -> (contents * metadata) Lwt.t

Source

val list : 
  tree ->
  ?offset:int ->
  ?length:int ->
  ?cache:bool ->
  path ->
  (step * tree) list Lwt.t

Sourceval get : tree -> path -> contents Lwt.t

Sourceval add : tree -> path -> ?metadata:metadata -> contents -> tree Lwt.t

Source

val update : 
  tree ->
  path ->
  ?metadata:metadata ->
  (contents option -> contents option) ->
  tree Lwt.t

Sourceval remove : tree -> path -> tree Lwt.t

Sourceval mem_tree : tree -> path -> bool Lwt.t

Sourceval find_tree : tree -> path -> tree option Lwt.t

Sourceval get_tree : tree -> path -> tree Lwt.t

Sourceval add_tree : tree -> path -> tree -> tree Lwt.t

Sourceval update_tree : tree -> path -> (tree option -> tree option) -> tree Lwt.t

Sourceval merge : tree Irmin.Merge.t

Sourceval destruct : tree -> [ `Contents of Contents.t * metadata | `Node of node ]

Sourcetype marks

Sourceval empty_marks : unit -> marks

Sourcetype !'a force = [

| `False of path -> 'a -> 'a Lwt.t
| `True

]

Sourcetype uniq = [

| `False
| `Marks of marks
| `True

]

Sourcetype !'a node_fn = path -> step list -> 'a -> 'a Lwt.t

Sourcetype depth = [

| `Eq of int
| `Ge of int
| `Gt of int
| `Le of int
| `Lt of int

]

Sourceval depth_t : depth Irmin.Type.t

Source

val fold : 
  ?order:[ `Random of Random.State.t | `Sorted | `Undefined ] ->
  ?force:'a force ->
  ?cache:bool ->
  ?uniq:uniq ->
  ?pre:'a node_fn ->
  ?post:'a node_fn ->
  ?depth:depth ->
  ?contents:(path -> contents -> 'a -> 'a Lwt.t) ->
  ?node:(path -> node -> 'a -> 'a Lwt.t) ->
  ?tree:(path -> tree -> 'a -> 'a Lwt.t) ->
  tree ->
  'a ->
  'a Lwt.t

Sourcetype stats = {

nodes : int;
leafs : int;
skips : int;
depth : int;
width : int;

}

Sourceval stats_t : stats Irmin.Type.t

Sourceval stats : ?force:bool -> tree -> stats Lwt.t

Sourcetype concrete = [

| `Contents of contents * metadata
| `Tree of (step * concrete) list

]

Sourceval concrete_t : concrete Irmin.Type.t

Sourceval of_concrete : concrete -> tree

Sourceval to_concrete : tree -> concrete Lwt.t

Sourcemodule Proof : sig ... end

Sourceval clear : ?depth:int -> tree -> unit

Sourcetype counters = {

mutable contents_hash : int;
mutable contents_find : int;
mutable contents_add : int;
mutable contents_mem : int;
mutable node_hash : int;
mutable node_mem : int;
mutable node_index : int;
mutable node_add : int;
mutable node_find : int;
mutable node_val_v : int;
mutable node_val_find : int;
mutable node_val_list : int;

}

Sourceval counters : unit -> counters

Sourceval dump_counters : unit Fmt.t

Sourceval reset_counters : unit -> unit

Source

val inspect : 
  tree ->
  [ `Contents | `Node of [ `Key | `Map | `Portable_dirty | `Pruned | `Value ] ]

Sourcemodule Private : sig ... end

Sourcetype kinded_key = [

| `Contents of contents_key * metadata
| `Node of node_key

]

Sourceval kinded_key_t : kinded_key Irmin.Type.t

Sourceval key : tree -> kinded_key option

Sourceval find_key : Repo.t -> tree -> kinded_key option Lwt.t

Sourceval of_key : Repo.t -> kinded_key -> tree option Lwt.t

Sourceval shallow : Repo.t -> kinded_key -> tree

Sourceval hash : ?cache:bool -> tree -> hash

Sourcetype kinded_hash = [

| `Contents of hash * metadata
| `Node of hash

]

Sourceval kinded_hash : ?cache:bool -> tree -> kinded_hash

Sourceval of_hash : Repo.t -> kinded_hash -> tree option Lwt.t

Sourcetype verifier_error = [

| `Proof_mismatch of string
| `Stream_too_long of string
| `Stream_too_short of string

]

Sourceval verifier_error_t : verifier_error Irmin.Type.t

Source

val produce_proof : 
  repo ->
  kinded_key ->
  (tree -> (tree * 'a) Lwt.t) ->
  (Proof.tree Proof.t * 'a) Lwt.t

Source

val verify_proof : 
  Proof.tree Proof.t ->
  (tree -> (tree * 'a) Lwt.t) ->
  (tree * 'a, verifier_error) result Lwt.t

Source

val produce_stream : 
  repo ->
  kinded_key ->
  (tree -> (tree * 'a) Lwt.t) ->
  (Proof.stream Proof.t * 'a) Lwt.t

Source

val verify_stream : 
  Proof.stream Proof.t ->
  (tree -> (tree * 'a) Lwt.t) ->
  (tree * 'a, verifier_error) result Lwt.t

Install

Dune Dependency

Authors

Maintainers

Sources

doc/irmin-pack.unix/Irmin_pack_unix/KV/Make/Tree/index.html

Module `Make.Tree`Source

package irmin-pack

Install

Dune Dependency

Authors

Maintainers

Sources

doc/irmin-pack.unix/Irmin_pack_unix/KV/Make/Tree/index.html

Module Make.TreeSource

Module `Make.Tree`Source