RawPointerTransactionalMap.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 ihsan demir on 24/03/16.
#ifndef HAZELCAST_CLIENT_ADAPTOR_RAWPOINTERRawPointerTransactionalMap_H_
#define HAZELCAST_CLIENT_ADAPTOR_RAWPOINTERRawPointerTransactionalMap_H_

#include "hazelcast/client/TransactionalMap.h"
#include "hazelcast/client/impl/DataArrayImpl.h"

namespace hazelcast {
    namespace client {
        namespace adaptor {
            template<typename K, typename V>
            class RawPointerTransactionalMap {
            public:
                RawPointerTransactionalMap(TransactionalMap<K, V> &m) : map(m), serializationService(
                        m.context->getSerializationService()) {
                }

                bool containsKey(const K &key) {
                    return map.containsKey(key);
                }

                std::auto_ptr<V> get(const K &key) {
                    return serializationService.toObject<V>(map.getData(serializationService.toData<K>(&key)).get());
                }

                int size() {
                    return map.size();
                }

                bool isEmpty() {
                    return map.isEmpty();
                }

                std::auto_ptr<V> put(const K &key, const V &value) {
                    return serializationService.toObject<V>(map.putData(serializationService.toData<K>(&key),
                                                                        serializationService.toData<V>(&value)).get());
                };

                void set(const K &key, const V &value) {
                    map.set(key, value);
                }

                std::auto_ptr<V> putIfAbsent(const K &key, const V &value) {
                    return serializationService.toObject<V>(map.putIfAbsentData(serializationService.toData<K>(&key),
                                                                                serializationService.toData<V>(
                                                                                        &value)).get());
                };

                std::auto_ptr<V> replace(const K &key, const V &value) {
                    return serializationService.toObject<V>(map.replaceData(serializationService.toData<K>(&key),
                                                                            serializationService.toData<V>(
                                                                                    &value)).get());
                };

                bool replace(const K &key, const V &oldValue, const V &newValue) {
                    return map.replace(key, oldValue, newValue);
                };

                std::auto_ptr<V> remove(const K &key) {
                    return serializationService.toObject<V>(map.removeData(serializationService.toData<K>(&key)).get());
                };

                void deleteEntry(const K &key) {
                    map.deleteEntry(key);
                };

                bool remove(const K &key, const V &value) {
                    return map.remove(key, value);
                }

                std::auto_ptr<DataArray<K> > keySet() {
                    return std::auto_ptr<DataArray<K> >(new impl::DataArrayImpl<K>(map.keySetData(), serializationService));
                }

                std::auto_ptr<DataArray<K> > keySet(const serialization::IdentifiedDataSerializable *predicate) {
                    return std::auto_ptr<DataArray<K> >(new impl::DataArrayImpl<K>(map.keySetData(predicate), serializationService));
                }

                std::auto_ptr<DataArray<V> > values() {
                    return std::auto_ptr<DataArray<V> >(new impl::DataArrayImpl<V>(map.valuesData(), serializationService));
                }

                std::auto_ptr<DataArray<V> > values(const serialization::IdentifiedDataSerializable *predicate) {
                    return std::auto_ptr<DataArray<V> >(new impl::DataArrayImpl<V>(map.valuesData(predicate), serializationService));
                }

            private:
                TransactionalMap<K, V> &map;
                serialization::pimpl::SerializationService &serializationService;
            };
        }
    }
}


#endif //HAZELCAST_CLIENT_ADAPTOR_RAWPOINTERRawPointerTransactionalMap_H_