ISet.h

/*
 * Copyright (c) 2008-2018, 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_ISET
#define HAZELCAST_ISET

#include "hazelcast/client/proxy/ISetImpl.h"
#include "hazelcast/client/impl/ItemEventHandler.h"
#include "hazelcast/client/protocol/codec/SetAddListenerCodec.h"

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

        template<typename E>
        class ISet : public proxy::ISetImpl {
            friend class impl::HazelcastClientInstanceImpl;
            friend class adaptor::RawPointerSet<E>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#endif /* HAZELCAST_ISET */