Make (p.irmin-client.3.11.0.doc.irmin-client.jsoo.Irmin_client

Parameters

module Store : Irmin.Generic_key.S

Signature

include Irmin.Generic_key.S
  with module Schema = Store.Schema
  with type Backend.Remote.endpoint = unit
  with type commit_key = Store.commit_key
  with type contents_key = Store.contents_key
  with type node_key = Store.node_key

module Schema = Store.Schema

type repo

type 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

val node_t : node Irmin__.Type.t

type tree

val tree_t : tree Irmin__.Type.t

type hash = Schema.Hash.t

val hash_t : hash Irmin__.Type.t

type commit

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

type branch = Schema.Branch.t

val branch_t : branch Irmin__.Type.t

type slice

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 = Store.contents_key

val contents_key_t : contents_key Irmin__.Type.t

type node_key = Store.node_key

val node_key_t : node_key Irmin__.Type.t

type commit_key = Store.commit_key

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

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

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

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

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

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

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

Sourceval 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 : 
  ?clear:bool ->
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  contents ->
  (unit, write_error) result Lwt.t

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

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

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

Source

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

Source

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

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

val test_and_set_exn : 
  ?clear:bool ->
  ?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 : 
  ?clear:bool ->
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:Info.f ->
  t ->
  path ->
  test:tree option ->
  set:tree option ->
  (unit, write_error) result Lwt.t

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

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

val test_set_and_get_exn : 
  ?clear:bool ->
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:(unit -> info) ->
  t ->
  path ->
  test:contents option ->
  set:contents option ->
  commit option Lwt.t

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

val test_set_and_get_tree_exn : 
  ?clear:bool ->
  ?retries:int ->
  ?allow_empty:bool ->
  ?parents:commit list ->
  info:(unit -> info) ->
  t ->
  path ->
  test:tree option ->
  set:tree option ->
  commit option Lwt.t

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

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

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

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

val with_tree : 
  ?clear:bool ->
  ?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) result Lwt.t

val with_tree_exn : 
  ?clear:bool ->
  ?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

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

type 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) 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) result Lwt.t

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

val lcas_with_commit : 
  t ->
  ?max_depth:int ->
  ?n:int ->
  commit ->
  (commit list, lca_error) 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__.Import.write ] Backend.Contents.t ->
  contents ->
  contents_key Lwt.t

val save_tree : 
  ?clear:bool ->
  repo ->
  [> Irmin__.Import.write ] Backend.Contents.t ->
  [> Irmin__.Import.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.

Sourceval connect : ?tls:bool -> ?hostname:string -> Uri.t -> repo Lwt.t

Sourceval reconnect : repo -> unit Lwt.t

Sourceval uri : repo -> Uri.t

Get the URI the client is connected to

Sourceval close : repo -> unit Lwt.t

Close connection to the server

Sourceval dup : repo -> repo Lwt.t

Duplicate a client. This will create a new connection with the same configuration

Sourceval ping : repo -> unit Irmin_server.Error.result Lwt.t

Ping the server

Sourceval export : ?depth:int -> repo -> slice Lwt.t

Sourceval import : repo -> slice -> unit Lwt.t

Sourcemodule Batch : sig ... end

The batch API is used to have better control of when data is sent between the client and server when manipulating trees.