hazelcast-client/lib/proxy/ReplicatedMapProxy.js

Hazelcast - open source In-Memory Data Grid - client for NodeJS

"use strict";
var __extends = (this && this.__extends) || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var Util_1 = require("../Util");
var ReplicatedMapPutCodec_1 = require("../codec/ReplicatedMapPutCodec");
var ReplicatedMapClearCodec_1 = require("../codec/ReplicatedMapClearCodec");
var ReplicatedMapGetCodec_1 = require("../codec/ReplicatedMapGetCodec");
var ReplicatedMapContainsKeyCodec_1 = require("../codec/ReplicatedMapContainsKeyCodec");
var ReplicatedMapContainsValueCodec_1 = require("../codec/ReplicatedMapContainsValueCodec");
var ReplicatedMapSizeCodec_1 = require("../codec/ReplicatedMapSizeCodec");
var ReplicatedMapIsEmptyCodec_1 = require("../codec/ReplicatedMapIsEmptyCodec");
var ReplicatedMapRemoveCodec_1 = require("../codec/ReplicatedMapRemoveCodec");
var ReplicatedMapPutAllCodec_1 = require("../codec/ReplicatedMapPutAllCodec");
var ReplicatedMapKeySetCodec_1 = require("../codec/ReplicatedMapKeySetCodec");
var ReplicatedMapValuesCodec_1 = require("../codec/ReplicatedMapValuesCodec");
var ReplicatedMapEntrySetCodec_1 = require("../codec/ReplicatedMapEntrySetCodec");
var ReplicatedMapRemoveEntryListenerCodec_1 = require("../codec/ReplicatedMapRemoveEntryListenerCodec");
var EntryEventType_1 = require("../core/EntryEventType");
var ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_1 = require("../codec/ReplicatedMapAddEntryListenerToKeyWithPredicateCodec");
var ReplicatedMapAddEntryListenerToKeyCodec_1 = require("../codec/ReplicatedMapAddEntryListenerToKeyCodec");
var ReplicatedMapAddEntryListenerWithPredicateCodec_1 = require("../codec/ReplicatedMapAddEntryListenerWithPredicateCodec");
var ReplicatedMapAddEntryListenerCodec_1 = require("../codec/ReplicatedMapAddEntryListenerCodec");
var PartitionSpecificProxy_1 = require("./PartitionSpecificProxy");
var ReplicatedMapProxy = (function (_super) {
    __extends(ReplicatedMapProxy, _super);
    function ReplicatedMapProxy() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    ReplicatedMapProxy.prototype.put = function (key, value, ttl) {
        if (ttl === void 0) { ttl = 0; }
        Util_1.assertNotNull(key);
        Util_1.assertNotNull(value);
        var valueData = this.toData(value);
        var keyData = this.toData(key);
        return this.encodeInvokeOnKey(ReplicatedMapPutCodec_1.ReplicatedMapPutCodec, keyData, keyData, valueData, ttl);
    };
    ReplicatedMapProxy.prototype.clear = function () {
        return this.encodeInvokeOnRandomTarget(ReplicatedMapClearCodec_1.ReplicatedMapClearCodec);
    };
    ReplicatedMapProxy.prototype.get = function (key) {
        Util_1.assertNotNull(key);
        var keyData = this.toData(key);
        return this.encodeInvokeOnKey(ReplicatedMapGetCodec_1.ReplicatedMapGetCodec, keyData, keyData);
    };
    ReplicatedMapProxy.prototype.containsKey = function (key) {
        Util_1.assertNotNull(key);
        var keyData = this.toData(key);
        return this.encodeInvokeOnKey(ReplicatedMapContainsKeyCodec_1.ReplicatedMapContainsKeyCodec, keyData, keyData);
    };
    ReplicatedMapProxy.prototype.containsValue = function (value) {
        Util_1.assertNotNull(value);
        var valueData = this.toData(value);
        return this.encodeInvoke(ReplicatedMapContainsValueCodec_1.ReplicatedMapContainsValueCodec, valueData);
    };
    ReplicatedMapProxy.prototype.size = function () {
        return this.encodeInvoke(ReplicatedMapSizeCodec_1.ReplicatedMapSizeCodec);
    };
    ReplicatedMapProxy.prototype.isEmpty = function () {
        return this.encodeInvoke(ReplicatedMapIsEmptyCodec_1.ReplicatedMapIsEmptyCodec);
    };
    ReplicatedMapProxy.prototype.remove = function (key) {
        Util_1.assertNotNull(key);
        var keyData = this.toData(key);
        return this.encodeInvokeOnKey(ReplicatedMapRemoveCodec_1.ReplicatedMapRemoveCodec, keyData, keyData);
    };
    ReplicatedMapProxy.prototype.putAll = function (pairs) {
        var pair;
        var pairId;
        var entries = [];
        for (pairId in pairs) {
            pair = pairs[pairId];
            var keyData = this.toData(pair[0]);
            var valueData = this.toData(pair[1]);
            entries.push([keyData, valueData]);
        }
        return this.encodeInvokeOnRandomTarget(ReplicatedMapPutAllCodec_1.ReplicatedMapPutAllCodec, entries);
    };
    ReplicatedMapProxy.prototype.keySet = function () {
        var toObject = this.toObject.bind(this);
        return this.encodeInvoke(ReplicatedMapKeySetCodec_1.ReplicatedMapKeySetCodec).then(function (keySet) {
            return keySet.map(toObject);
        });
    };
    ReplicatedMapProxy.prototype.values = function (comparator) {
        var toObject = this.toObject.bind(this);
        return this.encodeInvoke(ReplicatedMapValuesCodec_1.ReplicatedMapValuesCodec).then(function (valuesData) {
            var results = valuesData.map(toObject);
            if (comparator) {
                return results.sort(comparator);
            }
            return results;
        });
    };
    ReplicatedMapProxy.prototype.entrySet = function () {
        var toObject = this.toObject.bind(this);
        return this.encodeInvoke(ReplicatedMapEntrySetCodec_1.ReplicatedMapEntrySetCodec).then(function (entrySet) {
            return entrySet.map(function (entry) { return [toObject(entry[0]), toObject(entry[1])]; });
        });
    };
    ReplicatedMapProxy.prototype.addEntryListenerToKeyWithPredicate = function (listener, key, predicate, localOnly) {
        return this.addEntryListenerInternal(listener, predicate, key, localOnly);
    };
    ReplicatedMapProxy.prototype.addEntryListenerWithPredicate = function (listener, predicate, localOnly) {
        return this.addEntryListenerInternal(listener, predicate, undefined, localOnly);
    };
    ReplicatedMapProxy.prototype.addEntryListenerToKey = function (listener, key, localOnly) {
        return this.addEntryListenerInternal(listener, undefined, key, localOnly);
    };
    ReplicatedMapProxy.prototype.addEntryListener = function (listener, localOnly) {
        return this.addEntryListenerInternal(listener, undefined, undefined, localOnly);
    };
    ReplicatedMapProxy.prototype.removeEntryListener = function (listenerId) {
        return this.client.getListenerService().deregisterListener(ReplicatedMapRemoveEntryListenerCodec_1.ReplicatedMapRemoveEntryListenerCodec.encodeRequest(this.name, listenerId), ReplicatedMapRemoveEntryListenerCodec_1.ReplicatedMapRemoveEntryListenerCodec.decodeResponse);
    };
    ReplicatedMapProxy.prototype.addEntryListenerInternal = function (listener, predicate, key, localOnly) {
        if (localOnly === void 0) { localOnly = false; }
        var toObject = this.toObject.bind(this);
        var entryEventHandler = function (key, val, oldVal, mergingVal, event, uuid, numberOfAffectedEntries) {
            var eventParams = [key, oldVal, val, mergingVal, numberOfAffectedEntries, uuid];
            eventParams = eventParams.map(toObject);
            var eventToListenerMap = (_a = {},
                _a[EntryEventType_1.EntryEventType.ADDED] = 'added',
                _a[EntryEventType_1.EntryEventType.REMOVED] = 'removed',
                _a[EntryEventType_1.EntryEventType.UPDATED] = 'updated',
                _a[EntryEventType_1.EntryEventType.EVICTED] = 'evicted',
                _a[EntryEventType_1.EntryEventType.CLEAR_ALL] = 'clearedAll',
                _a);
            var eventMethod = eventToListenerMap[event];
            if (listener.hasOwnProperty(eventMethod)) {
                listener[eventMethod].apply(null, eventParams);
            }
            var _a;
        };
        var request;
        var handler;
        var responser;
        if (key && predicate) {
            var keyData = this.toData(key);
            var predicateData = this.toData(predicate);
            request = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_1.ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeRequest(this.name, keyData, predicateData, localOnly);
            handler = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_1.ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.handle;
            responser = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_1.ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.decodeResponse;
        }
        else if (key && !predicate) {
            var keyData = this.toData(key);
            request = ReplicatedMapAddEntryListenerToKeyCodec_1.ReplicatedMapAddEntryListenerToKeyCodec.encodeRequest(this.name, keyData, localOnly);
            handler = ReplicatedMapAddEntryListenerToKeyCodec_1.ReplicatedMapAddEntryListenerToKeyCodec.handle;
            responser = ReplicatedMapAddEntryListenerToKeyCodec_1.ReplicatedMapAddEntryListenerToKeyCodec.decodeResponse;
        }
        else if (!key && predicate) {
            var predicateData = this.toData(predicate);
            request = ReplicatedMapAddEntryListenerWithPredicateCodec_1.ReplicatedMapAddEntryListenerWithPredicateCodec.encodeRequest(this.name, predicateData, localOnly);
            handler = ReplicatedMapAddEntryListenerWithPredicateCodec_1.ReplicatedMapAddEntryListenerWithPredicateCodec.handle;
            responser = ReplicatedMapAddEntryListenerWithPredicateCodec_1.ReplicatedMapAddEntryListenerWithPredicateCodec.decodeResponse;
        }
        else {
            request = ReplicatedMapAddEntryListenerCodec_1.ReplicatedMapAddEntryListenerCodec.encodeRequest(this.name, localOnly);
            handler = ReplicatedMapAddEntryListenerCodec_1.ReplicatedMapAddEntryListenerCodec.handle;
            responser = ReplicatedMapAddEntryListenerCodec_1.ReplicatedMapAddEntryListenerCodec.decodeResponse;
        }
        return this.client.getListenerService().registerListener(request, function (m) {
            handler(m, entryEventHandler, toObject);
        }, responser);
    };
    return ReplicatedMapProxy;
}(PartitionSpecificProxy_1.PartitionSpecificProxy));
exports.ReplicatedMapProxy = ReplicatedMapProxy;
//# sourceMappingURL=ReplicatedMapProxy.js.map