package octez-internal-libs

  1. Overview
  2. Docs
package octez-internal-libs
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Source file pack_value_intf.ml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
(*
 * Copyright (c) 2018-2022 Tarides <contact@tarides.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *)

open! Import

type length_header = [ `Varint ] option
type weight = Immediate of int | Deferred of (unit -> int)
type kinded = ..

module type S = sig
  include Irmin.Type.S

  type hash
  type key
  type kind

  val hash : t -> hash
  val kind : t -> kind

  val length_header : kind -> length_header
  (** Describes the length header formats for the {i data} sections of pack
      entries. *)

  val weight : t -> weight
  (** [weight t] is the [t]'s LRU weight. *)

  val encode_bin :
    dict:(string -> int option) ->
    offset_of_key:(key -> int63 option) ->
    hash ->
    t Irmin.Type.encode_bin

  val decode_bin :
    dict:(int -> string option) ->
    key_of_offset:(int63 -> key) ->
    key_of_hash:(hash -> key) ->
    t Irmin.Type.decode_bin

  val decode_bin_length : string -> int -> int

  val to_kinded : t -> kinded
  (** [to_kinded t] returns a {!kinded} version of [t]. *)

  val of_kinded : kinded -> t
  (** [of_kinded k] is the inverse of [to_kinded t].

      It is expected that an implementation only works for [k] that is returned
      from [to_kinded t] and will raise an exception otherwise. *)
end

module type T = sig
  type t
end

(* A subset of [Irmin_pack.Conf.S] relevant to the format of pack entries,
   copied here to avoid cyclic dependencies. *)
module type Config = sig
  val contents_length_header : length_header
end

module type Sigs = sig
  module Kind : sig
    type t =
      | Commit_v1
      | Commit_v2
      | Contents
      | Inode_v1_unstable
      | Inode_v1_stable
      | Inode_v2_root
      | Inode_v2_nonroot
      | Dangling_parent_commit
    [@@deriving irmin]

    val all : t list
    val to_enum : t -> int
    val to_magic : t -> char
    val of_magic_exn : char -> t
    val pp : t Fmt.t

    val length_header_exn : t -> length_header
    (** Raises an exception on [Contents], as the availability of a length
        header is user defined. *)
  end

  type nonrec weight = weight = Immediate of int | Deferred of (unit -> int)

  type nonrec kinded = kinded = ..
  (** [kinded] is an extenisble variant that each {!S} extends so that it can
      define {!S.to_kinded} and {!S.of_kinded}. Its purpose is to allow
      containers, such as {!Irmin_pack_unix.Lru}, to store and return all types
      of {!S} and thus be usable by modules defined over {!S}, such as
      {!Irmin_pack_unix.Pack_store}. *)

  module type S = S with type kind := Kind.t
  module type Config = Config

  module Of_contents
      (_ : Config)
      (Hash : Irmin.Hash.S)
      (Key : T)
      (Contents : Irmin.Contents.S) :
    S with type t = Contents.t and type hash = Hash.t and type key = Key.t

  module Of_commit
      (Hash : Irmin.Hash.S)
      (Key : Irmin.Key.S with type hash = Hash.t)
      (Commit : Irmin.Commit.Generic_key.S
                  with type node_key = Key.t
                   and type commit_key = Key.t) : sig
    include S with type t = Commit.t and type hash = Hash.t and type key = Key.t

    module Commit_direct : sig
      type address = Offset of int63 | Hash of hash [@@deriving irmin]

      type t = {
        node_offset : address;
        parent_offsets : address list;
        info : Commit.Info.t;
      }
      [@@deriving irmin]
    end
  end
end
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct