@celerispay/hazelcast-client 3.12.5

package/lib/proxy/MultiMap.d.ts

@@ -0,0 +1,153 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { EntryListener } from '../core/EntryListener';
+import { ReadOnlyLazyList } from '../core/ReadOnlyLazyList';
+import { DistributedObject } from '../DistributedObject';
+export interface MultiMap<K, V> extends DistributedObject {
+    /**
+     * Adds a key-value pair to this multi-map.
+     * If this multi-map already has some value associated with the specified key, then calling this method
+     * will not replace the old value. Instead, both values will be associated with the same key.
+     * @param key key to add.
+     * @param value value to associate with the key.
+     * @return `true` if this multi-map did not have the specified value associated
+     * with the specified key, `false` otherwise.
+     */
+    put(key: K, value: V): Promise<boolean>;
+    /**
+     * Retrieves a list of values associated with the specified key.
+     * @param key key to search for.
+     * @return a list of values associated with the specified key.
+     */
+    get(key: K): Promise<ReadOnlyLazyList<V>>;
+    /**
+     * Removes an association of the specified value with the specified key. Calling this method does not affect
+     * other values associated with the same key.
+     * @param key key from which the value should be detached.
+     * @param value value to be removed.
+     * @return `true` if the value was detached from the specified key, `false` if it was not.
+     */
+    remove(key: K, value: V): Promise<boolean>;
+    /**
+     * Detaches all values from the specified key.
+     * @param key key from which all entries should be removed.
+     * @return a list of old values that were associated with this key prior to this method call.
+     */
+    removeAll(key: K): Promise<ReadOnlyLazyList<V>>;
+    /**
+     * @return an array of all keys in this multi-map.
+     */
+    keySet(): Promise<K[]>;
+    /**
+     * @return a flat list of all values stored in this multi-map.
+     */
+    values(): Promise<ReadOnlyLazyList<V>>;
+    /**
+     * Returns all entries in this multi-map. If a certain key has multiple values associated with it,
+     * then one pair will be returned for each value.
+     * @return an array of all key value pairs stored in this multi-map.
+     */
+    entrySet(): Promise<Array<[K, V]>>;
+    /**
+     * Checks if this multi-map contains a specified key.
+     * @param key key to search for.
+     * @returns `true` if this map contains the specified key, `false` otherwise.
+     */
+    containsKey(key: K): Promise<boolean>;
+    /**
+     * @param value value to search for.
+     * @return `true` if the specified value is associated with at least one key in this multi-map,
+     * `false` otherwise.
+     */
+    containsValue(value: V): Promise<boolean>;
+    /**
+     * @param key key to match against.
+     * @param value value to match against.
+     * @return `true` if this multi-map has an association between
+     * the specified key and the specified value, `false` otherwise.
+     */
+    containsEntry(key: K, value: V): Promise<boolean>;
+    /**
+     * @return the total number of values in this multi-map.
+     */
+    size(): Promise<number>;
+    /**
+     * Removes all entries from this multi-map.
+     */
+    clear(): Promise<void>;
+    /**
+     * @param key key to search for.
+     * @return the number of values associated with the specified key.
+     */
+    valueCount(key: K): Promise<number>;
+    /**
+     * Adds an entry listener to this multi-map.
+     * @param listener entry listener to be attached
+     * @param key if specified then this entry listener will only be notified of updates related to this key.
+     * @param includeValue if `true`, then the event will include the modified value.
+     * @return registration ID for this entry listener
+     */
+    addEntryListener(listener: EntryListener<K, V>, key?: K, includeValue?: boolean): Promise<string>;
+    /**
+     * Removes the entry listener by the registration ID.
+     * @param listenerId registration ID that was returned when this listener was added.
+     */
+    removeEntryListener(listenerId: string): Promise<boolean>;
+    /**
+     * Locks the specified key.
+     * If the specified key cannot be locked immediately, then the returned Promise will be resolved
+     * only when the lock becomes available.
+     * All attempts to access the locked key will block until the lock is released.
+     *
+     * Locking is reentrant, meaning that the lock owner can obtain the lock multiple times.
+     * If the lock was acquired multiple times, then `unlock` method must be called the same amount of
+     * times, otherwise the lock will remain unavailable.
+     *
+     * If lease time is specified, then the lock will automatically become available
+     * after the specified time has passed.
+     * If lease time is not specified or is less than zero,
+     * then lock owner must call `unlock` to make the lock available.
+     * @param key key to be locked.
+     * @param leaseMillis lease time in milliseconds.
+     */
+    lock(key: K, leaseMillis?: number): Promise<void>;
+    /**
+     * @param key key to be checked
+     * @return `true` if this key is locked, `false` otherwise
+     */
+    isLocked(key: K): Promise<boolean>;
+    /**
+     * Attempts to acquire the lock for the specified key within the specified timeout.
+     * The returned promise will be returned either when the lock becomes available
+     * or when the timeout is reached.
+     *
+     * If the specified key cannot be locked immediately, then the returned Promise will be resolved
+     * only when the lock becomes available.
+     * All attempts to access the locked key will block until the lock is released.
+     *
+     * Locking is reentrant, meaning that the lock owner can obtain the lock multiple times.
+     * If the lock was acquired multiple times, then `unlock` method must be called the same amount of
+     * times, otherwise the lock will remain unavailable.
+     *
+     * If lease time is specified, then the lock will automatically become available
+     * after the specified time has passed.
+     * If lease time is not specified or is less than zero,
+     * then lock owner must call `unlock` to make the lock available.
+     * @param key key to be locked
+     * @param timeoutMillis timeout for locking, in milliseconds
+     * @param leaseMillis lease time in milliseconds
+     */
+    tryLock(key: K, timeoutMillis?: number, leaseMillis?: number): Promise<boolean>;
+    /**
+     * Unlocks the specified key
+     * @param key key to be unlocked
+     */
+    unlock(key: K): Promise<void>;
+    /**
+     * Forcefully unlocks the specified key, disregarding the acquisition count.
+     * This in contrast to the regular `unlock`, which has to be called the same amount of times as
+     * the lock was acquired.
+     * @param key key to be unlocked.
+     */
+    forceUnlock(key: K): Promise<void>;
+}

