@celerispay/hazelcast-client 3.12.5

package/lib/proxy/NearCachedMapProxy.js

@@ -0,0 +1,284 @@
+"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 Promise = require("bluebird");
+var MapAddNearCacheEntryListenerCodec_1 = require("../codec/MapAddNearCacheEntryListenerCodec");
+var MapAddNearCacheInvalidationListenerCodec_1 = require("../codec/MapAddNearCacheInvalidationListenerCodec");
+var MapRemoveEntryListenerCodec_1 = require("../codec/MapRemoveEntryListenerCodec");
+var EventType_1 = require("../core/EventType");
+var StaleReadDetectorImpl_1 = require("../nearcache/StaleReadDetectorImpl");
+var MapProxy_1 = require("./MapProxy");
+var BuildInfo_1 = require("../BuildInfo");
+var NearCachedMapProxy = /** @class */ (function (_super) {
+    __extends(NearCachedMapProxy, _super);
+    function NearCachedMapProxy(client, servicename, name) {
+        var _this = _super.call(this, client, servicename, name) || this;
+        _this.nearCache = _this.client.getNearCacheManager().getOrCreateNearCache(name);
+        if (_this.nearCache.isInvalidatedOnChange()) {
+            _this.addNearCacheInvalidationListener().then(function (id) {
+                _this.invalidationListenerId = id;
+                _this.nearCache.setReady();
+            });
+        }
+        else {
+            _this.nearCache.setReady();
+        }
+        return _this;
+    }
+    NearCachedMapProxy.prototype.clear = function () {
+        return _super.prototype.clear.call(this).then(this.invalidateCacheAndReturn.bind(this));
+    };
+    NearCachedMapProxy.prototype.evictAll = function () {
+        this.nearCache.clear();
+        return _super.prototype.evictAll.call(this).then(this.invalidateCacheAndReturn.bind(this));
+    };
+    NearCachedMapProxy.prototype.containsKeyInternal = function (keyData) {
+        var _this = this;
+        return this.nearCache.get(keyData).then(function (cachedValue) {
+            if (cachedValue !== undefined) {
+                return Promise.resolve(cachedValue != null);
+            }
+            else {
+                return _super.prototype.containsKeyInternal.call(_this, keyData);
+            }
+        });
+    };
+    NearCachedMapProxy.prototype.deleteInternal = function (keyData) {
+        this.nearCache.invalidate(keyData);
+        return _super.prototype.deleteInternal.call(this, keyData).then(this.invalidateCacheEntryAndReturn.bind(this, keyData));
+    };
+    NearCachedMapProxy.prototype.evictInternal = function (key) {
+        return _super.prototype.evictInternal.call(this, key).then(this.invalidateCacheEntryAndReturn.bind(this, key));
+    };
+    NearCachedMapProxy.prototype.putAllInternal = function (partitionsToKeysData) {
+        var _this = this;
+        return _super.prototype.putAllInternal.call(this, partitionsToKeysData).then(function () {
+            for (var partition in partitionsToKeysData) {
+                partitionsToKeysData[partition].forEach(function (entry) {
+                    _this.nearCache.invalidate(entry[0]);
+                });
+            }
+        });
+    };
+    NearCachedMapProxy.prototype.postDestroy = function () {
+        var _this = this;
+        return this.removeNearCacheInvalidationListener().then(function () {
+            _this.client.getNearCacheManager().destroyNearCache(_this.name);
+        }).then(function () {
+            return _super.prototype.postDestroy.call(_this);
+        });
+    };
+    NearCachedMapProxy.prototype.putIfAbsentInternal = function (keyData, valueData, ttl) {
+        return _super.prototype.putIfAbsentInternal.call(this, keyData, valueData, ttl).then(this.invalidateCacheEntryAndReturn.bind(this, keyData));
+    };
+    NearCachedMapProxy.prototype.putTransientInternal = function (keyData, valueData, ttl) {
+        return _super.prototype.putTransientInternal.call(this, keyData, valueData, ttl).then(this.invalidateCacheEntryAndReturn.bind(this, keyData));
+    };
+    NearCachedMapProxy.prototype.executeOnKeyInternal = function (keyData, proData) {
+        return _super.prototype.executeOnKeyInternal.call(this, keyData, proData).then(this.invalidateCacheEntryAndReturn.bind(this, keyData));
+    };
+    NearCachedMapProxy.prototype.putInternal = function (keyData, valueData, ttl) {
+        return _super.prototype.putInternal.call(this, keyData, valueData, ttl).then(this.invalidateCacheEntryAndReturn.bind(this, keyData));
+    };
+    NearCachedMapProxy.prototype.getInternal = function (keyData) {
+        var _this = this;
+        return this.nearCache.get(keyData).then(function (cachedValue) {
+            if (cachedValue !== undefined) {
+                return Promise.resolve(cachedValue);
+            }
+            else {
+                var reservation_1 = _this.nearCache.tryReserveForUpdate(keyData);
+                return _super.prototype.getInternal.call(_this, keyData).then(function (val) {
+                    _this.nearCache.tryPublishReserved(keyData, val, reservation_1);
+                    return val;
+                }).catch(function (err) {
+                    throw err;
+                });
+            }
+        });
+    };
+    NearCachedMapProxy.prototype.tryRemoveInternal = function (keyData, timeout) {
+        return _super.prototype.tryRemoveInternal.call(this, keyData, timeout).then(this.invalidateCacheEntryAndReturn.bind(this, keyData));
+    };
+    NearCachedMapProxy.prototype.removeInternal = function (keyData, value) {
+        return _super.prototype.removeInternal.call(this, keyData, value).then(this.invalidateCacheEntryAndReturn.bind(this, keyData));
+    };
+    NearCachedMapProxy.prototype.getAllInternal = function (partitionsToKeys, result) {
+        var _this = this;
+        if (result === void 0) { result = []; }
+        var promises = [];
+        try {
+            var _loop_1 = function (partition) {
+                var partitionArray = partitionsToKeys[partition];
+                var _loop_2 = function (i) {
+                    var key = partitionArray[i];
+                    promises.push(this_1.nearCache.get(key).then(function (cachedResult) {
+                        if (cachedResult !== undefined) {
+                            result.push([_this.toObject(partitionArray[i]), cachedResult]);
+                            partitionArray.splice(i, 1);
+                        }
+                    }));
+                };
+                for (var i = partitionArray.length - 1; i >= 0; i--) {
+                    _loop_2(i);
+                }
+            };
+            var this_1 = this;
+            for (var partition in partitionsToKeys) {
+                _loop_1(partition);
+            }
+        }
+        catch (err) {
+            return Promise.resolve([]);
+        }
+        return Promise.all(promises).then(function () {
+            var reservations = [];
+            for (var partition in partitionsToKeys) {
+                var partitionArray = partitionsToKeys[partition];
+                for (var _i = 0, partitionArray_1 = partitionArray; _i < partitionArray_1.length; _i++) {
+                    var key = partitionArray_1[_i];
+                    reservations.push(_this.nearCache.tryReserveForUpdate(key));
+                }
+            }
+            return _super.prototype.getAllInternal.call(_this, partitionsToKeys, result).then(function (serializedEntryArray) {
+                serializedEntryArray.forEach(function (serializedEntry, index) {
+                    var key = serializedEntry[0];
+                    var value = serializedEntry[1];
+                    _this.nearCache.tryPublishReserved(key, value, reservations[index]);
+                });
+                return result;
+            });
+        });
+    };
+    NearCachedMapProxy.prototype.replaceIfSameInternal = function (keyData, oldValueData, newValueData) {
+        return _super.prototype.replaceIfSameInternal.call(this, keyData, oldValueData, newValueData)
+            .then(this.invalidateCacheEntryAndReturn.bind(this, keyData));
+    };
+    NearCachedMapProxy.prototype.replaceInternal = function (keyData, valueData) {
+        return _super.prototype.replaceInternal.call(this, keyData, valueData).then(this.invalidateCacheEntryAndReturn.bind(this, keyData));
+    };
+    NearCachedMapProxy.prototype.setInternal = function (keyData, valueData, ttl) {
+        return _super.prototype.setInternal.call(this, keyData, valueData, ttl).then(this.invalidateCacheEntryAndReturn.bind(this, keyData));
+    };
+    NearCachedMapProxy.prototype.tryPutInternal = function (keyData, valueData, timeout) {
+        return _super.prototype.tryPutInternal.call(this, keyData, valueData, timeout)
+            .then(this.invalidateCacheEntryAndReturn.bind(this, keyData));
+    };
+    NearCachedMapProxy.prototype.removeNearCacheInvalidationListener = function () {
+        this.client.getRepairingTask().deregisterHandler(this.name);
+        return this.client.getListenerService().deregisterListener(this.invalidationListenerId);
+    };
+    NearCachedMapProxy.prototype.invalidateCacheEntryAndReturn = function (keyData, retVal) {
+        this.nearCache.invalidate(keyData);
+        return retVal;
+    };
+    NearCachedMapProxy.prototype.invalidateCacheAndReturn = function (retVal) {
+        this.nearCache.clear();
+        return retVal;
+    };
+    NearCachedMapProxy.prototype.addNearCacheInvalidationListener = function () {
+        var _this = this;
+        var codec = this.createInvalidationListenerCodec(this.name, EventType_1.EventType.INVALIDATION);
+        if (this.supportsRepairableNearCache()) {
+            return this.createNearCacheEventHandler().then(function (handler) {
+                return _this.client.getListenerService().registerListener(codec, handler);
+            });
+        }
+        else {
+            return this.client.getListenerService().registerListener(codec, this.createPre38NearCacheEventHandler());
+        }
+    };
+    NearCachedMapProxy.prototype.createInvalidationListenerCodec = function (name, flags) {
+        if (this.supportsRepairableNearCache()) {
+            return {
+                encodeAddRequest: function (localOnly) {
+                    return MapAddNearCacheInvalidationListenerCodec_1.MapAddNearCacheInvalidationListenerCodec.encodeRequest(name, flags, localOnly);
+                },
+                decodeAddResponse: function (msg) {
+                    return MapAddNearCacheInvalidationListenerCodec_1.MapAddNearCacheInvalidationListenerCodec.decodeResponse(msg).response;
+                },
+                encodeRemoveRequest: function (listenerId) {
+                    return MapRemoveEntryListenerCodec_1.MapRemoveEntryListenerCodec.encodeRequest(name, listenerId);
+                },
+            };
+        }
+        else {
+            return {
+                encodeAddRequest: function (localOnly) {
+                    return MapAddNearCacheEntryListenerCodec_1.MapAddNearCacheEntryListenerCodec.encodeRequest(name, flags, localOnly);
+                },
+                decodeAddResponse: function (msg) {
+                    return MapAddNearCacheEntryListenerCodec_1.MapAddNearCacheEntryListenerCodec.decodeResponse(msg).response;
+                },
+                encodeRemoveRequest: function (listenerId) {
+                    return MapRemoveEntryListenerCodec_1.MapRemoveEntryListenerCodec.encodeRequest(name, listenerId);
+                },
+            };
+        }
+    };
+    NearCachedMapProxy.prototype.supportsRepairableNearCache = function () {
+        return this.getConnectedServerVersion() >= BuildInfo_1.BuildInfo.calculateServerVersion(3, 8, 0);
+    };
+    NearCachedMapProxy.prototype.createPre38NearCacheEventHandler = function () {
+        var nearCache = this.nearCache;
+        var handle = function (keyData) {
+            if (keyData == null) {
+                nearCache.clear();
+            }
+            else {
+                nearCache.invalidate(keyData);
+            }
+        };
+        var handleBatch = function (keys) {
+            keys.forEach(function (key) {
+                nearCache.invalidate(key);
+            });
+        };
+        return function (m) {
+            MapAddNearCacheEntryListenerCodec_1.MapAddNearCacheEntryListenerCodec.handle(m, handle, handleBatch);
+        };
+    };
+    NearCachedMapProxy.prototype.createNearCacheEventHandler = function () {
+        var _this = this;
+        var repairingTask = this.client.getRepairingTask();
+        return repairingTask.registerAndGetHandler(this.getName(), this.nearCache).then(function (repairingHandler) {
+            var staleReadDetector = new StaleReadDetectorImpl_1.StaleReadDetectorImpl(repairingHandler, _this.client.getPartitionService());
+            _this.nearCache.setStaleReadDetector(staleReadDetector);
+            var handle = function (key, sourceUuid, partitionUuid, sequence) {
+                repairingHandler.handle(key, sourceUuid, partitionUuid, sequence);
+            };
+            var handleBatch = function (keys, sourceUuids, partititonUuids, sequences) {
+                repairingHandler.handleBatch(keys, sourceUuids, partititonUuids, sequences);
+            };
+            return function (m) {
+                MapAddNearCacheInvalidationListenerCodec_1.MapAddNearCacheInvalidationListenerCodec.handle(m, handle, handleBatch);
+            };
+        });
+    };
+    return NearCachedMapProxy;
+}(MapProxy_1.MapProxy));
+exports.NearCachedMapProxy = NearCachedMapProxy;

