package decompress

  1. Overview
  2. Docs
Implementation of Zlib in OCaml

Install 

dune-project
 Dependency

github.com Readme Changelog MIT License Edit opam file Versions (16)

Authors

  1. R
    Romain Calascibetta <romain.calascibetta@gmail.com>

Maintainers

  1. R
    Romain Calascibetta <romain.calascibetta@gmail.com>

Sources

decompress-v0.8.1.tbz
sha256=903b0926fe2380caf156fcdefa38bc48794f7fcf7d6befd1719aab3f8c0f1188
md5=6c600b0188516d405510cd95d8d82481

doc/decompress.impl/Decompress_impl/RFC1951_deflate/index.html

Module Decompress_impl.RFC1951_deflateSource

Sourcemodule F : sig ... end
Sourcetype ('i, 'o) t = {
  1. hold : int;
  2. bits : int;
  3. temp : ([ Safe.ro | Safe.wo ], 'o) Safe.t;
  4. o_off : int;
  5. o_pos : int;
  6. o_len : int;
  7. i_off : int;
  8. i_pos : int;
  9. i_len : int;
  10. level : int;
  11. wbits : int;
  12. write : int;
  13. adler : Checkseum.Adler32.t;
  14. state : ('i, 'o) state;
  15. wi : 'i B.t;
  16. wo : 'o B.t;
}
Sourceand ('i, 'o) k = (Safe.ro, 'i) Safe.t -> (Safe.wo, 'o) Safe.t -> ('i, 'o) t -> ('i, 'o) res
Sourceand ('i, 'o) state =
  1. | MakeBlock of ('i, 'o) block
  2. | WriteBlock of ('i, 'o) k
  3. | FastBlock of (int * int) array * (int * int) array * Hunk.t Q.t * code * flush
  4. | AlignBlock of F.t option * bool
  5. | FixedBlock of F.t
  6. | DynamicHeader of ('i, 'o) k
  7. | StaticHeader of ('i, 'o) k
  8. | AlignF of ('i, 'o) k
  9. | Finish of int
  10. | Exception of error
Sourceand ('i, 'o) res =
  1. | Cont of ('i, 'o) t
  2. | Wait of ('i, 'o) t
  3. | Flush of ('i, 'o) t
  4. | Ok of ('i, 'o) t
  5. | Error of ('i, 'o) t * error
Sourceand ('i, 'o) block =
  1. | Static of {
    1. lz : 'i L.t;
    2. frequencies : F.t;
    3. deflate : Hunk.t Seq.t;
    }
  2. | Dynamic of {
    1. lz : 'i L.t;
    2. frequencies : F.t;
    3. deflate : Hunk.t Seq.t;
    }
  3. | Flat of int
Sourceand flush =
  1. | Sync of F.t
  2. | Partial of F.t
  3. | Full
  4. | Final
Sourceand code =
  1. | Length
  2. | ExtLength
  3. | Dist
  4. | ExtDist
Sourceand meth =
  1. | PARTIAL
  2. | SYNC
  3. | FULL
Sourceval pp_code : Format.formatter -> code -> unit
Sourceval pp_flush : Format.formatter -> flush -> unit
Sourceval pp_block : Format.formatter -> ('a, 'b) block -> unit
Sourceval pp_state : Format.formatter -> ('a, 'b) state -> unit
Sourceval pp : Format.formatter -> ('a, 'b) t -> unit
Sourceval await : ('i, 'o) t -> ('i, 'o) res
Sourceval error : ('i, 'o) t -> error -> ('i, 'o) res
Sourceval ok : ('i, 'o) t -> int -> ('i, 'o) res
Sourceval block_of_flush : flush -> ('a, 'b) state
Sourceval put_byte : ctor: (('a -> ([< `Rd | `Wr Wr ] as 'b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) -> ('d, 'c) state) -> int -> ('a -> ('b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) -> 'a -> ('b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res
Sourceval put_short_lsb : ctor: (('a -> ([< `Rd | `Wr Wr ] as 'b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) -> ('d, 'c) state) -> int -> ('a -> ('b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) -> 'a -> ('b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res
Sourceval align : ctor: (('a -> ([< `Rd | `Wr Wr ] as 'b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) -> ('d, 'c) state) -> ('a -> ('b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) -> 'a -> ('b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res
Sourceval put_bits : ctor: (('a -> ([< `Rd | `Wr Wr ] as 'b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) -> ('d, 'c) state) -> (int * int) -> ('a -> ('b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) -> 'a -> ('b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res
Sourceval put_bit : ctor: (('a -> ([< `Rd | `Wr Wr ] as 'b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) -> ('d, 'c) state) -> bool -> ('a -> ('b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res) -> 'a -> ('b, 'c) Safe.t -> ('d, 'c) t -> ('d, 'c) res
Sourcemodule KWriteBlock : sig ... end
Sourcemodule KDynamicHeader : sig ... end
Sourceval get_tree_symbols : int -> int array -> int -> int array -> int array * int array
Sourceval block_of_level : witness:'a L.B.t -> wbits:int -> ?frequencies:F.t -> int -> ('a, 'b) block
Sourceval zip : 'a array -> 'b array -> ('a * 'b) array
Sourceval write_block : (int * int) array -> (int * int) array -> Hunk.t Q.t -> flush -> (Safe.ro, 'a) Safe.t -> (Safe.wo, 'b) Safe.t -> ('a, 'b) t -> ('a, 'b) res
Sourceval static : 'a -> Hunk.t Q.t -> ('a -> flush) -> (Safe.ro, 'b) Safe.t -> (Safe.wo, 'c) Safe.t -> ('b, 'c) t -> ('b, 'c) res
Sourceval dynamic : (int array * int array) -> Hunk.t Q.t -> ((int array * int array) -> flush) -> (Safe.ro, 'a) Safe.t -> (Safe.wo, 'a) Safe.t -> ('a, 'a) t -> ('a, 'a) res
Sourceval align_bytes : (Safe.ro, 'a) Safe.t -> (Safe.wo, 'b) Safe.t -> ('a, 'b) t -> ('a, 'b) res
Sourceval write_flat : int -> int -> int -> bool -> (Safe.ro, 'a) Safe.t -> (Safe.wo, 'b) Safe.t -> ('a, 'b) t -> ('a, 'b) res
Sourceval flat : int -> int -> int -> bool -> (Safe.ro, 'a) Safe.t -> (Safe.wo, 'b) Safe.t -> ('a, 'b) t -> ('a, 'b) res
Sourceval make_block : (L.Safe.ro, 'a) L.Safe.t -> 'b -> ('a, 'a) t -> ('a, 'c) block -> ('a, 'a) res
Sourceval fixed_block : F.t -> bool -> (Safe.ro, 'a) Safe.t -> (Safe.wo, 'b) Safe.t -> ('a, 'b) t -> ('a, 'b) res
Sourceval align_block : F.t option -> bool -> (Safe.ro, 'a) Safe.t -> (Safe.wo, 'b) Safe.t -> ('a, 'b) t -> ('a, 'b) res
Sourceval write_fast_block : 'a -> ([< `Rd | `Wr Wr ], 'b) Safe.t -> ('c, 'b) t -> (int * int) array -> (int * int) array -> Hunk.t Q.t -> code -> flush -> ('c, 'b) res
Sourceval flush : int -> int -> ('a, 'b) t -> ('a, 'b) t
Sourceval get_frequencies : ('a, 'b) t -> F.t
Sourceval set_frequencies : ?paranoid:bool -> (int array * int array) -> ('a, 'b) t -> ('a, 'b) t
Sourceval to_final : 'a -> flush
Sourceval to_partial : F.t -> flush
Sourceval to_sync : F.t -> flush
Sourceval to_full : 'a -> flush
Sourceval finish : ('a, 'a) t -> ('a, 'a) t
Sourceval no_flush : int -> int -> ('a, 'b) t -> ('a, 'b) t
Sourceval partial_flush : int -> int -> ('a, 'a) t -> ('a, 'a) t
Sourceval sync_flush : int -> int -> ('a, 'a) t -> ('a, 'a) t
Sourceval full_flush : int -> int -> ('a, 'a) t -> ('a, 'a) t
Sourceval flush_of_meth : meth -> int -> int -> ('a, 'a) t -> ('a, 'a) t
Sourceval eval0 : (L.Safe.ro, 'a) L.Safe.t -> (Safe.wo, 'a) Safe.t -> ('a, 'a) t -> ('a, 'a) res
Sourceval eval : 'a -> 'a -> ('a, 'a) t -> [> `Await of ('a, 'a) t | `End of ('a, 'a) t | `Error of ('a, 'a) t * error | `Flush of ('a, 'a) t ]
Sourceval used_in : ('a, 'b) t -> int
Sourceval used_out : ('a, 'b) t -> int
Sourceval bits_remaining : ('a, 'b) t -> int
Sourceval default : witness:'a Safe.B.t -> ?wbits:int -> int -> ('a, 'a) t
include sig ... end
Sourceval to_result : 'a -> 'a -> ?meth:(meth * int) -> ('a -> int option -> int) -> ('a -> int -> int) -> ('a, 'a) t -> (('a, 'a) t, error) result
Sourceval bytes : 'a -> 'a -> ?meth:(meth * int) -> ('a -> int option -> int) -> ('a -> int -> int) -> ('a, 'a) t -> (('a, 'a) t, error) result
Sourceval bigstring : 'a -> 'a -> ?meth:(meth * int) -> ('a -> int option -> int) -> ('a -> int -> int) -> ('a, 'a) t -> (('a, 'a) t, error) result