The path to the file the stream is writing to as specified in the first argument to {@link createWriteStream}. If path is passed as a string, thenwriteStream.path will be a string. If path is passed as a Buffer, thenwriteStream.path will be a Buffer.

pending

var pending: Boolean

This property is true if the underlying file has not been opened yet, i.e. before the 'ready' event is emitted.

readonlyWritable

val readonlyWritable: Boolean

Is true if it is safe to call writable.write(), which means the stream has not been destroyed, errored, or ended.

writable

open override var writable: Boolean

writableCorked

open val writableCorked: Double

Number of times writable.uncork() needs to be called in order to fully uncork the stream.

writableEnded

open val writableEnded: Boolean

Is true after writable.end() has been called. This property does not indicate whether the data has been flushed, for this use writable.writableFinished instead.

writableFinished

open val writableFinished: Boolean

Is set to true immediately before the 'finish' event is emitted.

writableHighWaterMark

open val writableHighWaterMark: Double

Return the value of highWaterMark passed when creating this Writable.

writableLength

open val writableLength: Double

This property contains the number of bytes (or objects) in the queue ready to be written. The value provides introspection data regarding the status of the highWaterMark.

writableNeedDrain

open val writableNeedDrain: Boolean

Is true if the stream's buffer has been full and stream will emit 'drain'.

writableObjectMode

open val writableObjectMode: Boolean

Getter for the property objectMode of a given Writable stream.

Functions

_destroy

open fun _destroy(error: JsError?, callback: (JsError?) -> Unit)

_final

open fun _final(callback: (JsError?) -> Unit)

_write

open fun _write(chunk: Any?, encoding: BufferEncoding, callback: (JsError?) -> Unit)

addListener

open override fun addListener(event: Symbol, listener: Function<Unit>)

open override fun addListener(event: String, listener: Function<Unit>)

fun addListener(event: WriteStreamEvent.DRAIN, listener: () -> Unit)

fun addListener(event: WriteStreamEvent.ERROR, listener: (JsError) -> Unit)

fun addListener(event: WriteStreamEvent.FINISH, listener: () -> Unit)

fun addListener(event: WriteStreamEvent.OPEN, listener: (fd: Double) -> Unit)

fun addListener(event: WriteStreamEvent.PIPE, listener: (src: Readable) -> Unit)

fun addListener(event: WriteStreamEvent.READY, listener: () -> Unit)

