Options
All
  • Public
  • Public/Protected
  • All
Menu

Class AbstractMap_PrimitiveCRDT<K, V, SetArgs, Events> Abstract

Skeletal implementation of the IMap interface, as a subclass of PrimitiveCRDT.

This class is a convenience for Collab implementers. It provides some default method implementations and leaves the others abstract.

Type Parameters

Hierarchy

Implements

  • IMap<K, V, SetArgs, Events>

Index

Constructors

  • Initializes this Collab with the given InitToken.

    The InitToken must have provided by our parent explicitly for this constructor call.

    Typically, a Collab subclass takes init as its first constructor argument and calls super(init).

    Type Parameters

    Parameters

    Returns AbstractMap_PrimitiveCRDT<K, V, SetArgs, Events>

Properties

name: string

Internal (this/parent) use only.

This Collab's name, which distinguishes it among its siblings in the tree of Collabs.

parent: Parent

Internal (this/parent) use only.

This Collab's parent in the tree of Collabs.

runtime: IRuntime

The ambient IRuntime.

Use this to access utilities like IRuntime.replicaID.

size: number

The number of present keys in the map.

Methods

  • [iterator](): IterableIterator<[K, V]>
  • Returns an iterator for entries in the map.

    The iteration order is NOT eventually consistent: it may differ on replicas with the same state.

    Returns IterableIterator<[K, V]>

  • canGC(): boolean
  • Internal (parent) use only.

    If this Collab is in its initial, post-constructor state, then this method may (but is not required to) return true; otherwise, it returns false.

    By default, this method always returns false; override to change.

    If this method returns true:

    1. The parent may choose to weakly reference this object to save memory (e.g., CLazyMap does so). If this becomes garbage collected, then is needed later, the parent will recreate it using the same constructor call.
    2. The parent may skip calling save during saving. When loading the resulting saved state, the parent will call load(null, meta). load should process this as if called with the output of save from a garbage-collectable state. For a nontrivial example, see [[CMultiValueMap.load]]'s implementation.

    Returns boolean

  • clear(): void
  • Deletes every key in the map.

    Returns void

  • delete(key: K): void
  • Deletes the given key, making it no longer present in this map.

    Parameters

    • key: K

    Returns void

  • emit<K>(eventName: K, event: Events[K] & CollabEvent, options?: { skipAnyEvent?: boolean }): void
  • Emits an event, which triggers all the registered event handlers.

    See CollabEventsRecord for advice on what events to emit.

    This is a wrapper around EventEmitter.emit that forces events to extend CollabEvent and also emits an "Any" event.

    Type Parameters

    • K extends string | number | symbol

    Parameters

    • eventName: K
    • event: Events[K] & CollabEvent
    • Optional options: { skipAnyEvent?: boolean }
      • Optional skipAnyEvent?: boolean

        Set to true to skip emitting an "Any" event.

    Returns void

  • entries(): IterableIterator<[K, V]>
  • Returns an iterator of key, value pairs for every entry in the map.

    The iteration order is NOT eventually consistent: it may differ on replicas with the same state.

    Returns IterableIterator<[K, V]>

  • finalize(): void
  • Internal (parent) use only.

    Called by this Collab's parent when it has been deleted from a collection on the local replica and can no longer be used (e.g., due to CSet.delete on this or an ancestor). A Collab implementation can implement this method to clean up external resources, e.g., associated DOM elements.

    finalize has no relation to the JavaScript garbage collector or canGC.

    By default, this method does nothing.

    Returns void

  • forEach(callbackfn: ((value: V, key: K, map: AbstractMap_PrimitiveCRDT<K, V, SetArgs, Events>) => void), thisArg?: any): void
  • Executes a provided function once for each (key, value) pair in the map, in the same order as entries.

    Parameters

    Returns void

  • get(key: K): undefined | V
  • Returns the value associated to key, or undefined if key is not present.

    Parameters

    • key: K

    Returns undefined | V

  • has(key: K): boolean
  • Returns whether key is present in the map.

    Parameters

    • key: K

    Returns boolean

  • keyOf(searchElement: V): undefined | K
  • Returns the key for some occurrence of a value searchElement in this map, or undefined if searchElement is not associated with any key.

    Parameters

    • searchElement: V

    Returns undefined | K

  • keys(): IterableIterator<K>
  • Returns an iterator for keys in the map.

    The iteration order is NOT eventually consistent: it may differ on replicas with the same state.

    Returns IterableIterator<K>

  • Internal (parent) use only.

    Called by this Collab's parent to load saved state. You may assume that the saved state was generated by save on some replica of this Collab, possibly in a different collaboration session, with guarantees set by the runtime.

    This method may also be called with savedStateTree = null; you should ignore such calls (i.e., return immediately) unless you override canGC. If you do override canGC, see that method's docs for instructions.

    Parameters

    Returns void

  • Called by this Collab's parent to load some saved state. You may assume that the saved state was generated by saveCRDT on some replica of this Collab, possibly in a different collaboration session, with guarantees set by the runtime.

    This method may also be called with savedState = null; you should ignore such calls (i.e., return immediately) unless you override canGC. If you do override canGC, see that method's docs for instructions.

    Parameters

    • savedState: null | Uint8Array

      The saved state to load, or null as described above.

    • meta: SavedStateMeta

      Generic metadata attached to this message by the CRuntime. Note that meta.updateType is always "savedState".

    • crdtMeta: CRDTSavedStateMeta

      CRDT-specific metadata attached to this message by the CRuntime. It contains all fields and vector clock entries.

    Returns void

  • loadPrimitive(savedState: null | Uint8Array, meta: SavedStateMeta): void
  • Called by this Collab's parent to load some saved state. You may assume that the saved state was generated by savePrimitive on some replica of this Collab, possibly in a different collaboration session, with guarantees set by the runtime.

    This method may also be called with savedState = null; you should ignore such calls (i.e., return immediately) unless you override canGC. If you do override canGC, see that method's docs for instructions.

    Parameters

    Returns void

  • on<K>(eventName: K, handler: ((event: Events[K], caller: AbstractMap_PrimitiveCRDT<K, V, SetArgs, Events>) => void), options?: { once?: boolean }): (() => void)
  • Registers an event handler that is triggered when the event happens.

    Type Parameters

    • K extends string | number | symbol

    Parameters

    • eventName: K

      Name of the event to listen on.

    • handler: ((event: Events[K], caller: AbstractMap_PrimitiveCRDT<K, V, SetArgs, Events>) => void)

      Callback that handles the event.

    • Optional options: { once?: boolean }
      • Optional once?: boolean

        If true, the event handler is triggered at most once (the next time the event happens), then unsubscribed.

    Returns (() => void)

    An "off" function that removes the event handler when called.

      • (): void
      • Registers an event handler that is triggered when the event happens.

        Returns void

        An "off" function that removes the event handler when called.

  • receive(messageStack: (string | Uint8Array)[], meta: MessageMeta): void
  • Internal (parent) use only.

    Receives a message sent by send on a local or remote replica of this Collab.

    This method processes the message, changes the local state accordingly, and emits events describing the local changes.

    This method should make assumptions and ensure consistency guarantees appropriate to its use case. For example, CRDTs may assume eventual, exactly-once, causal-order message delivery, and they must ensure strong eventual consistency.

    Parameters

    Returns void

  • Receives a message sent by sendCRDT on a local or remote replica of this PrimitiveCRDT.

    This method processes the message, changes the local state accordingly, and emits events describing the local changes.

    This method may assume eventual, exactly-once, causal-order message delivery, and it must ensure strong eventual consistency.

    See Collab.receive.

    Parameters

    • message: string | Uint8Array

      The message sent by sendCRDT.

    • meta: MessageMeta

      Generic metadata attached to this message by the CRuntime. Note that meta.updateType is always "message".

    • crdtMeta: CRDTMessageMeta

      CRDT-specific metadata attached to this message by the CRuntime. It contains all fields that were accessed during the sender's local call to receiveCRDT, plus requests made in sendCRDT.

    Returns void

  • receivePrimitive(message: string | Uint8Array, meta: MessageMeta): void
  • Internal (parent) use only.

    Returns saved state describing the current state of this Collab.

    The saved state may later be passed to load on a replica of this Collab, possibly in a different collaboration session, with rules set by the runtime. For example, CRuntime allows load at any time; it must then act as a merge operation (like a state-based CRDT), applying all updates that the saved replica had applied before saving, ignoring duplicates.

    save may be called at any time, possibly many times while an app is running. Calling save should not affect this Collab's user-visible state.

    For convenience, the saved state may be expressed as a tree of Uint8Arrays instead of just a single Uint8Array; see [[SaveStateTree]]'s docs.

    Returns SavedStateTree

    The saved state.

  • saveCRDT(): Uint8Array
  • Returns saved state describing the current state of this Collab.

    The saved state may later be passed to loadCRDT on a replica of this Collab, possibly in a different collaboration session, with rules set by the runtime. For example, CRuntime allows load to be called only at the beginning of a session, before sending or receiving any messages.

    saveCRDT may be called at any time, possibly many times while an app is running. Calling saveCRDT should not affect this Collab's user-visible state.

    Returns Uint8Array

    The saved state.

  • savePrimitive(): Uint8Array
  • Returns saved state describing the current state of this Collab.

    The saved state may later be passed to loadPrimitive on a replica of this Collab, possibly in a different collaboration session, with rules set by the runtime. For example, CRuntime allows load to be called only at the beginning of a session, before sending or receiving any messages.

    savePrimitive may be called at any time, possibly many times while an app is running. Calling savePrimitive should not affect this Collab's user-visible state.

    Returns Uint8Array

    The saved state.

  • send(messageStack: (string | Uint8Array)[], metaRequests: MetaRequest[]): void
  • Broadcasts a message to other replicas of this Collab. The message will be delivered to all replicas' receive, including locally.

    For convenience, the message may be expressed as a stack of (Uint8Array | string), instead of just a single Uint8Array. This is useful for parents sending messages on behalf of their children; see the implementation of CObject for an example.

    Parameters

    • messageStack: (string | Uint8Array)[]

      The message to send, in the form of a stack of Uint8Arrays. Note that this method may mutate it in-place.

    • metaRequests: MetaRequest[]

      A stack of metadata requests. The runtime will use the union of these when creating the MessageMeta for receive. Note that the stack need not align with messageStack, and this method may mutate it in place.

    Returns void

  • sendCRDT(message: string | Uint8Array, metaRequest?: CRDTMetaRequest): void
  • Broadcasts a message to other replicas of this CRDT. The message will be delivered to all replicas' receiveCRDT, including locally.

    Call this method instead of Collab.send or CPrimitive.sendPrimitive.

    By default, receiveCRDT's crdtMeta will contain all fields that are accessed during the sender's local call to receiveCRDT. You can request additional fields with metaRequest.

    Parameters

    • message: string | Uint8Array

      The message to send.

    • Optional metaRequest: CRDTMetaRequest

    Returns void

  • sendPrimitive(message: string | Uint8Array, metaRequest?: MetaRequest): void
  • set(key: K, ...args: SetArgs): undefined | V
  • Sets the value at key using args.

    Typically, args are broadcast to all replicas in serialized form. Every replica then uses them to contruct the actual value of type V.

    Parameters

    • key: K
    • Rest ...args: SetArgs

    Returns undefined | V

    The set value, or undefined if it is not constructed immediately.

  • toString(): string
  • Returns string

  • values(): IterableIterator<V>
  • Returns an iterator for values in the map.

    The iteration order is NOT eventually consistent: it may differ on replicas with the same state.

    Returns IterableIterator<V>

Generated using TypeDoc