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>

namespace infinispan {
namespace hotrod {

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)
    {
        RemoteCache<K, V> rcache;
        initCache(rcache, forceReturnValue);
        rcache.keyMarshaller.reset(new BasicMarshaller<K>(), &Marshaller<K>::destroy);
        rcache.valueMarshaller.reset(new BasicMarshaller<V>(), &Marshaller<V>::destroy);
        return rcache;
    }

    template <class K, class V> RemoteCache<K, V> getCache(
        const std::string& name, bool forceReturnValue = false)
    {
        RemoteCache<K, V> rcache;
        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;
    }

    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)
    {
        RemoteCache<K, V> rcache;
        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)
    {
        RemoteCache<K, V> rcache;
        initCache(rcache, name.c_str(), forceReturnValue);
        rcache.keyMarshaller.reset(km, kd);
        rcache.valueMarshaller.reset(vm, vd);
        return rcache;
    }

    // DEPRECATED
    template <class K, class V> RemoteCache<K, V> getCache(
        HR_SHARED_PTR<Marshaller<K> > km, HR_SHARED_PTR<Marshaller<V> > vm,
        bool forceReturnValue = false)
    {
        RemoteCache<K, V> rcache;
        initCache(rcache, forceReturnValue);
        rcache.keyMarshallerPtr.reset(new portable::counted_wrapper<HR_SHARED_PTR<Marshaller<K> > >(km), &genericDelete);
        rcache.valueMarshallerPtr.reset(new portable::counted_wrapper<HR_SHARED_PTR<Marshaller<V> > >(vm), &genericDelete);
        rcache.keyMarshaller.reset(&*km, &genericNoDelete);
        rcache.valueMarshaller.reset(&*vm, &genericNoDelete);
        return rcache;
    }

    template <class K, class V> RemoteCache<K, V> getCache(
        HR_SHARED_PTR<Marshaller<K> > km, HR_SHARED_PTR<Marshaller<V> > vm,
        const std::string& name, bool forceReturnValue = false)
    {
        RemoteCache<K, V> rcache;
        initCache(rcache, name.c_str(), forceReturnValue);
        rcache.keyMarshallerPtr.reset(new portable::counted_wrapper<HR_SHARED_PTR<Marshaller<K> > >(km), &genericDelete);
        rcache.valueMarshallerPtr.reset(new portable::counted_wrapper<HR_SHARED_PTR<Marshaller<V> > >(vm), &genericDelete);
        rcache.keyMarshaller.reset(&*km, &genericNoDelete);
        rcache.valueMarshaller.reset(&*vm, &genericNoDelete);
        return rcache;
    }

private:
    void *impl;

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