generic_record_builder.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 <unordered_set>
 
#include <boost/optional.hpp>
#include <boost/any.hpp>
#include <boost/variant.hpp>
 
#include "hazelcast/client/serialization/pimpl/compact/schema_writer.h"
#include "hazelcast/client/serialization/generic_record.h"
#include "hazelcast/client/big_decimal.h"
#include "hazelcast/client/local_time.h"
#include "hazelcast/client/local_date.h"
#include "hazelcast/client/local_date_time.h"
#include "hazelcast/client/offset_date_time.h"
#include "hazelcast/util/byte.h"
 
namespace hazelcast {
namespace client {
namespace serialization {
namespace pimpl {
class compact_stream_serializer;
}
namespace generic_record {

class HAZELCAST_API generic_record_builder
{
public:
    explicit generic_record_builder(std::string type_name);

    generic_record build();

    generic_record_builder& set_boolean(std::string field_name, bool value);

    generic_record_builder& set_int8(std::string field_name, int8_t value);

    generic_record_builder& set_int16(std::string field_name, int16_t value);

    generic_record_builder& set_int32(std::string field_name, int32_t value);

    generic_record_builder& set_int64(std::string field_name, int64_t value);

    generic_record_builder& set_float32(std::string field_name, float value);

    generic_record_builder& set_float64(std::string field_name, double value);

    generic_record_builder& set_nullable_boolean(std::string field_name,
                                                 boost::optional<bool> value);

    generic_record_builder& set_nullable_int8(std::string field_name,
                                              boost::optional<int8_t> value);

    generic_record_builder& set_nullable_int16(std::string field_name,
                                               boost::optional<int16_t> value);

    generic_record_builder& set_nullable_int32(std::string field_name,
                                               boost::optional<int32_t> value);

    generic_record_builder& set_nullable_int64(std::string field_name,
                                               boost::optional<int64_t> value);

    generic_record_builder& set_nullable_float32(std::string field_name,
                                                 boost::optional<float> value);

    generic_record_builder& set_nullable_float64(std::string field_name,
                                                 boost::optional<double> value);

    generic_record_builder& set_string(std::string field_name,
                                       boost::optional<std::string> value);

    generic_record_builder& set_string(std::string field_name,
                                       const char* cstr);

    generic_record_builder& set_generic_record(
      std::string field_name,
      boost::optional<generic_record> value);

    generic_record_builder& set_decimal(std::string field_name,
                                        boost::optional<big_decimal> value);

    generic_record_builder& set_time(std::string field_name,
                                     boost::optional<local_time> value);

    generic_record_builder& set_date(std::string field_name,
                                     boost::optional<local_date> value);

    generic_record_builder& set_timestamp(
      std::string field_name,
      boost::optional<local_date_time> value);

    generic_record_builder& set_timestamp_with_timezone(
      std::string field_name,
      boost::optional<offset_date_time> value);

    generic_record_builder& set_array_of_boolean(
      std::string field_name,
      boost::optional<std::vector<bool>> value);

    generic_record_builder& set_array_of_boolean(std::string field_name,
                                                 std::vector<bool> value);

    generic_record_builder& set_array_of_boolean(std::string field_name,
        std::initializer_list<bool> value);

    generic_record_builder& set_array_of_int8(
      std::string field_name,
      boost::optional<std::vector<int8_t>> value);

    generic_record_builder& set_array_of_int8(std::string field_name,
                                              std::vector<int8_t> value);

    generic_record_builder& set_array_of_int8(std::string field_name,
        std::initializer_list<int8_t> value);

    generic_record_builder& set_array_of_int16(
      std::string field_name,
      boost::optional<std::vector<int16_t>> value);

    generic_record_builder& set_array_of_int16(std::string field_name,
                                               std::vector<int16_t> value);

    generic_record_builder& set_array_of_int16(std::string field_name,
        std::initializer_list<int16_t> value);

    generic_record_builder& set_array_of_int32(
      std::string field_name,
      boost::optional<std::vector<int32_t>> value);

    generic_record_builder& set_array_of_int32(std::string field_name,
                                               std::vector<int32_t> value);

    generic_record_builder& set_array_of_int32(std::string field_name,
        std::initializer_list<int32_t> value);

    generic_record_builder& set_array_of_int64(
      std::string field_name,
      boost::optional<std::vector<int64_t>> value);

    generic_record_builder& set_array_of_int64(std::string field_name,
                                               std::vector<int64_t> value);

    generic_record_builder& set_array_of_int64(std::string field_name,
        std::initializer_list<int64_t> value);

    generic_record_builder& set_array_of_float32(
      std::string field_name,
      boost::optional<std::vector<float>> value);

    generic_record_builder& set_array_of_float32(std::string field_name,
                                                 std::vector<float> value);

    generic_record_builder& set_array_of_float32(std::string field_name,
        std::initializer_list<float> value);

    generic_record_builder& set_array_of_float64(
      std::string field_name,
      boost::optional<std::vector<double>> value);

    generic_record_builder& set_array_of_float64(std::string field_name,
                                                 std::vector<double> value);

    generic_record_builder& set_array_of_float64(std::string field_name,
        std::initializer_list<double> value);

    generic_record_builder& set_array_of_nullable_boolean(
      std::string field_name,
      boost::optional<std::vector<boost::optional<bool>>> value);

    generic_record_builder& set_array_of_nullable_boolean(
      std::string field_name,
      std::vector<bool> value);

    generic_record_builder& set_array_of_nullable_boolean(
        std::string field_name,
        std::initializer_list<bool> value);

    generic_record_builder& set_array_of_nullable_int8(
      std::string field_name,
      boost::optional<std::vector<boost::optional<int8_t>>> value);

