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 <string>
#include <map>
#include <memory>

namespace infinispan {
namespace hotrod {

class RemoteCacheManagerImpl;

class HR_EXTERN RemoteCacheManager
{
public:

    explicit RemoteCacheManager(bool start_ = true);

    explicit RemoteCacheManager(
            const std::map<std::string, std::string>& configuration,
            bool start_ = true) {
        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>();
            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>();
            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>();
            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>();
            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);

private:
    void *impl;
    std::map<std::string, std::unique_ptr<RemoteCacheBase> > remoteCacheMap;

    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&);

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