Class DictionaryLiveAdapter

Live trading dictionary adapter with pluggable storage backend.

Features:

  • Adapter pattern for swappable dictionary instance implementations
  • Default backend: DictionaryPersistInstance (file-system backed, survives restarts)
  • Alternative backends: DictionaryLocalInstance, DictionaryDummyInstance
  • Convenience methods: useLocal(), usePersist(), useDummy(), useDictionaryAdapter()
  • Memoized instances per (signalId, dictionaryName) pair; cleared via disposeSignal() from Dictionary.enable

Implements

  • TDictionaryAdapter

Constructors

constructor

Properties

clear delete disposeSignal entries get has keys set size useDictionaryAdapter useDummy useLocal usePersist values

Constructors

constructor

Properties

clear

clear: (
    dto: { dictionaryName: string; signalId: string; when: Date },
) => Promise<void>

Remove all entries for a signal (hard delete).

delete

delete: (
    dto: { dictionaryName: string; signalId: string; when: Date },
    key: string,
) => Promise<boolean>

Remove the entry under key for a signal (hard delete).

Type declaration

    • (
          dto: { dictionaryName: string; signalId: string; when: Date },
          key: string,
      ): Promise<boolean>

    • Parameters

      • dto: { dictionaryName: string; signalId: string; when: Date }
        • dictionaryName: string

          Dictionary name

        • signalId: string

          Signal identifier

        • when: Date

          Logical timestamp at which the delete is happening

      • key: string

        Entry key

      Returns Promise<boolean>

      true if an entry existed and was removed

disposeSignal

disposeSignal: (signalId: string) => void

Disposes all memoized instances for the given signalId. Called by Dictionary.enable subscription when a signal is cancelled or closed.

Type declaration

    • (signalId: string): void

    • Parameters

      • signalId: string

        Signal identifier to dispose

      Returns void

entries

entries: <Value = unknown>(
    dto: { dictionaryName: string; signalId: string; when: Date },
) => Promise<[string, Value][]>

List [key, value] pairs of visible entries for a signal (look-ahead-guarded).

Type declaration

    • <Value = unknown>(
          dto: { dictionaryName: string; signalId: string; when: Date },
      ): Promise<[string, Value][]>

    • Type Parameters

      • Value = unknown

      Parameters

      • dto: { dictionaryName: string; signalId: string; when: Date }
        • dictionaryName: string

          Dictionary name

        • signalId: string

          Signal identifier

        • when: Date

          Logical timestamp at which the read is happening (look-ahead guard)

      Returns Promise<[string, Value][]>

      Array of [key, value] tuples

get

get: <Value = unknown>(
    dto: { dictionaryName: string; signalId: string; when: Date },
    key: string,
) => Promise<Value>

Read the value stored under key for a signal.

Type declaration

    • <Value = unknown>(
          dto: { dictionaryName: string; signalId: string; when: Date },
          key: string,
      ): Promise<Value>

    • Type Parameters

      • Value = unknown

      Parameters

      • dto: { dictionaryName: string; signalId: string; when: Date }
        • dictionaryName: string

          Dictionary name

        • signalId: string

          Signal identifier

        • when: Date

          Logical timestamp at which the read is happening (look-ahead guard)

      • key: string

        Entry key

      Returns Promise<Value>

      Stored value, or null

has

has: (
    dto: { dictionaryName: string; signalId: string; when: Date },
    key: string,
) => Promise<boolean>

Check whether a visible entry exists under key for a signal.

Type declaration

    • (
          dto: { dictionaryName: string; signalId: string; when: Date },
          key: string,
      ): Promise<boolean>

    • Parameters

      • dto: { dictionaryName: string; signalId: string; when: Date }
        • dictionaryName: string

          Dictionary name

        • signalId: string

          Signal identifier

        • when: Date

          Logical timestamp at which the check is happening (look-ahead guard)

      • key: string

        Entry key

      Returns Promise<boolean>

      true if a visible entry exists

keys

keys: (
    dto: { dictionaryName: string; signalId: string; when: Date },
) => Promise<string[]>

List keys of visible entries for a signal (look-ahead-guarded).

Type declaration

    • (
          dto: { dictionaryName: string; signalId: string; when: Date },
      ): Promise<string[]>

    • Parameters

      • dto: { dictionaryName: string; signalId: string; when: Date }
        • dictionaryName: string

          Dictionary name

        • signalId: string

          Signal identifier

        • when: Date

          Logical timestamp at which the read is happening (look-ahead guard)

      Returns Promise<string[]>

      Array of keys

set

set: <Value = unknown>(
    dto: { dictionaryName: string; signalId: string; when: Date },
    key: string,
    value: Value,
) => Promise<void>

Write value under key for a signal.

Type declaration

    • <Value = unknown>(
          dto: { dictionaryName: string; signalId: string; when: Date },
          key: string,
          value: Value,
      ): Promise<void>

    • Type Parameters

      • Value = unknown

      Parameters

      • dto: { dictionaryName: string; signalId: string; when: Date }
        • dictionaryName: string

          Dictionary name

        • signalId: string

          Signal identifier

        • when: Date

          Logical timestamp this value belongs to

      • key: string

        Entry key

      • value: Value

        Value to store

      Returns Promise<void>

size

size: (
    dto: { dictionaryName: string; signalId: string; when: Date },
) => Promise<number>

Count visible entries for a signal (look-ahead-guarded).

Type declaration

    • (dto: { dictionaryName: string; signalId: string; when: Date }): Promise<number>

    • Parameters

      • dto: { dictionaryName: string; signalId: string; when: Date }
        • dictionaryName: string

          Dictionary name

        • signalId: string

          Signal identifier

        • when: Date

          Logical timestamp at which the read is happening (look-ahead guard)

      Returns Promise<number>

      Number of visible entries

useDictionaryAdapter

useDictionaryAdapter: (Ctor: TDictionaryInstanceCtor) => void

Switches to a custom dictionary adapter implementation.

Type declaration

useDummy

useDummy: () => void

Switches to dummy adapter that discards all writes.

useLocal

useLocal: () => void

Switches to in-memory adapter. All data lives in process memory only.

usePersist

usePersist: () => void

Switches to file-system backed adapter (default). Data is persisted to disk via PersistDictionaryAdapter.

values

values: <Value = unknown>(
    dto: { dictionaryName: string; signalId: string; when: Date },
) => Promise<Value[]>

List values of visible entries for a signal (look-ahead-guarded).

Type declaration

    • <Value = unknown>(
          dto: { dictionaryName: string; signalId: string; when: Date },
      ): Promise<Value[]>

    • Type Parameters

      • Value = unknown

      Parameters

      • dto: { dictionaryName: string; signalId: string; when: Date }
        • dictionaryName: string

          Dictionary name

        • signalId: string

          Signal identifier

        • when: Date

          Logical timestamp at which the read is happening (look-ahead guard)

      Returns Promise<Value[]>

      Array of values

Settings

Member Visibility

On This Page

Constructors
Properties