package irmin-fs

  1. Overview
  2. Docs
Generic file-system backend for Irmin

Install 

dune-project
 Dependency

github.com Readme Changelog ISC License Edit opam file Versions (4)

Authors

  1. T
    Thomas Gazagnaire
  2. T
    Thomas Leonard

Maintainers

  1. T
    thomas@gazagnaire.org

Sources

irmin-3.6.1.tbz
sha256=11fc2570bdbfd48478c89113fc801084a84a9a2c12d9bf8c64e05ce64ae19bd7
sha512=2171699ca24dec5c9c908a2676b272e034c14eb17f7052a794535e52af0be40be68a689e59c0a640ee244b11703320483f4d0c261542e6242ba23a8f1272b9b0

doc/irmin-fs.unix/Irmin_fs_unix/Make/Tree/index.html

Module Make.Tree

val path_t : path Irmin__.Type.t
val step_t : step Irmin__.Type.t
val metadata_t : metadata Irmin__.Type.t
val contents_t : contents Irmin__.Type.t
val contents_key_t : contents_key Irmin__.Type.t
val node_t : node Irmin__.Type.t
val hash_t : hash Irmin__.Type.t
val t : tree Irmin__.Type.t
val empty : unit -> tree
val singleton : path -> ?metadata:metadata -> contents -> tree
val of_contents : ?metadata:metadata -> contents -> tree
val of_node : node -> tree
type elt = [
  1. | `Contents of contents * metadata
  2. | `Node of node
]
val v : elt -> tree
val kinded_hash_t : [ `Contents of hash * metadata | `Node of hash ] Irmin__.Type.t
val pruned : [ `Contents of hash * metadata | `Node of hash ] -> tree
val kind : tree -> path -> [ `Contents | `Node ] option Lwt.t
val is_empty : tree -> bool
val diff : tree -> tree -> (path * (contents * metadata) Irmin__.Diff.t) list Lwt.t
exception Dangling_hash of {
  1. context : string;
  2. hash : hash;
}
exception Pruned_hash of {
  1. context : string;
  2. hash : hash;
}
exception Portable_value of {
  1. context : string;
}
type error = [
  1. | `Dangling_hash of hash
  2. | `Portable_value
  3. | `Pruned_hash of hash
]
type !'a or_error = ('a, error) result
module Contents : sig ... end
val mem : tree -> path -> bool Lwt.t
val find_all : tree -> path -> (contents * metadata) option Lwt.t
val length : tree -> ?cache:bool -> path -> int Lwt.t
val find : tree -> path -> contents option Lwt.t
val get_all : tree -> path -> (contents * metadata) Lwt.t
val list : tree -> ?offset:int -> ?length:int -> ?cache:bool -> path -> (step * tree) list Lwt.t
val seq : tree -> ?offset:int -> ?length:int -> ?cache:bool -> path -> (step * tree) Irmin__.Import.Seq.t Lwt.t
val get : tree -> path -> contents Lwt.t
val add : tree -> path -> ?metadata:metadata -> contents -> tree Lwt.t
val update : tree -> path -> ?metadata:metadata -> (contents option -> contents option) -> tree Lwt.t
val remove : tree -> path -> tree Lwt.t
val mem_tree : tree -> path -> bool Lwt.t
val find_tree : tree -> path -> tree option Lwt.t
val get_tree : tree -> path -> tree Lwt.t
val add_tree : tree -> path -> tree -> tree Lwt.t
val update_tree : tree -> path -> (tree option -> tree option) -> tree Lwt.t
val merge : tree Irmin__.Merge.t
val destruct : tree -> [ `Contents of Contents.t * metadata | `Node of node ]
type marks
val empty_marks : unit -> marks
type !'a force = [
  1. | `False of path -> 'a -> 'a Lwt.t
  2. | `True
]
type uniq = [
  1. | `False
  2. | `Marks of marks
  3. | `True
]
type (!'a, !'b) folder = path -> 'b -> 'a -> 'a Lwt.t
type depth = [
  1. | `Eq of int
  2. | `Ge of int
  3. | `Gt of int
  4. | `Le of int
  5. | `Lt of int
]
val depth_t : depth Irmin__.Type.t
val fold : ?order:[ `Random of Random.State.t | `Sorted | `Undefined ] -> ?force:'a force -> ?cache:bool -> ?uniq:uniq -> ?pre:('a, step list) folder -> ?post:('a, step list) folder -> ?depth:depth -> ?contents:('a, contents) folder -> ?node:('a, node) folder -> ?tree:('a, tree) folder -> tree -> 'a -> 'a Lwt.t
type stats = {
  1. nodes : int;
  2. leafs : int;
  3. skips : int;
  4. depth : int;
  5. width : int;
}
val stats_t : stats Irmin__.Type.t
val stats : ?force:bool -> tree -> stats Lwt.t
type concrete = [
  1. | `Contents of contents * metadata
  2. | `Tree of (step * concrete) list
]
val concrete_t : concrete Irmin__.Type.t
val of_concrete : concrete -> tree
val to_concrete : tree -> concrete Lwt.t
module Proof : sig ... end
val clear : ?depth:int -> tree -> unit
type counters = {
  1. mutable contents_hash : int;
  2. mutable contents_find : int;
  3. mutable contents_add : int;
  4. mutable contents_mem : int;
  5. mutable node_hash : int;
  6. mutable node_mem : int;
  7. mutable node_index : int;
  8. mutable node_add : int;
  9. mutable node_find : int;
  10. mutable node_val_v : int;
  11. mutable node_val_find : int;
  12. mutable node_val_list : int;
}
val counters : unit -> counters
val dump_counters : unit Fmt.t
val reset_counters : unit -> unit
val inspect : tree -> [ `Contents | `Node of [ `Key | `Map | `Portable_dirty | `Pruned | `Value ] ]
module Private : sig ... end
type kinded_key = [
  1. | `Contents of contents_key * metadata
  2. | `Node of node_key
]
val kinded_key_t : kinded_key Irmin__.Type.t
val key : tree -> kinded_key option
val find_key : Repo.t -> tree -> kinded_key option Lwt.t
val of_key : Repo.t -> kinded_key -> tree option Lwt.t
val shallow : Repo.t -> kinded_key -> tree
val hash : ?cache:bool -> tree -> hash
type kinded_hash = [
  1. | `Contents of hash * metadata
  2. | `Node of hash
]
val kinded_hash : ?cache:bool -> tree -> kinded_hash
val of_hash : Repo.t -> kinded_hash -> tree option Lwt.t
type verifier_error = [
  1. | `Proof_mismatch of string
  2. | `Stream_too_long of string
  3. | `Stream_too_short of string
]
val verifier_error_t : verifier_error Irmin__.Type.t
val produce_proof : repo -> kinded_key -> (tree -> (tree * 'a) Lwt.t) -> (Proof.tree Proof.t * 'a) Lwt.t
val verify_proof : Proof.tree Proof.t -> (tree -> (tree * 'a) Lwt.t) -> (tree * 'a, verifier_error) result Lwt.t
val hash_of_proof_state : Proof.tree -> kinded_hash
val produce_stream : repo -> kinded_key -> (tree -> (tree * 'a) Lwt.t) -> (Proof.stream Proof.t * 'a) Lwt.t
val verify_stream : Proof.stream Proof.t -> (tree -> (tree * 'a) Lwt.t) -> (tree * 'a, verifier_error) result Lwt.t