• Home
• com.alachisoft.ncache
• ncache-client
• 5.2.0
• source code
• CacheImplBase.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.alachisoft.ncache.client.internal.caching.CacheImplBase Maven / Gradle / Ivy

package com.alachisoft.ncache.client.internal.caching;

//import Alachisoft.NCache.Common.Util.*;

import Alachisoft.NCache.Caching.CompressedValueEntry;
import Alachisoft.NCache.Caching.Queries.QueryResultSet;
import Alachisoft.NCache.Common.BitSet;
import Alachisoft.NCache.Common.DataReader.RecordSetEnumerator;
import Alachisoft.NCache.Common.DataReader.RecordSetEnumeratorImpl;
import Alachisoft.NCache.Common.DataStructures.EnumerationDataChunk;
import Alachisoft.NCache.Common.DataStructures.EnumerationPointer;
import Alachisoft.NCache.Common.DataTypes.CollectionCreateOrGetOperation;
import Alachisoft.NCache.Common.DataTypes.CollectionOperation;
import Alachisoft.NCache.Common.DataTypes.Counter.CounterGetOperation;
import Alachisoft.NCache.Common.DataTypes.Counter.CounterOperation;
import Alachisoft.NCache.Common.DataTypes.Dictionary.DictionaryAddOperation;
import Alachisoft.NCache.Common.DataTypes.Dictionary.DictionaryContainsOperation;
import Alachisoft.NCache.Common.DataTypes.Dictionary.DictionaryGetOperation;
import Alachisoft.NCache.Common.DataTypes.Dictionary.DictionaryRemoveOperation;
import Alachisoft.NCache.Common.DataTypes.GetCollectionChunkOperation;
import Alachisoft.NCache.Common.DataTypes.HashSet.*;
import Alachisoft.NCache.Common.DataTypes.List.*;
import Alachisoft.NCache.Common.DataTypes.Queue.QueueDequeueOperation;
import Alachisoft.NCache.Common.DataTypes.Queue.QueueEnqueueOperation;
import Alachisoft.NCache.Common.DataTypes.Queue.QueuePeekOperation;
import Alachisoft.NCache.Common.DataTypes.Queue.QueueSearchOperation;
import Alachisoft.NCache.Common.DataTypes.Responses.GetCollectionChunkResponseBase;
import Alachisoft.NCache.Common.Enum.SubscriptionType;
import Alachisoft.NCache.Common.Enum.TopicOperationType;
import Alachisoft.NCache.Common.Enum.UserObjectType;
import Alachisoft.NCache.Common.Extensibility.Client.RPC.PartitioningStrategy;
import Alachisoft.NCache.Common.JSON.ExtendedJsonValueBase;
import Alachisoft.NCache.Common.Locking.LockAccessType;

import Alachisoft.NCache.Common.Logger.ILogger;
import com.alachisoft.ncache.client.*;
import com.alachisoft.ncache.client.ClientInfo;
import com.alachisoft.ncache.client.internal.communication.Connection;
import com.alachisoft.ncache.client.internal.communication.ModuleOperation;
import com.alachisoft.ncache.client.datastructures.DataStructureAttributes;
import com.alachisoft.ncache.client.internal.messaging.ReceivedMessages;
import com.alachisoft.ncache.common.caching.statistics.monitoring.PublisherContextMetaPublisher;
import com.alachisoft.ncache.runtime.CacheItemPriority;
import com.alachisoft.ncache.runtime.caching.*;
import com.alachisoft.ncache.runtime.caching.messaging.TopicPriority;
import com.alachisoft.ncache.runtime.dependencies.CacheDependency;
import com.alachisoft.ncache.runtime.events.DataTypeEventDataFilter;
import com.alachisoft.ncache.runtime.events.EventDataFilter;
import com.alachisoft.ncache.runtime.events.ListenerType;
import com.alachisoft.ncache.runtime.exceptions.SecurityException;
import com.alachisoft.ncache.runtime.exceptions.*;
import com.alachisoft.ncache.runtime.util.TimeSpan;
import com.alachisoft.ncache.serialization.util.TypeInfoMap;
import tangible.RefObject;

