`S.Branch`

A branch store.

```
include Atomic_write.S
with type key = Schema.Branch.t
with type value = Commit.key
```

Atomic-write stores are stores where it is possible to read, update and remove elements, with atomically guarantees.

Read-only stores are store where it is only possible to read existing values.

`type key = Schema.Branch.t`

The type for keys.

`type value = Commit.key`

The type for raw values.

`find t k`

is `Some v`

if `k`

is associated to `v`

in `t`

and `None`

is `k`

is not present in `t`

.

`set t k v`

replaces the contents of `k`

by `v`

in `t`

. If `k`

is not already defined in `t`

, create a fresh binding. Raise `Invalid_argument`

if `k`

is the empty path.

`test_and_set t key ~test ~set`

sets `key`

to `set`

only if the current value of `key`

is `test`

and in that case returns `true`

. If the current value of `key`

is different, it returns `false`

. `None`

means that the value does not have to exist or is removed.

**Note:** The operation is guaranteed to be atomic.

`watch_key t k ?init f`

adds `f`

to the list of `t`

's watch handlers for the key `k`

and returns the watch handler to be used with `unwatch`

. `init`

is the optional initial value of the key.

`val clear : t -> unit Lwt.t`

Clear the store. This operation is expected to be slow.

`val close : t -> unit Lwt.t`

`close t`

frees up all the resources associated with `t`

. Any operations run on a closed handle will raise `Closed`

.

`module Key : sig ... end`

Base functions on keys.