Module IO.Input

Input channel (byte source)

include module type of struct include Iostream.In_buf end
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 -> Iostream.In.t -> t
val bufferized : ?bytes:bytes -> Iostream.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 -> in_channel -> t
val of_in_channel : ?bytes:bytes -> in_channel -> t

Wrap a standard input channel.

class open_file : ?bytes:bytes -> ?mode:int -> ?flags:open_flag list -> string -> t
val open_file : ?bytes:bytes -> ?mode:int -> ?flags:open_flag list -> string -> t
val with_open_file : ?bytes:bytes -> ?mode:int -> ?flags:open_flag list -> string -> (t -> 'a) -> 'a
val fill_buf : t -> Iostream.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 of_in : ?bytes:bytes -> Iostream.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 into_in : t -> Iostream.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 -> Iostream.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
val of_unix_fd : ?close_noerr:bool -> closed:bool ref -> buf:Slice.t -> Unix.file_descr -> t
val of_slice : Slice.t -> t
val input : t -> bytes -> int -> int -> int

Read into the given slice.

  • returns

    the number of bytes read, 0 means end of input.

val close : < close : unit -> unit.. > -> unit

Close the channel.

val really_input : t -> bytes -> int -> int -> unit

Read exactly len bytes.

  • raises End_of_file

    if the input did not contain enough data.

val iter_slice : (Slice.t -> unit) -> t -> unit
val iter : (bytes -> int -> int -> unit) -> t -> unit
val to_chan : out_channel -> t -> unit
val to_chan' : Iostream.Out.t -> t -> unit
val read_all_using : buf:Buf.t -> t -> string
val read_exactly_ : too_short:(unit -> unit) -> t -> bytes -> int -> unit

Read n bytes from the input into bytes.

val read_line_into : t -> buf:Buf.t -> unit

read a line into the buffer, after clearing it.

val read_line_using : buf:Buf.t -> t -> string
val read_line_using_opt : buf:Buf.t -> t -> string option
val reading_exactly_ : skip_on_close:bool -> close_rec:bool -> size:int -> bytes:bytes -> t -> t
val limit_size_to : close_rec:bool -> max_size:int -> bytes:bytes -> t -> t

new stream with maximum size max_size.

  • parameter close_rec

    if true, closing this will also close the input stream

val reading_exactly : close_rec:bool -> size:int -> bytes:bytes -> t -> t

New stream that consumes exactly size bytes from the input. If fewer bytes are read before close is called, we read and discard the remaining quota of bytes before close returns.

  • parameter close_rec

    if true, closing this will also close the input stream

val read_chunked : bytes:bytes -> fail:(string -> exn) -> t -> t
val output_chunked' : ?buf:Buf.t -> Iostream.Out_buf.t -> t -> unit

Output a stream using chunked encoding

val output_chunked : ?buf:Buf.t -> out_channel -> t -> unit

print a stream as a series of chunks