package/lib/proxy/MultiMap.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/MultiMapProxy.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { EntryListener } from '../core/EntryListener';
+import { ReadOnlyLazyList } from '../core/ReadOnlyLazyList';
+import { BaseProxy } from './BaseProxy';
+import { MultiMap } from './MultiMap';
+export declare class MultiMapProxy<K, V> extends BaseProxy implements MultiMap<K, V> {
+    private lockReferenceIdGenerator;
+    private deserializeList;
+    put(key: K, value: V): Promise<boolean>;
+    get(key: K): Promise<ReadOnlyLazyList<V>>;
+    remove(key: K, value: V): Promise<boolean>;
+    removeAll(key: K): Promise<ReadOnlyLazyList<V>>;
+    keySet(): Promise<K[]>;
+    values(): Promise<ReadOnlyLazyList<V>>;
+    entrySet(): Promise<Array<[K, V]>>;
+    containsKey(key: K): Promise<boolean>;
+    containsValue(value: V): Promise<boolean>;
+    containsEntry(key: K, value: V): Promise<boolean>;
+    size(): Promise<number>;
+    clear(): Promise<void>;
+    valueCount(key: K): Promise<number>;
+    addEntryListener(listener: EntryListener<K, V>, key?: K, includeValue?: boolean): Promise<string>;
+    removeEntryListener(listenerId: string): Promise<boolean>;
+    lock(key: K, leaseMillis?: number): Promise<void>;
+    isLocked(key: K): Promise<boolean>;
+    tryLock(key: K, timeoutMillis?: number, leaseMillis?: number): Promise<boolean>;
+    unlock(key: K): Promise<void>;
+    forceUnlock(key: K): Promise<void>;
+    private nextSequence();
+    private createEntryListenerToKey(name, keyData, includeValue);
+    private createEntryListener(name, includeValue);
+}

