Module type Smart.DECODER

module Hash : sig ... end
module Reference : Reference.S with module Hash := Hash
module Common : COMMON with type hash := Hash.t and type reference := Reference.t
type decoder

The type decoder.

val pp_decoder : decoder Fmt.t

Pretty-printer of decoder.

val extract_payload : decoder -> Cstruct.t
type error = [
| `Expected_char of char

Appears when we encountered an other character than what we expected stricly.

| `Unexpected_char of char

Appears when we encountered a character and we don't know what we can do with this.

| `Unexpected_flush_pkt_line

Appears when we encountered a flush packet and we don't expect this.

| `No_assert_predicate of char -> bool

Appears when one character does not respect the predicate.

| `Expected_string of string

Appears when we don't have strictly the string expected.

| `Unexpected_empty_pkt_line

Appears when we encountered an empty packet and we don't expect this.

| `Malformed_pkt_line

Appears when we encountered a flow which does not respect the packet format.

| `Unexpected_end_of_input
| `Unexpected_pkt_line
| `Unexpected_hashes of Hash.t * Hash.t
]

The type error.

val pp_error : error Fmt.t

Pretty-printer of error.

type 'a state =
| Ok of 'a

The end value of the decoding.

| Read of {
buffer : Cstruct.t;
off : int;
len : int;
continue : int -> 'a state;
}

Means that we expect an input. We provide an Cstruct.t with an offset and a length. The client is able to Cstruct.blit the input in this range. Then, he can call continue with how many byte(s) he read.

| Error of {
err : error;
buf : Cstruct.t;
committed : int;
}

When we retrieve an error, we return this value with how many byte(s) we processed and the current input.

type _ transaction =
| HttpReferenceDiscovery : string -> (Common.advertised_refs, [ `Msg of string ]) Stdlib.result transaction
| ReferenceDiscovery : (Common.advertised_refs, [ `Msg of string ]) Stdlib.result transaction
| ShallowUpdate : Common.shallow_update transaction
| Negociation : Hash.Set.t * ack_mode -> Common.acks transaction
| NegociationResult : Common.negociation_result transaction
| PACK : side_band -> flow transaction
| ReportStatus : string list * side_band -> Common.report_status transaction
| HttpReportStatus : string list * side_band -> Common.report_status transaction
| Upload_request : Common.upload_request transaction
| Git_proto_request : Common.git_proto_request transaction
| Update_request : Common.update_request transaction

The type transaction to describe what is expected to decode/receive.

and ack_mode = [
| `Ack
| `Multi_ack
| `Multi_ack_detailed
]

The ACK mode type to describe which mode is shared by the client and the server.

and flow = [
| `Raw of Cstruct.t
| `End
| `Err of Cstruct.t
| `Out of Cstruct.t
]

The representation of the output side-band.

and side_band = [
| `Side_band
| `Side_band_64k
| `No_multiplexe
]

The side-band mode type to describe which mode is shared by the client and the server.

val decode : decoder -> 'result transaction -> 'result state

decode decoder transaction decodes the input represented by decoder in the way of the transaction and returns the value expected and described by transaction or an error.

val decoder : unit -> decoder

decoder () makes a new decoder.

val of_string : string -> 'v transaction -> ('v, error * Cstruct.t * int) Stdlib.result