Blob.h

/*
 * MIT License
 *
 * Copyright (c) 2025 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 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_BLOB_H
#define FBCPP_BLOB_H
 
#include "fb-api.h"
#include "SmartPtrs.h"
#include "Exception.h"
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <span>
#include <utility>
#include <vector>
 
 
namespace fbcpp
{
    class Attachment;
    class Transaction;
 
    class BlobId final
    {
    public:
        bool isEmpty() const noexcept
        {
            return id.gds_quad_high == 0 && id.gds_quad_low == 0;
        }
 
    public:
        ISC_QUAD id{0, 0};
    };
 
    enum class BlobStorage : std::uint8_t
    {
        MAIN = isc_bpb_storage_main,
        TEMPORARY = isc_bpb_storage_temp
    };
 
    enum class BlobType : std::uint8_t
    {
        SEGMENTED = isc_bpb_type_segmented,
        STREAM = isc_bpb_type_stream
    };
 
    class BlobOptions final
    {
    public:
        const std::vector<std::uint8_t>& getBpb() const noexcept
        {
            return bpb;
        }
 
        BlobOptions& setBpb(const std::vector<std::uint8_t>& value)
        {
            bpb = value;
            return *this;
        }
 
        BlobOptions& setBpb(std::vector<std::uint8_t>&& value)
        {
            bpb = std::move(value);
            return *this;
        }
 
        const std::optional<BlobType> getType() const
        {
            return type;
        }
 
        BlobOptions& setType(BlobType value)
        {
            type = value;
            return *this;
        }
 
        const std::optional<BlobType> getSourceType() const
        {
            return sourceType;
        }
 
        BlobOptions& setSourceType(BlobType value)
        {
            sourceType = value;
            return *this;
        }
 
        const std::optional<BlobType> getTargetType() const
        {
            return targetType;
        }
 
        BlobOptions& setTargetType(BlobType value)
        {
            targetType = value;
            return *this;
        }
 
        const std::optional<std::int16_t> getSourceCharSet() const
        {
            return sourceCharSet;
        }
 
        BlobOptions& setSourceCharSet(std::int16_t value)
        {
            sourceCharSet = value;
            return *this;
        }
 
        const std::optional<std::int16_t> getTargetCharSet() const
        {
            return targetCharSet;
        }
 
        BlobOptions& setTargetCharSet(std::int16_t value)
        {
            targetCharSet = value;
            return *this;
        }
 
        const std::optional<BlobStorage> getStorage() const
        {
            return storage;
        }
 
        BlobOptions& setStorage(BlobStorage value)
        {
            storage = value;
            return *this;
        }
 
    private:
        std::vector<std::uint8_t> bpb;
        std::optional<BlobType> type;
        std::optional<BlobType> sourceType;
        std::optional<BlobType> targetType;
        std::optional<std::int16_t> sourceCharSet;
        std::optional<std::int16_t> targetCharSet;
        std::optional<BlobStorage> storage;
    };
 
    enum class BlobSeekMode : int
    {
        FROM_BEGIN = 0,
        FROM_CURRENT = blb_seek_relative,
        FROM_END = blb_seek_from_tail
    };
 
    class Blob final
    {
    public:
        Blob(Attachment& attachment, Transaction& transaction, const BlobOptions& options = {});
 
        Blob(Attachment& attachment, Transaction& transaction, const BlobId& blobId, const BlobOptions& options = {});
 
        Blob(Blob&& o) noexcept
            : attachment{o.attachment},
              transaction{o.transaction},
              id{o.id},
              status{std::move(o.status)},
              statusWrapper{std::move(o.statusWrapper)},
              handle{std::move(o.handle)}
        {
        }
 
        Blob& operator=(Blob&&) = delete;
 
        Blob(const Blob&) = delete;
 
        Blob& operator=(const Blob&) = delete;
 
        ~Blob() noexcept
        {
            if (isValid())
            {
                try
                {
                    close();
                }
                catch (...)
                {
                    // swallow
                }
            }
        }
 
    public:
        bool isValid() const noexcept
        {
            return handle != nullptr;
        }
 
        const BlobId& getId() const noexcept
        {
            return id;
        }
 
        unsigned getLength();
 
        FbRef<fb::IBlob> getHandle() noexcept
        {
            return handle;
        }
 
        unsigned read(std::span<std::byte> buffer);
 
        unsigned read(std::span<char> buffer)
        {
            return read(std::as_writable_bytes(buffer));
        }
 
        unsigned readSegment(std::span<std::byte> buffer);
 
        unsigned readSegment(std::span<char> buffer)
        {
            return readSegment(std::as_writable_bytes(buffer));
        }
 
        void write(std::span<const std::byte> buffer);
 
        void write(std::span<const char> buffer)
        {
            write(std::as_bytes(buffer));
        }
 
        void writeSegment(std::span<const std::byte> buffer);
 
        void writeSegment(std::span<const char> buffer)
        {
            writeSegment(std::as_bytes(buffer));
        }
 
        int seek(BlobSeekMode mode, int offset);
 
        void cancel();
 
        void close();
 
    private:
        std::vector<std::uint8_t> prepareBpb(const BlobOptions& options);
 
    private:
        Attachment& attachment;
        Transaction& transaction;
        BlobId id;
        FbUniquePtr<fb::IStatus> status;
        impl::StatusWrapper statusWrapper;
        FbRef<fb::IBlob> handle;
    };
}  // namespace fbcpp
 
 
#endif  // FBCPP_BLOB_H