Array.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_ARRAY_H
#define FBCPP_ARRAY_H
 
#include "fb-cpp-export.h"
#include "fb-api.h"
#include "Descriptor.h"
#include <cstddef>
#include <optional>
#include <span>
#include <string>
#include <type_traits>
#include <vector>
 
 
namespace fbcpp
{
    class Attachment;
    class Transaction;
 
    class ArrayId final
    {
    public:
        bool isEmpty() const noexcept
        {
            return id.gds_quad_high == 0 && id.gds_quad_low == 0;
        }
 
    public:
        ISC_QUAD id{0, 0};
    };
 
    struct ArrayBound final
    {
        short lower;
 
        short upper;
    };
 
    struct ArrayDescriptor final
    {
        std::string relation;
 
        std::string field;
 
        DescriptorOriginalType elementType;
 
        int scale;
 
        unsigned elementLength;
 
        std::vector<ArrayBound> bounds;
    };
 
    class FB_CPP_EXPORT Array final
    {
    public:
        Array(Attachment& attachment, Transaction& transaction, ArrayDescriptor descriptor, ArrayId id = {});
 
        Array(const Array&) = delete;
        Array& operator=(const Array&) = delete;
        Array(Array&&) = delete;
        Array& operator=(Array&&) = delete;
 
    public:
        const ArrayId& getId() const noexcept
        {
            return id;
        }
 
        const ArrayDescriptor& getDescriptor() const noexcept
        {
            return descriptor;
        }
 
        std::size_t getSliceLength() const;
 
        unsigned read(std::span<std::byte> buffer);
 
        void write(std::span<const std::byte> buffer);
 
        template <typename T, std::size_t Extent>
        requires(!std::is_same_v<std::remove_cv_t<T>, std::byte>)
        unsigned read(std::span<T, Extent> buffer)
        {
            static_assert(std::is_trivially_copyable_v<T>);
            return read(std::as_writable_bytes(buffer));
        }
 
        template <typename T, std::size_t Extent>
        requires(!std::is_same_v<std::remove_cv_t<T>, std::byte>)
        void write(std::span<const T, Extent> buffer)
        {
            static_assert(std::is_trivially_copyable_v<T>);
            write(std::as_bytes(buffer));
        }
 
    private:
        void validateBuffer(std::size_t size) const;
        ISC_ARRAY_DESC buildIscDescriptor() const;
 
    private:
        Attachment& attachment;
        Transaction& transaction;
        ArrayDescriptor descriptor;
        ArrayId id;
    };
}  // namespace fbcpp
 
 
#endif  // FBCPP_ARRAY_H