read_result_set.h

/*
 * Copyright (c) 2008-2025, 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>
 
#include <boost/optional.hpp>
 
#include "hazelcast/client/serialization/pimpl/data.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 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_;
};
} // namespace rb
} // namespace client
} // namespace hazelcast
 
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif