Class QUICStream

Hierarchy

  • CreateDestroy
    • QUICStream

Implements

  • ReadableWritablePair<Uint8Array, Uint8Array>

Constructors

constructor

Properties

[initLock] _readClosed _writeClosed closedP codeToReason connection initiated logger readable readableChunk? readableController reasonToCode rejectReadableP? rejectWritableP? resolveClosedP resolveReadableP? resolveWritableP? streamId type writable writableController

Accessors

[destroyed] [eventHandled] [eventHandlers] [eventTarget] [handleEventError] [statusP] [status] closed meta readClosed writeClosed

Methods

addEventListener cancel destroy dispatchEvent handleEventQUICStreamCloseRead handleEventQUICStreamCloseWrite handleEventQUICStreamError readableCancel readablePull readableStart removeEventListener writableAbort writableClose writableStart writableWrite createQUICStream

Constructors

constructor

Properties

Readonly [initLock]

[initLock]: RWLockWriter

Protected _readClosed

_readClosed: boolean = false

Protected _writeClosed

_writeClosed: boolean = false

Readonly closedP

closedP: Promise<void>

Protected codeToReason

codeToReason: StreamCodeToReason

Protected connection

connection: QUICConnection

Readonly initiated

initiated: "peer" | "local"

Protected logger

logger: Logger

Readonly readable

readable: ReadableStream<Uint8Array>

Protected Optional readableChunk

readableChunk?: Buffer

Protected readableController

readableController: ReadableStreamDefaultController<any>

Protected reasonToCode

reasonToCode: StreamReasonToCode

Protected Optional rejectReadableP

rejectReadableP?: ((reason?) => void)

Type declaration

    • (reason?): void

    • Parameters

      • Optional reason: any

      Returns void

Protected Optional rejectWritableP

rejectWritableP?: ((reason?) => void)

Type declaration

    • (reason?): void

    • Parameters

      • Optional reason: any

      Returns void

Protected resolveClosedP

resolveClosedP: (() => void)

Type declaration

    • (): void

    • Returns void

Protected Optional resolveReadableP

resolveReadableP?: (() => void)

Type declaration

    • (): void

    • Returns void

Protected Optional resolveWritableP

resolveWritableP?: (() => void)

Type declaration

    • (): void

    • Returns void

Readonly streamId

streamId: StreamId

Readonly type

type: "bidi" | "uni"

Readonly writable

writable: WritableStream<Uint8Array>

Protected writableController

writableController: WritableStreamDefaultController

Accessors

[destroyed]

  • get [destroyed](): boolean

  • Returns boolean

[eventHandled]

  • get [eventHandled](): ReadonlyWeakSet<Event>

  • Returns ReadonlyWeakSet<Event>

[eventHandlers]

  • get [eventHandlers](): ReadonlyMap<string, Set<EventHandlerInfo>>

  • Returns ReadonlyMap<string, Set<EventHandlerInfo>>

[eventTarget]

  • get [eventTarget](): EventTarget

  • Returns EventTarget

[handleEventError]

  • get [handleEventError](): ((evt) => void)

  • Returns ((evt) => void)

      • (evt): void

      • Parameters

        • evt: EventError

        Returns void

[statusP]

  • get [statusP](): Promise<Status>

  • Returns Promise<Status>

[status]

  • get [status](): Status

  • Returns Status

closed

meta

readClosed

  • get readClosed(): boolean

  • Returns true if the readable has closed.

    Returns boolean

writeClosed

  • get writeClosed(): boolean

  • Returns true of the writable has closed.

    Returns boolean

Methods

addEventListener

  • Parameters

    • type: string
    • callback: null | EventListenerOrEventListenerObject
    • Optional options: boolean | AddEventListenerOptions

    Returns void

cancel

  • Cancels the readable and aborts the writable.

    If streams have already closed or cancelled then this will do nothing. If the underlying quiche streams already closed then this will do nothing.

    Cancellation will occur in the background.

    Parameters

    • Optional reason: any

    Returns void

    Throws

    • if cancel fails

destroy

  • Destroy the QUIC stream.

    Parameters

    • opts: {
          force?: boolean;
          reason?: any;
      } = {}
      • Optional force?: boolean

        if true, this will cancel readable and abort writable.

      • Optional reason?: any

        the reason to send to the peer, and if readable and writable is cancelled and aborted, then this will be the readable and writable error.

    Returns Promise<void>

    Throws

    • if cancel fails

dispatchEvent

  • Parameters

    • event: Event

    Returns boolean

Protected handleEventQUICStreamCloseRead

  • Handles EventQUICStreamCloseRead. Registered once.

    Returns Promise<void>

Protected handleEventQUICStreamCloseWrite

  • Handles EventQUICStreamCloseWrite. Registered once.

    Returns Promise<void>

Protected handleEventQUICStreamError

  • Handles EventQUICStreamError.

    This event propagates all errors relating to locally cancelling or aborting the readable or writable, or receiving a RESET_STREAM or STOP_SENDING on the readable or writable respectively.

    Internal errors will be thrown upwards to become an uncaught exception.

    Parameters

    Returns void

    Throws

Protected readableCancel

  • ReadableStream ensures that this method is idempotent

    Parameters

    • Optional reason: any

    Returns void

    Throws

Protected readablePull

  • Serialised by ReadableStream.

    Returns Promise<void>

    Throws

Protected readableStart

  • Parameters

    • controller: ReadableStreamDefaultController<any>

    Returns void

removeEventListener

  • Parameters

    • type: string
    • callback: null | EventListenerOrEventListenerObject
    • Optional options: boolean | EventListenerOptions

    Returns void

Protected writableAbort

  • WritableStream ensures that this method is idempotent.

    Parameters

    • Optional reason: any

    Returns void

    Throws

Protected writableClose

  • Serialised with this.writableWrite by WritableStream.

    Returns void

    Throws

Protected writableStart

  • Parameters

    • controller: WritableStreamDefaultController

    Returns void

Protected writableWrite

  • Serialised with this.writableClose by WritableStream.

    Parameters

    • chunk: Uint8Array

    Returns Promise<void>

    Throws

Static createQUICStream

  • Creates a QUIC stream.

    This creation is synchronous as it avoids the need for concurrent locking for generating new stream IDs.

    Parameters

    • opts: {
          codeToReason?: StreamCodeToReason;
          config: QUICConfig;
          connection: QUICConnection;
          initiated: "peer" | "local";
          logger?: Logger;
          reasonToCode?: StreamReasonToCode;
          streamId: StreamId;
      }
      • Optional codeToReason?: StreamCodeToReason

        maps stream error codes to reasons

      • config: QUICConfig

        QUIC config

      • connection: QUICConnection

        QUIC connection

      • initiated: "peer" | "local"

        local or peer initiated stream

      • Optional logger?: Logger

        The reasonToCode defaults to returning 0 as the code. The codeToReason defaults to returning Error instance.

      • Optional reasonToCode?: StreamReasonToCode

        maps stream error reasons to stream error codes

      • streamId: StreamId

        stream ID

    Returns QUICStream

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc