RemoteCacheManager.h

Go to the documentation of this file.

#ifndef ISPN_HOTROD_REMOTECACHEMANAGER_H
#define ISPN_HOTROD_REMOTECACHEMANAGER_H
 
#include "infinispan/hotrod/BasicMarshaller.h"
#include "infinispan/hotrod/ImportExport.h"
#include "infinispan/hotrod/RemoteCache.h"
#include "infinispan/hotrod/Configuration.h"
#include "infinispan/hotrod/RemoteCounterManager.h"
#include "infinispan/hotrod/TransactionManager.h"
 
 
 
#include <string>
#include <map>
#include <memory>
 
namespace infinispan {
namespace hotrod {
 
class RemoteCacheManagerImpl;
class RemoteCacheManagerAdmin;
 
class HR_EXTERN RemoteCacheManager
{
public:
 
    explicit RemoteCacheManager(bool start_ = true);
 
    explicit RemoteCacheManager(
            const std::map<std::string, std::string>& configuration,
            bool start_ = true) : transactionManager(TransactionManagerLookup::lookup()) {
        init(configuration, start_);
    }
 
    explicit RemoteCacheManager(
            const Configuration& configuration,
            bool start = true);
 
    ~RemoteCacheManager();
 
    void start();
 
    void stop();
 
    bool isStarted();
 
    const Configuration& getConfiguration();
 
    template <class K, class V> RemoteCache<K, V> &getCache(
            bool forceReturnValue) {
        const std::string key = forceReturnValue ? "/true" : "/false";
        if (remoteCacheMap.find(key)==remoteCacheMap.end())
        {
                        auto rcache = new RemoteCache<K, V>(transactionManager,
                                        transactionTable, forceReturnValue,
                                        getConfiguration().isTransactional());
                        try {
            initCache(*rcache, forceReturnValue, getConfiguration().getNearCacheConfiguration());
                        } catch (...) {
                                delete rcache;
                                throw;
                        }
                        remoteCacheMap[key] = std::unique_ptr<RemoteCacheBase>(rcache);
        }
         auto cache = (RemoteCache<K, V> *)remoteCacheMap[key].get();
         cache->keyMarshaller.reset(new BasicMarshaller<K>());
         cache->valueMarshaller.reset(new BasicMarshaller<V>());
         return *cache;
    }
 
    template <class K, class V> RemoteCache<K, V> &getCache() {
        return getCache<K,V>(getConfiguration().isForceReturnValue());
    }
 
        template<class K, class V> RemoteCache<K, V>& getCache(
                        const std::string &name, bool forceReturnValue) {
                const std::string key =
                                forceReturnValue ? name + "/true" : name + "/false";
                if (remoteCacheMap.find(key) == remoteCacheMap.end()) {
                        auto rcache = new RemoteCache<K, V>(transactionManager,
                                        transactionTable, forceReturnValue,
                                        getConfiguration().isTransactional());
                        try {
                                initCache(*rcache, name.c_str(), forceReturnValue);
                        } catch (...) {
                                delete rcache;
                                throw;
                        }
                        remoteCacheMap[key] = std::unique_ptr<RemoteCacheBase >(rcache);
                }
        auto cache = (RemoteCache<K, V> *)remoteCacheMap[key].get();
        cache->keyMarshaller.reset(new BasicMarshaller<K>());
        cache->valueMarshaller.reset(new BasicMarshaller<V>());
                return *cache;
        }
 
    template <class K, class V> RemoteCache<K, V> &getCache(
            const std::string& name) {
        return getCache<K,V>(name, getConfiguration().isForceReturnValue());
    }
 
