package irmin-pack

  1. Overview
  2. Docs
Irmin backend which stores values in a pack file

Install 

dune-project
 Dependency

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

Authors

  1. T
    Thomas Gazagnaire

Maintainers

  1. T
    thomas@gazagnaire.org

Sources

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

doc/irmin-pack.unix/Irmin_pack_unix/Maker/Make/Backend/Node/Val/index.html

Module Node.ValSource

Val provides base functions for node values.

Node values

Sourcetype t = value

The type for node values.

Sourcetype metadata = Metadata.t

The type for node metadata.

Sourceval metadata_t : metadata Irmin.Type.t
Sourcetype contents_key = Contents.key

The type for contents keys.

Sourceval contents_key_t : contents_key Irmin.Type.t
Sourcetype node_key = key

The type for node keys.

Sourceval node_key_t : node_key Irmin.Type.t
Sourcetype step = Path.step

The type for steps between nodes.

Sourcetype value = [
  1. | `Node of node_key
  2. | `Contents of contents_key * metadata
]

The type for either (node) keys or (contents) keys combined with their metadata.

Sourcetype hash = hash

The type of hashes of values.

Sourceval of_list : (step * value) list -> t

of_list l is the node n such that list n = l.

Sourceval list : ?offset:int -> ?length:int -> ?cache:bool -> t -> (step * value) list

list t is the contents of t. offset and length are used to paginate results.

Sourceval of_seq : (unit -> (step * value) Seq.node) -> t

of_seq s is the node n such that seq n = s.

Sourceval seq : ?offset:int -> ?length:int -> ?cache:bool -> t -> unit -> (step * value) Seq.node

seq t is the contents of t. offset and length are used to paginate results.

See caching for an explanation of the cache parameter

Sourceval empty : unit -> t

empty () is the empty node.

Sourceval is_empty : t -> bool

is_empty t is true iff t is empty.

Sourceval length : t -> int

length t is the number of entries in t.

Sourceval hash_exn : ?force:bool -> t -> hash

hash_exn t is the hash of t.

Another way of computing it is Hash.Typed(Hash)(Node).hash t which computes the pre-hash of t before hashing it using Hash. hash_exn might be faster because the it may be optimised (e.g. it may use caching).

hash_exn t is hash_exn ~force:true t which is not expected to raise an exception. hash_exn ~force:false t will raise Not_found if the hash requires IOs to be computed.

Sourceval clear : t -> unit

Cleanup internal caches.

Sourceval find : ?cache:bool -> t -> step -> value option

find t s is the value associated with s in t.

A node can point to user-defined contents. The edge between the node and the contents is labeled by a step.

See caching for an explanation of the cache parameter

Sourceval add : t -> step -> value -> t

add t s v is the node where find t v is Some s but is similar to t otherwise.

Sourceval remove : t -> step -> t

remove t s is the node where find t s is None but is similar to t otherwise.

Metadata functions.

caching

cache regulates the caching behaviour regarding the node's internal data which may be lazily loaded from the backend, depending on the node implementation.

cache defaults to true which may greatly reduce the IOs and the runtime but may also increase the memory consumption.

cache = false doesn't replace a call to clear, it only prevents the storing of new data, it doesn't discard the existing one.

Recursive Nodes

Some Node implementations (like irmin-pack's inodes) can represent a node as a set of nodes. One operation on such "high-level" node corresponds to a sequence of recursive calls to the underlying "lower-level" nodes. Note: theses effects are not in the Lwt monad on purpose (so Tree.hash and Tree.equal are not in the Lwt monad as well).

type effect := expected_depth:int -> node_key -> t option

The type for read effects.

Sourceval with_handler : (effect -> effect) -> t -> t

with_handler f replace the current effect handler h by f h. f h will be called for all the recursive read effects that are required by recursive operations on nodes. .

type head := [
  1. | `Node of (step * value) list
  2. | `Inode of int * (int * hash) list
]
Sourceval head : t -> head

Reveal the shallow internal structure of the node.

Only hashes and not keys are revealed in the `Inode case, this is because these inodes might not be keyed yet.

merging

Sourceval merge : contents:contents_key option Irmin.Merge.t -> node:node_key option Irmin.Merge.t -> t Irmin.Merge.t

merge is the merge function for nodes.

Sourceexception Dangling_hash of {
  1. context : string;
  2. hash : hash;
}