Module Reader

module Reader: Reader

module Read_result: sig .. end

module Id: Core.Std.Unique_id

type t

val io_stats : Io_stats.t

io_stats Overall IO statistics for all readers

val last_read_time : t -> Core.Std.Time.t

last_read_time t returns time of the most recent read system call that returned data.

val stdin : t Core.Std.Lazy.t

stdin is a reader for file descriptor 0. It is lazy because we don't want to create it in all programs that happen to link with async.

val open_file : ?buf_len:int -> string -> t Import.Deferred.t

open_file file opens file for reading and returns a reader reading from it.

val transfer : t -> string Import.Pipe.Writer.t -> unit Import.Deferred.t

transfer t pipe_w transfers data from t into pipe_w one chunk at a time (whatever is read from the underlying file descriptor without post-processing). The result becomes determined after reaching EOF on t and the final bytes have been transferred.

This function will normally not be needed (see pipe).

val pipe : t -> string Import.Pipe.Reader.t

pipe t returns the reader end of a pipe that will continually be filled with chunks of data from the underlying Reader.t. When the reader reaches EOF or the pipe is closed, pipe closes the the reader, and then after the reader close is finished, closes the pipe.

val create : ?buf_len:int -> Fd.t -> t

create ~buf_len fd creates a new reader that is reading from fd.

val of_in_channel : Pervasives.in_channel -> Fd.Kind.t -> t

