RequestMessageFormat.h

/*
 * MIT License
 *
 * Copyright (c) 2026 Adriano dos Santos Fernandes
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
 
#ifndef FBCPP_REQUEST_MESSAGE_FORMAT_H
#define FBCPP_REQUEST_MESSAGE_FORMAT_H
 
#include "../config.h"
#include "fb-cpp-export.h"
#include "../fb-api.h"
#include "../types.h"
#include "../Descriptor.h"
#include "../Exception.h"
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
#include <boost/multiprecision/cpp_int.hpp>
#endif
 
 
namespace fbcpp::request
{
    class FB_CPP_EXPORT RequestMessageFormat final
    {
    public:
        RequestMessageFormat& addBool(bool isNullable)
        {
            return addField(DescriptorAdjustedType::BOOLEAN, 1u, 1u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addInt16(bool isNullable)
        {
            return addField(DescriptorAdjustedType::INT16, 2u, 2u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addScaledInt16(bool isNullable, int scale)
        {
            return addField(DescriptorAdjustedType::INT16, 2u, 2u, scale, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addInt32(bool isNullable)
        {
            return addField(DescriptorAdjustedType::INT32, 4u, 4u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addScaledInt32(bool isNullable, int scale)
        {
            return addField(DescriptorAdjustedType::INT32, 4u, 4u, scale, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addInt64(bool isNullable)
        {
            return addField(DescriptorAdjustedType::INT64, 8u, 8u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addScaledInt64(bool isNullable, int scale)
        {
            return addField(DescriptorAdjustedType::INT64, 8u, 8u, scale, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addScaledOpaqueInt128(bool isNullable, int scale)
        {
            return addField(DescriptorAdjustedType::INT128, 16u, 8u, scale, 0, 0, isNullable);
        }
 
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
        RequestMessageFormat& addScaledBoostInt128(bool isNullable, int scale)
        {
            return addField(DescriptorAdjustedType::INT128, 16u, 8u, scale, 0, 0, isNullable);
        }
#endif
 
        RequestMessageFormat& addFloat(bool isNullable)
        {
            return addField(DescriptorAdjustedType::FLOAT, 4u, 4u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addDouble(bool isNullable)
        {
            return addField(DescriptorAdjustedType::DOUBLE, 8u, 8u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addDecFloat16(bool isNullable)
        {
            return addField(DescriptorAdjustedType::DECFLOAT16, 8u, 8u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addDecFloat34(bool isNullable)
        {
            return addField(DescriptorAdjustedType::DECFLOAT34, 16u, 8u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addDate(bool isNullable)
        {
            return addField(DescriptorAdjustedType::DATE, 4u, 4u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addTime(bool isNullable)
        {
            return addField(DescriptorAdjustedType::TIME, 4u, 4u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addTimestamp(bool isNullable)
        {
            return addField(DescriptorAdjustedType::TIMESTAMP, 8u, 4u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addTimeTz(bool isNullable)
        {
            return addField(DescriptorAdjustedType::TIME_TZ, 6u, 4u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addTimestampTz(bool isNullable)
        {
            return addField(DescriptorAdjustedType::TIMESTAMP_TZ, 10u, 4u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addBlobId(bool isNullable)
        {
            return addField(DescriptorAdjustedType::BLOB, 8u, 4u, 0, 0, 0, isNullable);
        }
 
        RequestMessageFormat& addString(bool isNullable, unsigned length, std::optional<unsigned> charSetId = {})
        {
            if (length == 0u || length > 65535u - sizeof(std::uint16_t))
                throw FbCppException("Invalid string length");
 
            return addField(DescriptorAdjustedType::STRING, length + sizeof(std::uint16_t), sizeof(std::uint16_t), 0,
                charSetId.value_or(0u), 0, isNullable);
        }
 
    public:
        unsigned getCount() const noexcept
        {
            return static_cast<unsigned>(descriptors.size());
        }
 
        const std::vector<Descriptor>& getDescriptors() const noexcept
        {
            return descriptors;
        }
 
        unsigned getLength() const noexcept
        {
            return length;
        }
 
        unsigned getBlrFieldIndex(unsigned index) const
        {
            if (index >= blrFieldIndexes.size())
                throw std::out_of_range("index out of range");
 
            return blrFieldIndexes[index];
        }
 
        std::vector<std::byte> buildBlrMessageClause(unsigned messageNumber) const;
 
    private:
        RequestMessageFormat& addField(DescriptorAdjustedType adjustedType, unsigned dataLength, unsigned alignment,
            int scale, unsigned charSetId, int subType, bool isNullable);
 
        static void appendByte(std::vector<std::byte>& blr, std::uint8_t value)
        {
            blr.push_back(static_cast<std::byte>(value));
        }
 
        static void appendWord(std::vector<std::byte>& blr, std::uint16_t value)
        {
            blr.push_back(static_cast<std::byte>(value & 0xffu));
            blr.push_back(static_cast<std::byte>((value >> 8) & 0xffu));
        }
 
        void appendBlrDataType(std::vector<std::byte>& blr, const Descriptor& descriptor) const;
 
    private:
        std::vector<Descriptor> descriptors;
        std::vector<unsigned> blrFieldIndexes;
        unsigned nullableCount = 0;
        unsigned length = 0;
    };
}  // namespace fbcpp::request
 
 
#endif  // FBCPP_REQUEST_MESSAGE_FORMAT_H