irmin-pack 3.3.1 · OCaml Package

irmin-pack

Parameters

module C : Irmin.Contents.S

Signature

module H : sig ... end

module Index : sig ... end

module Io = Io.Unix

module Errs : sig ... end

module Control : sig ... end

module Aof : sig ... end

module File_manager : sig ... end

module Dict : sig ... end

module XKey : sig ... end

module X : sig ... end

val integrity_check : 
  ?ppf:Stdlib.Format.formatter ->
  auto_repair:bool ->
  X.Repo.t ->
  ([> `Fixed of int | `No_error ],
    [> `Cannot_fix of string | `Corrupted of int ])
    Stdlib.result

module Schema : sig ... end

type repo = X.Repo.t

type t = Irmin.Of_backend(X).t

type step = Schema.Path.step

val step_t : step Irmin.Type.t

type path = Schema.Path.t

val path_t : path Irmin.Type.t

type metadata = Schema.Metadata.t

val metadata_t : metadata Irmin.Type.t

type contents = Schema.Contents.t

val contents_t : contents Irmin.Type.t

type node = Irmin.Of_backend(X).node

val node_t : node Irmin.Type.t

type tree = Irmin.Of_backend(X).tree

val tree_t : tree Irmin.Type.t

type hash = Schema.Hash.t

val hash_t : hash Irmin.Type.t

type commit = Irmin.Of_backend(X).commit

val commit_t : repo -> commit Irmin.Type.t

type branch = Schema.Branch.t

val branch_t : branch Irmin.Type.t

type slice = X.Slice.t

val slice_t : slice Irmin.Type.t

type info = Schema.Info.t

val info_t : info Irmin.Type.t

type lca_error = [

| `Max_depth_reached
| `Too_many_lcas

]

val lca_error_t : lca_error Irmin.Type.t

type ff_error = [

| `Max_depth_reached
| `No_change
| `Rejected
| `Too_many_lcas

]

val ff_error_t : ff_error Irmin.Type.t

module Info : sig ... end

type contents_key = X.Contents.Key.t

val contents_key_t : contents_key Irmin.Type.t

type node_key = X.Node.Key.t

val node_key_t : node_key Irmin.Type.t

type commit_key = X.Commit.Key.t

val commit_key_t : commit_key Irmin.Type.t

module Repo : sig ... end

val empty : repo -> t Lwt.t

val main : repo -> t Lwt.t

val of_branch : repo -> branch -> t Lwt.t

val of_commit : commit -> t Lwt.t

val repo : t -> repo

val tree : t -> tree Lwt.t

module Status : sig ... end

val status : t -> Status.t

module Head : sig ... end

module Hash : sig ... end

module Commit : sig ... end

module Contents : sig ... end

module Tree : sig ... end

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

val list : t -> path -> (step * tree) list Lwt.t

val mem : t -> path -> bool Lwt.t

val mem_tree : t -> path -> bool Lwt.t

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

val find : t -> path -> contents option Lwt.t

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

val get : t -> path -> contents Lwt.t

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

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

val key : 
  t ->
  path ->
  [ `Contents of contents_key | `Node of node_key ] option Lwt.t

val hash : t -> path -> hash option Lwt.t

type write_error = [

| `Conflict of string
| `Test_was of tree option
| `Too_many_retries of int

]

val write_error_t : write_error Irmin.Type.t

val set : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  contents ->
  (unit, write_error) Stdlib.result Lwt.t

val set_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  contents ->
  unit Lwt.t

val set_tree : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  tree ->
  (unit, write_error) Stdlib.result Lwt.t

val set_tree_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  tree ->
  unit Lwt.t

val remove : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  (unit, write_error) Stdlib.result Lwt.t

val remove_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  unit Lwt.t

val test_and_set : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  test:contents option ->
  set:contents option ->
  (unit, write_error) Stdlib.result Lwt.t

val test_and_set_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  test:contents option ->
  set:contents option ->
  unit Lwt.t

val test_and_set_tree : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  test:tree option ->
  set:tree option ->
  (unit, write_error) Stdlib.result Lwt.t

val test_and_set_tree_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  test:tree option ->
  set:tree option ->
  unit Lwt.t

val merge : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  old:contents option ->
  t ->
  path ->
  contents option ->
  (unit, write_error) Stdlib.result Lwt.t

val merge_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  old:contents option ->
  t ->
  path ->
  contents option ->
  unit Lwt.t

val merge_tree : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  old:tree option ->
  t ->
  path ->
  tree option ->
  (unit, write_error) Stdlib.result Lwt.t

val merge_tree_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  old:tree option ->
  t ->
  path ->
  tree option ->
  unit Lwt.t

val with_tree : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  ?strategy:[ `Merge | `Set | `Test_and_set ] ->
  info:Info.f ->
  t ->
  path ->
  (tree option -> tree option Lwt.t) ->
  (unit, write_error) Stdlib.result Lwt.t