    generic_record_builder& set_array_of_nullable_int8(
      std::string field_name,
      std::vector<int8_t> value);

    generic_record_builder& set_array_of_nullable_int8(
        std::string field_name,
        std::initializer_list<int8_t> value);

    generic_record_builder& set_array_of_nullable_int16(
      std::string field_name,
      boost::optional<std::vector<boost::optional<int16_t>>> value);

    generic_record_builder& set_array_of_nullable_int16(
      std::string field_name,
      std::vector<int16_t> value);

    generic_record_builder& set_array_of_nullable_int16(
        std::string field_name,
        std::initializer_list<int16_t> value);

    generic_record_builder& set_array_of_nullable_int32(
      std::string field_name,
      boost::optional<std::vector<boost::optional<int32_t>>> value);

    generic_record_builder& set_array_of_nullable_int32(
      std::string field_name,
      std::vector<int32_t> value);

    generic_record_builder& set_array_of_nullable_int32(
        std::string field_name,
        std::initializer_list<int32_t> value);

    generic_record_builder& set_array_of_nullable_int64(
      std::string field_name,
      boost::optional<std::vector<boost::optional<int64_t>>> value);

    generic_record_builder& set_array_of_nullable_int64(
      std::string field_name,
      std::vector<int64_t> value);

    generic_record_builder& set_array_of_nullable_int64(
        std::string field_name,
        std::initializer_list<int64_t> value);

    generic_record_builder& set_array_of_nullable_float32(
      std::string field_name,
      boost::optional<std::vector<boost::optional<float>>> value);

    generic_record_builder& set_array_of_nullable_float32(
      std::string field_name,
      std::vector<float> value);

    generic_record_builder& set_array_of_nullable_float32(
        std::string field_name,
        std::initializer_list<float> value);

    generic_record_builder& set_array_of_nullable_float64(
      std::string field_name,
      boost::optional<std::vector<boost::optional<double>>> value);

    generic_record_builder& set_array_of_nullable_float64(
      std::string field_name,
      std::vector<double> value);

    generic_record_builder& set_array_of_nullable_float64(
        std::string field_name,
        std::initializer_list<double> value);

    generic_record_builder& set_array_of_string(
      std::string field_name,
      boost::optional<std::vector<boost::optional<std::string>>> value);

    generic_record_builder& set_array_of_decimal(
      std::string field_name,
      boost::optional<std::vector<boost::optional<big_decimal>>> value);

    generic_record_builder& set_array_of_time(
      std::string field_name,
      boost::optional<std::vector<boost::optional<local_time>>> value);

    generic_record_builder& set_array_of_date(
      std::string field_name,
      boost::optional<std::vector<boost::optional<local_date>>> value);

    generic_record_builder& set_array_of_timestamp(
      std::string field_name,
      boost::optional<std::vector<boost::optional<local_date_time>>> value);

    generic_record_builder& set_array_of_timestamp_with_timezone(
      std::string field_name,
      boost::optional<std::vector<boost::optional<offset_date_time>>> value);

    generic_record_builder& set_array_of_generic_record(
      std::string field_name,
      boost::optional<std::vector<boost::optional<generic_record>>> value);
 
private:
    enum class strategy
    {
        default_builder,
        cloner,
        schema_bounded
    };
 
    friend class generic_record;
    friend class pimpl::compact_stream_serializer;
    generic_record_builder(
      std::shared_ptr<pimpl::schema>); // DeserializedSchemaBoundGenericRecordBuilder
    generic_record_builder(
      std::shared_ptr<pimpl::schema>,
      std::unordered_map<std::string,
                         boost::any>); // DeserializedGenericRecordCloner
 
    template<typename T>
    generic_record_builder& write(std::string field_name,
                                  T value,
                                  field_kind kind)
    {
        if (already_built_) {
            BOOST_THROW_EXCEPTION(exception::hazelcast_serialization{
              boost::str(boost::format("Illegal to write after record is "
                                       "built. {field : %1%, kind : %2%}") %
                         field_name % kind) });
        }
 
        if (strategy_ == strategy::cloner ||
            strategy_ == strategy::schema_bounded) {
            const auto& schema =
              *boost::get<std::shared_ptr<pimpl::schema>>(writer_or_schema_);
 
            check_type_with_schema(schema, field_name, kind);
        }
 
        if (strategy_ == strategy::cloner) {
            bool inserted = overwritten_fields_.insert(field_name).second;
 
            if (!inserted) {
                BOOST_THROW_EXCEPTION(exception::hazelcast_serialization{
                  "Field can only be written once." });
            }
        } else if (objects_.find(field_name) != end(objects_)) {
            BOOST_THROW_EXCEPTION(exception::hazelcast_serialization{
              "Field can only be written once" });
        }
 
        if (strategy_ == strategy::cloner) {
            auto existing = objects_.find(field_name);
 
            assert(existing != end(objects_));
            existing->second = std::move(value);
        } else {
            (void)objects_.emplace(field_name, std::move(value));
        }
 
        if (strategy_ == strategy::default_builder) {
            pimpl::schema_writer& writer =
              boost::get<pimpl::schema_writer>(writer_or_schema_);
 
            writer.add_field(std::move(field_name), kind);
        }
 
        return *this;
    }
 
    void check_type_with_schema(const pimpl::schema&,
                                const std::string& field_name,
                                field_kind) const;
 
    strategy strategy_;
    bool already_built_;
    std::unordered_set<std::string> overwritten_fields_;
    std::unordered_map<std::string, boost::any> objects_;
    boost::variant<pimpl::schema_writer, std::shared_ptr<pimpl::schema>> writer_or_schema_;
};
 
} // namespace generic_record
} // namespace serialization
} // namespace client
} // namespace hazelcast