balsoft/ligo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Data_encoding: rename Size into Binary_size

Browse Source
This commit is contained in:
Grégoire Henry 2018-05-17 15:55:13 +02:00 committed by Benjamin Canou
parent b164dd6cc5
commit b83797371e
8 changed files with 74 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
src/lib_data_encoding/binary.ml
View File

@ -31,23 +31,23 @@ let rec length : type x. x Encoding.t -> x -> int = fun e ->
| Null -> fun _ -> 0 | Null -> fun _ -> 0
| Empty -> fun _ -> 0 | Empty -> fun _ -> 0
| Constant _ -> fun _ -> 0 | Constant _ -> fun _ -> 0
| Bool -> fun _ -> Size.bool | Bool -> fun _ -> Binary_size.bool
| Int8 -> fun _ -> Size.int8 | Int8 -> fun _ -> Binary_size.int8
| Uint8 -> fun _ -> Size.uint8 | Uint8 -> fun _ -> Binary_size.uint8
| Int16 -> fun _ -> Size.int16 | Int16 -> fun _ -> Binary_size.int16
| Uint16 -> fun _ -> Size.uint16 | Uint16 -> fun _ -> Binary_size.uint16
| Int31 -> fun _ -> Size.int31 | Int31 -> fun _ -> Binary_size.int31
| Int32 -> fun _ -> Size.int32 | Int32 -> fun _ -> Binary_size.int32
| Int64 -> fun _ -> Size.int64 | Int64 -> fun _ -> Binary_size.int64
| Z -> fun z -> (Z.numbits z + 1 + 6) / 7 | Z -> fun z -> (Z.numbits z + 1 + 6) / 7
| RangedInt { minimum ; maximum } -> | RangedInt { minimum ; maximum } ->
fun _ -> Size.(integer_to_size @@ range_to_size ~minimum ~maximum) fun _ -> Binary_size.(integer_to_size @@ range_to_size ~minimum ~maximum)
| Float -> fun _ -> Size.float | Float -> fun _ -> Binary_size.float
| RangedFloat _ -> fun _ -> Size.float | RangedFloat _ -> fun _ -> Binary_size.float
| Bytes `Fixed n -> fun _ -> n | Bytes `Fixed n -> fun _ -> n
| String `Fixed n -> fun _ -> n | String `Fixed n -> fun _ -> n
| String_enum (_, arr) -> | String_enum (_, arr) ->
fun _ -> Size.(integer_to_size @@ enum_size arr) fun _ -> Binary_size.(integer_to_size @@ enum_size arr)
| Objs (`Fixed n, _, _) -> fun _ -> n | Objs (`Fixed n, _, _) -> fun _ -> n
| Tups (`Fixed n, _, _) -> fun _ -> n | Tups (`Fixed n, _, _) -> fun _ -> n
| Union (`Fixed n, _, _) -> fun _ -> n | Union (`Fixed n, _, _) -> fun _ -> n
@ -61,7 +61,7 @@ let rec length : type x. x Encoding.t -> x -> int = fun e ->
let length2 = length e2 in let length2 = length e2 in
fun (v1, v2) -> length1 v1 + length2 v2 fun (v1, v2) -> length1 v1 + length2 v2
| Union (`Dynamic, sz, cases) -> | Union (`Dynamic, sz, cases) ->
let tag_size = Size.tag_size sz in let tag_size = Binary_size.tag_size sz in
let case_length (Case { encoding = e ; proj }) = let case_length (Case { encoding = e ; proj }) =
let length v = tag_size + length e v in let length v = tag_size + length e v in
fun v -> Option.map ~f:length (proj v) in fun v -> Option.map ~f:length (proj v) in
@ -103,7 +103,7 @@ let rec length : type x. x Encoding.t -> x -> int = fun e ->
| [] -> (List.rev acc, json_only_cases) | [] -> (List.rev acc, json_only_cases)
| Case { tag = Json_only } :: tl -> case_lengths true acc tl | Case { tag = Json_only } :: tl -> case_lengths true acc tl
| Case { encoding = e ; proj ; tag = Tag _ } :: tl -> | Case { encoding = e ; proj ; tag = Tag _ } :: tl ->
let length v = Size.tag_size sz + length e v in let length v = Binary_size.tag_size sz + length e v in
case_lengths case_lengths
json_only_cases json_only_cases
((fun v -> ((fun v ->
@ -131,7 +131,7 @@ let rec length : type x. x Encoding.t -> x -> int = fun e ->
| Splitted { encoding = e } -> length e | Splitted { encoding = e } -> length e
| Dynamic_size e -> | Dynamic_size e ->
let length = length e in let length = length e in
fun v -> Size.int32 + length v fun v -> Binary_size.int32 + length v
| Delayed f -> length (f ()) | Delayed f -> length (f ())
(** Writer *) (** Writer *)
@ -142,17 +142,17 @@ module Writer = struct
if (v < - (1 lsl 7) || v >= 1 lsl 7) then if (v < - (1 lsl 7) || v >= 1 lsl 7) then
invalid_arg "Data_encoding.Binary.Writer.int8" ; invalid_arg "Data_encoding.Binary.Writer.int8" ;
MBytes.set_int8 buf ofs v; MBytes.set_int8 buf ofs v;
ofs + Size.int8 ofs + Binary_size.int8
let uint8 v buf ofs = let uint8 v buf ofs =
if (v < 0 || v >= 1 lsl 8) then if (v < 0 || v >= 1 lsl 8) then
invalid_arg "Data_encoding.Binary.Writer.uint8" ; invalid_arg "Data_encoding.Binary.Writer.uint8" ;
MBytes.set_int8 buf ofs v; MBytes.set_int8 buf ofs v;
ofs + Size.uint8 ofs + Binary_size.uint8
let char v buf ofs = let char v buf ofs =
MBytes.set_char buf ofs v; MBytes.set_char buf ofs v;
ofs + Size.char ofs + Binary_size.char
let bool v buf ofs = let bool v buf ofs =
uint8 (if v then 255 else 0) buf ofs uint8 (if v then 255 else 0) buf ofs
@ -161,33 +161,33 @@ module Writer = struct
if (v < - (1 lsl 15) || v >= 1 lsl 15) then if (v < - (1 lsl 15) || v >= 1 lsl 15) then
invalid_arg "Data_encoding.Binary.Writer.int16" ; invalid_arg "Data_encoding.Binary.Writer.int16" ;
MBytes.set_int16 buf ofs v; MBytes.set_int16 buf ofs v;
ofs + Size.int16 ofs + Binary_size.int16
let uint16 v buf ofs = let uint16 v buf ofs =
if (v < 0 || v >= 1 lsl 16) then if (v < 0 || v >= 1 lsl 16) then
invalid_arg "Data_encoding.Binary.Writer.uint16" ; invalid_arg "Data_encoding.Binary.Writer.uint16" ;
MBytes.set_int16 buf ofs v; MBytes.set_int16 buf ofs v;
ofs + Size.uint16 ofs + Binary_size.uint16
let uint30 v buf ofs = let uint30 v buf ofs =
if v < 0 || (Sys.int_size > 31 && v >= 1 lsl 30) then if v < 0 || (Sys.int_size > 31 && v >= 1 lsl 30) then
invalid_arg "Data_encoding.Binary.Writer.uint30" ; invalid_arg "Data_encoding.Binary.Writer.uint30" ;
MBytes.set_int32 buf ofs (Int32.of_int v); MBytes.set_int32 buf ofs (Int32.of_int v);
ofs + Size.uint30 ofs + Binary_size.uint30
let int31 v buf ofs = let int31 v buf ofs =
if Sys.int_size > 31 && (v < ~- (1 lsl 30) || v >= 1 lsl 30) then if Sys.int_size > 31 && (v < ~- (1 lsl 30) || v >= 1 lsl 30) then
invalid_arg "Data_encoding.Binary.Writer.int31" ; invalid_arg "Data_encoding.Binary.Writer.int31" ;
MBytes.set_int32 buf ofs (Int32.of_int v); MBytes.set_int32 buf ofs (Int32.of_int v);
ofs + Size.int31 ofs + Binary_size.int31
let int32 v buf ofs = let int32 v buf ofs =
MBytes.set_int32 buf ofs v; MBytes.set_int32 buf ofs v;
ofs + Size.int32 ofs + Binary_size.int32
let int64 v buf ofs = let int64 v buf ofs =
MBytes.set_int64 buf ofs v; MBytes.set_int64 buf ofs v;
ofs + Size.int64 ofs + Binary_size.int64
let z v res ofs = let z v res ofs =
let sign = Z.sign v < 0 in let sign = Z.sign v < 0 in
@ -216,7 +216,7 @@ module Writer = struct
let float v buf ofs = let float v buf ofs =
(*Here, float means float64, which is written using MBytes.set_double !!*) (*Here, float means float64, which is written using MBytes.set_double !!*)
MBytes.set_double buf ofs v; MBytes.set_double buf ofs v;
ofs + Size.float ofs + Binary_size.float
let fixed_kind_bytes length s buf ofs = let fixed_kind_bytes length s buf ofs =
if MBytes.length s <> length then invalid_arg "fixed_kind_bytes"; if MBytes.length s <> length then invalid_arg "fixed_kind_bytes";
@ -383,7 +383,7 @@ let rec write_rec
if v < minimum || v > maximum if v < minimum || v > maximum
then invalid_arg (Printf.sprintf "Integer %d not in range [%d, %d]." v minimum maximum) ; then invalid_arg (Printf.sprintf "Integer %d not in range [%d, %d]." v minimum maximum) ;
let v = if minimum >= 0 then v - minimum else v in let v = if minimum >= 0 then v - minimum else v in
match Size.range_to_size ~minimum ~maximum with match Binary_size.range_to_size ~minimum ~maximum with
| `Uint8 -> uint8 v | `Uint8 -> uint8 v
| `Uint16 -> uint16 v | `Uint16 -> uint16 v
| `Uint30 -> uint30 v | `Uint30 -> uint30 v
@ -406,7 +406,7 @@ let rec write_rec
| String_enum (tbl, arr) -> | String_enum (tbl, arr) ->
(fun v -> (fun v ->
let value = get_string_enum_case tbl v in let value = get_string_enum_case tbl v in
match Size.enum_size arr with match Binary_size.enum_size arr with
| `Uint30 -> uint30 value | `Uint30 -> uint30 value
| `Uint16 -> uint16 value | `Uint16 -> uint16 value
| `Uint8 -> uint8 value) | `Uint8 -> uint8 value)
@ -470,7 +470,7 @@ let rec write_rec_buffer
value minimum maximum) ; value minimum maximum) ;
let value = if minimum >= 0 then value - minimum else value in let value = if minimum >= 0 then value - minimum else value in
begin begin
match Size.range_to_size ~minimum ~maximum with match Binary_size.range_to_size ~minimum ~maximum with
| `Uint30 -> uint30 value buffer | `Uint30 -> uint30 value buffer
| `Uint16 -> uint16 value buffer | `Uint16 -> uint16 value buffer
| `Uint8 -> uint8 value buffer | `Uint8 -> uint8 value buffer
@ -484,7 +484,7 @@ let rec write_rec_buffer
value minimum maximum) ; value minimum maximum) ;
float value buffer float value buffer
| String_enum (tbl, arr) -> | String_enum (tbl, arr) ->
(match Size.enum_size arr with (match Binary_size.enum_size arr with
| `Uint30 -> BufferedWriter.uint30 | `Uint30 -> BufferedWriter.uint30
| `Uint16 -> BufferedWriter.uint16 | `Uint16 -> BufferedWriter.uint16
| `Uint8 -> BufferedWriter.uint8) | `Uint8 -> BufferedWriter.uint8)
@ -551,38 +551,38 @@ let to_bytes t v =
module Reader = struct module Reader = struct
let int8 buf ofs _len = let int8 buf ofs _len =
ofs + Size.int8, MBytes.get_int8 buf ofs ofs + Binary_size.int8, MBytes.get_int8 buf ofs
let uint8 buf ofs _len = let uint8 buf ofs _len =
ofs + Size.uint8, MBytes.get_uint8 buf ofs ofs + Binary_size.uint8, MBytes.get_uint8 buf ofs
let char buf ofs _len = let char buf ofs _len =
ofs + Size.char, MBytes.get_char buf ofs ofs + Binary_size.char, MBytes.get_char buf ofs
let bool buf ofs len = let bool buf ofs len =
let ofs, v = int8 buf ofs len in let ofs, v = int8 buf ofs len in
ofs, v <> 0 ofs, v <> 0
let int16 buf ofs _len = let int16 buf ofs _len =
ofs + Size.int16, MBytes.get_int16 buf ofs ofs + Binary_size.int16, MBytes.get_int16 buf ofs
let uint16 buf ofs _len = let uint16 buf ofs _len =
ofs + Size.uint16, MBytes.get_uint16 buf ofs ofs + Binary_size.uint16, MBytes.get_uint16 buf ofs
let uint30 buf ofs _len = let uint30 buf ofs _len =
let v = Int32.to_int (MBytes.get_int32 buf ofs) in let v = Int32.to_int (MBytes.get_int32 buf ofs) in
if v < 0 then if v < 0 then
failwith "Data_encoding.Binary.Reader.uint30: invalid data." ; failwith "Data_encoding.Binary.Reader.uint30: invalid data." ;
ofs + Size.uint30, v ofs + Binary_size.uint30, v
let int31 buf ofs _len = let int31 buf ofs _len =
ofs + Size.int31, Int32.to_int (MBytes.get_int32 buf ofs) ofs + Binary_size.int31, Int32.to_int (MBytes.get_int32 buf ofs)
let int32 buf ofs _len = let int32 buf ofs _len =
ofs + Size.int32, MBytes.get_int32 buf ofs ofs + Binary_size.int32, MBytes.get_int32 buf ofs
let int64 buf ofs _len = let int64 buf ofs _len =
ofs + Size.int64, MBytes.get_int64 buf ofs ofs + Binary_size.int64, MBytes.get_int64 buf ofs
let z buf ofs _len = let z buf ofs _len =
let res = Buffer.create 100 in let res = Buffer.create 100 in
@ -615,7 +615,7 @@ module Reader = struct
(** read a float64 (double) **) (** read a float64 (double) **)
let float buf ofs _len = let float buf ofs _len =
(*Here, float means float64, which is read using MBytes.get_double !!*) (*Here, float means float64, which is read using MBytes.get_double !!*)
ofs + Size.float, MBytes.get_double buf ofs ofs + Binary_size.float, MBytes.get_double buf ofs
let int_of_int32 i = let int_of_int32 i =
let i' = Int32.to_int i in let i' = Int32.to_int i in
@ -690,7 +690,7 @@ module Reader = struct
cases in cases in
fun buf ofs len -> fun buf ofs len ->
let ofs, tag = read_tag sz buf ofs len in let ofs, tag = read_tag sz buf ofs len in
try List.assoc tag read_cases buf ofs (len - Size.tag_size sz) try List.assoc tag read_cases buf ofs (len - Binary_size.tag_size sz)
with Not_found -> raise (Unexpected_tag tag) with Not_found -> raise (Unexpected_tag tag)
end end
@ -715,7 +715,7 @@ let rec read_rec : type a. a Encoding.t-> MBytes.t -> int -> int -> int * a = fu
| RangedInt { minimum ; maximum } -> | RangedInt { minimum ; maximum } ->
(fun buf ofs alpha -> (fun buf ofs alpha ->
let ofs, value = let ofs, value =
match Size.range_to_size ~minimum ~maximum with match Binary_size.range_to_size ~minimum ~maximum with
| `Int8 -> int8 buf ofs alpha | `Int8 -> int8 buf ofs alpha
| `Int16 -> int16 buf ofs alpha | `Int16 -> int16 buf ofs alpha
| `Int31 -> int31 buf ofs alpha | `Int31 -> int31 buf ofs alpha
@ -740,7 +740,7 @@ let rec read_rec : type a. a Encoding.t-> MBytes.t -> int -> int -> int * a = fu
| String_enum (_, arr) -> begin | String_enum (_, arr) -> begin
fun buf ofs a -> fun buf ofs a ->
let ofs, ind = let ofs, ind =
match Size.enum_size arr with match Binary_size.enum_size arr with
| `Uint8 -> uint8 buf ofs a | `Uint8 -> uint8 buf ofs a
| `Uint16 -> uint16 buf ofs a | `Uint16 -> uint16 buf ofs a
| `Uint30 -> uint30 buf ofs a in | `Uint30 -> uint30 buf ofs a in
@ -756,7 +756,7 @@ let rec read_rec : type a. a Encoding.t-> MBytes.t -> int -> int -> int * a = fu
(fun buf ofs len -> (fun buf ofs len ->
let ofs, v = int8 buf ofs len in let ofs, v = int8 buf ofs len in
if v = 0 then ofs, None if v = 0 then ofs, None
else let ofs, v = read buf ofs (len - Size.int8) in ofs, Some v) else let ofs, v = read buf ofs (len - Binary_size.int8) in ofs, Some v)
| Obj (Opt (`Variable, _, t)) -> | Obj (Opt (`Variable, _, t)) ->
let read = read_rec t in let read = read_rec t in
(fun buf ofs len -> (fun buf ofs len ->

0
src/lib_data_encoding/size.ml → src/lib_data_encoding/binary_size.ml
View File

0
src/lib_data_encoding/size.mli → src/lib_data_encoding/binary_size.mli
View File

26
src/lib_data_encoding/binary_stream.ml
View File

@ -93,10 +93,10 @@ open Encoding (* open here, shadow below, use shadowed definitions later *)
or raise Need_more_data *) or raise Need_more_data *)
let int8 buf = let int8 buf =
generic_read_data Size.int8 (fun x y _ -> MBytes.get_int8 x y) buf generic_read_data Binary_size.int8 (fun x y _ -> MBytes.get_int8 x y) buf
let uint8 buf = let uint8 buf =
generic_read_data Size.uint8 (fun x y _ -> MBytes.get_uint8 x y) buf generic_read_data Binary_size.uint8 (fun x y _ -> MBytes.get_uint8 x y) buf
let char buf = let char buf =
let buf, v = int8 buf in let buf, v = int8 buf in
@ -107,13 +107,13 @@ let bool buf =
buf, v <> 0 buf, v <> 0
let int16 buf = let int16 buf =
generic_read_data Size.int16 (fun x y _ -> MBytes.get_int16 x y) buf generic_read_data Binary_size.int16 (fun x y _ -> MBytes.get_int16 x y) buf
let uint16 buf = let uint16 buf =
generic_read_data Size.uint16 (fun x y _ -> MBytes.get_uint16 x y) buf generic_read_data Binary_size.uint16 (fun x y _ -> MBytes.get_uint16 x y) buf
let uint30 buf = let uint30 buf =
generic_read_data Size.uint30 generic_read_data Binary_size.uint30
(fun x y _ -> (fun x y _ ->
let v = Int32.to_int (MBytes.get_int32 x y) in let v = Int32.to_int (MBytes.get_int32 x y) in
if v < 0 then if v < 0 then
@ -121,19 +121,19 @@ let uint30 buf =
v) buf v) buf
let int31 buf = let int31 buf =
generic_read_data Size.int31 generic_read_data Binary_size.int31
(fun x y _ -> Int32.to_int (MBytes.get_int32 x y)) buf (fun x y _ -> Int32.to_int (MBytes.get_int32 x y)) buf
let int32 buf = let int32 buf =
generic_read_data Size.int32 (fun x y _ -> MBytes.get_int32 x y) buf generic_read_data Binary_size.int32 (fun x y _ -> MBytes.get_int32 x y) buf
let int64 buf = let int64 buf =
generic_read_data Size.int64 (fun x y _ -> MBytes.get_int64 x y) buf generic_read_data Binary_size.int64 (fun x y _ -> MBytes.get_int64 x y) buf
(** read a float64 (double) **) (** read a float64 (double) **)
let float buf = let float buf =
(*Here, float means float64, which is read using MBytes.get_double !!*) (*Here, float means float64, which is read using MBytes.get_double !!*)
generic_read_data Size.float (fun x y _ -> MBytes.get_double x y) buf generic_read_data Binary_size.float (fun x y _ -> MBytes.get_double x y) buf
let fixed_length_bytes length buf = let fixed_length_bytes length buf =
generic_read_data length MBytes.sub buf generic_read_data length MBytes.sub buf
@ -189,7 +189,7 @@ let rec data_checker
while_not_terminator 0 buf while_not_terminator 0 buf
| RangedInt { minimum ; maximum } -> | RangedInt { minimum ; maximum } ->
let (stream, ranged) = let (stream, ranged) =
match Size.range_to_size ~minimum ~maximum with match Binary_size.range_to_size ~minimum ~maximum with
| `Int8 -> int8 buf | `Int8 -> int8 buf
| `Int16 -> int16 buf | `Int16 -> int16 buf
| `Int31 -> int31 buf | `Int31 -> int31 buf
@ -218,7 +218,7 @@ let rec data_checker
| String_enum (_, arr) -> | String_enum (_, arr) ->
next_path path next_path path
(match Size.enum_size arr with (match Binary_size.enum_size arr with
| `Uint8 -> fst @@ uint8 buf | `Uint8 -> fst @@ uint8 buf
| `Uint16 -> fst @@ uint16 buf | `Uint16 -> fst @@ uint16 buf
| `Uint30 -> fst @@ uint30 buf) | `Uint30 -> fst @@ uint30 buf)
@ -238,7 +238,7 @@ let rec data_checker
| Obj (Opt (`Dynamic, _, e)) -> | Obj (Opt (`Dynamic, _, e)) ->
let buf, v = int8 buf in let buf, v = int8 buf in
if v = 0 then next_path path buf if v = 0 then next_path path buf
else data_checker path e buf (len - Size.int8) else data_checker path e buf (len - Binary_size.int8)
| Obj (Opt (`Variable, _, e)) -> | Obj (Opt (`Variable, _, e)) ->
if len = 0 then next_path path buf if len = 0 then next_path path buf
@ -296,7 +296,7 @@ let rec data_checker
in in
begin match opt with begin match opt with
| None -> raise (Encoding.Unexpected_tag ctag) | None -> raise (Encoding.Unexpected_tag ctag)
| Some func -> func (len - (Size.tag_size sz)) | Some func -> func (len - (Binary_size.tag_size sz))
end end
| Dynamic_size e -> | Dynamic_size e ->

2
src/lib_data_encoding/data_encoding.mli
View File

@ -128,7 +128,7 @@ module Encoding: sig
bytes, with a running unary size bit: the most significant bit of bytes, with a running unary size bit: the most significant bit of
each byte tells is this is the last byte in the sequence (0) or if each byte tells is this is the last byte in the sequence (0) or if
there is more to read (1). The second most significant bit of the there is more to read (1). The second most significant bit of the
first byte is reserved for the sign (positive if zero). Size and first byte is reserved for the sign (positive if zero). Binary_size and
sign bits ignored, data is then the binary representation of the sign bits ignored, data is then the binary representation of the
absolute value of the number in little endian order. *) absolute value of the number in little endian order. *)
val z : Z.t encoding val z : Z.t encoding

28
src/lib_data_encoding/encoding.ml
View File

@ -67,7 +67,7 @@ module Kind = struct
| [] -> assert false (* should be rejected by Data_encoding.union *) | [] -> assert false (* should be rejected by Data_encoding.union *)
| k :: ks -> | k :: ks ->
match List.fold_left merge k ks with match List.fold_left merge k ks with
| `Fixed n -> `Fixed (n + Size.tag_size sz) | `Fixed n -> `Fixed (n + Binary_size.tag_size sz)
| k -> k | k -> k
end end
@ -100,7 +100,7 @@ type 'a desc =
| Objs : Kind.t * 'a t * 'b t -> ('a * 'b) desc | Objs : Kind.t * 'a t * 'b t -> ('a * 'b) desc
| Tup : 'a t -> 'a desc | Tup : 'a t -> 'a desc
| Tups : Kind.t * 'a t * 'b t -> ('a * 'b) desc | Tups : Kind.t * 'a t * 'b t -> ('a * 'b) desc
| Union : Kind.t * Size.tag_size * 'a case list -> 'a desc | Union : Kind.t * Binary_size.tag_size * 'a case list -> 'a desc
| Mu : Kind.enum * string * ('a t -> 'a t) -> 'a desc | Mu : Kind.enum * string * ('a t -> 'a t) -> 'a desc
| Conv : | Conv :
{ proj : ('a -> 'b) ; { proj : ('a -> 'b) ;
@ -145,24 +145,24 @@ let rec classify : type a. a t -> Kind.t = fun e ->
| Null -> `Fixed 0 | Null -> `Fixed 0
| Empty -> `Fixed 0 | Empty -> `Fixed 0
| Constant _ -> `Fixed 0 | Constant _ -> `Fixed 0
| Bool -> `Fixed Size.bool | Bool -> `Fixed Binary_size.bool
| Int8 -> `Fixed Size.int8 | Int8 -> `Fixed Binary_size.int8
| Uint8 -> `Fixed Size.uint8 | Uint8 -> `Fixed Binary_size.uint8
| Int16 -> `Fixed Size.int16 | Int16 -> `Fixed Binary_size.int16
| Uint16 -> `Fixed Size.uint16 | Uint16 -> `Fixed Binary_size.uint16
| Int31 -> `Fixed Size.int31 | Int31 -> `Fixed Binary_size.int31
| Int32 -> `Fixed Size.int32 | Int32 -> `Fixed Binary_size.int32
| Int64 -> `Fixed Size.int64 | Int64 -> `Fixed Binary_size.int64
| Z -> `Dynamic | Z -> `Dynamic
| RangedInt { minimum ; maximum } -> | RangedInt { minimum ; maximum } ->
`Fixed Size.(integer_to_size @@ range_to_size ~minimum ~maximum) `Fixed Binary_size.(integer_to_size @@ range_to_size ~minimum ~maximum)
| Float -> `Fixed Size.float | Float -> `Fixed Binary_size.float
| RangedFloat _ -> `Fixed Size.float | RangedFloat _ -> `Fixed Binary_size.float
(* Tagged *) (* Tagged *)
| Bytes kind -> (kind :> Kind.t) | Bytes kind -> (kind :> Kind.t)
| String kind -> (kind :> Kind.t) | String kind -> (kind :> Kind.t)
| String_enum (_, cases) -> | String_enum (_, cases) ->
`Fixed Size.(integer_to_size @@ enum_size cases) `Fixed Binary_size.(integer_to_size @@ enum_size cases)
| Obj (Opt (kind, _, _)) -> (kind :> Kind.t) | Obj (Opt (kind, _, _)) -> (kind :> Kind.t)
| Objs (kind, _, _) -> kind | Objs (kind, _, _) -> kind
| Tups (kind, _, _) -> kind | Tups (kind, _, _) -> kind

4
src/lib_data_encoding/encoding.mli
View File

@ -16,7 +16,7 @@ module Kind: sig
type enum = [ `Dynamic | `Variable ] type enum = [ `Dynamic | `Variable ]
val combine: string -> t -> t -> t val combine: string -> t -> t -> t
val merge : t -> t -> t val merge : t -> t -> t
val merge_list: Size.tag_size -> t list -> t val merge_list: Binary_size.tag_size -> t list -> t
end end
type case_tag = Tag of int | Json_only type case_tag = Tag of int | Json_only
@ -47,7 +47,7 @@ type 'a desc =
| Objs : Kind.t * 'a t * 'b t -> ('a * 'b) desc | Objs : Kind.t * 'a t * 'b t -> ('a * 'b) desc
| Tup : 'a t -> 'a desc | Tup : 'a t -> 'a desc
| Tups : Kind.t * 'a t * 'b t -> ('a * 'b) desc | Tups : Kind.t * 'a t * 'b t -> ('a * 'b) desc
| Union : Kind.t * Size.tag_size * 'a case list -> 'a desc | Union : Kind.t * Binary_size.tag_size * 'a case list -> 'a desc
| Mu : Kind.enum * string * ('a t -> 'a t) -> 'a desc | Mu : Kind.enum * string * ('a t -> 'a t) -> 'a desc
| Conv : | Conv :
{ proj : ('a -> 'b) ; { proj : ('a -> 'b) ;

2
src/lib_data_encoding/test/read_failure.ml
View File

@ -88,7 +88,7 @@ let all ?expected name write_encoding read_encoding value =
let all_ranged_int minimum maximum = let all_ranged_int minimum maximum =
let encoding = ranged_int minimum maximum in let encoding = ranged_int minimum maximum in
let signed = let signed =
match Size.range_to_size ~minimum ~maximum with match Binary_size.range_to_size ~minimum ~maximum with
| `Int31 | `Int8 | `Int16 -> true | `Int31 | `Int8 | `Int16 -> true
| `Uint8 | `Uint16 | `Uint30 -> false in | `Uint8 | `Uint16 | `Uint30 -> false in
let write_encoding = let write_encoding =