        template<class K, class V> RemoteCache<K, V>& getCache(Marshaller<K> *km,
                        void (*kd)(Marshaller<K>*), Marshaller<V> *vm,
                        void (*vd)(Marshaller<V>*), bool forceReturnValue) {
                const std::string key = forceReturnValue ? "/true" : "/false";
                if (remoteCacheMap.find(key) == remoteCacheMap.end()) {
                        auto rcache = new RemoteCache<K, V>(transactionManager,
                                        transactionTable, forceReturnValue,
                                        getConfiguration().isTransactional());
                        try {
                                initCache(*rcache, forceReturnValue,
                                                getConfiguration().getNearCacheConfiguration());
                        } catch (...) {
                                delete rcache;
                                throw;
                        }
                        remoteCacheMap[key] = std::unique_ptr<RemoteCacheBase>(rcache);
                }
                auto cache = (RemoteCache<K, V>*) remoteCacheMap[key].get();
                cache->keyMarshaller.reset(km);
                cache->valueMarshaller.reset(vm);
                return *cache;
        }
 
    template<class K, class V> RemoteCache<K, V> &getCache(
            Marshaller<K> *km, void (*kd)(Marshaller<K> *),
            Marshaller<V> *vm, void (*vd)(Marshaller<V> *)) {
        return getCache<K,V>(km, kd, vm, vd, getConfiguration().isForceReturnValue());
    }
        template<class K, class V> RemoteCache<K, V>& getCache(Marshaller<K> *km,
                        void (*kd)(Marshaller<K>*), Marshaller<V> *vm,
                        void (*vd)(Marshaller<V>*), const std::string &name,
                        bool forceReturnValue) {
                const std::string key =
                                forceReturnValue ? name + "/true" : name + "/false";
                if (remoteCacheMap.find(key) == remoteCacheMap.end()) {
                        auto rcache = new RemoteCache<K, V>(transactionManager,
                                        transactionTable, forceReturnValue,
                                        getConfiguration().isTransactional());
                        try {
                        initCache(*rcache, name.c_str(), forceReturnValue,
                                        getConfiguration().getNearCacheConfiguration());
                        } catch (...) {
                                delete rcache;
                                throw;
                        }
                        remoteCacheMap[key] = std::unique_ptr<RemoteCacheBase >(rcache);
                }
                auto cache = (RemoteCache<K, V>*) remoteCacheMap[key].get();
                cache->keyMarshaller.reset(km);
                cache->valueMarshaller.reset(vm);
                return *cache;
        }
 
    template <class K, class V> RemoteCache<K, V> &getCache(
            Marshaller<K> *km, void (*kd)(Marshaller<K> *),
            Marshaller<V> *vm, void (*vd)(Marshaller<V> *),
            const std::string& name) {
        return getCache(km, kd, vm, vd, name, getConfiguration().isForceReturnValue());
    }
    bool switchToDefaultCluster();
 
    bool switchToCluster(std::string clusterName);
 
    RemoteCounterManager& getCounterManager();
    std::shared_ptr<RemoteCacheManagerAdmin> administration() {
       return newRemoteCacheManagerAdmin();
    }
 
    std::set<std::string> getCacheNames();
    TransactionManager& getTransactionManager() const
    {
        return transactionManager;
    }
 
private:
    void *impl;
    std::map<std::string, std::unique_ptr<RemoteCacheBase> > remoteCacheMap;
    std::function<void(std::string&)> cacheRemover;
    TransactionManager& transactionManager;
    TransactionTable transactionTable;
 
    void init(const std::map<std::string, std::string>& configuration, bool start);
 
    void initCache(RemoteCacheBase& cache, bool forceReturnValue, NearCacheConfiguration nc = NearCacheConfiguration());
    void initCache(RemoteCacheBase& cache, const char *name, bool forceReturnValue, NearCacheConfiguration nc = NearCacheConfiguration());
 
    // not implemented
    RemoteCacheManager(const RemoteCacheManager&);
    RemoteCacheManager operator=(const RemoteCacheManager&);
 
    std::shared_ptr<RemoteCacheManagerAdmin> newRemoteCacheManagerAdmin();
 
    template<typename T> static void genericDelete(T *t) { delete t; }
    template<typename T> static void genericNoDelete(T *) { }
};
 
}} // namespace infinispan::hotrod
 
#endif  /* ISPN_HOTROD_REMOTECACHEMANAGER_H */