read_result_set.h

/*
 * Copyright (c) 2008-2021, 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.
 */
#pragma once
 
#include <vector>
 
#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 rb {
            class HAZELCAST_API read_result_set {
            public:
                static const int64_t SEQUENCE_UNAVAILABLE = -1;
 
                read_result_set(int32_t read_count, std::vector<serialization::pimpl::data> &&data_items,
                                serialization::pimpl::SerializationService &serialization_service,
                                boost::optional<std::vector<int64_t>> &item_seqs, int64_t next_seq)
                              : items_read_count_(read_count), item_seqs_(std::move(item_seqs)), next_seq_(next_seq) {
                    for (auto &&item : data_items) {
                        items_.emplace_back(item, serialization_service);
                    }
                }
 
                int32_t read_count() const {
                    return items_read_count_;
                }
 
                const std::vector<typed_data> &get_items() const {
                    return items_;
                }
 
                int64_t get_sequence(int32_t index) const {
                    if (index >= (int32_t) item_seqs_->size() || index < 0) {
                        BOOST_THROW_EXCEPTION((exception::exception_builder<exception::illegal_argument>(
                                "read_result_set::getSequence") << "Index " << index
                                                              << " is out of bounds. Sequences size is:"
                                                              << item_seqs_->size()).build());
                    }
 
                    return (*item_seqs_)[index];
                }
 
                int64_t get_next_sequence_to_read_from() const {
                    return next_seq_;
                }
 
            private:
                int32_t items_read_count_;
                std::vector<typed_data> items_;
                boost::optional<std::vector<int64_t>> item_seqs_;
                int64_t next_seq_;
            };
        }
    }
}
 
#if  defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif