package iostream

  1. Overview
  2. Docs

Buffered input stream.

class type t = object ... end

The implementation of buffered input streams.

class virtual t_from_refill : ?bytes:bytes -> unit -> object ... end

A mixin to implement a buffered input by only providing a refill method. Add a close method and it's good to go.

val create : ?bytes:bytes -> ?close:(unit -> unit) -> refill:(bytes -> int) -> unit -> t

Create a new buffered input stream.

  • parameter refill

    will be called to refill the content of the bytes, returning how many bytes were added (starting at offset 0).

  • parameter buf

    the underlying buffer

  • raises Invalid_argument

    if the buffer's length is not at least 16.

class of_bytes : ?off:int -> ?len:int -> bytes -> t
val of_bytes : ?off:int -> ?len:int -> bytes -> t
class of_string : ?off:int -> ?len:int -> string -> t
val of_string : ?off:int -> ?len:int -> string -> t
class bufferized : ?bytes:bytes -> In.t -> t
val bufferized : ?bytes:bytes -> In.t -> t

Read from the given buffer.

  • parameter off

    initial offset (default 0)

  • parameter len

    length of the slice in the bytes. (default all available bytes from offset)

class of_in_channel : ?bytes:bytes -> Stdlib.in_channel -> t
val of_in_channel : ?bytes:bytes -> Stdlib.in_channel -> t

Wrap a standard input channel.

class open_file : ?bytes:bytes -> ?mode:int -> ?flags:Stdlib.open_flag list -> string -> t
val open_file : ?bytes:bytes -> ?mode:int -> ?flags:Stdlib.open_flag list -> string -> t
val with_open_file : ?bytes:bytes -> ?mode:int -> ?flags:Stdlib.open_flag list -> string -> (t -> 'a) -> 'a
val fill_buf : t -> Slice.t

fill_buffer bic returns a slice into bic's internal buffer, and ensures it's empty only if bic.ic is empty.

val input : t -> bytes -> int -> int -> int

Read into the given slice of bytes.

val of_in : ?bytes:bytes -> In.t -> t

Make a buffered version of the input stream.

  • parameter bytes

    the buffer to use.

  • raises Invalid_argument

    if the buffer's length is not at least 16.

val consume : t -> int -> unit

consume bic n consumes n bytes from bic. Precondition: n <= get_len bic, ie. one cannot consume bytes that have not yet been obtained via fill_buffer or fill_and_get.

val close : t -> unit

Close the input stream.

val into_in : t -> In.t

Cast into a In.t. This doesn't allocate.

val input_all_into_buffer : t -> Stdlib.Buffer.t -> unit

Read the whole content into the given buffer.

val input_all : ?buf:bytes -> t -> string

input_all ic reads the whole content of ic into a string.

  • parameter buf

    the initial buffer to use internally.

  • since 0.2
val copy_into : t -> Out.t -> unit

Copy the entire stream into the given output.

val skip : t -> int -> unit

skip ic n reads and dicards the next n bytes in ic.

val input_line : ?buffer:Stdlib.Buffer.t -> t -> string option

Read a line from the input. Return None if the stream is empty.

  • parameter buffer

    a buffer to use to hold the line.

val input_lines : ?buffer:Stdlib.Buffer.t -> t -> string list

Read all lines from the input.

val to_iter : t -> (char -> unit) -> unit
val to_seq : t -> char Stdlib.Seq.t
val of_seq : ?bytes:bytes -> char Stdlib.Seq.t -> t