package/lib/proxy/PNCounter.d.ts

@@ -0,0 +1,162 @@
+/// <reference types="bluebird" />
+/// <reference types="long" />
+import * as Promise from 'bluebird';
+import * as Long from 'long';
+import { DistributedObject } from '../DistributedObject';
+/**
+ * PN (Positive-Negative) CRDT counter.
+ * <p>
+ * The counter supports adding and subtracting values as well as
+ * retrieving the current counter value.
+ * The counter guarantees that whenever two nodes have received the
+ * same set of updates, possibly in a different order, their state is
+ * identical, and any conflicting updates are merged automatically.
+ * If no new updates are made to the shared state, all nodes that can
+ * communicate will eventually have the same data.
+ * <p>
+ * The invocation is remote. This may lead to indeterminate state -
+ * the update may be applied but the response has not been received.
+ * In this case, the caller will be notified with a `TargetDisconnectedError`
+ * <p>
+ * The read and write methods provide monotonic read and RYW (read-your-write)
+ * guarantees. These guarantees are session guarantees which means that if
+ * no replica with the previously observed state is reachable, the session
+ * guarantees are lost and the method invocation will throw a
+ * `ConsistencyLostError`. This does not mean
+ * that an update is lost. All of the updates are part of some replica and
+ * will be eventually reflected in the state of all other replicas. This
+ * error just means that you cannot observe your own writes because
+ * all replicas that contain your updates are currently unreachable.
+ * After you have received a `ConsistencyLostError`, you can either
+ * wait for a sufficiently up-to-date replica to become reachable in which
+ * case the session can be continued or you can reset the session by calling
+ * the `reset()` method. If you have called the `reset()` method,
+ * a new session is started with the next invocation to a CRDT replica.
+ * <p>
+ * <b>NOTE:</b>
+ * The CRDT state is kept entirely on non-lite (data) members. If there
+ * aren't any and the methods here are invoked, they will
+ * fail with a `NoDataMemberInClusterError`.
+ *
+ * @requires Hazelcast 3.10
+ */
+export interface PNCounter extends DistributedObject {
+    /**
+     * Returns the current value of the counter.
+     *
+     * @throws `NoDataMemberInClusterError` if the cluster does not contain
+     *                                        any data members
+     * @throws `UnsupportedOperationError`  if the cluster version is less
+     *                                        than 3.10
+     * @throws `ConsistencyLostError`       if the session guarantees have
+     *                                        been lost
+     * @returns the current value of the counter
+     */
+    get(): Promise<Long>;
+    /**
+     * Adds the given value to the current value.
+     *
+     * @param delta the value to add
+     * @return the previous value
+     * @throws `NoDataMemberInClusterError` if the cluster does not contain
+     *                                        any data members
+     * @throws `UnsupportedOperationError`  if the cluster version is less
+     *                                        than 3.10
+     * @throws `ConsistencyLostError`       if the session guarantees have
+     *                                        been lost
+     */
+    getAndAdd(delta: Long | number): Promise<Long>;
+    /**
+     * Adds the given value to the current value.
+     *
+     * @param delta the value to add
+     * @return the updated value
+     * @throws `NoDataMemberInClusterError` if the cluster does not contain
+     *                                        any data members
+     * @throws `UnsupportedOperationError`  if the cluster version is less
+     *                                        than 3.10
+     * @throws `ConsistencyLostError`       if the session guarantees have
+     *                                        been lost
+     */
+    addAndGet(delta: Long | number): Promise<Long>;
+    /**
+     * Subtracts the given value from the current value.
+     *
+     * @param delta the value to add
+     * @return the previous value
+     * @throws `NoDataMemberInClusterError` if the cluster does not contain
+     *                                        any data members
+     * @throws `UnsupportedOperationError`  if the cluster version is less
+     *                                        than 3.10
+     * @throws `ConsistencyLostError`       if the session guarantees have
+     *                                        been lost
+     */
+    getAndSubtract(delta: Long | number): Promise<Long>;
+    /**
+     * Subtracts the given value from the current value.
+     *
+     * @param delta the value to subtract
+     * @return the updated value
+     * @throws `NoDataMemberInClusterError` if the cluster does not contain
+     *                                        any data members
+     * @throws `UnsupportedOperationError`  if the cluster version is less
+     *                                        than 3.10
+     * @throws `ConsistencyLostError`       if the session guarantees have
+     *                                        been lost
+     */
+    subtractAndGet(delta: Long | number): Promise<Long>;
+    /**
+     * Decrements by one the current value.
+     *
+     * @return the updated value
+     * @throws `NoDataMemberInClusterError` if the cluster does not contain
+     *                                        any data members
+     * @throws `UnsupportedOperationError`  if the cluster version is less
+     *                                        than 3.10
+     * @throws `ConsistencyLostError`       if the session guarantees have
+     *                                        been lost
+     */
+    decrementAndGet(): Promise<Long>;
+    /**
+     * Increments by one the current value.
+     *
+     * @return the updated value
+     * @throws `NoDataMemberInClusterError` if the cluster does not contain
+     *                                        any data members
+     * @throws `UnsupportedOperationError`  if the cluster version is less
+     *                                        than 3.10
+     * @throws `ConsistencyLostError`       if the session guarantees have
+     *                                        been lost
+     */
+    incrementAndGet(): Promise<Long>;
+    /**
+     * Decrements by one the current value.
+     *
+     * @return the previous value
+     * @throws `NoDataMemberInClusterError` if the cluster does not contain
+     *                                        any data members
+     * @throws `UnsupportedOperationError`  if the cluster version is less
+     *                                        than 3.10
+     * @throws `ConsistencyLostError`       if the session guarantees have
+     *                                        been lost
+     */
+    getAndDecrement(): Promise<Long>;
+    /**
+     * Increments by one the current value.
+     *
+     * @return the previous value
+     * @throws `NoDataMemberInClusterError` if the cluster does not contain
+     *                                        any data members
+     * @throws `UnsupportedOperationError`  if the cluster version is less
+     *                                        than 3.10
+     * @throws `ConsistencyLostError`       if the session guarantees have
+     *                                        beenlost
+     */
+    getAndIncrement(): Promise<Long>;
+    /**
+     * Resets the observed state by this PN counter. This method may be used
+     * after a method invocation has thrown a `ConsistencyLostError`
+     * to reset the proxy and to be able to start a new session.
+     */
+    reset(): Promise<void>;
+}

