Tiny_httpd_stream
Byte streams.
These used to live in Tiny_httpd
but are now in their own module.
type t = {
mutable bs : bytes; | (* The bytes *) |
mutable off : int; | (* Beginning of valid slice in |
mutable len : int; | (* Length of valid slice in |
fill_buf : unit -> unit; | (* See the current slice of the internal buffer as |
consume : int -> unit; | (* Consume |
close : unit -> unit; | (* Close the stream. *) |
_rest : hidden; | (* Use |
}
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 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.
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.