IMap.h

/*
 * Copyright (c) 2008-2019, 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"
#include "hazelcast/client/map/ClientMapProxy.h"
#include "hazelcast/client/Future.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 {
        class HazelcastClient;

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

        namespace spi {
            class ProxyManager;
        }

        template<typename K, typename V>
        class IMap {
            friend class spi::ProxyManager;

            friend class impl::HazelcastClientInstanceImpl;

            friend class adaptor::RawPointerMap<K, V>;

        public:
            static const std::string SERVICE_NAME;

            bool containsKey(const K &key) {
                return mapImpl->containsKey(key);
            }

            bool containsValue(const V &value) {
                return mapImpl->containsValue(value);
            }

            boost::shared_ptr<V> get(const K &key) {
                return mapImpl->get(key);
            }

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

            boost::shared_ptr<V> put(const K &key, const V &value, int64_t ttlInMillis) {
                return mapImpl->put(key, value, ttlInMillis);
            }

            boost::shared_ptr<V> remove(const K &key) {
                return mapImpl->remove(key);
            }

            void removeAll(const query::Predicate &predicate) {
                mapImpl->removeAll(predicate);
            }

            bool remove(const K &key, const V &value) {
                return mapImpl->remove(key, value);
            }

            void deleteEntry(const K &key) {
                mapImpl->deleteEntry(key);
            }

            void flush() {
                mapImpl->flush();
            }

            bool tryRemove(const K &key, int64_t timeoutInMillis) {
                return mapImpl->tryRemove(key, timeoutInMillis);
            }

            bool tryPut(const K &key, const V &value, int64_t timeoutInMillis) {
                return mapImpl->tryPut(key, value, timeoutInMillis);
            }

            void putTransient(const K &key, const V &value, int64_t ttlInMillis) {
                mapImpl->putTransient(key, value, ttlInMillis);
            }

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

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

            bool replace(const K &key, const V &oldValue, const V &newValue) {
                return mapImpl->replace(key, oldValue, newValue);
            }

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

            void lock(const K &key) {
                mapImpl->lock(key);
            }

            void lock(const K &key, int64_t leaseTime) {
                mapImpl->lock(key, leaseTime);
            }

            bool isLocked(const K &key) {
                return mapImpl->isLocked(key);
            }

            bool tryLock(const K &key) {
                return mapImpl->tryLock(key);
            }

            bool tryLock(const K &key, int64_t timeInMillis) {
                return mapImpl->tryLock(key, timeInMillis);
            }

            void unlock(const K &key) {
                mapImpl->unlock(key);
            }

            void forceUnlock(const K &key) {
                mapImpl->forceUnlock(key);
            }

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

            void removeInterceptor(const std::string &id) {
                mapImpl->removeInterceptor(id);
            }

            std::string addEntryListener(EntryListener<K, V> &listener, bool includeValue) {
                return mapImpl->addEntryListener(listener, includeValue);
            }

            std::string
            addEntryListener(EntryListener<K, V> &listener, const query::Predicate &predicate, bool includeValue) {
                return mapImpl->addEntryListener(listener, predicate, includeValue);
            }

            bool removeEntryListener(const std::string &registrationId) {
                return mapImpl->removeEntryListener(registrationId);
            }


            std::string addEntryListener(EntryListener<K, V> &listener, const K &key, bool includeValue) {
                return mapImpl->addEntryListener(listener, key, includeValue);
            }

            EntryView<K, V> getEntryView(const K &key) {
                return mapImpl->getEntryView(key);
            }

            bool evict(const K &key) {
                return mapImpl->evict(key);
            }

            void evictAll() {
                mapImpl->evictAll();
            }

            std::map<K, V> getAll(const std::set<K> &keys) {
                return mapImpl->getAll(keys);
            }

            std::vector<K> keySet() {
                return mapImpl->keySet();
            }

            std::vector<K> keySet(const serialization::IdentifiedDataSerializable &predicate) {
                return mapImpl->keySet(predicate);
            }

            std::vector<K> keySet(const query::Predicate &predicate) {
                return mapImpl->keySet(predicate);
            }

            std::vector<K> keySet(query::PagingPredicate<K, V> &predicate) {
                return mapImpl->keySet(predicate);
            }

            std::vector<V> values() {
                return mapImpl->values();
            }

            std::vector<V> values(const serialization::IdentifiedDataSerializable &predicate) {
                return mapImpl->values(predicate);
            }

            std::vector<V> values(const query::Predicate &predicate) {
                return mapImpl->values(predicate);
            }

            std::vector<V> values(query::PagingPredicate<K, V> &predicate) {
                return mapImpl->values(predicate);
            }

            std::vector<std::pair<K, V> > entrySet() {
                return mapImpl->entrySet();
            }

            std::vector<std::pair<K, V> > entrySet(const serialization::IdentifiedDataSerializable &predicate) {
                return mapImpl->entrySet(predicate);
            }

            std::vector<std::pair<K, V> > entrySet(const query::Predicate &predicate) {
                return mapImpl->entrySet(predicate);
            }

            std::vector<std::pair<K, V> > entrySet(query::PagingPredicate<K, V> &predicate) {
                return mapImpl->entrySet(predicate);
            }

            void addIndex(const std::string &attribute, bool ordered) {
                mapImpl->addIndex(attribute, ordered);
            }

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

            template<typename ResultType, typename EntryProcessor>
            std::map<K, boost::shared_ptr<ResultType> >
            executeOnKeys(const std::set<K> &keys, const EntryProcessor &entryProcessor) {
                return mapImpl->template executeOnKeys<ResultType, EntryProcessor>(keys, entryProcessor);
            }

            template<typename ResultType, typename EntryProcessor>
            Future<ResultType> submitToKey(const K &key, const EntryProcessor &entryProcessor) {
                return mapImpl->template submitToKey<ResultType, EntryProcessor>(key, entryProcessor);
            }

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

            template<typename ResultType, typename EntryProcessor>
            std::map<K, boost::shared_ptr<ResultType> > executeOnEntries(const EntryProcessor &entryProcessor,
                                                                         const serialization::IdentifiedDataSerializable &predicate) {
                return mapImpl->template executeOnEntries<ResultType, EntryProcessor>(entryProcessor, predicate);
            }

            template<typename ResultType, typename EntryProcessor>
            std::map<K, boost::shared_ptr<ResultType> >
            executeOnEntries(const EntryProcessor &entryProcessor, const query::Predicate &predicate) {
                return mapImpl->template executeOnEntries<ResultType, EntryProcessor>(entryProcessor, predicate);
            }

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

            void set(const K &key, const V &value, int64_t ttl) {
                mapImpl->set(key, value, ttl);
            }

            int size() {
                return mapImpl->size();
            }

            bool isEmpty() {
                return mapImpl->isEmpty();
            }


            void putAll(const std::map<K, V> &entries) {
                return mapImpl->putAll(entries);
            }

            void clear() {
                mapImpl->clear();
            }

            void destroy() {
                mapImpl->destroy();
            }

            monitor::LocalMapStats &getLocalMapStats() {
                return mapImpl->getLocalMapStats();
            }

            boost::shared_ptr<ICompletableFuture<V> > getAsync(const K &key) {
                return mapImpl->getAsync(key);
            }

            boost::shared_ptr<ICompletableFuture<V> > putAsync(const K &key, const V &value) {
                return mapImpl->putAsync(key, value);
            }

            boost::shared_ptr<ICompletableFuture<V> >
            putAsync(const K &key, const V &value, int64_t ttl, const util::concurrent::TimeUnit &ttlUnit) {
                return mapImpl->putAsync(key, value, ttl, ttlUnit);
            }

            boost::shared_ptr<ICompletableFuture<V> >
            putAsync(const K &key, const V &value, int64_t ttl, const util::concurrent::TimeUnit &ttlUnit,
                     int64_t maxIdle, const util::concurrent::TimeUnit &maxIdleUnit) {
                return mapImpl->putAsync(key, value, ttl, ttlUnit, maxIdle, maxIdleUnit);
            }

            boost::shared_ptr<ICompletableFuture<void> > setAsync(const K &key, const V &value) {
                return mapImpl->setAsync(key, value);
            }

            boost::shared_ptr<ICompletableFuture<void> >
            setAsync(const K &key, const V &value, int64_t ttl, const util::concurrent::TimeUnit &ttlUnit) {
                return mapImpl->setAsync(key, value, ttl, ttlUnit);
            }

            boost::shared_ptr<ICompletableFuture<void> >
            setAsync(const K &key, const V &value, int64_t ttl, const util::concurrent::TimeUnit &ttlUnit,
                     int64_t maxIdle, const util::concurrent::TimeUnit &maxIdleUnit) {
                return mapImpl->setAsync(key, value, ttl, ttlUnit, maxIdle, maxIdleUnit);
            }

            boost::shared_ptr<ICompletableFuture<V> > removeAsync(const K &key) {
                return mapImpl->removeAsync(key);
            }

        private:
            IMap(boost::shared_ptr<spi::ClientProxy> clientProxy) {
                mapImpl = boost::static_pointer_cast<map::ClientMapProxy<K, V> >(clientProxy);
            }

            boost::shared_ptr<map::ClientMapProxy<K, V> > mapImpl;
        };

        template<typename K, typename V>
        const std::string IMap<K, V>::SERVICE_NAME = "hz:impl:mapService";
    }
}

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

#endif /* HAZELCAST_IMAP */