import java.io.IOException;
import java.net.InetAddress;
import java.text.ParseException;
import java.util.*;


public abstract class CacheImplBase implements PublisherContextMetaPublisher {

    private String _clientID;
    private boolean _encryptionEnabled;

    private ClientInfo _clientInfo;


    public CacheImplBase() {
        try {
            _clientInfo = new ClientInfo();
            _clientInfo.setProcessID((int) ProcessHandle.current().pid());
            _clientInfo.setClientID(UUID.randomUUID().toString() );
            _clientInfo.setMachineName(InetAddress.getLocalHost().getHostName().toString());

            //Taimoor: from NCache 4.1 SP2 private patch 2 ownward client version will also be sent
            //Client version has following format :
            //[2 digits for major version][1 digit for service paack][1 digit for private patch]
            //e.g. 4122 means 4.1 major , 2 for service pack 2 and last 4 for private patch 4
            _clientInfo.setClientVersion(5000); //changed for 5.0

            _clientID = ClientInfo.getLegacyClientID(_clientInfo);

        } catch (Exception e) {
        }
    }

    public boolean getEncryptionEnabled() {
        return _encryptionEnabled;
    }

    public void setEncryptionEnabled(boolean value) {
        _encryptionEnabled = value;
    }

    public ClientInfo getLocalClientInfo() {
        return _clientInfo;
    }
    abstract public ILogger getNCacheLog();

    abstract protected void registerCustomEventListener(CustomListener listener) throws GeneralFailureException, OperationFailedException, AggregateException, SecurityException, ConfigurationException, ConnectionException, Exception;

    abstract protected void registerCacheEventlistener(CacheListener listener, EnumSet registerAgainst) throws GeneralFailureException, OperationFailedException, AggregateException, SecurityException, ConfigurationException, ConnectionException, StreamNotFoundException, StreamException, StreamAlreadyLockedException, LicensingException, OperationNotSupportedException, CommandException;

    abstract protected void registerCacheStatusEventlistener(CacheStatusEventListener listener, EnumSet registerAgainst) throws GeneralFailureException, OperationFailedException, AggregateException, SecurityException, ConfigurationException, ConnectionException, StreamNotFoundException, StreamException, StreamAlreadyLockedException, LicensingException, OperationNotSupportedException, CommandException;

    abstract protected void unregisterCacheEventlistener(CacheListener listener, EnumSet unregisterAgainst) throws GeneralFailureException, OperationFailedException, AggregateException, SecurityException, ConfigurationException, ConnectionException, StreamNotFoundException, StreamException, StreamAlreadyLockedException, LicensingException, OperationNotSupportedException, CommandException;

    abstract protected void unregisterCacheStatusEventlistener(CacheStatusEventListener listener, EnumSet unregisterAgainst) throws GeneralFailureException, OperationFailedException, AggregateException, SecurityException, ConfigurationException, ConnectionException, StreamNotFoundException, StreamException, StreamAlreadyLockedException, LicensingException, OperationNotSupportedException, CommandException;

    abstract protected void unregisterCustomEventListener(CustomListener listener) throws GeneralFailureException, OperationFailedException, AggregateException, SecurityException, ConfigurationException, ConnectionException, Exception;

    boolean isInproc() {
        return false;
    }

    boolean getSerializationEnabled() {
        return true;
    }

    abstract protected TypeInfoMap getTypeMap();

    abstract protected void setTypeMap(TypeInfoMap value);

    abstract public long getCompressionThreshold();

    abstract protected void setCompressionThreshold(long value);

    abstract public boolean getCompressionEnabled();

    abstract protected void setCompressionEnabled(boolean value);

    protected abstract void registerCacheClientConnectivityEvent() throws CacheException;

    protected abstract void unregisterCacheClientConnectivityEvent() throws CacheException;

    abstract void registerCacheStoppedEvent() throws CacheException;

    abstract void unregisterCacheStoppedEvent() throws CacheException;

