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())
        {
            RemoteCache<K,V> *pRc;
            pRc= new RemoteCache<K,V>(transactionManager, transactionTable, forceReturnValue, getConfiguration().isTransactional());
            remoteCacheMap[key]= std::unique_ptr<RemoteCacheBase>(pRc);
            RemoteCache<K, V> *rcache=(RemoteCache<K, V> *)remoteCacheMap[key].get();
            rcache->keyMarshaller.reset(new BasicMarshaller<K>());
            rcache->valueMarshaller.reset(new BasicMarshaller<V>());
            initCache(*rcache, forceReturnValue, getConfiguration().getNearCacheConfiguration());
            return *rcache;
        }
        return *(RemoteCache<K, V> *)remoteCacheMap[key].get();
    }

    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())
        {
            RemoteCache<K,V> *pRc= new RemoteCache<K,V>(transactionManager, transactionTable, forceReturnValue, getConfiguration().isTransactional());
            remoteCacheMap[key]= std::unique_ptr<RemoteCacheBase>(pRc);
            RemoteCache<K, V> *rcache=(RemoteCache<K, V> *)remoteCacheMap[key].get();
            rcache->keyMarshaller.reset(new BasicMarshaller<K>());
            rcache->valueMarshaller.reset(new BasicMarshaller<V>());
            initCache(*rcache, name.c_str(), forceReturnValue);
            return *rcache;
        }
        return *(RemoteCache<K, V> *)remoteCacheMap[key].get();
    }

    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()) {
            RemoteCache<K, V> *pRc = new RemoteCache<K, V>(transactionManager, transactionTable, forceReturnValue, getConfiguration().isTransactional());
            remoteCacheMap[key] = std::unique_ptr < RemoteCacheBase > (pRc);
        }
        RemoteCache<K, V> *rcache =
                (RemoteCache<K, V> *) remoteCacheMap[key].get();
        rcache->keyMarshaller.reset(km);
        rcache->valueMarshaller.reset(vm);
        initCache(*rcache, forceReturnValue, getConfiguration().getNearCacheConfiguration());
        return *rcache;
    }

    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()) {
            RemoteCache<K, V> *pRc = new RemoteCache<K, V>(transactionManager, transactionTable, forceReturnValue, getConfiguration().isTransactional());
            remoteCacheMap[key] = std::unique_ptr < RemoteCacheBase > (pRc);
        }
        RemoteCache<K, V> *rcache =
                (RemoteCache<K, V> *) remoteCacheMap[key].get();
        rcache->keyMarshaller.reset(km);
        rcache->valueMarshaller.reset(vm);
        initCache(*rcache, name.c_str(), forceReturnValue, getConfiguration().getNearCacheConfiguration());
        return *rcache;
    }

    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 */