IMap.h

/*
 * Copyright (c) 2008-2015, Hazelcast, Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef HAZELCAST_IMAP
#define HAZELCAST_IMAP

#include "hazelcast/client/proxy/IMapImpl.h"
#include "hazelcast/client/impl/EntryEventHandler.h"
#include "hazelcast/client/EntryListener.h"
#include "hazelcast/client/EntryView.h"
#include <string>
#include <map>
#include <set>
#include <vector>
#include <stdexcept>
#include <climits>

#if  defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(push)
#pragma warning(disable: 4251) //for dll export
#endif

namespace hazelcast {
    namespace client {

        template<typename K, typename V>
        class IMap : public proxy::IMapImpl {
            friend class HazelcastClient;

        public:

            bool containsKey(const K &key) {
                return proxy::IMapImpl::containsKey(toData(key));
            }

            bool containsValue(const V &value) {
                return proxy::IMapImpl::containsValue(toData(value));
            }

            boost::shared_ptr<V> get(const K &key) {
                return toObject<V>(proxy::IMapImpl::get(toData(key)));
            }

            boost::shared_ptr<V> put(const K &key, const V &value) {
                return toObject<V>(proxy::IMapImpl::put(toData(key), toData(value)));
            }

            boost::shared_ptr<V> remove(const K &key) {
                return toObject<V>(proxy::IMapImpl::remove(toData(key)));
            }

            bool remove(const K &key, const V &value) {
                return proxy::IMapImpl::remove(toData(key), toData(value));
            }

            void deleteEntry(const K &key) {
                proxy::IMapImpl::deleteEntry(toData(key));
            }

            void flush() {
                proxy::IMapImpl::flush();
            }

            bool tryRemove(const K &key, long timeoutInMillis) {
                return proxy::IMapImpl::tryRemove(toData(key), timeoutInMillis);
            }

            bool tryPut(const K &key, const V &value, long timeoutInMillis) {
                return proxy::IMapImpl::tryPut(toData(key), toData(value), timeoutInMillis);
            }

            boost::shared_ptr<V> put(const K &key, const V &value, long ttlInMillis) {
                return toObject<V>(proxy::IMapImpl::put(toData(key), toData(value), ttlInMillis));
            }

            void putTransient(const K &key, const V &value, long ttlInMillis) {
                proxy::IMapImpl::putTransient(toData(key), toData(value), ttlInMillis);
            }

            boost::shared_ptr<V> putIfAbsent(const K &key, const V &value) {
                return putIfAbsent(key, value, -1);
            }

            boost::shared_ptr<V> putIfAbsent(const K &key, const V &value, long ttlInMillis) {
                return toObject<V>(proxy::IMapImpl::putIfAbsent(toData(key), toData(value), ttlInMillis));
            }

            bool replace(const K &key, const V &oldValue, const V &newValue) {
                return proxy::IMapImpl::replace(toData(key), toData(oldValue), toData(newValue));
            }

            boost::shared_ptr<V> replace(const K &key, const V &value) {
                return toObject<V>(proxy::IMapImpl::replace(toData(key), toData(value)));
            }

            void set(const K &key, const V &value, long ttl) {
                proxy::IMapImpl::set(toData(key), toData(value), ttl);
            }

            void lock(const K &key) {
                proxy::IMapImpl::lock(toData(key));
            }

            void lock(const K &key, long leaseTime) {
                proxy::IMapImpl::lock(toData(key), leaseTime);
            }

            bool isLocked(const K &key) {
                return proxy::IMapImpl::isLocked(toData(key));
            }

            bool tryLock(const K &key) {
                return tryLock(key, 0);
            }

            bool tryLock(const K &key, long timeInMillis) {
                return proxy::IMapImpl::tryLock(toData(key), timeInMillis);
            }

            void unlock(const K &key) {
                proxy::IMapImpl::unlock(toData(key));
            }

            void forceUnlock(const K &key) {
                proxy::IMapImpl::forceUnlock(toData(key));
            }

            template<typename MapInterceptor>
            std::string addInterceptor(MapInterceptor &interceptor) {
                return proxy::IMapImpl::addInterceptor(interceptor);
            }

            void removeInterceptor(const std::string &id) {
                proxy::IMapImpl::removeInterceptor(id);
            }

            std::string addEntryListener(EntryListener<K, V> &listener, bool includeValue) {
                impl::EntryEventHandler<K, V, protocol::codec::MapAddEntryListenerCodec::AbstractEventHandler> *entryEventHandler =
                        new impl::EntryEventHandler<K, V, protocol::codec::MapAddEntryListenerCodec::AbstractEventHandler>(
                                getName(), context->getClusterService(), context->getSerializationService(), listener,
                                includeValue);
                return proxy::IMapImpl::addEntryListener(entryEventHandler, includeValue);
            }

            bool removeEntryListener(const std::string &registrationId) {
                return proxy::IMapImpl::removeEntryListener(registrationId);
            }


            std::string addEntryListener(EntryListener<K, V> &listener, const K &key, bool includeValue) {
                serialization::pimpl::Data keyData = toData(key);
                impl::EntryEventHandler<K, V, protocol::codec::MapAddEntryListenerCodec::AbstractEventHandler> *entryEventHandler =
                        new impl::EntryEventHandler<K, V, protocol::codec::MapAddEntryListenerCodec::AbstractEventHandler>(
                                getName(), context->getClusterService(), context->getSerializationService(), listener,
                                includeValue);
                return proxy::IMapImpl::addEntryListener(entryEventHandler, keyData, includeValue);
            }

            EntryView<K, V> getEntryView(const K &key) {
                serialization::pimpl::Data keyData = toData(key);
                std::auto_ptr<map::DataEntryView> dataEntryView = proxy::IMapImpl::getEntryView(keyData);
                boost::shared_ptr<V> v = toObject<V>(dataEntryView->getValue());
                EntryView<K, V> view(key, *v, *dataEntryView);
                return view;
            }

            bool evict(const K &key) {
                return proxy::IMapImpl::evict(toData(key));
            }

            void evictAll() {
                proxy::IMapImpl::evictAll();
            }

            std::map<K, V> getAll(const std::set<K> &keys) {
                std::vector<serialization::pimpl::Data> keySet(keys.size());
                int i = 0;
                for (typename std::set<K>::iterator it = keys.begin(); it != keys.end(); ++it) {
                    keySet[i++] = toData(*it);
                }
                std::map<K, V> result;
                std::vector<std::pair<serialization::pimpl::Data, serialization::pimpl::Data> > entrySet = proxy::IMapImpl::getAll(
                        keySet);
                for (std::vector<std::pair<serialization::pimpl::Data, serialization::pimpl::Data> >::const_iterator it = entrySet.begin();
                     it != entrySet.end(); ++it) {
                    boost::shared_ptr<K> key = toObject<K>(it->first);
                    boost::shared_ptr<V> value = toObject<V>(it->second);
                    result[*key] = *value;
                }
                return result;
            }

            std::vector<K> keySet() {
                std::vector<serialization::pimpl::Data> dataResult = proxy::IMapImpl::keySet();
                int size = dataResult.size();
                std::vector<K> keys(size);
                for (int i = 0; i < size; ++i) {
                    boost::shared_ptr<K> key = toObject<K>(dataResult[i]);
                    keys[i] = *key;
                }
                return keys;
            }

            std::vector<K> keySet(const serialization::IdentifiedDataSerializable &predicate) {
                std::vector<serialization::pimpl::Data> dataResult = proxy::IMapImpl::keySet(predicate);
                int size = dataResult.size();
                std::vector<K> keys(size);
                for (int i = 0; i < size; ++i) {
                    boost::shared_ptr<K> key = toObject<K>(dataResult[i]);
                    keys[i] = *key;
                }
                return keys;
            }

            std::vector<V> values() {
                std::vector<serialization::pimpl::Data> dataResult = proxy::IMapImpl::values();
                int size = dataResult.size();
                std::vector<K> values(size);
                for (int i = 0; i < size; ++i) {
                    boost::shared_ptr<K> value = toObject<K>(dataResult[i]);
                    values[i] = *value;
                }
                return values;
            }

            std::vector<V> values(const serialization::IdentifiedDataSerializable &predicate) {
                std::vector<serialization::pimpl::Data> dataResult = proxy::IMapImpl::values(predicate);
                int size = dataResult.size();
                std::vector<V> values(size);
                for (int i = 0; i < size; ++i) {
                    boost::shared_ptr<V> value = toObject<V>(dataResult[i]);
                    values[i] = *value;
                }
                return values;
            }

            std::vector<std::pair<K, V> > entrySet() {
                std::vector<std::pair<serialization::pimpl::Data, serialization::pimpl::Data> > dataResult = proxy::IMapImpl::entrySet();
                size_t size = dataResult.size();
                std::vector<std::pair<K, V> > entries(size);
                for (size_t i = 0; i < size; ++i) {
                    boost::shared_ptr<K> key = toObject<K>(dataResult[i].first);
                    boost::shared_ptr<V> value = toObject<V>(dataResult[i].second);
                    entries[i] = std::make_pair(*key, *value);
                }
                return entries;
            }

            std::vector<std::pair<K, V> > entrySet(const serialization::IdentifiedDataSerializable &predicate) {
                std::vector<std::pair<serialization::pimpl::Data, serialization::pimpl::Data> > dataResult = proxy::IMapImpl::entrySet(
                        predicate);
                size_t size = dataResult.size();
                std::vector<std::pair<K, V> > entries(size);
                for (size_t i = 0; i < size; ++i) {
                    boost::shared_ptr<K> key = toObject<K>(dataResult[i].first);
                    boost::shared_ptr<V> value = toObject<V>(dataResult[i].second);
                    entries[i] = std::make_pair(*key, *value);
                }
                return entries;
            }

            void addIndex(const std::string &attribute, bool ordered) {
                proxy::IMapImpl::addIndex(attribute, ordered);
            }

            template<typename ResultType, typename EntryProcessor>
            boost::shared_ptr<ResultType> executeOnKey(const K &key, EntryProcessor &entryProcessor) {
                return proxy::IMapImpl::executeOnKey<K, ResultType, EntryProcessor>(key, entryProcessor);
            }

            template<typename ResultType, typename EntryProcessor>
            std::map<K, boost::shared_ptr<ResultType> > executeOnEntries(EntryProcessor &entryProcessor) {
                return proxy::IMapImpl::executeOnEntries<K, ResultType, EntryProcessor>(entryProcessor);
            }

            void set(const K &key, const V &value) {
                set(key, value, -1);
            }

            int size() {
                return proxy::IMapImpl::size();
            }

            bool isEmpty() {
                return proxy::IMapImpl::isEmpty();
            }


            void putAll(const std::map<K, V> &entries) {
                return proxy::IMapImpl::putAll(toDataEntriesSet(entries));
            }

            void clear() {
                proxy::IMapImpl::clear();
            }

        private:
            IMap(const std::string &instanceName, spi::ClientContext *context)
                    : proxy::IMapImpl(instanceName, context) {
            }


        };
    }
}

#if  defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif

#endif /* HAZELCAST_IMAP */