@celerispay/hazelcast-client 3.12.5

package/lib/proxy/ListProxy.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { ItemListener } from '../core/ItemListener';
+import { ReadOnlyLazyList } from '../core/ReadOnlyLazyList';
+import { IList } from './IList';
+import { PartitionSpecificProxy } from './PartitionSpecificProxy';
+export declare class ListProxy<E> extends PartitionSpecificProxy implements IList<E> {
+    add(element: E): Promise<boolean>;
+    addAll(elements: E[]): Promise<boolean>;
+    addAllAt(index: number, elements: E[]): Promise<boolean>;
+    addAt(index: number, element: E): Promise<void>;
+    clear(): Promise<void>;
+    contains(entry: E): Promise<boolean>;
+    containsAll(elements: E[]): Promise<boolean>;
+    isEmpty(): Promise<boolean>;
+    remove(entry: E): Promise<boolean>;
+    removeAll(elements: E[]): Promise<boolean>;
+    retainAll(elements: E[]): Promise<boolean>;
+    removeAt(index: number): Promise<E>;
+    get(index: number): Promise<E>;
+    set(index: number, element: E): Promise<E>;
+    indexOf(element: E): Promise<number>;
+    lastIndexOf(element: E): Promise<number>;
+    size(): Promise<number>;
+    subList(start: number, end: number): Promise<ReadOnlyLazyList<E>>;
+    toArray(): Promise<E[]>;
+    addItemListener(listener: ItemListener<E>, includeValue: boolean): Promise<string>;
+    removeItemListener(registrationId: string): Promise<boolean>;
+    private serializeList(input);
+    private createItemListener(name, includeValue);
+}

package/lib/proxy/ListProxy.js

