Module Tiny_httpd_stream

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

  • since 0.3
val to_chan : Stdlib.out_channel -> t -> unit

Write the stream to the channel.

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

make ~fill () creates a byte stream.

  • parameter fill

    is used to refill the buffer, and is called initially.

  • parameter close

    optional closing.

  • parameter init_size

    size of the buffer.

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.

  • parameter buf

    a buffer to (re)use. Its content will be cleared.

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

Read the whole stream into a string.

  • parameter buf

    a buffer to (re)use. Its content will be cleared.

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.

  • parameter buf

    buffer used for intermediate storage.

  • parameter fail

    used to build an exception if reading fails.

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.

  • parameter close_rec

    if true, closing the resulting stream also closes bs

  • parameter too_short

    is called if bs closes with still n bytes remaining

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

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