val with_file : ?buf_len:int ->
       ?exclusive:bool ->
       string -> f:(t -> 'a Import.Deferred.t) -> 'a Import.Deferred.t

with_file file f opens files, creates a reader with it, and passes the reader to f. It closes the reader when the result of f becomes determined, and returns f's result.

NOTE, you need to be careful that all your IO is done when the deferred you return becomes determined. If for example, you use with_file, and call lines, make sure you return a deferred that becomes determined when the EOF is reached on the pipe, not when you get the pipe (because you get it straight away).

val close : t -> unit Import.Deferred.t

close t prevents further use of t and closes t's underlying file descriptor. The result of close becomes determined once the underlying file descriptor has been closed. It is an error to call other operations on t after close t has been called, except that calls of close subsequent to the original call to close will return the same deferred as the original call.

close_finished t becomes determined after t's underlying file descriptor has been closed, i.e. it is the same as the result of close. close_finished differs from close in that it does not have the side effect of initiating a close.

is_closed t returns true iff close t has been called.

with_close t ~f runs f (), and closes t after f finishes or raises.

val close_finished : t -> unit Import.Deferred.t

val is_closed : t -> bool

val with_close : t -> f:(unit -> 'a Import.Deferred.t) -> 'a Import.Deferred.t

val id : t -> Id.t

id t
Returns a name for this reader that is unique across all instances of the reader module.

val fd : t -> Fd.t

fd t
Returns the Fd.t used to create this reader

val read : t ->
       ?pos:int -> ?len:int -> string -> int Read_result.t Import.Deferred.t

read t ?pos ?len buf reads up to len bytes into buf, blocking until some data is available or end-of-input is reached. The resulting i satisfies 0 < i <= len.

val read_one_chunk_at_a_time_until_eof : t ->
       handle_chunk:(Core.Std.Bigstring.t ->
                     pos:int ->
                     len:int -> [ `Continue | `Stop of 'a ] Import.Deferred.t) ->
       [ `Eof | `Stopped of 'a ] Import.Deferred.t

read_one_chunk_at_a_time_until_eof t ~handle_chunk reads into t's internal buffer, and whenever bytes are available, applies handle_chunk to them. It waits to read again until the deferred returned by handle_chunk becomes determined.

val read_substring : t ->
       Core.Std.Substring.t -> int Read_result.t Import.Deferred.t

read_substring t ss reads up to Substring.length ss bytes into ss, blocking until some data is available or Eof is reched. The resulting i satisfies 0 < i <= Substring.length ss.

val read_bigsubstring : t ->
       Core.Std.Bigsubstring.t -> int Read_result.t Import.Deferred.t

val read_char : t -> char Read_result.t Import.Deferred.t

val really_read : t ->
       ?pos:int -> ?len:int -> string -> [ `Eof of int | `Ok ] Import.Deferred.t

really_read t buf ?pos ?len reads until it fills len bytes of buf starting at pos or runs out of input. In the former case it returns `Ok. In the latter, it returns `Eof n where n is the number of bytes that were read before end of input, and 0 <= n < String.length ss.

val really_read_substring : t -> Core.Std.Substring.t -> [ `Eof of int | `Ok ] Import.Deferred.t

val really_read_bigsubstring : t ->
       Core.Std.Bigsubstring.t -> [ `Eof of int | `Ok ] Import.Deferred.t

val read_until : t ->
       [ `Char of char | `Pred of char -> bool ] ->
       keep_delim:bool ->
       [ `Eof | `Eof_without_delim of string | `Ok of string ] Import.Deferred.t

read_until t pred ~keep_delim reads until it hits a delimiter c such that:

if pred = `Char c' then c = c'
if pred = `Pred p then p c

`Char c' is equivalent to `Pred (fun c -> c = c') but the underlying implementation is more efficient, in particular it will not call a function on every input character.

read_until returns a freshly-allocated string consisting of all the characters read and optionally including the delimiter as per keep_delim.

val read_until_max : t ->
       [ `Char of char | `Pred of char -> bool ] ->
       keep_delim:bool ->
       max:int ->
       [ `Eof
       | `Eof_without_delim of string
       | `Max_exceeded of string
       | `Ok of string ] Import.Deferred.t

just like read_until, except you have the option of specifiying a maximum number of chars to read.

val read_line : t -> string Read_result.t Import.Deferred.t

read_line t reads up to, and including the next newline (\n) character and returns a freshly-allocated string containing everything up to but not including the newline character. If read_line encounters EOF before the newline char then everything read up to but not including EOF will be returned as a line.

val really_read_line : wait_time:Core.Std.Time.Span.t -> t -> string option Import.Deferred.t

really_read_line ~wait_time t reads up to, and including the next newline (\n) character and returns an optional, freshly-allocated string containing everything up to but not including the newline character. If really_read_line encounters EOF before the newline char, then a time span of wait_time will be used before the input operation is retried. If the descriptor is closed, None will be returned.

type 'a read = ?parse_pos:Core.Std.Sexp.Parse_pos.t -> 'a

val read_sexp : (t -> Core.Std.Sexp.t Read_result.t Import.Deferred.t)
       read

read_sexp t reads the next sexp.

val read_sexps : (t -> Core.Std.Sexp.t Import.Pipe.Reader.t) read

read_sexps t reads all the sexps and returns them as a pipe. When the reader reaches EOF or the pipe is closed, read_sexps closes the the reader, and then after the reader close is finished, closes the pipe.

val read_bin_prot : ?max_len:int ->
       t ->
       'a Bin_prot.Type_class.reader ->
       'a Read_result.t Import.Deferred.t

read_bin_prot ?max_len t bp_reader reads the next binary protocol message using binary protocol reader bp_reader. The format is the "size-prefixed binary protocol", in which the length of the data is prefixed as a 64-bit integer to the data. This is the format that Writer.write_bin_prot writes.

val read_marshal_raw : t -> string Read_result.t Import.Deferred.t

Read and return a buffer containing one marshaled value, but don't unmarshal it. You can just call Marshal.from_string on the string, and cast it to the desired type (preferrably the actual type). similar to Marshal.from_channel, but suffers from the String-length limitation (16MB) on 32bit platforms.

val read_marshal : t -> 'a Read_result.t Import.Deferred.t

Like read_marshal_raw, but unmarshal the value after reading it

val recv : t -> string Read_result.t Import.Deferred.t

recv t returns a string that was written with Writer.send

val read_all : t ->
       (t -> 'a Read_result.t Import.Deferred.t) ->
       'a Import.Pipe.Reader.t

read_all t read_one returns a pipe that receives all values read from t by repeatedly using read_one t. When the reader reaches EOF, it closes the reader, and then after the reader close is finished, closes the pipe.

val lines : t -> string Import.Pipe.Reader.t

lines t reads all the lines from t and puts them in the pipe, one line per pipe element. When the reader reaches EOF or the pipe is closed, lines closes the the reader, and then after the reader close is finished, closes the pipe.

val contents : t -> string Import.Deferred.t

contents t returns the string corresponding to the full contents (up to EOF) of the reader. contents closes t before returning the string.

val file_contents : string -> string Import.Deferred.t

file_contents file returns the string with the full contents of the file

val load_sexp : ?exclusive:bool ->
       string -> (Core.Std.Sexp.t -> 'a) -> 'a Core.Std.Or_error.t Import.Deferred.t

load_sexp ?exclusive file ~f loads and convert the S-expression in a given file using f, and returns the deferred conversion result as a variant of either Ok res or Error exn otherwise. This function provides accurate error locations for failed conversions.

val load_sexp_exn : ?exclusive:bool -> string -> (Core.Std.Sexp.t -> 'a) -> 'a Import.Deferred.t

val load_sexps : ?exclusive:bool ->
       string ->
       (Core.Std.Sexp.t -> 'a) -> 'a list Core.Std.Or_error.t Import.Deferred.t

load_sexps file ~f load and convert the S-expressions in a given file using f, and return the deferred list of conversion results as variants of either Ok res or Error exn otherwise. This function is as efficient as load_sexps followed by conversion if there are no errors, but provides accurate error locations for failed conversions.

val load_sexps_exn : ?exclusive:bool ->
       string -> (Core.Std.Sexp.t -> 'a) -> 'a list Import.Deferred.t

val invariant : t -> unit

val sexp_of_t : t -> Sexplib.Sexp.t