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





#ifndef HAZELCAST_TransactionalMap
#define HAZELCAST_TransactionalMap

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

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

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

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

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

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

            bool isEmpty() {
                return size() == 0;
            }

            boost::shared_ptr<V> put(const K& key, const V& value) {
                return toObject<V>(proxy::TransactionalMapImpl::put(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 toObject<V>(proxy::TransactionalMapImpl::putIfAbsent(toData(&key), toData(&value)));
            };

            boost::shared_ptr<V> replace(const K& key, const V& value) {
                return toObject<V>(proxy::TransactionalMapImpl::replace(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 toObject<V>(proxy::TransactionalMapImpl::remove(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::keySet());
            }

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

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

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

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

            }

        };
    }
}


#endif //HAZELCAST_TransactionalMap