package/lib/proxy/MultiMapProxy.js

@@ -0,0 +1,238 @@
+"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 MultiMapForceUnlockCodec_1 = require("../codec/MultiMapForceUnlockCodec");
+var MultiMapIsLockedCodec_1 = require("../codec/MultiMapIsLockedCodec");
+var MultiMapLockCodec_1 = require("../codec/MultiMapLockCodec");
+var MultiMapTryLockCodec_1 = require("../codec/MultiMapTryLockCodec");
+var MultiMapUnlockCodec_1 = require("../codec/MultiMapUnlockCodec");
+var EventType_1 = require("../core/EventType");
+var EntryListener_1 = require("../core/EntryListener");
+var ReadOnlyLazyList_1 = require("../core/ReadOnlyLazyList");
+var MultiMapAddEntryListenerCodec_1 = require("./../codec/MultiMapAddEntryListenerCodec");
+var MultiMapAddEntryListenerToKeyCodec_1 = require("./../codec/MultiMapAddEntryListenerToKeyCodec");
+var MultiMapClearCodec_1 = require("./../codec/MultiMapClearCodec");
+var MultiMapContainsEntryCodec_1 = require("./../codec/MultiMapContainsEntryCodec");
+var MultiMapContainsKeyCodec_1 = require("./../codec/MultiMapContainsKeyCodec");
+var MultiMapContainsValueCodec_1 = require("./../codec/MultiMapContainsValueCodec");
+var MultiMapEntrySetCodec_1 = require("./../codec/MultiMapEntrySetCodec");
+var MultiMapGetCodec_1 = require("./../codec/MultiMapGetCodec");
+var MultiMapKeySetCodec_1 = require("./../codec/MultiMapKeySetCodec");
+var MultiMapPutCodec_1 = require("./../codec/MultiMapPutCodec");
+var MultiMapRemoveCodec_1 = require("./../codec/MultiMapRemoveCodec");
+var MultiMapRemoveEntryCodec_1 = require("./../codec/MultiMapRemoveEntryCodec");
+var MultiMapRemoveEntryListenerCodec_1 = require("./../codec/MultiMapRemoveEntryListenerCodec");
+var MultiMapSizeCodec_1 = require("./../codec/MultiMapSizeCodec");
+var MultiMapValueCountCodec_1 = require("./../codec/MultiMapValueCountCodec");
+var MultiMapValuesCodec_1 = require("./../codec/MultiMapValuesCodec");
+var BaseProxy_1 = require("./BaseProxy");
+var MapListener_1 = require("../core/MapListener");
+var MultiMapProxy = /** @class */ (function (_super) {
+    __extends(MultiMapProxy, _super);
+    function MultiMapProxy() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.lockReferenceIdGenerator = _this.client.getLockReferenceIdGenerator();
+        _this.deserializeList = function (items) {
+            return items.map(_this.toObject.bind(_this));
+            // tslint:disable-next-line:semicolon
+        };
+        return _this;
+    }
+    /*tslint:disable:member-ordering*/
+    MultiMapProxy.prototype.put = function (key, value) {
+        var keyData = this.toData(key);
+        var valueData = this.toData(value);
+        return this.encodeInvokeOnKey(MultiMapPutCodec_1.MultiMapPutCodec, keyData, keyData, valueData, 1);
+    };
+    MultiMapProxy.prototype.get = function (key) {
+        var _this = this;
+        var keyData = this.toData(key);
+        return this.encodeInvokeOnKey(MultiMapGetCodec_1.MultiMapGetCodec, keyData, keyData, 1).then(function (data) {
+            return new ReadOnlyLazyList_1.ReadOnlyLazyList(data, _this.client.getSerializationService());
+        });
+    };
+    MultiMapProxy.prototype.remove = function (key, value) {
+        var keyData = this.toData(key);
+        var valueData = this.toData(value);
+        return this.encodeInvokeOnKey(MultiMapRemoveEntryCodec_1.MultiMapRemoveEntryCodec, keyData, keyData, valueData, 1);
+    };
+    MultiMapProxy.prototype.removeAll = function (key) {
+        var _this = this;
+        var keyData = this.toData(key);
+        return this.encodeInvokeOnKey(MultiMapRemoveCodec_1.MultiMapRemoveCodec, keyData, keyData, 1).then(function (data) {
+            return new ReadOnlyLazyList_1.ReadOnlyLazyList(data, _this.client.getSerializationService());
+        });
+    };
+    MultiMapProxy.prototype.keySet = function () {
+        return this.encodeInvokeOnRandomTarget(MultiMapKeySetCodec_1.MultiMapKeySetCodec)
+            .then(this.deserializeList);
+    };
+    MultiMapProxy.prototype.values = function () {
+        var _this = this;
+        return this.encodeInvokeOnRandomTarget(MultiMapValuesCodec_1.MultiMapValuesCodec).then(function (data) {
+            return new ReadOnlyLazyList_1.ReadOnlyLazyList(data, _this.client.getSerializationService());
+        });
+    };
+    MultiMapProxy.prototype.entrySet = function () {
+        var _this = this;
+        return this.encodeInvokeOnRandomTarget(MultiMapEntrySetCodec_1.MultiMapEntrySetCodec)
+            .then(function (entrySet) {
+            return entrySet.map(function (entry) {
+                return [_this.toObject(entry[0]), _this.toObject(entry[1])];
+            });
+        });
+    };
+    MultiMapProxy.prototype.containsKey = function (key) {
+        var keyData = this.toData(key);
+        return this.encodeInvokeOnKey(MultiMapContainsKeyCodec_1.MultiMapContainsKeyCodec, keyData, keyData, 1);
+    };
+    MultiMapProxy.prototype.containsValue = function (value) {
+        var valueData = this.toData(value);
+        return this.encodeInvokeOnRandomTarget(MultiMapContainsValueCodec_1.MultiMapContainsValueCodec, valueData);
+    };
+    MultiMapProxy.prototype.containsEntry = function (key, value) {
+        var keyData = this.toData(key);
+        var valueData = this.toData(value);
+        return this.encodeInvokeOnKey(MultiMapContainsEntryCodec_1.MultiMapContainsEntryCodec, keyData, keyData, valueData, 1);
+    };
+    MultiMapProxy.prototype.size = function () {
+        return this.encodeInvokeOnRandomTarget(MultiMapSizeCodec_1.MultiMapSizeCodec);
+    };
+    MultiMapProxy.prototype.clear = function () {
+        return this.encodeInvokeOnRandomTarget(MultiMapClearCodec_1.MultiMapClearCodec);
+    };
+    MultiMapProxy.prototype.valueCount = function (key) {
+        var keyData = this.toData(key);
+        return this.encodeInvokeOnKey(MultiMapValueCountCodec_1.MultiMapValueCountCodec, keyData, keyData, 1);
+    };
+    MultiMapProxy.prototype.addEntryListener = function (listener, key, includeValue) {
+        var _this = this;
+        if (includeValue === void 0) { includeValue = true; }
+        var toObject = this.toObject.bind(this);
+        /* tslint:disable: no-shadowed-variable */
+        var entryEventHandler = function (key, value, oldValue, mergingValue, eventType, uuid, numberOfAffectedEntries) {
+            var member = _this.client.getClusterService().getMember(uuid);
+            var name = _this.name;
+            key = toObject(key);
+            value = toObject(value);
+            oldValue = toObject(oldValue);
+            mergingValue = toObject(mergingValue);
+            var entryEvent = new EntryListener_1.EntryEvent(name, key, value, oldValue, mergingValue, member);
+            var mapEvent = new MapListener_1.MapEvent(name, numberOfAffectedEntries, member);
+            // Multi map only supports these three event types
+            switch (eventType) {
+                case EventType_1.EventType.ADDED:
+                    if (listener.added) {
+                        listener.added.apply(null, [entryEvent]);
+                    }
+                    break;
+                case EventType_1.EventType.REMOVED:
+                    if (listener.removed) {
+                        listener.removed.apply(null, [entryEvent]);
+                    }
+                    break;
+                case EventType_1.EventType.CLEAR_ALL:
+                    if (listener.mapCleared) {
+                        listener.mapCleared.apply(null, [mapEvent]);
+                    }
+                    break;
+            }
+        };
+        if (key) {
+            var keyData = this.toData(key);
+            var handler = function (m) {
+                MultiMapAddEntryListenerToKeyCodec_1.MultiMapAddEntryListenerToKeyCodec.handle(m, entryEventHandler, toObject);
+            };
+            var codec = this.createEntryListenerToKey(this.name, keyData, includeValue);
+            return this.client.getListenerService().registerListener(codec, handler);
+        }
+        else {
+            var listenerHandler = function (m) {
+                MultiMapAddEntryListenerCodec_1.MultiMapAddEntryListenerCodec.handle(m, entryEventHandler, toObject);
+            };
+            var codec = this.createEntryListener(this.name, includeValue);
+            return this.client.getListenerService().registerListener(codec, listenerHandler);
+        }
+    };
+    MultiMapProxy.prototype.removeEntryListener = function (listenerId) {
+        return this.client.getListenerService().deregisterListener(listenerId);
+    };
+    MultiMapProxy.prototype.lock = function (key, leaseMillis) {
+        if (leaseMillis === void 0) { leaseMillis = -1; }
+        var keyData = this.toData(key);
+        return this.encodeInvokeOnKey(MultiMapLockCodec_1.MultiMapLockCodec, keyData, keyData, 1, leaseMillis, this.nextSequence());
+    };
+    MultiMapProxy.prototype.isLocked = function (key) {
+        var keyData = this.toData(key);
+        return this.encodeInvokeOnKey(MultiMapIsLockedCodec_1.MultiMapIsLockedCodec, keyData, keyData);
+    };
+    MultiMapProxy.prototype.tryLock = function (key, timeoutMillis, leaseMillis) {
+        if (timeoutMillis === void 0) { timeoutMillis = 0; }
+        if (leaseMillis === void 0) { leaseMillis = -1; }
+        var keyData = this.toData(key);
+        return this.encodeInvokeOnKey(MultiMapTryLockCodec_1.MultiMapTryLockCodec, keyData, keyData, 1, leaseMillis, timeoutMillis, this.nextSequence());
+    };
+    MultiMapProxy.prototype.unlock = function (key) {
+        var keyData = this.toData(key);
+        return this.encodeInvokeOnKey(MultiMapUnlockCodec_1.MultiMapUnlockCodec, keyData, keyData, 1, this.nextSequence());
+    };
+    MultiMapProxy.prototype.forceUnlock = function (key) {
+        var keyData = this.toData(key);
+        return this.encodeInvokeOnKey(MultiMapForceUnlockCodec_1.MultiMapForceUnlockCodec, keyData, keyData, this.nextSequence());
+    };
+    MultiMapProxy.prototype.nextSequence = function () {
+        return this.lockReferenceIdGenerator.getNextReferenceId();
+    };
+    MultiMapProxy.prototype.createEntryListenerToKey = function (name, keyData, includeValue) {
+        return {
+            encodeAddRequest: function (localOnly) {
+                return MultiMapAddEntryListenerToKeyCodec_1.MultiMapAddEntryListenerToKeyCodec.encodeRequest(name, keyData, includeValue, localOnly);
+            },
+            decodeAddResponse: function (msg) {
+                return MultiMapAddEntryListenerToKeyCodec_1.MultiMapAddEntryListenerToKeyCodec.decodeResponse(msg).response;
+            },
+            encodeRemoveRequest: function (listenerId) {
+                return MultiMapRemoveEntryListenerCodec_1.MultiMapRemoveEntryListenerCodec.encodeRequest(name, listenerId);
+            },
+        };
+    };
+    MultiMapProxy.prototype.createEntryListener = function (name, includeValue) {
+        return {
+            encodeAddRequest: function (localOnly) {
+                return MultiMapAddEntryListenerCodec_1.MultiMapAddEntryListenerCodec.encodeRequest(name, includeValue, localOnly);
+            },
+            decodeAddResponse: function (msg) {
+                return MultiMapAddEntryListenerCodec_1.MultiMapAddEntryListenerCodec.decodeResponse(msg).response;
+            },
+            encodeRemoveRequest: function (listenerId) {
+                return MultiMapRemoveEntryListenerCodec_1.MultiMapRemoveEntryListenerCodec.encodeRequest(name, listenerId);
+            },
+        };
+    };
+    return MultiMapProxy;
+}(BaseProxy_1.BaseProxy));
+exports.MultiMapProxy = MultiMapProxy;