val with_tree_exn : 
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  ?strategy:[ `Merge | `Set | `Test_and_set ] ->
  info:Info.f ->
  t ->
  path ->
  (tree option -> tree option Lwt.t) ->
  unit Lwt.t

val clone : src:t -> dst:branch -> t Lwt.t

type watch = Irmin.Of_backend(X).watch

val watch : 
  t ->
  ?init:commit ->
  (commit Irmin.Diff.t -> unit Lwt.t) ->
  watch Lwt.t

val watch_key : 
  t ->
  path ->
  ?init:commit ->
  ((commit * tree) Irmin.Diff.t -> unit Lwt.t) ->
  watch Lwt.t

val unwatch : watch -> unit Lwt.t

type !'a merge =
  info:Info.f ->
  ?max_depth:int ->
  ?n:int ->
  'a ->
  (unit, Irmin.Merge.conflict) Stdlib.result Lwt.t

val merge_into : into:t -> t merge

val merge_with_branch : t -> branch merge

val merge_with_commit : t -> commit merge

val lcas : 
  ?max_depth:int ->
  ?n:int ->
  t ->
  t ->
  (commit list, lca_error) Stdlib.result Lwt.t

val lcas_with_branch : 
  t ->
  ?max_depth:int ->
  ?n:int ->
  branch ->
  (commit list, lca_error) Stdlib.result Lwt.t

val lcas_with_commit : 
  t ->
  ?max_depth:int ->
  ?n:int ->
  commit ->
  (commit list, lca_error) Stdlib.result Lwt.t

module History : sig ... end

val history : 
  ?depth:int ->
  ?min:commit list ->
  ?max:commit list ->
  t ->
  History.t Lwt.t

val last_modified : ?depth:int -> ?n:int -> t -> path -> commit list Lwt.t

module Branch : sig ... end

module Path : sig ... end

module Metadata : sig ... end

module Backend : sig ... end

type Irmin__.Remote.t +=

| E of Backend.Remote.endpoint

val of_backend_node : repo -> Backend.Node.value -> node

val to_backend_node : node -> Backend.Node.value Lwt.t

val to_backend_portable_node : node -> Backend.Node_portable.t Lwt.t

val to_backend_commit : commit -> Backend.Commit.value

val of_backend_commit : 
  repo ->
  Backend.Commit.Key.t ->
  Backend.Commit.value ->
  commit

val save_contents : 
  [> Irmin.Perms.write ] Backend.Contents.t ->
  contents ->
  contents_key Lwt.t

val save_tree : 
  ?clear:bool ->
  repo ->
  [> Irmin.Perms.write ] Backend.Contents.t ->
  [> Irmin.Perms.read_write ] Backend.Node.t ->
  tree ->
  [ `Contents of contents_key | `Node of node_key ] Lwt.t

val master : repo -> t Lwt.t

deprecated Use `main` instead.

val integrity_check_inodes : 
  ?heads:commit Irmin.Export_for_backends.List.t ->
  Repo.t ->
  ([> `Msg of string ], [> `Msg of string ]) Stdlib.result Lwt.t

module Stats : sig ... end

val stats : 
  dump_blob_paths_to:string option ->
  commit:commit ->
  Repo.t ->
  unit Lwt.t

val reload : X.Repo.t -> unit

val flush : X.Repo.t -> unit

module Traverse_pack_file : sig ... end

val traverse_pack_file : 
  [ `Check_and_fix_index
  | `Check_index
  | `Reconstruct_index of [ `In_place | `Output of string ] ] ->
  Irmin.config ->
  unit

val test_traverse_pack_file : 
  [ `Check_and_fix_index
  | `Check_index
  | `Reconstruct_index of [ `In_place | `Output of string ] ] ->
  Irmin.config ->
  unit

module Snapshot : sig ... end

package irmin-pack

Parameters

Signature