package/lib/proxy/PNCounter.js

@@ -0,0 +1,17 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/proxy/PNCounterProxy.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="bluebird" />
+/// <reference types="long" />
+import * as Promise from 'bluebird';
+import * as Long from 'long';
+import { BaseProxy } from './BaseProxy';
+import { PNCounter } from './PNCounter';
+export declare class PNCounterProxy extends BaseProxy implements PNCounter {
+    private static readonly EMPTY_ARRAY;
+    private lastObservedVectorClock;
+    private maximumReplicaCount;
+    private currentTargetReplicaAddress;
+    get(): Promise<Long>;
+    getAndAdd(delta: Long | number): Promise<Long>;
+    addAndGet(delta: Long | number): Promise<Long>;
+    getAndSubtract(delta: Long | number): Promise<Long>;
+    subtractAndGet(delta: Long | number): Promise<Long>;
+    decrementAndGet(): Promise<Long>;
+    incrementAndGet(): Promise<Long>;
+    getAndDecrement(): Promise<Long>;
+    getAndIncrement(): Promise<Long>;
+    reset(): Promise<void>;
+    private invokeInternal(excludedAddresses, lastError, codec, ...codecArgs);
+    private encodeInvokeInternal<T>(target, codec, ...codecArguments);
+    private getCRDTOperationTarget(excludedAddresses);
+    private chooseTargetReplica(excludedAddresses);
+    private getReplicaAddresses(excludedAddresses);
+    private getMaxConfiguredReplicaCount();
+    private updateObservedReplicaTimestamps(observedTimestamps);
+    private toVectorClock(timestamps);
+}