package/lib/proxy/NearCachedMapProxy.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import HazelcastClient from '../HazelcastClient';
+import { Data } from '../serialization/Data';
+import { MapProxy } from './MapProxy';
+export declare class NearCachedMapProxy<K, V> extends MapProxy<K, V> {
+    private nearCache;
+    private invalidationListenerId;
+    constructor(client: HazelcastClient, servicename: string, name: string);
+    clear(): Promise<void>;
+    evictAll(): Promise<void>;
+    protected containsKeyInternal(keyData: Data): Promise<boolean>;
+    protected deleteInternal(keyData: Data): Promise<void>;
+    protected evictInternal(key: Data): Promise<boolean>;
+    protected putAllInternal(partitionsToKeysData: {
+        [id: string]: Array<[Data, Data]>;
+    }): Promise<void>;
+    protected postDestroy(): Promise<void>;
+    protected putIfAbsentInternal(keyData: Data, valueData: Data, ttl: number): Promise<V>;
+    protected putTransientInternal(keyData: Data, valueData: Data, ttl: number): Promise<void>;
+    protected executeOnKeyInternal(keyData: Data, proData: Data): Promise<V>;
+    protected putInternal(keyData: Data, valueData: Data, ttl: number): Promise<V>;
+    protected getInternal(keyData: Data): Promise<V>;
+    protected tryRemoveInternal(keyData: Data, timeout: number): Promise<boolean>;
+    protected removeInternal(keyData: Data, value: V): Promise<V>;
+    protected getAllInternal(partitionsToKeys: {
+        [id: string]: Data[];
+    }, result?: any[]): Promise<any[]>;
+    protected replaceIfSameInternal(keyData: Data, oldValueData: Data, newValueData: Data): Promise<boolean>;
+    protected replaceInternal(keyData: Data, valueData: Data): Promise<V>;
+    protected setInternal(keyData: Data, valueData: Data, ttl: number): Promise<void>;
+    protected tryPutInternal(keyData: Data, valueData: Data, timeout: number): Promise<boolean>;
+    private removeNearCacheInvalidationListener();
+    private invalidateCacheEntryAndReturn<T>(keyData, retVal);
+    private invalidateCacheAndReturn<T>(retVal);
+    private addNearCacheInvalidationListener();
+    private createInvalidationListenerCodec(name, flags);
+    private supportsRepairableNearCache();
+    private createPre38NearCacheEventHandler();
+    private createNearCacheEventHandler();
+}