fs2.io
package fs2.io
Type members
Value members
Methods
def readInputStream[F <: ([_$1] =>> Any)](fis: F[InputStream], chunkSize: Int, closeAfterUse: Boolean)(F: Sync[F]): Stream[F, Byte]
Reads all bytes from the specified
Set
InputStream
with a buffer size of chunkSize
.Set
closeAfterUse
to false if the InputStream
should not be closed after use. def readOutputStream[F <: ([_$6] =>> Any)](chunkSize: Int)(f: OutputStream => F[Unit])(evidence$1: Async[F]): Stream[F, Byte]
Take a function that emits to an OutputStream effectfully,
and return a stream which, when run, will perform that function and emit
the bytes recorded in the OutputStream as an fs2.Stream
and return a stream which, when run, will perform that function and emit
the bytes recorded in the OutputStream as an fs2.Stream
The stream produced by this will terminate if:
-
-
-
f
returns-
f
calls OutputStream#close
If none of those happens, the stream will run forever.
def stdoutLines[F <: ([_$9] =>> Any), O](charset: Charset)(evidence$4: Sync[F], evidence$5: Show[O]): (F, O) => INothing
Writes this stream to standard output asynchronously, converting each element to
a sequence of bytes via
a sequence of bytes via
Show
and the given Charset
.Each write operation is performed on the supplied execution context. Writes are
blocking so the execution context should be configured appropriately.
blocking so the execution context should be configured appropriately.
Pipe that converts a stream of bytes to a stream that will emit a single
that is closed whenever the resulting stream terminates.
java.io.InputStream
,that is closed whenever the resulting stream terminates.
If the
original stream completely terminates.
close
of resulting input stream is invoked manually, then this will await until theoriginal stream completely terminates.
Because all
should be consumed on a different thread pool than the one that is backing the effect.
InputStream
methods block (including close
), the resulting InputStream
should be consumed on a different thread pool than the one that is backing the effect.
Note that the implementation is not thread safe -- only one thread is allowed at any time
to operate on the resulting
to operate on the resulting
java.io.InputStream
. def toInputStreamResource[F <: ([_$14] =>> Any)](source: Stream[F, Byte])(evidence$8: Async[F]): Resource[F, InputStream]
Like toInputStream but returns a
Resource
rather than a single element stream. def unsafeReadInputStream[F <: ([_$2] =>> Any)](fis: F[InputStream], chunkSize: Int, closeAfterUse: Boolean)(F: Sync[F]): Stream[F, Byte]
Reads all bytes from the specified
Set
InputStream
with a buffer size of chunkSize
.Set
closeAfterUse
to false if the InputStream
should not be closed after use.Recycles an underlying input buffer for performance. It is safe to call
this as long as whatever consumes this
returned or pipe it to a combinator that does (e.g.
this as long as whatever consumes this
Stream
does not store the Chunk
returned or pipe it to a combinator that does (e.g.
buffer
). UsereadInputStream
for a safe version. def writeOutputStream[F <: ([_$5] =>> Any)](fos: F[OutputStream], closeAfterUse: Boolean)(F: Sync[F]): (F, Byte) => INothing
Writes all bytes to the specified
the
OutputStream
. Set closeAfterUse
to false ifthe
OutputStream
should not be closed after use.Each write operation is performed on the supplied execution context. Writes are
blocking so the execution context should be configured appropriately.
blocking so the execution context should be configured appropriately.