Options
All
  • Public
  • Public/Protected
  • All
Menu

Class MapDownlink<K, V, KU, VU>

Type parameters

  • K: KU

  • V: VU

  • KU

  • VU

Hierarchy

Implements

Index

Accessors

Methods

Accessors

size

  • get size(): number

Methods

bindInput

  • bindInput(input: MapOutlet<K, V, Map<K, V>>): void

bindOutput

body

clear

  • clear(): void

close

  • close(): void

command

Protected copy

  • copy(context: DownlinkContext, owner: DownlinkOwner | undefined, hostUri: Uri, nodeUri: Uri, laneUri: Uri, prio: number, rate: number, body: Value, flags: number, observers: ReadonlyArray<MapDownlinkObserver<K, V, KU, VU>> | null, keyForm?: Form<K, KU>, valueForm?: Form<V, VU>, state0?: BTree<Value, Value>): this

delete

  • delete(key: KU): boolean

didClear

didClose

didConnect

didDisconnect

didDrop

didFail

Protected didInvalidate

  • didInvalidate(): void

Protected didInvalidateKey

  • didInvalidateKey(key: K, effect: KeyEffect): void

didLink

Protected didReconcile

  • didReconcile(version: number): void

Protected didReconcileKey

  • didReconcileKey(key: K, effect: KeyEffect, version: number): void

didRemove

didSync

didTake

didUnlink

didUpdate

disconnectInputs

  • disconnectInputs(): void

disconnectOutputs

  • disconnectOutputs(): void

drop

  • drop(lower: number): this

entries

filter

firstEntry

  • firstEntry(): [K, V] | undefined

firstKey

  • firstKey(): K | undefined

firstValue

  • firstValue(): V | undefined

forEach

  • forEach<T, S>(callback: (this: S, key: K, value: V, downlink: MapDownlink<K, V, KU, VU>) => T | void, thisArg?: S): T | undefined

get

getEntry

  • getEntry(index: number): [K, V] | undefined

has

  • has(key: KU): boolean

hostUri

  • hostUri(): Uri
  • hostUri(hostUri: AnyUri): this

initialState

input

  • input(): MapOutlet<K, V, Map<K, V>> | null

invalidate

  • invalidate(): void

invalidateInput

  • invalidateInput(): void

invalidateInputKey

  • invalidateInputKey(key: K, effect: KeyEffect): void

invalidateKey

  • invalidateKey(key: K, effect: KeyEffect): void

invalidateOutput

  • invalidateOutput(): void

invalidateOutputKey

  • invalidateOutputKey(key: K, effect: KeyEffect): void

isAuthenticated

  • isAuthenticated(): boolean

isConnected

  • isConnected(): boolean

isEmpty

  • isEmpty(): boolean

isLinked

  • isLinked(): boolean

isSynced

  • isSynced(): boolean

keepLinked

  • keepLinked(): boolean
  • keepLinked(keepLinked: boolean): this

keepSynced

  • keepSynced(): boolean
  • keepSynced(keepSynced: boolean): this

keyForm

keyIterator

keys

laneUri

  • laneUri(): Uri
  • laneUri(laneUri: AnyUri): this

lastEntry

  • lastEntry(): [K, V] | undefined

lastKey

  • lastKey(): K | undefined

lastValue

  • lastValue(): V | undefined

map

memoize

  • memoize(): MapOutlet<K, V, MapDownlink<K, V, KU, VU>>

nextEntry

  • nextEntry(keyObject: K): [K, V] | undefined

nextKey

  • nextKey(keyObject: K): K | undefined

nextValue

  • nextValue(keyObject: K): V | undefined

nodeUri

  • nodeUri(): Uri
  • nodeUri(nodeUri: AnyUri): this

observe

onCommand

onEvent

Protected onInvalidate

  • onInvalidate(): void

Protected onInvalidateKey

  • onInvalidateKey(key: K, effect: KeyEffect): void

Protected onReconcile

  • onReconcile(version: number): void

Protected onReconcileKey

  • onReconcileKey(key: K, effect: KeyEffect, version: number): void

open

  • open(): this

outlet

  • outlet(key: K): Outlet<V>

outputIterator

previousEntry

  • previousEntry(keyObject: K): [K, V] | undefined

previousKey

  • previousKey(keyObject: K): K | undefined

previousValue

  • previousValue(keyObject: K): V | undefined

prio

  • prio(): number
  • prio(prio: number): this

rate

  • rate(): number
  • rate(rate: number): this

reconcile

  • reconcile(version: number): void

reconcileInput

  • reconcileInput(version: number): void

reconcileInputKey

  • reconcileInputKey(key: K, version: number): void

reconcileKey

  • reconcileKey(key: K, version: number): void

reconcileOutput

  • reconcileOutput(version: number): void

reconcileOutputKey

  • reconcileOutputKey(key: K, version: number): void

reduce

  • reduce<U>(identity: U, accumulator: (result: U, element: V) => U, combiner: (result: U, result2: U) => U): Outlet<U>

  • Type parameters

    • U

    Parameters

    • identity: U
    • accumulator: (result: U, element: V) => U
        • (result: U, element: V): U

        • Parameters

          • result: U
          • element: V

          Returns U

    • combiner: (result: U, result2: U) => U
        • (result: U, result2: U): U

        • Parameters

          • result: U
          • result2: U

          Returns U

    Returns Outlet<U>

session

set

  • set(key: KU, newValue: VU): this

setState

snapshot

take

  • take(upper: number): this

type

unbindInput

  • unbindInput(): void

unbindOutput

unbindOutputs

  • unbindOutputs(): void

unobserve

  • unobserve(observer: unknown): this

valueForm

  • valueForm(): Form<V, VU>
  • valueForm<V2, V2U>(valueForm: Form<V2, V2U>): MapDownlink<K, V2, KU, V2U>

values

watch

willClear

willDrop

Protected willInvalidate

  • willInvalidate(): void

Protected willInvalidateKey

  • willInvalidateKey(key: K, effect: KeyEffect): void

willLink

Protected willReconcile

  • willReconcile(version: number): void

Protected willReconcileKey

  • willReconcileKey(key: K, effect: KeyEffect, version: number): void

willRemove

willSync

willTake

willUnlink

willUpdate

Static initForm