ReadResultSet.h

/*
 * Copyright (c) 2008-2019, 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_RINGBUFFER_READRESULTSET_H_
#define HAZELCAST_CLIENT_RINGBUFFER_READRESULTSET_H_

#include <stdint.h>

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

namespace hazelcast {
    namespace client {
        namespace ringbuffer {
            template<typename E>
            class ReadResultSet {
            public:
                static const int64_t SEQUENCE_UNAVAILABLE = -1;

                ReadResultSet() {}

                ReadResultSet(int32_t readCount, const std::vector<serialization::pimpl::Data> &dataItems,
                              serialization::pimpl::SerializationService &serializationService,
                              std::auto_ptr<std::vector<int64_t> > &itemSeqs, bool itemSeqsExist,
                              int64_t nextSeq) : itemsReadCount(readCount),
                                                 items(new client::impl::DataArrayImpl<E>(dataItems,
                                                                                          serializationService)),
                                                 itemSeqs(itemSeqs),
                                                 itemSeqsExist(itemSeqsExist),
                                                 nextSeq(nextSeq) {}

                virtual ~ReadResultSet() {}

                virtual int32_t readCount() const {
                    return itemsReadCount;
                }

                virtual DataArray<E> &getItems() {
                    return *items;
                }

                virtual int64_t getSequence(int32_t index) const {
                    if (!itemSeqsExist) {
                        throw exception::IllegalArgumentException("ReadResultSet::getSequence",
                                                                  "No item sequences exist");
                    }
                    if (index >= (int32_t) itemSeqs->size() || index < 0) {
                        throw (exception::ExceptionBuilder<exception::IllegalArgumentException>(
                                "ReadResultSet::getSequence") << "Index " << index
                                                              << " is out of bounds. Sequences size is:"
                                                              << itemSeqs->size()).build();
                    }

                    return (*itemSeqs)[index];
                }

                virtual int64_t getNextSequenceToReadFrom() const {
                    return nextSeq;
                }

            private:
                int32_t itemsReadCount;
                std::auto_ptr<client::impl::DataArrayImpl<E> > items;
                std::auto_ptr<std::vector<int64_t> > itemSeqs;
                bool itemSeqsExist;
                int64_t nextSeq;
            };
        }
    }
}

#endif /* HAZELCAST_CLIENT_RINGBUFFER_READRESULTSET_H_ */