Ringbuffer.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_CLIENT_MIXEDTYPE_RINGBUFFER_H_
#define HAZELCAST_CLIENT_MIXEDTYPE_RINGBUFFER_H_

#include <stdint.h>

#include "hazelcast/client/TypedData.h"
#include "hazelcast/client/proxy/ProxyImpl.h"
#include "hazelcast/client/protocol/codec/RingbufferAddCodec.h"

#if  defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(push)
#pragma warning(disable: 4251) //for dll export
#endif

namespace hazelcast {
    namespace client {
        namespace mixedtype {
            class HAZELCAST_API Ringbuffer : public proxy::ProxyImpl {
                friend class client::impl::HazelcastClientInstanceImpl;

            public:
                Ringbuffer(const Ringbuffer &rhs);

                virtual ~Ringbuffer();

                int64_t capacity();

                int64_t size();

                int64_t tailSequence();

                int64_t headSequence();

                int64_t remainingCapacity();

                template <typename E>
                int64_t add(const E &item) {
                    serialization::pimpl::Data itemData = toData<E>(item);
                    std::auto_ptr<protocol::ClientMessage> msg = protocol::codec::RingbufferAddCodec::encodeRequest(
                            getName(), OVERWRITE, itemData);
                    return invokeAndGetResult<int64_t, protocol::codec::RingbufferAddCodec::ResponseParameters>(msg, partitionId);
                }

                TypedData readOne(int64_t sequence);

            private:
                Ringbuffer(const std::string &objectName, spi::ClientContext *context);

                enum OverflowPolicy {

                            OVERWRITE = 0
                };

                int32_t partitionId;
                util::Atomic<int64_t> bufferCapacity;
            };
        }
    }
}

#if  defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif

#endif //HAZELCAST_CLIENT_MIXEDTYPE_RINGBUFFER_H_