package shuttle

You can search for identifiers within the package.

in-package search v0.2.0

package shuttle

shuttle
- CHANGES
- README
- Library shuttle
  - Shuttle
    
    Bytebuffer
    
    To_bytes
    
    To_string
    
    Fill
    
    Consume
    
    Input_channel
    
    Output_channel
    
    Connection
- Sources
  - shuttle
    
    bytebuffer.ml
    
    connection.ml
    
    import.ml
    
    input_channel.ml
    
    input_channel0.ml
    
    output_channel.ml
    
    output_channel0.ml
    
    shuttle.ml
    
    shuttle__.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Shuttle.Input_channel`Source

Alternative to Async_unix.Reader, based on the low latency transport in async_rpc.

Sourcetype 'a handle_chunk_result = [

| `Stop of 'a
(*
Stop a indicates that the read loop's handler consumed 0 bytes and that the read loop should stop.
*)
| `Continue
(*
Continue indicates that the read loop's handler consumed some bytes, and would like to keep reading.
*)

]

Source

val sexp_of_handle_chunk_result : 
  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
  'a handle_chunk_result ->
  Ppx_sexp_conv_lib.Sexp.t

Sourcetype t

Sourceval sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t

Sourceval create : ?buf_len:int -> Async_unix.Fd.t -> t

Sourceval is_closed : t -> bool

Sourceval closed : t -> unit Async_kernel.Deferred.t

Sourceval close : t -> unit Async_kernel.Deferred.t

Source

val read_one_chunk_at_a_time : 
  t ->
  on_chunk:(Bytebuffer.t -> 'a handle_chunk_result) ->
  [ `Stopped of 'a | `Eof | `Eof_with_unconsumed of Core.Bigstring.t ]
    Async_kernel.Deferred.t

read_one_chunk_at_a_time ~on_chunk reads bytes into the reader's internal buffer, and calls on_chunk whenever there is data available.

Sourceval drain : t -> unit Async_kernel.Deferred.t

drain t reads chunks of data from the reader and discards them.

Sourceval pipe : t -> string Async_kernel.Pipe.Reader.t

pipe returns a reader pipe that contains the results of reading chunks from an input_channel.

Source

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

transfer will read chunks from an input channel and write them to the provided writer end of an async pipe. The deferred returned by the function will be determined on EOF or if the writer is closed. Use transfer in scenarios where pipe is needed, but if there is a need to not close the channel automatically once the transfer is finished.

Source

val of_pipe : 
  Core.Info.t ->
  string Async_kernel.Pipe.Reader.t ->
  t Async_kernel.Deferred.t

package shuttle

Module Shuttle.Input_channelSource

Module `Shuttle.Input_channel`Source