Class Memory<E>

constructor

• new Memory<in out E>(_map?): Memory<E>

• Creates a new Memory with no locations set.

  Type Parameters

  • in out E

  Parameters

  • _map: Map<bigint, E> = ...

  Returns Memory<E>

Readonly maxInvalidateSizeAllowed

size

• get size(): number

• Returns number

  the number of values stored in the Memory.

clone

• clone(): Memory<E>

• Creates a shallow copy of this Memory. That is, the keys are copied but the values are kept the same for both this Memory and the cloned one.

  Returns Memory<E>

  a new Memory with the same elements as this one.

entries

• entries(): IterableIterator<[bigint, E]>

• Returns an iterable of location, value pairs for every entry in the Memory.

  Returns IterableIterator<[bigint, E]>

get

• get(location): undefined | E

• Returns a specified value from the Memory object. If the value stored at the provided location is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Memory.

  Parameters

  • location: bigint

  Returns undefined | E

  Returns the value stored at the specified location. If no value is stored at the specified location, undefined is returned.

has

• has(location): boolean

• Parameters

  • location: bigint

  Returns boolean

  boolean indicating whether a value in the specified location exists or not.

invalidateAll

• invalidateAll(): void

• Invalidates the whole memory region.

  That is, after invalidateAll, get with any argument will return undefined.

  Returns void

invalidateRange

• invalidateRange(offset, size, invalidateAll?): void

• Tries to invalidate the memory range indicated by [offset, offset + size]. It can do so when both offset and size are reducible to Val, and size is no greater than maxInvalidateSizeAllowed. This last restriction is to avoid iterating over a large range.

  Otherwise, when invalidateAll is set clears the whole memory.

  Parameters

  • offset: Expr

    the offset in memory to invalidate.

  • size: Expr

    the size to invalidate.

  • invalidateAll: boolean = true

    indicates to clear the whole memory in case neither offset nor size are not reducible to Val.

  Returns void

keys

• keys(): IterableIterator<bigint>

• Returns an iterable of keys in the Memory.

  Returns IterableIterator<bigint>

range

• range(offset, size, miss): E[]

• Parameters

  • offset: bigint

  • size: bigint

  • miss: ((location) => E)

    • • (location): E

      • Parameters

        • location: bigint

        Returns E

  Returns E[]

set

• set(location, value): Memory<E>

• Sets the new value at the specified location. If a value at the same location already exists, the value will be updated.

  Parameters

  • location: bigint

  • value: E

  Returns Memory<E>

  the this Memory so calls can be chained.