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/portable.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(portable::map<portable::string, portable::string>(
                configuration, portable::string::convert(), portable::string::convert()), 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 = false)
    {
        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();
          initCache(*rcache, forceReturnValue);
          rcache->keyMarshaller.reset(new BasicMarshaller<K>(), &Marshaller<K>::destroy);
          rcache->valueMarshaller.reset(new BasicMarshaller<V>(), &Marshaller<V>::destroy);
          return *rcache;
        }
        return *(RemoteCache<K, V> *)remoteCacheMap[key].get();
    }

    template <class K, class V> RemoteCache<K, V> &getCache(
        const std::string& name, bool forceReturnValue = false)
    {
        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();
          initCache(*rcache, name.c_str(), forceReturnValue);
          rcache->keyMarshaller.reset(new BasicMarshaller<K>(), &Marshaller<K>::destroy);
          rcache->valueMarshaller.reset(new BasicMarshaller<V>(), &Marshaller<V>::destroy);
          return *rcache;
        }
        return *(RemoteCache<K, V> *)remoteCacheMap[key].get();
    }

        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 = false) {
                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();
                        initCache(*rcache, forceReturnValue);
                        rcache->keyMarshaller.reset(km, kd);
                        rcache->valueMarshaller.reset(km, kd);
                        return *rcache;
                }
                RemoteCache<K, V> *rcache =
                                (RemoteCache<K, V> *) remoteCacheMap[key].get();
                initCache(*rcache, forceReturnValue);
                rcache->keyMarshaller.reset(km, kd);
                rcache->valueMarshaller.reset(vm, vd);
                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, bool forceReturnValue = false)
    {
                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();
                        initCache(*rcache, name.c_str(), forceReturnValue);
                        rcache->keyMarshaller.reset(km, kd);
                        rcache->valueMarshaller.reset(vm, vd);
                        return *rcache;
                }
                RemoteCache<K, V> *rcache =
                                (RemoteCache<K, V> *) remoteCacheMap[key].get();
                initCache(*rcache, name.c_str(), forceReturnValue);
                rcache->keyMarshaller.reset(km, kd);
                rcache->valueMarshaller.reset(vm, vd);
                return *rcache;
    }


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

    void init(const portable::map<portable::string, portable::string>& configuration, bool start);

    void initCache(RemoteCacheBase& cache, bool forceReturnValue);
    void initCache(RemoteCacheBase& cache, const char *name, bool forceReturnValue);

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