IList.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.
 */
#ifndef HAZELCAST_ILIST
#define HAZELCAST_ILIST

#include "hazelcast/client/serialization/pimpl/Data.h"
#include "hazelcast/client/DistributedObject.h"
#include "hazelcast/client/ItemListener.h"
#include "hazelcast/client/impl/ItemEventHandler.h"
#include "hazelcast/client/proxy/IListImpl.h"
#include "hazelcast/client/protocol/codec/ListAddListenerCodec.h"

#include <stdexcept>


namespace hazelcast {
    namespace client {

        template<typename E>
        class IList : public proxy::IListImpl {
            friend class HazelcastClient;

        public:
            std::string addItemListener(ItemListener<E> &listener, bool includeValue) {
                impl::ItemEventHandler<E, protocol::codec::ListAddListenerCodec::AbstractEventHandler> *entryEventHandler =
                        new impl::ItemEventHandler<E, protocol::codec::ListAddListenerCodec::AbstractEventHandler>(
                                getName(), context->getClusterService(), context->getSerializationService(), listener,
                                includeValue);
                return proxy::IListImpl::addItemListener(entryEventHandler, includeValue);
            }

            bool removeItemListener(const std::string &registrationId) {
                return proxy::IListImpl::removeItemListener(registrationId);
            }

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

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

            bool contains(const E &element) {
                return proxy::IListImpl::contains(toData(element));
            }

            std::vector<E> toArray() {
                return toObjectCollection<E>(proxy::IListImpl::toArray());
            }

            bool add(const E &element) {
                return proxy::IListImpl::add(toData(element));
            }

            bool remove(const E &element) {
                return proxy::IListImpl::remove(toData(element));
            }

            bool containsAll(const std::vector<E> &elements) {
                return proxy::IListImpl::containsAll(toDataCollection(elements));
            }

            bool addAll(const std::vector<E> &elements) {
                return proxy::IListImpl::addAll(toDataCollection(elements));
            }

            bool addAll(int index, const std::vector<E> &elements) {
                return proxy::IListImpl::addAll(index, toDataCollection(elements));
            }

            bool removeAll(const std::vector<E> &elements) {
                return proxy::IListImpl::removeAll(toDataCollection(elements));
            }

            bool retainAll(const std::vector<E> &elements) {
                return proxy::IListImpl::retainAll(toDataCollection(elements));
            }

            void clear() {
                proxy::IListImpl::clear();
            }

            boost::shared_ptr<E> get(int index) {
                return toObject<E>(proxy::IListImpl::get(index));
            }

            boost::shared_ptr<E> set(int index, const E &element) {
                return toObject<E>(proxy::IListImpl::set(index, toData(element)));
            }

            void add(int index, const E &element) {
                proxy::IListImpl::add(index, toData(element));
            }

            boost::shared_ptr<E> remove(int index) {
                return toObject<E>(proxy::IListImpl::remove(index));
            }

            int indexOf(const E &element) {
                return proxy::IListImpl::indexOf(toData(element));
            }

            int lastIndexOf(const E &element) {
                return proxy::IListImpl::lastIndexOf(toData(element));
            }

            std::vector<E> subList(int fromIndex, int toIndex) {
                return toObjectCollection<E>(proxy::IListImpl::subList(fromIndex, toIndex));
            }

        private:
            IList(const std::string &instanceName, spi::ClientContext *context)
                    : proxy::IListImpl(instanceName, context) {
            }
        };
    }
}

#endif /* HAZELCAST_ILIST */