package/lib/proxy/PNCounterProxy.js

@@ -0,0 +1,181 @@
+"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 Promise = require("bluebird");
+var Long = require("long");
+var PNCounterAddCodec_1 = require("../codec/PNCounterAddCodec");
+var PNCounterGetCodec_1 = require("../codec/PNCounterGetCodec");
+var PNCounterGetConfiguredReplicaCountCodec_1 = require("../codec/PNCounterGetConfiguredReplicaCountCodec");
+var MemberSelectors_1 = require("../core/MemberSelectors");
+var VectorClock_1 = require("../core/VectorClock");
+var HazelcastError_1 = require("../HazelcastError");
+var Util_1 = require("../Util");
+var BaseProxy_1 = require("./BaseProxy");
+var PNCounterProxy = /** @class */ (function (_super) {
+    __extends(PNCounterProxy, _super);
+    function PNCounterProxy() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.lastObservedVectorClock = new VectorClock_1.VectorClock();
+        _this.maximumReplicaCount = 0;
+        return _this;
+    }
+    PNCounterProxy.prototype.get = function () {
+        return this.invokeInternal(PNCounterProxy.EMPTY_ARRAY, null, PNCounterGetCodec_1.PNCounterGetCodec);
+    };
+    PNCounterProxy.prototype.getAndAdd = function (delta) {
+        return this.invokeInternal(PNCounterProxy.EMPTY_ARRAY, null, PNCounterAddCodec_1.PNCounterAddCodec, delta, true);
+    };
+    PNCounterProxy.prototype.addAndGet = function (delta) {
+        return this.invokeInternal(PNCounterProxy.EMPTY_ARRAY, null, PNCounterAddCodec_1.PNCounterAddCodec, delta, false);
+    };
+    PNCounterProxy.prototype.getAndSubtract = function (delta) {
+        if (!Long.isLong(delta)) {
+            delta = Long.fromNumber(delta);
+        }
+        return this.invokeInternal(PNCounterProxy.EMPTY_ARRAY, null, PNCounterAddCodec_1.PNCounterAddCodec, delta.neg(), true);
+    };
+    PNCounterProxy.prototype.subtractAndGet = function (delta) {
+        if (!Long.isLong(delta)) {
+            delta = Long.fromNumber(delta);
+        }
+        return this.invokeInternal(PNCounterProxy.EMPTY_ARRAY, null, PNCounterAddCodec_1.PNCounterAddCodec, delta.neg(), false);
+    };
+    PNCounterProxy.prototype.decrementAndGet = function () {
+        return this.invokeInternal(PNCounterProxy.EMPTY_ARRAY, null, PNCounterAddCodec_1.PNCounterAddCodec, Long.fromNumber(-1), false);
+    };
+    PNCounterProxy.prototype.incrementAndGet = function () {
+        return this.invokeInternal(PNCounterProxy.EMPTY_ARRAY, null, PNCounterAddCodec_1.PNCounterAddCodec, Long.fromNumber(1), false);
+    };
+    PNCounterProxy.prototype.getAndDecrement = function () {
+        return this.invokeInternal(PNCounterProxy.EMPTY_ARRAY, null, PNCounterAddCodec_1.PNCounterAddCodec, Long.fromNumber(-1), true);
+    };
+    PNCounterProxy.prototype.getAndIncrement = function () {
+        return this.invokeInternal(PNCounterProxy.EMPTY_ARRAY, null, PNCounterAddCodec_1.PNCounterAddCodec, Long.fromNumber(1), true);
+    };
+    PNCounterProxy.prototype.reset = function () {
+        this.lastObservedVectorClock = new VectorClock_1.VectorClock();
+        return Promise.resolve();
+    };
+    PNCounterProxy.prototype.invokeInternal = function (excludedAddresses, lastError, codec) {
+        var _this = this;
+        var codecArgs = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+            codecArgs[_i - 3] = arguments[_i];
+        }
+        return this.getCRDTOperationTarget(excludedAddresses).then(function (target) {
+            if (target == null) {
+                if (lastError) {
+                    throw lastError;
+                }
+                else {
+                    throw new HazelcastError_1.NoDataMemberInClusterError('Cannot invoke operations on a CRDT ' +
+                        'because the cluster does not contain any data members');
+                }
+            }
+            return _this.encodeInvokeInternal.apply(_this, [target, codec].concat(codecArgs)).then(function (result) {
+                _this.updateObservedReplicaTimestamps(result.replicaTimestamps);
+                return result.value;
+            }).catch(function (err) {
+                if (excludedAddresses === PNCounterProxy.EMPTY_ARRAY) {
+                    excludedAddresses = [];
+                }
+                excludedAddresses.push(target);
+                return _this.invokeInternal.apply(_this, [excludedAddresses, err, codec].concat(codecArgs));
+            });
+        });
+    };
+    PNCounterProxy.prototype.encodeInvokeInternal = function (target, codec) {
+        var codecArguments = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            codecArguments[_i - 2] = arguments[_i];
+        }
+        return this.encodeInvokeOnAddress.apply(this, [codec, target].concat(codecArguments, [this.lastObservedVectorClock.entrySet(), target]));
+    };
+    PNCounterProxy.prototype.getCRDTOperationTarget = function (excludedAddresses) {
+        var _this = this;
+        if (this.currentTargetReplicaAddress != null &&
+            !excludedAddresses.some(this.currentTargetReplicaAddress.equals.bind(this.currentTargetReplicaAddress))) {
+            return Promise.resolve(this.currentTargetReplicaAddress);
+        }
+        else {
+            return this.chooseTargetReplica(excludedAddresses).then(function (target) {
+                _this.currentTargetReplicaAddress = target;
+                return target;
+            });
+        }
+    };
+    PNCounterProxy.prototype.chooseTargetReplica = function (excludedAddresses) {
+        return this.getReplicaAddresses(excludedAddresses).then(function (replicaAddresses) {
+            if (replicaAddresses.length === 0) {
+                return null;
+            }
+            return replicaAddresses[Util_1.randomInt(replicaAddresses.length)];
+        });
+    };
+    PNCounterProxy.prototype.getReplicaAddresses = function (excludedAddresses) {
+        var dataMembers = this.client.getClusterService().getMembers(MemberSelectors_1.MemberSelectors.DATA_MEMBER_SELECTOR);
+        return this.getMaxConfiguredReplicaCount().then(function (replicaCount) {
+            var currentCount = Math.min(replicaCount, dataMembers.length);
+            var replicaAddresses = [];
+            for (var i = 0; i < currentCount; i++) {
+                var memberAddress = dataMembers[i].address;
+                if (!excludedAddresses.some(memberAddress.equals.bind(memberAddress))) {
+                    replicaAddresses.push(memberAddress);
+                }
+            }
+            return replicaAddresses;
+        });
+    };
+    PNCounterProxy.prototype.getMaxConfiguredReplicaCount = function () {
+        var _this = this;
+        if (this.maximumReplicaCount > 0) {
+            return Promise.resolve(this.maximumReplicaCount);
+        }
+        else {
+            return this.encodeInvokeOnRandomTarget(PNCounterGetConfiguredReplicaCountCodec_1.PNCounterGetConfiguredReplicaCountCodec).then(function (count) {
+                _this.maximumReplicaCount = count;
+                return _this.maximumReplicaCount;
+            });
+        }
+    };
+    PNCounterProxy.prototype.updateObservedReplicaTimestamps = function (observedTimestamps) {
+        var observedClock = this.toVectorClock(observedTimestamps);
+        if (observedClock.isAfter(this.lastObservedVectorClock)) {
+            this.lastObservedVectorClock = observedClock;
+        }
+    };
+    PNCounterProxy.prototype.toVectorClock = function (timestamps) {
+        var vectorClock = new VectorClock_1.VectorClock();
+        timestamps.forEach(function (entry) {
+            vectorClock.setReplicaTimestamp(entry[0], entry[1]);
+        });
+        return vectorClock;
+    };
+    PNCounterProxy.EMPTY_ARRAY = [];
+    return PNCounterProxy;
+}(BaseProxy_1.BaseProxy));
+exports.PNCounterProxy = PNCounterProxy;