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 <string>
#include <map>
#include <set>
#include <vector>
#include <stdexcept>
#include <climits>
#include "hazelcast/client/protocol/codec/MapAddEntryListenerWithPredicateCodec.h"
#include "hazelcast/client/impl/EntryArrayImpl.h"
#include "hazelcast/client/proxy/IMapImpl.h"
#include "hazelcast/client/impl/EntryEventHandler.h"
#include "hazelcast/client/EntryListener.h"
#include "hazelcast/client/EntryView.h"

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

namespace hazelcast {
    namespace client {
        namespace adaptor {
            template <typename K, typename V>
            class RawPointerMap;
        }

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

        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 boost::shared_ptr<V>(toObject<V>(proxy::IMapImpl::getData(toData(key))));
            }

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

            boost::shared_ptr<V> remove(const K &key) {
                return boost::shared_ptr<V>(toObject<V>(proxy::IMapImpl::removeData(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 boost::shared_ptr<V>(toObject<V>(proxy::IMapImpl::putData(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 boost::shared_ptr<V>(toObject<V>(proxy::IMapImpl::putIfAbsentData(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 boost::shared_ptr<V>(toObject<V>(proxy::IMapImpl::replaceData(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);
            }

            std::string addEntryListener(EntryListener<K, V> &listener, const query::Predicate &predicate, bool includeValue) {
                impl::EntryEventHandler<K, V, protocol::codec::MapAddEntryListenerWithPredicateCodec::AbstractEventHandler> *entryEventHandler =
                        new impl::EntryEventHandler<K, V, protocol::codec::MapAddEntryListenerWithPredicateCodec::AbstractEventHandler>(
                                getName(), context->getClusterService(), context->getSerializationService(), listener,
                                includeValue);
                return proxy::IMapImpl::addEntryListener(entryEventHandler, predicate, 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::getEntryViewData(keyData);
                std::auto_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());
                size_t 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::getAllData(
                        keySet);
                for (std::vector<std::pair<serialization::pimpl::Data, serialization::pimpl::Data> >::const_iterator it = entrySet.begin();
                     it != entrySet.end(); ++it) {
                    std::auto_ptr<K> key = toObject<K>(it->first);
                    std::auto_ptr<V> value = toObject<V>(it->second);
                    result[*key] = *value;
                }
                return result;
            }

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

            std::vector<K> keySet(const serialization::IdentifiedDataSerializable &predicate) {
                const query::Predicate *p = (const query::Predicate *)(&predicate);
                return keySet(*p);
            }

            std::vector<K> keySet(const query::Predicate &predicate) {
                std::vector<serialization::pimpl::Data> dataResult = proxy::IMapImpl::keySetData(predicate);
                size_t size = dataResult.size();
                std::vector<K> keys(size);
                for (size_t i = 0; i < size; ++i) {
                    std::auto_ptr<K> key = toObject<K>(dataResult[i]);
                    keys[i] = *key;
                }
                return keys;
            }

            std::vector<K> keySet(query::PagingPredicate<K, V> &predicate) {
                predicate.setIterationType(query::KEY);

                std::vector<serialization::pimpl::Data> dataResult = keySetForPagingPredicateData(predicate);

                EntryVector entryResult;
                for (std::vector<serialization::pimpl::Data>::iterator it = dataResult.begin();it != dataResult.end(); ++it) {
                    entryResult.push_back(std::pair<serialization::pimpl::Data, serialization::pimpl::Data>(*it, serialization::pimpl::Data()));
                }

                impl::EntryArrayImpl<K, V> entries(entryResult, context->getSerializationService());
                entries.sort(query::KEY, predicate.getComparator());

                std::pair<size_t, size_t> range = updateAnchor<K, V>(entries, predicate, query::KEY);

                std::vector<K> result;
                for (size_t i = range.first; i < range.second; ++i) {
                    result.push_back(*entries.getKey(i));
                }

                return result;
            }

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

            std::vector<V> values(const serialization::IdentifiedDataSerializable &predicate) {
                const query::Predicate *p = (const query::Predicate *)(&predicate);
                return values(*p);
            }

            std::vector<V> values(const query::Predicate &predicate) {
                std::vector<serialization::pimpl::Data> dataResult = proxy::IMapImpl::valuesData(predicate);
                size_t size = dataResult.size();
                std::vector<V> values(size);
                for (size_t i = 0; i < size; ++i) {
                    std::auto_ptr<V> value = toObject<V>(dataResult[i]);
                    values[i] = *value;
                }
                return values;
            }

            std::vector<V> values(query::PagingPredicate<K, V> &predicate) {
                predicate.setIterationType(query::VALUE);

                EntryVector dataResult = proxy::IMapImpl::valuesForPagingPredicateData(predicate);

                impl::EntryArrayImpl<K, V> entries(dataResult, context->getSerializationService());

                entries.sort(query::VALUE, predicate.getComparator());

                std::pair<size_t, size_t> range = updateAnchor<K, V>(entries, predicate, query::VALUE);

                std::vector<V> result;
                for (size_t i = range.first; i < range.second; ++i) {
                    result.push_back(*entries.getValue(i));
                }
                return result;
            }

            std::vector<std::pair<K, V> > entrySet() {
                std::vector<std::pair<serialization::pimpl::Data, serialization::pimpl::Data> > dataResult = proxy::IMapImpl::entrySetData();
                size_t size = dataResult.size();
                std::vector<std::pair<K, V> > entries(size);
                for (size_t i = 0; i < size; ++i) {
                    std::auto_ptr<K> key = toObject<K>(dataResult[i].first);
                    std::auto_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::entrySetData(
                        predicate);
                size_t size = dataResult.size();
                std::vector<std::pair<K, V> > entries(size);
                for (size_t i = 0; i < size; ++i) {
                    std::auto_ptr<K> key = toObject<K>(dataResult[i].first);
                    std::auto_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 query::Predicate &predicate) {
                std::vector<std::pair<serialization::pimpl::Data, serialization::pimpl::Data> > dataResult = proxy::IMapImpl::entrySetData(
                        predicate);
                size_t size = dataResult.size();
                std::vector<std::pair<K, V> > entries(size);
                for (size_t i = 0; i < size; ++i) {
                    std::auto_ptr<K> key = toObject<K>(dataResult[i].first);
                    std::auto_ptr<V> value = toObject<V>(dataResult[i].second);
                    entries[i] = std::make_pair(*key, *value);
                }
                return entries;
            }

            std::vector<std::pair<K, V> > entrySet(query::PagingPredicate<K, V> &predicate) {
                std::vector<std::pair<serialization::pimpl::Data, serialization::pimpl::Data> > dataResult = proxy::IMapImpl::entrySetForPagingPredicateData(
                        predicate);

                impl::EntryArrayImpl<K, V> entries(dataResult, context->getSerializationService());
                entries.sort(query::ENTRY, predicate.getComparator());

                std::pair<size_t, size_t> range = updateAnchor<K, V>(entries, predicate, query::ENTRY);

                std::vector<std::pair<K, V> > result;
                for (size_t i = range.first; i < range.second; ++i) {
                    std::pair<const K *, const V *> entry = entries[i];
                    result.push_back(std::pair<K, V>(*entry.first, *entry.second));
                }
                return result;
            }

            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) {
                std::auto_ptr<serialization::pimpl::Data> resultData = proxy::IMapImpl::executeOnKeyData<K, EntryProcessor>(key, entryProcessor);

                return boost::shared_ptr<ResultType>(toObject<ResultType>(resultData));
            }

            template<typename ResultType, typename EntryProcessor>
            std::map<K, boost::shared_ptr<ResultType> > executeOnEntries(EntryProcessor &entryProcessor) {
                EntryVector entries = proxy::IMapImpl::executeOnEntriesData<EntryProcessor>(entryProcessor);
                std::map<K, boost::shared_ptr<ResultType> > result;
                for (size_t i = 0; i < entries.size(); ++i) {
                    std::auto_ptr<K> keyObj = toObject<K>(entries[i].first);
                    std::auto_ptr<ResultType> resObj = toObject<ResultType>(entries[i].second);
                    result[*keyObj] = resObj;
                }
                return result;
            }

            template<typename ResultType, typename EntryProcessor>
            std::map<K, boost::shared_ptr<ResultType> > executeOnEntries(EntryProcessor &entryProcessor, const serialization::IdentifiedDataSerializable &predicate) {
                const query::Predicate *p = (const query::Predicate *)(&predicate);
                return executeOnEntries<ResultType, EntryProcessor>(entryProcessor, *p);
            }

            template<typename ResultType, typename EntryProcessor>
            std::map<K, boost::shared_ptr<ResultType> > executeOnEntries(EntryProcessor &entryProcessor, const query::Predicate &predicate) {
                EntryVector entries = proxy::IMapImpl::executeOnEntriesData<EntryProcessor>(entryProcessor, predicate);
                std::map<K, boost::shared_ptr<ResultType> > result;
                for (size_t i = 0; i < entries.size(); ++i) {
                    std::auto_ptr<K> keyObj = toObject<K>(entries[i].first);
                    std::auto_ptr<ResultType> resObj = toObject<ResultType>(entries[i].second);
                    result[*keyObj] = resObj;
                }
                return result;
            }

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