IQueue.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_IQUEUE
#define HAZELCAST_IQUEUE

#include "hazelcast/client/proxy/IQueueImpl.h"
#include "hazelcast/client/ItemListener.h"
#include "hazelcast/client/impl/ItemEventHandler.h"
#include <stdexcept>
#include "hazelcast/client/protocol/codec/QueueAddListenerCodec.h"

namespace hazelcast {
    namespace client {
        namespace adaptor {
            template <typename E>
            class RawPointerQueue;
        }

        template<typename E>
        class IQueue : public proxy::IQueueImpl {
            friend class HazelcastClient;
            friend class adaptor::RawPointerQueue<E>;

        public:
            std::string addItemListener(ItemListener<E>& listener, bool includeValue) {
                spi::ClusterService& cs = context->getClusterService();
                serialization::pimpl::SerializationService& ss = context->getSerializationService();
                impl::ItemEventHandler<E, protocol::codec::QueueAddListenerCodec::AbstractEventHandler> *itemEventHandler =
                        new impl::ItemEventHandler<E, protocol::codec::QueueAddListenerCodec::AbstractEventHandler>(getName(), cs, ss, listener, includeValue);
                return proxy::IQueueImpl::addItemListener(itemEventHandler, includeValue);
            }

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

            bool offer(const E& element) {
                return offer(element, 0);
            }

            void put(const E& e) {
                offer(e, -1);
            }

            bool offer(const E& element, long timeoutInMillis) {
                return proxy::IQueueImpl::offer(toData(element), timeoutInMillis);
            }

            boost::shared_ptr<E> take() {
                return poll(-1);
            }

            boost::shared_ptr<E> poll(long timeoutInMillis) {
                return boost::shared_ptr<E>(boost::shared_ptr<E>(toObject<E>(
                        proxy::IQueueImpl::pollData(timeoutInMillis))));
            }

            int remainingCapacity() {
                return proxy::IQueueImpl::remainingCapacity();
            }

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

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

            size_t drainTo(std::vector<E>& elements) {
                return drainTo(elements, -1);
            }

            size_t drainTo(std::vector<E>& elements, size_t maxElements) {
                std::vector<serialization::pimpl::Data> coll = proxy::IQueueImpl::drainToData(maxElements);
                for (std::vector<serialization::pimpl::Data>::const_iterator it = coll.begin(); it != coll.end(); ++it) {
                    std::auto_ptr<E> e = context->getSerializationService().template toObject<E>(*it);
                    elements.push_back(*e);
                }
                return coll.size();
            }

            boost::shared_ptr<E> poll() {
                return poll(0);
            }

            boost::shared_ptr<E> peek() {
                return boost::shared_ptr<E>(toObject<E>(proxy::IQueueImpl::peekData()));
            }

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

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

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

            bool containsAll(const std::vector<E>& elements) {
                std::vector<serialization::pimpl::Data> list = toDataCollection(elements);
                return proxy::IQueueImpl::containsAll(list);
            }

            bool addAll(const std::vector<E>& elements) {
                std::vector<serialization::pimpl::Data> dataList = toDataCollection(elements);
                return proxy::IQueueImpl::addAll(dataList);
            }

            bool removeAll(const std::vector<E>& elements) {
                std::vector<serialization::pimpl::Data> dataList = toDataCollection(elements);
                return proxy::IQueueImpl::removeAll(dataList);
            }

            bool retainAll(const std::vector<E>& elements) {
                std::vector<serialization::pimpl::Data> dataList = toDataCollection(elements);
                return proxy::IQueueImpl::retainAll(dataList);
            }

            void clear() {
                proxy::IQueueImpl::clear();
            }
        private:
            IQueue(const std::string& instanceName, spi::ClientContext *context)
            : proxy::IQueueImpl(instanceName, context) {
            }
        };
    }
}

#endif /* HAZELCAST_IQUEUE */