    abstract void registerClearEvent() throws CacheException;

    abstract void unregisterClearEvent() throws CacheException;

    abstract public long getCount() throws CacheException;

    public final String getClientID() {
        return _clientID;
    }

    public void unregisterHashmapChangedNotification() throws GeneralFailureException, OperationFailedException, AggregateException, SecurityException, ConfigurationException, ConnectionException, Exception {
    }

    abstract public void makeTargetCacheActivePassive(boolean makeActive) throws GeneralFailureException, SecurityException, OperationFailedException, AggregateException, ConnectionException, Exception;

    abstract public String getName();

    abstract protected String getBridgeTargetCacheUniqueID();

    abstract protected void setBridgeTargetCacheUniqueID(String value);

    abstract public void dispose(boolean disposing) throws GeneralFailureException, OperationFailedException, ConfigurationException;

    abstract public Object getItem(String key) throws Exception;

    abstract Vector getCallbackQueue();

    abstract public void setItem(String key, Object value);

    abstract public CacheItemVersion add(String key, Object value, CacheDependency dependency, CacheSyncDependency syncDependency,
                                   java.util.Date absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority, short onRemoveCallback,
                                   short onUpdateCallback, short onDsItemAddedCallback, boolean isResyncExpiredItems,
                                   String group, java.util.HashMap queryInfo, BitSet flagMap,
                                   String providerName, String resyncProviderName,
                                   EventDataFilter itemUpdateDataFilter, EventDataFilter itemRemovedDataFilter,
                                   long size,boolean encryptionEnabled ,String clientId,String typeName)
            throws OperationFailedException, AggregateException, SecurityException, GeneralFailureException, ConnectionException, ConfigurationException, StreamException, StreamAlreadyLockedException, LicensingException, OperationNotSupportedException, StreamNotFoundException, CommandException;

    abstract public java.util.HashMap add(String[] keys, com.alachisoft.ncache.client.CacheItem[] items, short onDataSourceItemsAdded, String providerName, long[] sizes, boolean encryptionEnabled ,String clientID , short updateCallbackId , short removeCallbackId , EventDataFilter updateCallbackFilter , EventDataFilter removeCallbackFilter  ,boolean returnVersions , Map itemVersions , ListenerType listenerType) throws OperationFailedException, SecurityException, AggregateException, GeneralFailureException, ConfigurationException, StreamException, StreamAlreadyLockedException, LicensingException, OperationNotSupportedException, StreamNotFoundException, CommandException;


    /**
     * Function that choose the appropriate function of NCache's Cache, that need to be called according to the data provided to it.
     */
    abstract public Object addAsync(String key, Object value, CacheDependency dependency, CacheSyncDependency syncDependency, java.util.Date absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority,
                                    short onRemoveCallback, short onUpdateCallback, short onAsyncItemAddCallback, short dsItemAddedCallback, boolean isResyncExpiredItems, String group,
                                    java.util.HashMap queryInfo, BitSet flagMap, String providerName, String resyncProviderName, EventDataFilter itemUpdateDataFilter, EventDataFilter itemRemovedDataFilter, long size,
                                    String clientId, short updateCallbackId, short removeCallbackId, short dsItemAddedCallbackId) throws Exception;

    /**
     * Add dependency to the cache item.
     *
     * @param key              key used to reference the required object
     * @param dependency       CacheDependency to be added
     * @param isResyncRequired Boolean value indicating wether Resync is required or not
     * @return True if operations successeded else false
     */
    abstract public boolean addDependency(String key, CacheDependency dependency, boolean isResyncRequired) throws Exception;

    abstract public boolean addDependency(String key, CacheSyncDependency syncDependency) throws Exception;
//#endif

    public void clear(BitSet flagMap, short onDsClearedCallback, String providerName) throws CacheException {

    }

    abstract public void clearAsync(BitSet flagMap, short onDsClearedCallback, boolean isAsync, String providerName) throws OperationFailedException, GeneralFailureException, AggregateException, com.alachisoft.ncache.runtime.exceptions.SecurityException, ConnectionException, Exception;

