IMap.h

/*
 * Copyright (c) 2008-2017, 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_CLIENT_MIXEDTYPE_IMAP_H_
#define HAZELCAST_CLIENT_MIXEDTYPE_IMAP_H_

#include <string>
#include <map>
#include <vector>
#include "hazelcast/client/mixedtype/ClientMapProxy.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 mixedtype {
            namespace impl {
               class HazelcastClientImpl;
            }

            class HAZELCAST_API IMap {
                friend class impl::HazelcastClientImpl;
            public:
                template <typename K>
                bool containsKey(const K &key) {
                    return mapImpl->containsKey<K>(key);
                }

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

                template <typename K>
                TypedData get(const K &key) {
                    return mapImpl->get<K>(key);
                }

                template <typename K, typename V>
                TypedData put(const K &key, const V &value) {
                    return mapImpl->put(key, value);
                }

                template <typename K, typename V>
                TypedData put(const K &key, const V &value, long ttlInMillis) {
                    return mapImpl->put<K, V>(key, value, ttlInMillis);
                }

                template <typename K>
                TypedData remove(const K &key) {
                    return mapImpl->remove<K>(key);
                }

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

                void removeAll(const query::Predicate &predicate);

                template <typename K>
                void deleteEntry(const K &key) {
                    return mapImpl->deleteEntry<K>(key);
                }

                void flush();

                template <typename K>
                bool tryRemove(const K &key, long timeoutInMillis) {
                    return mapImpl->tryRemove<K>(key, timeoutInMillis);
                }

                template <typename K, typename V>
                bool tryPut(const K &key, const V &value, long timeoutInMillis) {
                    return mapImpl->tryPut<K, V>(key, value, timeoutInMillis);
                }

                template <typename K, typename V>
                void putTransient(const K &key, const V &value, long ttlInMillis) {
                    return mapImpl->putTransient<K, V>(key, value, ttlInMillis);
                }

                template <typename K, typename V>
                TypedData putIfAbsent(const K &key, const V &value) {
                    return mapImpl->putIfAbsent<K, V>(key, value);
                }

                template <typename K, typename V>
                TypedData putIfAbsent(const K &key, const V &value, long ttlInMillis) {
                    return mapImpl->putIfAbsent<K, V>(key, value, ttlInMillis);
                }

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

                template <typename K, typename V>
                TypedData replace(const K &key, const V &value) {
                    return mapImpl->replace<K, V>(key, value);
                }

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

                template <typename K, typename V>
                void set(const K &key, const V &value, long ttl) {
                    return mapImpl->set<K, V>(key, value, ttl);
                }

                template <typename K>
                void lock(const K &key) {
                    return mapImpl->lock<K>(key);
                }

                template <typename K>
                void lock(const K &key, long leaseTime) {
                    return mapImpl->lock<K>(key, leaseTime);
                }

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

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

                template <typename K>
                bool tryLock(const K &key, long timeInMillis) {
                    return mapImpl->tryLock<K>(key, timeInMillis);
                }

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

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

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

                void removeInterceptor(const std::string &id);

                std::string addEntryListener(MixedEntryListener &listener, bool includeValue);

                std::string
                addEntryListener(MixedEntryListener &listener, const query::Predicate &predicate, bool includeValue);

                bool removeEntryListener(const std::string &registrationId);

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

                template <typename K>
                std::auto_ptr<EntryView<TypedData, TypedData> > getEntryView(const K &key) {
                    return mapImpl->getEntryView<K>(key);
                }

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

                void evictAll();

                template <typename K>
                std::vector<std::pair<TypedData, TypedData> > getAll(const std::set<K> &keys) {
                    return mapImpl->getAll<K>(keys);
                }

                std::vector<TypedData> keySet();

                std::vector<TypedData> keySet(const serialization::IdentifiedDataSerializable &predicate);

                std::vector<TypedData> keySet(const query::Predicate &predicate);

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

                std::vector<TypedData> values();

                std::vector<TypedData> values(const serialization::IdentifiedDataSerializable &predicate);

                std::vector<TypedData> values(const query::Predicate &predicate);

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

                std::vector<std::pair<TypedData, TypedData> > entrySet();

                std::vector<std::pair<TypedData, TypedData> > entrySet(const serialization::IdentifiedDataSerializable &predicate);

                std::vector<std::pair<TypedData, TypedData> > entrySet(const query::Predicate &predicate);

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

                void addIndex(const std::string &attribute, bool ordered);

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

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

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

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

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

                int size();

                bool isEmpty();


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

                void clear();

                void destroy();

                monitor::LocalMapStats &getLocalMapStats();

            private:
                IMap(boost::shared_ptr<mixedtype::ClientMapProxy> proxy);

                boost::shared_ptr<mixedtype::ClientMapProxy> mapImpl;
            };
        }
    }
}

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

#endif /* HAZELCAST_CLIENT_MIXEDTYPE_IMAP_H_ */