fun addListener(event: WriteStreamEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun addListener(event: WritableEvent.DRAIN, listener: () -> Unit)

fun addListener(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun addListener(event: WritableEvent.FINISH, listener: () -> Unit)

fun addListener(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun addListener(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun addListener(event: WriteStreamEvent.CLOSE, listener: () -> Unit)

events.EventEmitter

fun addListener(event: WritableEvent.CLOSE, listener: () -> Unit)

Event emitter The defined events on documents including:

fun close(callback: (err: ErrnoException?) -> Unit = definedExternally)

Closes writeStream. Optionally accepts a callback that will be executed once the writeStreamis closed.

compose

open fun <T : ReadableStream> compose(stream: T, options: StreamComposeOptions = definedExternally): T

open fun <T : ReadableStream> compose(stream: AsyncIterable<T>, options: StreamComposeOptions = definedExternally): T

open fun <T : ReadableStream> compose(stream: JsIterable<T>, options: StreamComposeOptions = definedExternally): T

open fun <T : ReadableStream> compose(stream: ComposeFnParam, options: StreamComposeOptions = definedExternally): T

cork

open fun cork()

The writable.cork() method forces all written data to be buffered in memory. The buffered data will be flushed when either the {@link uncork} or {@link end} methods are called.

destroy

open fun destroy()

Destroy the stream. Optionally emit an 'error' event, and emit a 'close' event (unless emitClose is set to false). After this call, the writable stream has ended and subsequent calls to write() or end() will result in an ERR_STREAM_DESTROYED error. This is a destructive and immediate way to destroy a stream. Previous calls to write() may not have drained, and may trigger an ERR_STREAM_DESTROYED error. Use end() instead of destroy if data should flush before close, or wait for the 'drain' event before destroying the stream.

open fun destroy(error: JsError)

emit

fun emit(event: WritableEvent.CLOSE): Boolean

fun emit(event: WritableEvent.DRAIN): Boolean

fun emit(event: WritableEvent.FINISH): Boolean

open fun emit(event: Symbol, vararg args: Any?): Boolean

open fun emit(event: String, vararg args: Any?): Boolean

fun emit(event: WritableEvent.ERROR, err: JsError): Boolean

fun emit(event: WritableEvent.PIPE, src: Readable): Boolean

fun emit(event: WritableEvent.UNPIPE, src: Readable): Boolean

end

open override fun end(cb: () -> Unit)

Calling the writable.end() method signals that no more data will be written to the Writable. The optional chunk and encoding arguments allow one final additional chunk of data to be written immediately before closing the stream.

open override fun end(data: Uint8Array, cb: () -> Unit)

open fun end(chunk: Any?, cb: () -> Unit = definedExternally)

open override fun end(data: String, cb: () -> Unit)

open fun end(chunk: Any?, encoding: BufferEncoding, cb: () -> Unit = definedExternally)

open override fun end(str: String, encoding: BufferEncoding, cb: () -> Unit)

eventNames

fun eventNames(): Array<Any>

Returns an array listing the events for which the emitter has registered listeners. The values in the array are strings or Symbols.

getMaxListeners

fun getMaxListeners(): Double

Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to {@link defaultMaxListeners}.

open override fun on(event: Symbol, listener: Function<Unit>)

open override fun on(event: String, listener: Function<Unit>)

fun on(event: WriteStreamEvent.CLOSE, listener: () -> Unit)

fun on(event: WriteStreamEvent.DRAIN, listener: () -> Unit)

fun on(event: WriteStreamEvent.ERROR, listener: (JsError) -> Unit)

fun on(event: WriteStreamEvent.FINISH, listener: () -> Unit)

fun on(event: WriteStreamEvent.OPEN, listener: (fd: Double) -> Unit)

fun on(event: WriteStreamEvent.PIPE, listener: (src: Readable) -> Unit)

fun on(event: WriteStreamEvent.READY, listener: () -> Unit)

fun on(event: WriteStreamEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun on(event: WritableEvent.CLOSE, listener: () -> Unit)

fun on(event: WritableEvent.DRAIN, listener: () -> Unit)

fun on(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun on(event: WritableEvent.FINISH, listener: () -> Unit)

fun on(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun on(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

once

open override fun once(event: Symbol, listener: Function<Unit>)

open override fun once(event: String, listener: Function<Unit>)

fun once(event: WriteStreamEvent.CLOSE, listener: () -> Unit)

fun once(event: WriteStreamEvent.DRAIN, listener: () -> Unit)

fun once(event: WriteStreamEvent.ERROR, listener: (JsError) -> Unit)

fun once(event: WriteStreamEvent.FINISH, listener: () -> Unit)

fun once(event: WriteStreamEvent.OPEN, listener: (fd: Double) -> Unit)

fun once(event: WriteStreamEvent.PIPE, listener: (src: Readable) -> Unit)

fun once(event: WriteStreamEvent.READY, listener: () -> Unit)

fun once(event: WriteStreamEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun once(event: WritableEvent.CLOSE, listener: () -> Unit)

fun once(event: WritableEvent.DRAIN, listener: () -> Unit)

fun once(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun once(event: WritableEvent.FINISH, listener: () -> Unit)

fun once(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun once(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

pipe

fun <T : WritableStream> pipe(destination: T, options: StreamPipeOptions = definedExternally): T

prependListener

open override fun prependListener(event: Symbol, listener: Function<Unit>)

open override fun prependListener(event: String, listener: Function<Unit>)

fun prependListener(event: WriteStreamEvent.CLOSE, listener: () -> Unit)

fun prependListener(event: WriteStreamEvent.DRAIN, listener: () -> Unit)

fun prependListener(event: WriteStreamEvent.ERROR, listener: (JsError) -> Unit)

fun prependListener(event: WriteStreamEvent.FINISH, listener: () -> Unit)

fun prependListener(event: WriteStreamEvent.OPEN, listener: (fd: Double) -> Unit)

fun prependListener(event: WriteStreamEvent.PIPE, listener: (src: Readable) -> Unit)

fun prependListener(event: WriteStreamEvent.READY, listener: () -> Unit)

fun prependListener(event: WriteStreamEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun prependListener(event: WritableEvent.CLOSE, listener: () -> Unit)

fun prependListener(event: WritableEvent.DRAIN, listener: () -> Unit)

fun prependListener(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun prependListener(event: WritableEvent.FINISH, listener: () -> Unit)

fun prependListener(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun prependListener(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

prependOnceListener

open override fun prependOnceListener(event: Symbol, listener: Function<Unit>)

open override fun prependOnceListener(event: String, listener: Function<Unit>)

fun prependOnceListener(event: WriteStreamEvent.CLOSE, listener: () -> Unit)

fun prependOnceListener(event: WriteStreamEvent.DRAIN, listener: () -> Unit)

fun prependOnceListener(event: WriteStreamEvent.ERROR, listener: (JsError) -> Unit)

fun prependOnceListener(event: WriteStreamEvent.FINISH, listener: () -> Unit)

fun prependOnceListener(event: WriteStreamEvent.OPEN, listener: (fd: Double) -> Unit)

fun prependOnceListener(event: WriteStreamEvent.PIPE, listener: (src: Readable) -> Unit)

fun prependOnceListener(event: WriteStreamEvent.READY, listener: () -> Unit)

fun prependOnceListener(event: WriteStreamEvent.UNPIPE, listener: (src: Readable) -> Unit)

fun prependOnceListener(event: WritableEvent.CLOSE, listener: () -> Unit)

fun prependOnceListener(event: WritableEvent.DRAIN, listener: () -> Unit)

fun prependOnceListener(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun prependOnceListener(event: WritableEvent.FINISH, listener: () -> Unit)

fun prependOnceListener(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun prependOnceListener(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

removeListener

open fun removeListener(event: Symbol, listener: Function<Unit>)

open fun removeListener(event: String, listener: Function<Unit>)

fun removeListener(event: WritableEvent.CLOSE, listener: () -> Unit)

fun removeListener(event: WritableEvent.DRAIN, listener: () -> Unit)

fun removeListener(event: WritableEvent.ERROR, listener: (JsError) -> Unit)

fun removeListener(event: WritableEvent.FINISH, listener: () -> Unit)

fun removeListener(event: WritableEvent.PIPE, listener: (src: Readable) -> Unit)

fun removeListener(event: WritableEvent.UNPIPE, listener: (src: Readable) -> Unit)

setDefaultEncoding

open fun setDefaultEncoding(encoding: BufferEncoding)

The writable.setDefaultEncoding() method sets the default encoding for a Writable stream.

setMaxListeners

fun setMaxListeners(n: Number)

By default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default that helps finding memory leaks. The emitter.setMaxListeners() method allows the limit to be modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.

uncork

open fun uncork()

The writable.uncork() method flushes all data buffered since {@link cork} was called.

write

open override fun write(buffer: Uint8Array, cb: (JsError?) -> Unit): Boolean

open override fun write(buffer: String, cb: (JsError?) -> Unit): Boolean

open fun write(chunk: Any?, encoding: BufferEncoding, callback: (JsError?) -> Unit = definedExternally): Boolean

open override fun write(str: String, encoding: BufferEncoding, cb: (JsError?) -> Unit): Boolean

open fun write(chunk: Any?, callback: (JsError?) -> Unit = definedExternally): Boolean

The writable.write() method writes some data to the stream, and calls the supplied callback once the data has been fully handled. If an error occurs, the callback will be called with the error as its first argument. The callback is called asynchronously and before 'error' is emitted.