    abstract public void clearAsync(BitSet flagMap, short onAsyncCacheClearCallback, short onDsClearedCallback, boolean isAsync, String providerName) throws OperationFailedException, GeneralFailureException, AggregateException, com.alachisoft.ncache.runtime.exceptions.SecurityException, ConnectionException, Exception;

    public abstract boolean contains(String key) throws CacheException;

    public abstract Map containsBulk(String[] keys) throws CacheException;

    public abstract CompressedValueEntry get(String key, BitSet flagMap, String group, CacheItemVersion version, LockHandle  lockHandle, TimeSpan lockTimeout, LockAccessType accessType, ReadThruOptions options) throws OperationFailedException, GeneralFailureException, AggregateException, SecurityException, ConfigurationException, CommandException, StreamException, StreamAlreadyLockedException, LicensingException, OperationNotSupportedException, StreamNotFoundException;

    abstract public java.util.HashMap getByTag(Tag[] tags, Alachisoft.NCache.Caching.TagComparisonType comaprisonType) throws OperationFailedException, GeneralFailureException, AggregateException, com.alachisoft.ncache.runtime.exceptions.SecurityException, IllegalArgumentException, ConnectionException, Exception;


    abstract public java.util.Collection getKeysByTag(Tag[] tags, Alachisoft.NCache.Caching.TagComparisonType comaprisonType) throws OperationFailedException, GeneralFailureException, AggregateException, com.alachisoft.ncache.runtime.exceptions.SecurityException, IllegalArgumentException, ConnectionException, Exception;

    abstract public void removeByTag(Tag[] tags, Alachisoft.NCache.Caching.TagComparisonType comaprisonType) throws OperationFailedException, GeneralFailureException, AggregateException, com.alachisoft.ncache.runtime.exceptions.SecurityException, ConnectionException, IllegalArgumentException, Exception;

    abstract public Collection getGroupKeys(String group) throws OperationFailedException, GeneralFailureException, AggregateException, com.alachisoft.ncache.runtime.exceptions.SecurityException, ConnectionException, Exception;

    abstract public java.util.HashMap getGroupData(String group) throws OperationFailedException, GeneralFailureException, AggregateException, com.alachisoft.ncache.runtime.exceptions.SecurityException, ConnectionException, Exception;

    abstract public  java.util.Map get(String[] keys, BitSet flagMap, ReadThruOptions readThruOptions) throws OperationFailedException, GeneralFailureException, AggregateException, SecurityException, ConfigurationException, StreamException, StreamAlreadyLockedException, LicensingException, OperationNotSupportedException, StreamNotFoundException;

    public abstract Object getCacheItem(String key, BitSet flagMap, String group, CacheItemVersion version, LockHandle lockHandle, TimeSpan lockTimeout, LockAccessType accessType, ReadThruOptions readOptions) throws OperationFailedException, SecurityException, AggregateException, GeneralFailureException, ConfigurationException, StreamException, StreamAlreadyLockedException, LicensingException, OperationNotSupportedException, StreamNotFoundException, CommandException;


    public  List GetConnectedClientList() throws OperationFailedException, AggregateException, GeneralFailureException, CommandException, StreamNotFoundException, StreamException, OperationNotSupportedException, StreamAlreadyLockedException, ConfigurationException, LicensingException, SecurityException {
        return null;
    }

    abstract public java.util.HashMap insert(String[] keys, com.alachisoft.ncache.client.CacheItem[] items, short onDsItemsUpdatedCallback, String providerName,
                                             long[] sizes, boolean encryptionEnabled, String clientId,
                                             short updateCallbackId, short removeCallbackId,
                                             EventDataFilter updateCallbackFilter, EventDataFilter removeCallbackFilter, boolean returnVersions,
                                             Map itemVersions, ListenerType listenerType) throws OperationFailedException, AggregateException, SecurityException, GeneralFailureException, ConfigurationException, CacheException;

