Options
All
  • Public
  • Public/Protected
  • All
Menu

Class CVar<T>

A collaborative variable of type T.

A CVar<T> represents an opaque value of type T. Set and get the value with value. If multiple users set the value concurrently, one of them is picked arbitrarily.

Values must be internally immutable; mutating value internally will not change it on other replicas. To store (a reference to) a mutable value of type T, use a CVar<CollabID<C>>, where C is a Collab representing T. (Example)

See also: CBoolean, CCounter.

Type Parameters

  • T

    The variable type.

Hierarchy

Implements

  • IVar<T>

Index

Constructors

  • new CVar<T>(init: InitToken, initialValue: T, options?: { aggregator?: Aggregator<T>; valueSerializer?: Serializer<T> }): CVar<T>
  • Constructs a CVar with the given initialValue. The initialValue is used as the value before any value is set or just after clear is called.

    Type Parameters

    • T

    Parameters

    • init: InitToken
    • initialValue: T
    • options: { aggregator?: Aggregator<T>; valueSerializer?: Serializer<T> } = {}
      • Optional aggregator?: Aggregator<T>

        If provided, used to "aggregate" concurrently-set values, instead of picking one arbitrarily.

      • Optional valueSerializer?: Serializer<T>

        Serializer for set values. Defaults to [[DefaultSerializer]].

    Returns CVar<T>

Properties

children: Map<string, Collab<CollabEventsRecord>>

The children (registered Collab properties), keyed by name.

This map should only be read, not mutated. It is exposed to subclasses as a convenience for methods that loop over all children.

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]].

Accessors

  • get value(): T
  • set value(value: T): void

Methods

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

    By default, this method returns true if canGC returns true on every child. Override to change this behavior.

    See [[Collab.canGC]].

    Returns boolean

  • childSend(child: Collab<CollabEventsRecord>, messageStack: (string | Uint8Array)[], metaRequests: MetaRequest[]): void
  • Parameters

    • child: Collab<CollabEventsRecord>
    • messageStack: (string | Uint8Array)[]
    • metaRequests: MetaRequest[]

    Returns void

  • clear(): void
  • Resets this CVar to its initial state, so that its value is the constructor's initialValue.

    Unlike directly setting the value to initialValue, this operation clears the conflicts set, and a concurrent set-value operation will always win over this operation.

    A cleared CVar satisfies [[Collab.canGC]] and so can be "garbage collected" by [[CLazyMap]].

    Returns void

  • conflicts(): T[]
  • Returns all conflicting concurrently-set values. Their order is arbitrary but consistent across replicas.

    If this CVar was just initialized or clear was just called, this returns []. Otherwise, its first element is the set value.

    Returns T[]

  • emit<K>(eventName: K, event: VarEventsRecord<T>[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 keyof VarEventsRecord<T>

    Parameters

    • eventName: K
    • event: VarEventsRecord<T>[K] & CollabEvent
    • Optional options: { skipAnyEvent?: boolean }
      • Optional skipAnyEvent?: boolean

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

    Returns void

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

    By default, this methods calls finalize on every child. Override to change this behavior, e.g., to add your own finalization steps (but consider calling super.finalize()).

    Returns void

  • fromID<C>(id: CollabID<C>, startIndex?: number): undefined | C
  • Type Parameters

    • C extends Collab<CollabEventsRecord, C>

    Parameters

    • id: CollabID<C>
    • Optional startIndex: number

    Returns undefined | C

  • idOf<C>(descendant: C): CollabID<C>
  • Type Parameters

    • C extends Collab<CollabEventsRecord, C>

    Parameters

    • descendant: C

    Returns CollabID<C>

  • load(savedStateTree: null | SavedStateTree, meta: SavedStateMeta): void
  • Internal (parent) use only.

    Called by this Collab's parent to load saved state. See [[Collab.load]].

    A CObject subclass may override this method to load additional state from [[Collab.save]] or to perform extra setup - e.g., refreshing functional views that were not automatically updated by children's load events. It is recommended to do so as follows:

    load(savedStateTree: SavedStateTree | null, meta: SavedStateMeta) {
    super.load(savedStateTree, meta);
    // Process your extra saved state from savedStateTree.self.
    const savedState = savedStateTree === null? null: savedStateTree.self!;
    ...
    // Perform extra setup as needed.
    ...
    }

    Parameters

    • savedStateTree: null | SavedStateTree
    • meta: SavedStateMeta

    Returns void

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

    Type Parameters

    • K extends keyof VarEventsRecord<T>

    Parameters

    • eventName: K

      Name of the event to listen on.

    • handler: ((event: VarEventsRecord<T>[K], caller: CVar<T>) => void)

      Callback that handles the event.

        • (event: VarEventsRecord<T>[K], caller: CVar<T>): void
        • Parameters

          • event: VarEventsRecord<T>[K]
          • caller: CVar<T>

          Returns void

    • 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
  • Parameters

    • messageStack: (string | Uint8Array)[]
    • meta: MessageMeta

    Returns void

  • registerCollab<C>(name: string, collabCallback: ((init: InitToken) => C)): C
  • Registers a [[Collab]] property of this CObject with the given name, making it one of our children.

    Typically, you will call this method during the constructor in the style:

    this.foo = this.registerCollab("foo", (init) => new FooClass(init, constructor args...));
    

    where readonly foo: FooClass; is a Collab property. See Data Modeling for examples.

    Registrations must be identical across all replicas.

    See also: CRuntime.registerCollab.

    Type Parameters

    • C extends Collab<CollabEventsRecord, C>

    Parameters

    • name: string

      A name for this property, unique among this class's registerCollab calls. We recommend using the same name as the property, but you can also use short strings to reduce network usage ("", "0", "1", ...).

    • collabCallback: ((init: InitToken) => C)

      A callback that uses the given [[InitToken]] to construct the registered [[Collab]].

        • (init: InitToken): C
        • Parameters

          • init: InitToken

          Returns C

    Returns C

    The registered Collab.

  • save(): SavedStateTree
  • Internal (parent) use only.

    Returns saved state describing the current state of this CObject. See [[Collab.save]].

    A CObject subclass may override this method to save additional state. It is recommended to do so as follows:

    save() {
    const ans = super.save();
    // Put your extra saved state in ans.self, which is otherwise unused.
    ans.self = <subclass's saved state>;
    return ans;
    }

    Returns SavedStateTree

  • 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

  • set(value: T): T
  • Sets the current value. Equivalent to this.value = value.

    Parameters

    • value: T

    Returns T

    value

  • toString(): string

Generated using TypeDoc