@@ -0,0 +1,165 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var ListAddAllCodec_1 = require("../codec/ListAddAllCodec");
+var ListAddAllWithIndexCodec_1 = require("../codec/ListAddAllWithIndexCodec");
+var ListAddCodec_1 = require("../codec/ListAddCodec");
+var ListAddListenerCodec_1 = require("../codec/ListAddListenerCodec");
+var ListAddWithIndexCodec_1 = require("../codec/ListAddWithIndexCodec");
+var ListClearCodec_1 = require("../codec/ListClearCodec");
+var ListCompareAndRemoveAllCodec_1 = require("../codec/ListCompareAndRemoveAllCodec");
+var ListCompareAndRetainAllCodec_1 = require("../codec/ListCompareAndRetainAllCodec");
+var ListContainsAllCodec_1 = require("../codec/ListContainsAllCodec");
+var ListContainsCodec_1 = require("../codec/ListContainsCodec");
+var ListGetAllCodec_1 = require("../codec/ListGetAllCodec");
+var ListGetCodec_1 = require("../codec/ListGetCodec");
+var ListIndexOfCodec_1 = require("../codec/ListIndexOfCodec");
+var ListIsEmptyCodec_1 = require("../codec/ListIsEmptyCodec");
+var ListLastIndexOfCodec_1 = require("../codec/ListLastIndexOfCodec");
+var ListRemoveCodec_1 = require("../codec/ListRemoveCodec");
+var ListRemoveListenerCodec_1 = require("../codec/ListRemoveListenerCodec");
+var ListRemoveWithIndexCodec_1 = require("../codec/ListRemoveWithIndexCodec");
+var ListSetCodec_1 = require("../codec/ListSetCodec");
+var ListSizeCodec_1 = require("../codec/ListSizeCodec");
+var ListSubCodec_1 = require("../codec/ListSubCodec");
+var ItemListener_1 = require("../core/ItemListener");
+var ReadOnlyLazyList_1 = require("../core/ReadOnlyLazyList");
+var PartitionSpecificProxy_1 = require("./PartitionSpecificProxy");
+var ListProxy = /** @class */ (function (_super) {
+    __extends(ListProxy, _super);
+    function ListProxy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ListProxy.prototype.add = function (element) {
+        return this.encodeInvoke(ListAddCodec_1.ListAddCodec, this.toData(element));
+    };
+    ListProxy.prototype.addAll = function (elements) {
+        return this.encodeInvoke(ListAddAllCodec_1.ListAddAllCodec, this.serializeList(elements));
+    };
+    ListProxy.prototype.addAllAt = function (index, elements) {
+        return this.encodeInvoke(ListAddAllWithIndexCodec_1.ListAddAllWithIndexCodec, index, this.serializeList(elements));
+    };
+    ListProxy.prototype.addAt = function (index, element) {
+        return this.encodeInvoke(ListAddWithIndexCodec_1.ListAddWithIndexCodec, index, this.toData(element));
+    };
+    ListProxy.prototype.clear = function () {
+        return this.encodeInvoke(ListClearCodec_1.ListClearCodec);
+    };
+    ListProxy.prototype.contains = function (entry) {
+        return this.encodeInvoke(ListContainsCodec_1.ListContainsCodec, this.toData(entry));
+    };
+    ListProxy.prototype.containsAll = function (elements) {
+        return this.encodeInvoke(ListContainsAllCodec_1.ListContainsAllCodec, this.serializeList(elements));
+    };
+    ListProxy.prototype.isEmpty = function () {
+        return this.encodeInvoke(ListIsEmptyCodec_1.ListIsEmptyCodec);
+    };
+    ListProxy.prototype.remove = function (entry) {
+        return this.encodeInvoke(ListRemoveCodec_1.ListRemoveCodec, this.toData(entry));
+    };
+    ListProxy.prototype.removeAll = function (elements) {
+        return this.encodeInvoke(ListCompareAndRemoveAllCodec_1.ListCompareAndRemoveAllCodec, this.serializeList(elements));
+    };
+    ListProxy.prototype.retainAll = function (elements) {
+        return this.encodeInvoke(ListCompareAndRetainAllCodec_1.ListCompareAndRetainAllCodec, this.serializeList(elements));
+    };
+    ListProxy.prototype.removeAt = function (index) {
+        return this.encodeInvoke(ListRemoveWithIndexCodec_1.ListRemoveWithIndexCodec, index);
+    };
+    ListProxy.prototype.get = function (index) {
+        return this.encodeInvoke(ListGetCodec_1.ListGetCodec, index);
+    };
+    ListProxy.prototype.set = function (index, element) {
+        return this.encodeInvoke(ListSetCodec_1.ListSetCodec, index, this.toData(element));
+    };
+    ListProxy.prototype.indexOf = function (element) {
+        return this.encodeInvoke(ListIndexOfCodec_1.ListIndexOfCodec, this.toData(element));
+    };
+    ListProxy.prototype.lastIndexOf = function (element) {
+        return this.encodeInvoke(ListLastIndexOfCodec_1.ListLastIndexOfCodec, this.toData(element));
+    };
+    ListProxy.prototype.size = function () {
+        return this.encodeInvoke(ListSizeCodec_1.ListSizeCodec);
+    };
+    ListProxy.prototype.subList = function (start, end) {
+        var _this = this;
+        return this.encodeInvoke(ListSubCodec_1.ListSubCodec, start, end).then(function (encoded) {
+            return new ReadOnlyLazyList_1.ReadOnlyLazyList(encoded, _this.client.getSerializationService());
+        });
+    };
+    ListProxy.prototype.toArray = function () {
+        var _this = this;
+        return this.encodeInvoke(ListGetAllCodec_1.ListGetAllCodec).then(function (elements) {
+            return elements.map(function (element) {
+                return _this.toObject(element);
+            });
+        });
+    };
+    ListProxy.prototype.addItemListener = function (listener, includeValue) {
+        var _this = this;
+        var listenerHandler = function (message) {
+            ListAddListenerCodec_1.ListAddListenerCodec.handle(message, function (element, uuid, eventType) {
+                var responseObject = element ? _this.toObject(element) : null;
+                var member = _this.client.getClusterService().getMember(uuid);
+                var name = _this.name;
+                var itemEvent = new ItemListener_1.ItemEvent(name, eventType, responseObject, member);
+                if (eventType === ItemListener_1.ItemEventType.ADDED && listener.itemAdded) {
+                    listener.itemAdded.apply(null, [itemEvent]);
+                }
+                else if (eventType === ItemListener_1.ItemEventType.REMOVED && listener.itemRemoved) {
+                    listener.itemRemoved.apply(null, [itemEvent]);
+                }
+            });
+        };
+        var codec = this.createItemListener(this.name, includeValue);
+        return this.client.getListenerService().registerListener(codec, listenerHandler);
+    };
+    ListProxy.prototype.removeItemListener = function (registrationId) {
+        return this.client.getListenerService().deregisterListener(registrationId);
+    };
+    ListProxy.prototype.serializeList = function (input) {
+        var _this = this;
+        return input.map(function (each) {
+            return _this.toData(each);
+        });
+    };
+    ListProxy.prototype.createItemListener = function (name, includeValue) {
+        return {
+            encodeAddRequest: function (localOnly) {
+                return ListAddListenerCodec_1.ListAddListenerCodec.encodeRequest(name, includeValue, localOnly);
+            },
+            decodeAddResponse: function (msg) {
+                return ListAddListenerCodec_1.ListAddListenerCodec.decodeResponse(msg).response;
+            },
+            encodeRemoveRequest: function (listenerId) {
+                return ListRemoveListenerCodec_1.ListRemoveListenerCodec.encodeRequest(name, listenerId);
+            },
+        };
+    };
+    return ListProxy;
+}(PartitionSpecificProxy_1.PartitionSpecificProxy));
+exports.ListProxy = ListProxy;

package/lib/proxy/LockProxy.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { ILock } from './ILock';
+import { PartitionSpecificProxy } from './PartitionSpecificProxy';
+export declare class LockProxy extends PartitionSpecificProxy implements ILock {
+    private lockReferenceIdGenerator;
+    lock(leaseMillis?: number): Promise<void>;
+    tryLock(timeoutMillis?: number, leaseMillis?: number): Promise<boolean>;
+    unlock(): Promise<void>;
+    forceUnlock(): Promise<void>;
+    isLocked(): Promise<boolean>;
+    isLockedByThisClient(): Promise<boolean>;
+    getLockCount(): Promise<number>;
+    getRemainingLeaseTime(): Promise<number>;
+    private nextSequence();
+}

package/lib/proxy/LockProxy.js

@@ -0,0 +1,78 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var PartitionSpecificProxy_1 = require("./PartitionSpecificProxy");
+var LockForceUnlockCodec_1 = require("../codec/LockForceUnlockCodec");
+var LockGetLockCountCodec_1 = require("../codec/LockGetLockCountCodec");
+var LockGetRemainingLeaseTimeCodec_1 = require("../codec/LockGetRemainingLeaseTimeCodec");
+var LockIsLockedByCurrentThreadCodec_1 = require("../codec/LockIsLockedByCurrentThreadCodec");
+var LockIsLockedCodec_1 = require("../codec/LockIsLockedCodec");
+var LockLockCodec_1 = require("../codec/LockLockCodec");
+var LockTryLockCodec_1 = require("../codec/LockTryLockCodec");
+var LockUnlockCodec_1 = require("../codec/LockUnlockCodec");
+var LockProxy = /** @class */ (function (_super) {
+    __extends(LockProxy, _super);
+    function LockProxy() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.lockReferenceIdGenerator = _this.client.getLockReferenceIdGenerator();
+        return _this;
+    }
+    LockProxy.prototype.lock = function (leaseMillis) {
+        if (leaseMillis === void 0) { leaseMillis = -1; }
+        return this.encodeInvokeWithTimeout(Number.MAX_SAFE_INTEGER, LockLockCodec_1.LockLockCodec, leaseMillis, 1, this.nextSequence());
+    };
+    LockProxy.prototype.tryLock = function (timeoutMillis, leaseMillis) {
+        if (timeoutMillis === void 0) { timeoutMillis = 0; }
+        if (leaseMillis === void 0) { leaseMillis = -1; }
+        return this.encodeInvokeWithTimeout(Number.MAX_SAFE_INTEGER, LockTryLockCodec_1.LockTryLockCodec, 1, leaseMillis, timeoutMillis, this.nextSequence());
+    };
+    LockProxy.prototype.unlock = function () {
+        return this.encodeInvoke(LockUnlockCodec_1.LockUnlockCodec, 1, this.nextSequence());
+    };
+    LockProxy.prototype.forceUnlock = function () {
+        return this.encodeInvoke(LockForceUnlockCodec_1.LockForceUnlockCodec, this.nextSequence());
+    };
+    LockProxy.prototype.isLocked = function () {
+        return this.encodeInvoke(LockIsLockedCodec_1.LockIsLockedCodec);
+    };
+    LockProxy.prototype.isLockedByThisClient = function () {
+        return this.encodeInvoke(LockIsLockedByCurrentThreadCodec_1.LockIsLockedByCurrentThreadCodec, 1);
+    };
+    LockProxy.prototype.getLockCount = function () {
+        return this.encodeInvoke(LockGetLockCountCodec_1.LockGetLockCountCodec);
+    };
+    LockProxy.prototype.getRemainingLeaseTime = function () {
+        return this.encodeInvoke(LockGetRemainingLeaseTimeCodec_1.LockGetRemainingLeaseTimeCodec).then(function (long) {
+            return long.toNumber();
+        });
+    };
+    LockProxy.prototype.nextSequence = function () {
+        return this.lockReferenceIdGenerator.getNextReferenceId();
+    };
+    return LockProxy;
+}(PartitionSpecificProxy_1.PartitionSpecificProxy));
+exports.LockProxy = LockProxy;