    //#endif
    public abstract CacheItemVersion insert(String key, Object value, CacheDependency dependency, CacheSyncDependency syncDependency,
                                            java.util.Date absoluteExpiration, TimeSpan slidingExpiration, CacheItemPriority priority,
                                            short onRemoveCallback, short onUpdateCallback, short onDsItemUpdatedCallback,
                                            boolean isResyncExpiredItems, String group,  java.util.HashMap queryInfo,
                                            BitSet flagMap, String lockId, CacheItemVersion version, LockAccessType accessType,
                                            String providerName, String resyncProviderName, EventDataFilter updateCallbackFilter,
                                            EventDataFilter removeCallabackFilter, long size, boolean encryptionEnabled, String clientId,
                                            String typeName, ListenerType listenerType)
            throws CacheException;

    abstract public CompressedValueEntry remove(String key, BitSet flagMap,  short dsItemRemovedCallbackId, String lockId, CacheItemVersion version, LockAccessType accessType, String ProviderName) throws CacheException;

    abstract public void delete(String key, BitSet flagMap, short dsItemRemovedCallbackId, String lockId, CacheItemVersion version, LockAccessType accessType, String providerName) throws CacheException;

    abstract public java.util.HashMap remove(String[] keys, BitSet flagMap, String providerName, short onDsItemsRemovedCallback) throws CacheException, Exception;

    abstract public void delete(String[] keys, BitSet flagMap, String providerName, short onDsItemsRemovedCallback) throws CacheException;



    abstract public void remove(String group) throws OperationFailedException, GeneralFailureException, AggregateException, com.alachisoft.ncache.runtime.exceptions.SecurityException, ConnectionException;

    public Object safeSerialize(Object serializableObject, String serializationContext, BitSet flag, CacheImplBase cacheImpl,RefObject size, UserObjectType userObjectType) throws GeneralFailureException, OperationFailedException {
        return safeSerialize(serializableObject, serializationContext, flag, cacheImpl,size, userObjectType, false);
    }

    abstract public Object safeSerialize(Object serializableObject, String serializationContext, BitSet flag, CacheImplBase cacheImpl, RefObject size, UserObjectType userObjectType, boolean isCustomerAtributeBaseSerialized) throws GeneralFailureException, OperationFailedException;

    public abstract  T safeDeserialize(Object serializedObject, String serializationContext, BitSet flag, CacheImplBase cacheImpl, UserObjectType userObjectType, Class cls) throws OperationFailedException;

    abstract public Enumeration getEnumerator();

    abstract public java.util.ArrayList getNextChunk(java.util.ArrayList pointers) throws SecurityException, GeneralFailureException, OperationFailedException, AggregateException, ConnectionException, java.net.UnknownHostException, ConfigurationException, StreamException, StreamAlreadyLockedException, LicensingException, OperationNotSupportedException, StreamNotFoundException, CommandException;

    abstract public java.util.HashMap getCompactTypes();

    abstract public void unlock(String key) throws Exception;

    abstract public void unlock(String key, String lockId) throws Exception;

    abstract public boolean lock(String key, TimeSpan lockTimeout, LockHandle lockHandle) throws OperationFailedException, GeneralFailureException, AggregateException, SecurityException, ConnectionException, Exception;

    abstract public boolean isLocked(String key, LockHandle lockHandle) throws OperationFailedException, GeneralFailureException, AggregateException, SecurityException, ConnectionException, Exception;

    ///#region /           --- Stream Operations ---                      /
    public abstract String openStream(String key, StreamMode mode, String group, java.util.Date absExpiration, TimeSpan slidingExpiration, CacheDependency dependency, CacheItemPriority priority) throws
            GeneralFailureException, OperationFailedException, AggregateException, SecurityException, ConfigurationException,
            StreamAlreadyLockedException, StreamCloseException, StreamInvalidLockException, StreamException, StreamNotFoundException, ConnectionException, Exception;

    abstract public void closeStream(String key, String lockHandle) throws Exception;

    abstract public int readFromStream(tangible.RefObject buffer, String key, String lockHandle, int offset, int streamOffset, int length) throws Exception;

    abstract public void writeToStream(String key, String lockHandle, byte[] buffer, int srcOffset, int dstOffset, int length) throws Exception;

    abstract public long getStreamLength(String key, String lockHandle) throws Exception;

    abstract public boolean setAttributes(String key, CacheItemAttributes attribute) throws CacheException;

    abstract public boolean getOrCreate(String topicName, tangible.RefObject priority, TopicOperationType type) throws CacheException;

    abstract public void acknowledgeMessageReceipt(java.util.Map> topicWiseMessageIds) throws Exception;

    abstract public boolean removeTopic(String topicName, boolean b) throws CacheException;

    abstract public void publishMessage(String messageId, Object value, long time, long expiration, Hashtable metaInfo, BitSet flagMap) throws Exception;

    abstract public boolean unSubscribe(String topicName, String recepientId,SubscriptionPolicyType subscriptionPolicyType, SubscriptionType pubSubType, boolean dispose) throws Exception;

    abstract public ReceivedMessages getMessageData(BitSet flagMap) throws CacheException;

    // region IDataTypeManager

    abstract void createDataType(CollectionCreateOrGetOperation operation, DataStructureAttributes properties) throws OperationFailedException, LicensingException, CommandException;


    abstract boolean getDataType(CollectionCreateOrGetOperation operation) throws OperationFailedException, LicensingException, CommandException;

    // end

    // region Common Collection Methods

    abstract void CollectionClearOperation(CollectionOperation operation);

    abstract int CollectionCountOperation(CollectionOperation operation);

    abstract GetCollectionChunkResponseBase GetCollectionChunk(GetCollectionChunkOperation operation) ;

    // endregion

    // region Counter

    abstract long counterGetOperation(CounterGetOperation counterGetOperation);

    abstract long counterOperations(CounterOperation operation) ;

    // end

    // region Dictionary

    abstract void dictionaryAdd(DictionaryAddOperation operation) ;

    abstract Collection dictionaryGet(DictionaryGetOperation operation);

    abstract int dictionaryRemove(DictionaryRemoveOperation operation);

    abstract boolean dictionaryContains(DictionaryContainsOperation tempVar);

    // end

    // region HashSet

    abstract void hashSetAdd(HashSetAddOperation tempVar);

    abstract int hashSetRemove(HashSetRemoveOperation tempVar);

    abstract List hashSetGetRandom(HashSetGetRandomOperation operation);

    abstract List hashSetRemoveRandom(HashSetRemoveRandomOperation operation);

    abstract boolean hashSetContains(HashSetContainsOperation operation);

    // end

    // region Queue

    abstract boolean queueEnqueue(QueueEnqueueOperation operation);

    abstract ExtendedJsonValueBase queueDequeue(QueueDequeueOperation operation);

    abstract ExtendedJsonValueBase queuePeek(QueuePeekOperation queuePeekOperation);

    abstract boolean queueSearch(QueueSearchOperation operation);

    // endregion

    // region SearchService methods
    abstract public QueryResultSet search(String query, java.util.HashMap values) throws OperationFailedException, GeneralFailureException, AggregateException, SecurityException;

    abstract public int executeNonQuery(String query, java.util.HashMap values)
            throws Exception;

    abstract RecordSetEnumeratorImpl executeReaderCQ(ContinuousQuery continuousQuery, boolean getData, int chunkSize, String clientUniqueId, boolean notifyAdd, boolean notifyUpdate, boolean notifyRemove);

    abstract RecordSetEnumerator executeReader(String query, Map values, boolean getData, int chunkSize) throws OperationFailedException;

    // endregion

    // region List Methods

    public abstract void listRemoveWithIndex(ListRemoveWithIndexOperation operation);

    public abstract void listAddWithoutIndex(ListAddWithoutIndexOperation operation);

    public abstract boolean listAddWithPivot(ListAddWithPivotOperation operation);

    public abstract List listGetBulk(ListGetBulkOperation operation);

    public abstract int listRemoveWithoutIndex(ListRemoveWithoutIndexOperation operation);

    public abstract void listInsertWithIndex(ListInsertWithIndexOperation tempVar);

