TransactionalMap.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.
 */
//
// Created by sancar koyunlu on 8/5/13.
#ifndef HAZELCAST_TransactionalMap
#define HAZELCAST_TransactionalMap

#include "hazelcast/client/proxy/TransactionalMapImpl.h"

namespace hazelcast {
    namespace client {
        namespace serialization {
            namespace pimpl {
                class Data;
            }
        }

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

        template<typename K, typename V>
        class TransactionalMap : public proxy::TransactionalMapImpl {
            friend class TransactionContext;
            friend class adaptor::RawPointerTransactionalMap<K, V>;

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

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

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

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

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

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

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

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

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

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

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

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

            std::vector<K> keySet() {
                return toObjectCollection<K>(proxy::TransactionalMapImpl::keySetData());
            }

            std::vector<K> keySet(const serialization::IdentifiedDataSerializable *predicate) {
                return toObjectCollection<K>(proxy::TransactionalMapImpl::keySetData(predicate));
            }

            std::vector<V> values() {
                return toObjectCollection<K>(proxy::TransactionalMapImpl::valuesData());
            }

            std::vector<V> values(const serialization::IdentifiedDataSerializable *predicate) {
                return toObjectCollection<K>(proxy::TransactionalMapImpl::valuesData(predicate));
            }

        private:
            TransactionalMap(const std::string& name, txn::TransactionProxy *transactionProxy)
            : proxy::TransactionalMapImpl(name, transactionProxy) {

            }

        };
    }
}

#endif //HAZELCAST_TransactionalMap