blob_iface.hpp

/*
 Copyright 2024 Eugene Gershnik
 
 Use of this source code is governed by a BSD-style
 license that can be found in the LICENSE file or at
 https://github.com/gershnik/thinsqlitepp/blob/main/LICENSE
*/
 
#ifndef HEADER_SQLITEPP_BLOB_IFACE_INCLUDED
#define HEADER_SQLITEPP_BLOB_IFACE_INCLUDED
 
#include "handle.hpp"
#include "exception_iface.hpp"
#include "string_param.hpp"
#include "span.hpp"
 
namespace thinsqlitepp
{
 
    class blob final : public handle<sqlite3_blob, blob>
    {
    public:
        ~blob() noexcept
            { sqlite3_blob_close(c_ptr()); }
 
 
        void reopen(int64_t rowid)
        {
            int res = sqlite3_blob_reopen(c_ptr(), rowid);
            if (res != SQLITE_OK)
                throw exception(res); //we do not know the db here, unfortunately
        }
 
        size_t bytes() const noexcept
        { 
            int ret = sqlite3_blob_bytes(c_ptr());
            return ret >= 0 ? ret : 0;
        } 
 
        void read(size_t offset, span<std::byte> dest) const
        {
            int res = sqlite3_blob_read(c_ptr(), dest.data(), int_size(dest.size()), int_size(offset));
            if (res != SQLITE_OK)
                throw exception(res); //we do not know the db here, unfortunately
        }
 
    #if __cpp_lib_ranges >= 201911L
 
        template<std::ranges::contiguous_range R>
        requires(std::is_trivially_copyable_v<std::ranges::range_value_t<R>> &&
                 !std::is_const_v<std::remove_reference_t<std::ranges::range_reference_t<R>>>)
        void read(size_t offset, R & range) const
        {
            using value_type = std::remove_reference_t<std::ranges::range_reference_t<R>>;
            auto data = std::data(range);
            auto size = std::size(range);
            if (size > std::numeric_limits<int>::max() / sizeof(value_type))
                throw exception(SQLITE_TOOBIG);
            int res = sqlite3_blob_read(c_ptr(), data, int(size * sizeof(value_type)), int_size(offset));
            if (res != SQLITE_OK)
                throw exception(res); //we do not know the db here, unfortunately
        }
 
    #endif
 
        void write(size_t offset, span<const std::byte> src)
        {
            int res = sqlite3_blob_write(c_ptr(), src.data(), int_size(src.size()), int_size(offset));
            if (res != SQLITE_OK)
                throw exception(res); //we do not know the db here, unfortunately
        }
 
        void write(size_t offset, span<std::byte> src)
            { write(offset, span<const std::byte>(src)); }
 
    #if __cpp_lib_ranges >= 201911L
 
        template<std::ranges::contiguous_range R>
        requires(std::is_trivially_copyable_v<std::ranges::range_value_t<R>>)
        void write(size_t offset, R range) const
        {
            using value_type = std::remove_reference_t<std::ranges::range_reference_t<R>>;
            auto data = std::data(range);
            auto size = std::size(range);
            if (size > std::numeric_limits<int>::max() / sizeof(value_type))
                throw exception(SQLITE_TOOBIG);
            int res = sqlite3_blob_write(c_ptr(), data, int(size * sizeof(value_type)), int_size(offset));
            if (res != SQLITE_OK)
                throw exception(res); //we do not know the db here, unfortunately
        }
 
    #endif
    };
 
 
}
 
 
#endif