    public abstract int listSearch(ListSearchOperation operation);

    public abstract ExtendedJsonValueBase listGetItem(ListGetItemOperation operation);

    // endregion

    //region MessagingService
    public abstract String registerCQ(ContinuousQuery query, String clientUniqueId, boolean notifyAdd, boolean notifyUpdate, boolean notifyRemove) throws CacheException;

    public abstract void unRegisterCQ(String serverUniqueId, String clientUniqueId) throws CacheException;

    public abstract void registerKeyNotificationListener(String key, short update, short remove, EventDataFilter datafilter, boolean notifyOnItemExpiration, ListenerType listenerType) throws OperationFailedException, CommandException, StreamNotFoundException, StreamException, OperationNotSupportedException, StreamAlreadyLockedException, AggregateException, GeneralFailureException, ConfigurationException, LicensingException, SecurityException;

    public abstract void registerKeyNotificationListener(String[] key, short update, short remove, EventDataFilter datafilter, boolean notifyOnItemExpiration, ListenerType listenerType) throws OperationFailedException, CommandException, StreamNotFoundException, StreamException, OperationNotSupportedException, StreamAlreadyLockedException, AggregateException, GeneralFailureException, ConfigurationException, LicensingException, SecurityException;

    public abstract void registerKeyNotificationListener(String[] keys, short updateCallbackid, short removeCallbackid) throws CacheException;

    public abstract void unRegisterKeyNotificationListener(String key, short updateCallbackid, short removeCallbackid) throws CacheException;

    public abstract void unRegisterKeyNotificationListener(String[] key, short update, short remove) throws CacheException;

    public abstract void unRegisterGeneralNotificationListener(EventTypeInternal unregister, short sequenceNumber) throws CacheException;

    public abstract void registerGeneralNotification(EventTypeInternal eventType, EventDataFilter datafilter, short sequenceNumber) throws CacheException;

    public abstract void registerKeyNotificationListener(String[] keys, short updateCallbackid, short removeCallbackid, String clientId, ListenerType listenerType);

    public abstract void raiseCustomEvent(Object notifId, Object data) throws CacheException;

    public abstract void registerKeyNotificationListener(String key, short updateCallbackid, short removeCallbackid, boolean notifyOnItemExpiration) throws CacheException;

    public abstract boolean subscribe(String topicName, String subscriptionName, SubscriptionType subscriptionType, long creationTime, long expiration, SubscriptionPolicyType subscriptionPolicyType)throws CacheException;

    public abstract long getMessageCount(String topicName) throws OperationFailedException, CommandException, StreamNotFoundException, StreamException, OperationNotSupportedException, StreamAlreadyLockedException, AggregateException, GeneralFailureException, ConfigurationException, LicensingException, SecurityException;

    public abstract void registerKeyNotificationListener(String key, short callbackRef, short callbackRef1, EventDataFilter dataFilter, boolean notifyOnItemExpiration) throws CacheException;

    public abstract void registerKeyNotificationListener(String[] keys, short callbackRef, short callbackRef1, EventDataFilter dataFilter, boolean notifyOnItemExpiration) throws CacheException;


    public abstract Map getCacheItemBulk(String[] keysList, BitSet flagMap, ReadThruOptions readThruOptions) throws OperationFailedException, SecurityException, AggregateException, GeneralFailureException, StreamNotFoundException, OperationNotSupportedException, StreamException, ConfigurationException, LicensingException, StreamAlreadyLockedException;

    public abstract void InvalidateReaders(String toString);

    public abstract void setCompressionThresholdSize(long compressionThreshold);

    public abstract void registerHashmapChangedEvent(Connection connection) throws AggregateException, SecurityException, GeneralFailureException, OperationFailedException, ConfigurationException, StreamNotFoundException, StreamException, StreamAlreadyLockedException, LicensingException, OperationNotSupportedException, CommandException;

    public abstract void getTypeInfoMap(Connection connection) throws AggregateException, InternalCommandException, GeneralFailureException, OperationFailedException, SecurityException, OperationNotSupportedException, StreamException, ConfigurationException, LicensingException, StreamNotFoundException, StreamAlreadyLockedException, CommandException;

    public abstract void getThresholdSize(Connection connection) throws AggregateException, InternalCommandException, GeneralFailureException, OperationFailedException, OperationNotSupportedException, StreamException, SecurityException, LicensingException, ConfigurationException, StreamNotFoundException, StreamAlreadyLockedException, CacheException;

    public abstract void getExpirationFromServer(Connection connection) throws AggregateException, InternalCommandException, GeneralFailureException, OperationFailedException, OperationNotSupportedException, StreamException, SecurityException, LicensingException, ConfigurationException, StreamNotFoundException, StreamAlreadyLockedException, CommandException;

    public abstract void getSerializationFormat(Connection connection) throws AggregateException, InternalCommandException, GeneralFailureException, OperationFailedException, SecurityException, OperationNotSupportedException, StreamException, ConfigurationException, LicensingException, StreamNotFoundException, StreamAlreadyLockedException, CommandException;

    public abstract void getCompactTypesFromServer(Connection connection) throws AggregateException, InternalCommandException, GeneralFailureException, OperationFailedException, SecurityException, OperationNotSupportedException, StreamException, ConfigurationException, LicensingException, StreamNotFoundException, StreamAlreadyLockedException, CommandException;

    public abstract void getEncryptionKeyFromServer(Connection connection) throws AggregateException, InternalCommandException, GeneralFailureException, OperationFailedException, OperationNotSupportedException, StreamException, SecurityException, LicensingException, ConfigurationException, StreamNotFoundException, StreamAlreadyLockedException, CommandException;

    public abstract void reRegisterGeneralNotification(Connection connection) throws AggregateException, SecurityException, GeneralFailureException, OperationFailedException, ConfigurationException, StreamNotFoundException, StreamException, StreamAlreadyLockedException, LicensingException, OperationNotSupportedException, CommandException;

    public abstract void ExecuteModuleOperation(ModuleOperation operation) throws OperationFailedException, CommandException, LicensingException;

    public abstract PartitioningStrategy getPartitioningStrategy();

    public abstract boolean checkSecurityAuthorization(String cacheId, byte[] password, String userId) throws OperationFailedException, SecurityException, AggregateException, GeneralFailureException, CommandException, StreamNotFoundException, OperationNotSupportedException, StreamException, ConfigurationException, LicensingException, StreamAlreadyLockedException;


    //endregion

    public List getConnectedClientList()throws OperationFailedException, CommandException, StreamNotFoundException, StreamException, OperationNotSupportedException, StreamAlreadyLockedException, AggregateException, GeneralFailureException, ConfigurationException, LicensingException, SecurityException{
        return null;
    }

    public abstract Map publishMessage(String topicName, Map keyMessageBulk, boolean notifyDeliveryFailure) throws OperationFailedException, LicensingException, CommandException, StreamAlreadyLockedException, GeneralFailureException, OperationNotSupportedException, SecurityException, StreamException, ConfigurationException, StreamNotFoundException, AggregateException;

    public abstract void addCollectionNotificationListener(String collectionName, short addCallbackId, short updateCallbackId, short removeCallbackId, DataTypeEventDataFilter dataFilter, DistributedDataStructure dataType, boolean notifyOnItemExpiration) throws OperationFailedException, LicensingException, CommandException;

    public abstract void removeCollectionNotificationListener(String collectionName, short addCallbackId, short updateCallbackId, short removeCallbackId, EventTypeInternal eventType, DistributedDataStructure dataType) throws OperationFailedException, LicensingException, CommandException;

    public abstract HashMap getEncryptionInfo();

    public abstract void touch(ArrayList keys) throws OperationFailedException, LicensingException, CommandException, StreamAlreadyLockedException, GeneralFailureException, OperationNotSupportedException, SecurityException, StreamException, ConfigurationException, StreamNotFoundException, AggregateException;

    public abstract String getMonitoringSessionId();


    public abstract String getCacheConfigId();
}