Options
All
  • Public
  • Public/Protected
  • All
Menu

Class NearCachedMapProxy<K, V>

Type parameters

  • K

  • V

Hierarchy

Implements

Index

Constructors

constructor

Properties

Protected client

Protected name

name: string

Protected serviceName

serviceName: string

Methods

addEntryListener

  • addEntryListener(listener: MapListener<K, V>, key: K, includeValue?: boolean): Promise<string>

addEntryListenerWithPredicate

  • addEntryListenerWithPredicate(listener: MapListener<K, V>, predicate: Predicate, key: K, includeValue: boolean): Promise<string>

addIndex

  • addIndex(attribute: string, ordered: boolean): Promise<void>

aggregate

  • aggregate<R>(aggregator: Aggregator<R>): Promise<R>

aggregateWithPredicate

clear

  • clear(): Promise<void>

containsKey

  • containsKey(key: K): Promise<boolean>

Protected containsKeyInternal

  • containsKeyInternal(keyData: Data): Promise<boolean>

containsValue

  • containsValue(value: V): Promise<boolean>

delete

  • delete(key: K): Promise<void>

Protected deleteInternal

  • deleteInternal(keyData: Data): Promise<void>

destroy

  • destroy(): Promise<void>

Protected encodeInvokeOnAddress

  • encodeInvokeOnAddress<T>(codec: any, address: Address, ...codecArguments: any[]): Promise<T>

Protected encodeInvokeOnKey

  • encodeInvokeOnKey<T>(codec: any, partitionKey: any, ...codecArguments: any[]): Promise<T>
  • Encodes a request from a codec and invokes it on owner node of given key.

    Type parameters

    • T

    Parameters

    • codec: any
    • partitionKey: any
    • Rest ...codecArguments: any[]

    Returns Promise<T>

Protected encodeInvokeOnPartition

  • encodeInvokeOnPartition<T>(codec: any, partitionId: number, ...codecArguments: any[]): Promise<T>
  • Encodes a request from a codec and invokes it on owner node of given partition.

    Type parameters

    • T

    Parameters

    • codec: any
    • partitionId: number
    • Rest ...codecArguments: any[]

    Returns Promise<T>

Protected encodeInvokeOnRandomTarget

  • encodeInvokeOnRandomTarget<T>(codec: any, ...codecArguments: any[]): Promise<T>

entrySet

  • entrySet(): Promise<any[]>

entrySetWithPredicate

  • entrySetWithPredicate(predicate: Predicate): Promise<any[]>

evict

  • evict(key: K): Promise<boolean>

evictAll

  • evictAll(): Promise<void>

Protected evictInternal

  • evictInternal(key: Data): Promise<boolean>

executeOnEntries

executeOnKey

Protected executeOnKeyInternal

  • executeOnKeyInternal(keyData: Data, proData: Data): Promise<V>

executeOnKeys

flush

  • flush(): Promise<void>

forceUnlock

  • forceUnlock(key: K): Promise<void>

get

  • get(key: K): Promise<V>

getAll

  • getAll(keys: K[]): Promise<any[]>

Protected getAllInternal

  • getAllInternal(partitionsToKeys: object, result?: any[]): Promise<any[]>

Protected getConnectedServerVersion

  • getConnectedServerVersion(): number

getEntryView

  • getEntryView(key: K): Promise<EntryView<K, V>>

Protected getInternal

  • getInternal(keyData: Data): Promise<V>

getName

  • getName(): string

getPartitionKey

  • getPartitionKey(): string

getServiceName

  • getServiceName(): string

isEmpty

  • isEmpty(): Promise<boolean>

isLocked

  • isLocked(key: K): Promise<boolean>

keySet

  • keySet(): Promise<K[]>

keySetWithPredicate

  • keySetWithPredicate(predicate: Predicate): Promise<K[]>

loadAll

  • loadAll(keys?: K[], replaceExistingValues?: boolean): Promise<void>

lock

  • lock(key: K, ttl?: number): Promise<void>

Protected postDestroy

  • postDestroy(): Promise<void>

put

  • put(key: K, value: V, ttl?: number): Promise<V>

putAll

  • putAll(pairs: Array<[K, V]>): Promise<void>

Protected putAllInternal

  • putAllInternal(partitionsToKeysData: object): Promise<void>

putIfAbsent

  • putIfAbsent(key: K, value: V, ttl?: number): Promise<V>

Protected putIfAbsentInternal

  • putIfAbsentInternal(keyData: Data, valueData: Data, ttl: number): Promise<V>

Protected putInternal

  • putInternal(keyData: Data, valueData: Data, ttl: number): Promise<V>

putTransient

  • putTransient(key: K, value: V, ttl?: number): Promise<void>

Protected putTransientInternal

  • putTransientInternal(keyData: Data, valueData: Data, ttl: number): Promise<void>

remove

  • remove(key: K, value?: V): Promise<V>

removeEntryListener

  • removeEntryListener(listenerId: string): Promise<boolean>

Protected removeInternal

  • removeInternal(keyData: Data, value: V): Promise<V>

replace

  • replace(key: K, newValue: V): Promise<V>

replaceIfSame

  • replaceIfSame(key: K, oldValue: V, newValue: V): Promise<boolean>

Protected replaceIfSameInternal

  • replaceIfSameInternal(keyData: Data, oldValueData: Data, newValueData: Data): Promise<boolean>

Protected replaceInternal

  • replaceInternal(keyData: Data, valueData: Data): Promise<V>

set

  • set(key: K, value: V, ttl?: number): Promise<void>

Protected setInternal

  • setInternal(keyData: Data, valueData: Data, ttl: number): Promise<void>

size

  • size(): Promise<number>

Protected toData

  • toData(object: any): Data

Protected toObject

  • toObject(data: Data): any

tryLock

  • tryLock(key: K, timeout?: number, lease?: number): Promise<boolean>

tryPut

  • tryPut(key: K, value: V, timeout: number): Promise<boolean>

Protected tryPutInternal

  • tryPutInternal(keyData: Data, valueData: Data, timeout: number): Promise<boolean>

tryRemove

  • tryRemove(key: K, timeout: number): Promise<boolean>

Protected tryRemoveInternal

  • tryRemoveInternal(keyData: Data, timeout: number): Promise<boolean>

unlock

  • unlock(key: K): Promise<void>

values

valuesWithPredicate

Generated using TypeDoc