tiny_httpd 0.12 · OCaml Package

Byte streams.

These used to live in Tiny_httpd but are now in their own module.

type hidden

Type used to make t unbuildable via a record literal. Use make instead.

type t = {

mutable bs : bytes;
(*
The bytes
*)
mutable off : int;
(*
Beginning of valid slice in bs
*)
mutable len : int;
(*
Length of valid slice in bs. If len = 0 after a call to fill, then the stream is finished.
*)
fill_buf : unit -> unit;
(*
See the current slice of the internal buffer as bytes, i, len, where the slice is bytes[i] .. [bytes[i+len-1]]. Can block to refill the buffer if there is currently no content. If len=0 then there is no more data.
*)
consume : int -> unit;
(*
Consume n bytes from the buffer. This should only be called with n <= len.
*)
close : unit -> unit;
(*
Close the stream.
*)
_rest : hidden;
(*
Use make to build a stream.
*)

}

A buffered stream, with a view into the current buffer (or refill if empty), and a function to consume n bytes. See Byte_stream for more details.

val close : t -> unit

Close stream

val empty : t

Stream with 0 bytes inside

val of_chan : ?buf_size:int -> Stdlib.in_channel -> t

Make a buffered stream from the given channel.

val of_chan_close_noerr : ?buf_size:int -> Stdlib.in_channel -> t

Same as of_chan but the close method will never fail.

val of_bytes : ?i:int -> ?len:int -> bytes -> t

A stream that just returns the slice of bytes starting from i and of length len.

val of_string : string -> t

val iter : (bytes -> int -> int -> unit) -> t -> unit

Iterate on the chunks of the stream

val to_chan : Stdlib.out_channel -> t -> unit

Write the stream to the channel.

val make : 
  ?bs:bytes ->
  ?close:(t -> unit) ->
  consume:(t -> int -> unit) ->
  fill:(t -> unit) ->
  unit ->
  t

make ~fill () creates a byte stream.

val with_file : ?buf_size:int -> string -> (t -> 'a) -> 'a

Open a file with given name, and obtain an input stream on its content. When the function returns, the stream (and file) are closed.

val read_line : ?buf:Tiny_httpd_buf.t -> t -> string

Read a line from the stream.

val read_all : ?buf:Tiny_httpd_buf.t -> t -> string

Read the whole stream into a string.

val limit_size_to : 
  close_rec:bool ->
  max_size:int ->
  too_big:(int -> unit) ->
  t ->
  t

val read_chunked : ?buf:Tiny_httpd_buf.t -> fail:(string -> exn) -> t -> t

Convert a stream into a stream of byte chunks using the chunked encoding. The size of chunks is not specified.

val read_exactly : 
  close_rec:bool ->
  size:int ->
  too_short:(int -> unit) ->
  t ->
  t

read_exactly ~size bs returns a new stream that reads exactly size bytes from bs, and then closes.

val output_chunked : Stdlib.out_channel -> t -> unit

Write the stream into the channel, using the chunked encoding.

package tiny_httpd