package/lib/proxy/MapProxy.d.ts

@@ -0,0 +1,82 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { Aggregator } from '../aggregation/Aggregator';
+import { EntryView } from '../core/EntryView';
+import { MapListener } from '../core/MapListener';
+import { Predicate } from '../core/Predicate';
+import { ReadOnlyLazyList } from '../core/ReadOnlyLazyList';
+import { Data } from '../serialization/Data';
+import { IdentifiedDataSerializable, Portable } from '../serialization/Serializable';
+import { BaseProxy } from './BaseProxy';
+import { IMap } from './IMap';
+export declare class MapProxy<K, V> extends BaseProxy implements IMap<K, V> {
+    aggregate<R>(aggregator: Aggregator<R>): Promise<R>;
+    aggregateWithPredicate<R>(aggregator: Aggregator<R>, predicate: Predicate): Promise<R>;
+    executeOnKeys(keys: K[], entryProcessor: IdentifiedDataSerializable | Portable): Promise<any[]>;
+    executeOnKey(key: K, entryProcessor: IdentifiedDataSerializable | Portable): Promise<V>;
+    executeOnEntries(entryProcessor: IdentifiedDataSerializable | Portable, predicate?: Predicate): Promise<Array<[K, V]>>;
+    entrySetWithPredicate(predicate: Predicate): Promise<any[]>;
+    keySetWithPredicate(predicate: Predicate): Promise<K[]>;
+    valuesWithPredicate(predicate: Predicate): Promise<ReadOnlyLazyList<V>>;
+    addEntryListenerWithPredicate(listener: MapListener<K, V>, predicate: Predicate, key: K, includeValue: boolean): Promise<string>;
+    containsKey(key: K): Promise<boolean>;
+    containsValue(value: V): Promise<boolean>;
+    put(key: K, value: V, ttl?: number): Promise<V>;
+    putAll(pairs: Array<[K, V]>): Promise<void>;
+    get(key: K): Promise<V>;
+    remove(key: K, value?: V): Promise<V>;
+    size(): Promise<number>;
+    clear(): Promise<void>;
+    isEmpty(): Promise<boolean>;
+    getAll(keys: K[]): Promise<any[]>;
+    delete(key: K): Promise<void>;
+    entrySet(): Promise<any[]>;
+    evict(key: K): Promise<boolean>;
+    evictAll(): Promise<void>;
+    flush(): Promise<void>;
+    lock(key: K, ttl?: number): Promise<void>;
+    isLocked(key: K): Promise<boolean>;
+    unlock(key: K): Promise<void>;
+    forceUnlock(key: K): Promise<void>;
+    keySet(): Promise<K[]>;
+    loadAll(keys?: K[], replaceExistingValues?: boolean): Promise<void>;
+    putIfAbsent(key: K, value: V, ttl?: number): Promise<V>;
+    putTransient(key: K, value: V, ttl?: number): Promise<void>;
+    replace(key: K, newValue: V): Promise<V>;
+    replaceIfSame(key: K, oldValue: V, newValue: V): Promise<boolean>;
+    set(key: K, value: V, ttl?: number): Promise<void>;
+    values(): Promise<ReadOnlyLazyList<V>>;
+    getEntryView(key: K): Promise<EntryView<K, V>>;
+    addIndex(attribute: string, ordered: boolean): Promise<void>;
+    tryLock(key: K, timeout?: number, lease?: number): Promise<boolean>;
+    tryPut(key: K, value: V, timeout: number): Promise<boolean>;
+    tryRemove(key: K, timeout: number): Promise<boolean>;
+    addEntryListener(listener: MapListener<K, V>, key: K, includeValue?: boolean): Promise<string>;
+    removeEntryListener(listenerId: string): Promise<boolean>;
+    protected executeOnKeyInternal(keyData: Data, proData: Data): Promise<V>;
+    protected containsKeyInternal(keyData: Data): Promise<boolean>;
+    protected putInternal(keyData: Data, valueData: Data, ttl: number): Promise<V>;
+    protected putAllInternal(partitionsToKeysData: {
+        [id: string]: Array<[Data, Data]>;
+    }): Promise<void>;
+    protected getInternal(keyData: Data): Promise<V>;
+    protected removeInternal(keyData: Data, value?: V): Promise<V>;
+    protected getAllInternal(partitionsToKeys: {
+        [id: string]: Data[];
+    }, result?: any[]): Promise<Array<[Data, Data]>>;
+    protected deleteInternal(keyData: Data): Promise<void>;
+    protected evictInternal(keyData: Data): Promise<boolean>;
+    protected putIfAbsentInternal(keyData: Data, valueData: Data, ttl: number): Promise<V>;
+    protected putTransientInternal(keyData: Data, valueData: Data, ttl: number): Promise<void>;
+    protected replaceInternal(keyData: Data, newValueData: Data): Promise<V>;
+    protected replaceIfSameInternal(keyData: Data, oldValueData: Data, newValueData: Data): Promise<boolean>;
+    protected setInternal(keyData: Data, valueData: Data, ttl: number): Promise<void>;
+    protected tryPutInternal(keyData: Data, valueData: Data, timeout: number): Promise<boolean>;
+    protected tryRemoveInternal(keyData: Data, timeout: number): Promise<boolean>;
+    private addEntryListenerInternal(listener, predicate, key, includeValue);
+    private createEntryListenerToKey(name, keyData, includeValue, flags);
+    private createEntryListenerToKeyWithPredicate(name, keyData, predicateData, includeValue, flags);
+    private createEntryListenerWithPredicate(name, predicateData, includeValue, flags);
+    private createEntryListener(name, includeValue, flags);
+    private checkNotPagingPredicate(v);
+}