buffers.h

 
 
#pragma once
 
#include "bytes.h"
 
namespace ghassanpl
{
    namespace detail
    {
        template <typename BUFFER>
        consteval auto deduce_buffer_element_type() noexcept
        {
            if constexpr (requires { typename BUFFER::value_type; })
                return std::type_identity<typename BUFFER::value_type>{};
            else if constexpr (requires { typename BUFFER::char_type; })
                return std::type_identity<typename BUFFER::char_type>{};
        }
    }
 
    
 
    template <typename BUFFER>
    using buffer_element_type = typename decltype(detail::deduce_buffer_element_type<BUFFER>())::type;
 
    template <typename BUFFER, typename T>
    bool buffer_append(BUFFER&& buffer, T&& val)
    {
        if constexpr (requires { buffer.append(val); })
        {
            buffer.append(val);
            return true;
        }
        else if constexpr (requires { buffer.push_back(val); })
        {
            buffer.push_back(val);
            return true;
        }
        else if constexpr (requires { buffer.insert(buffer.end(), val); })
        {
            buffer.insert(buffer.end(), val);
            return true;
        }
        else if constexpr (requires { buffer.put(val); }) 
        {
            buffer.put(val);
            return true;
        }
        else
        {
            static_assert(!std::same_as<T, T>, "buffer cannot be appended with this value type - buffer_append might need to be specialized");
            return false;
        }
    }
 
    template <typename BUFFER, typename ELEMENT_VALUE>
    concept output_buffer = requires (BUFFER buffer, ELEMENT_VALUE val) {
        ::ghassanpl::buffer_append(buffer, val);
    };
 
    template <typename BUFFER>
    bool buffer_reserve(BUFFER& buffer, size_t additional)
    {
        if constexpr (requires { buffer.reserve(std::ranges::size(buffer) + additional); })
        {
            buffer.reserve(std::ranges::size(buffer) + additional);
            return true;
        }
        else
            return false;
    }
 
    template <typename BUFFER, typename RANGE>
    requires output_buffer<BUFFER, std::ranges::range_value_t<RANGE>>
    size_t buffer_append_range(BUFFER& buffer, RANGE&& range)
    {
        if constexpr (std::ranges::sized_range<RANGE>)
            buffer_reserve(buffer, std::ranges::size(range));
 
        /*
                if constexpr (requires { buffer.append(val); })
        {
            buffer.append(val);
            return true;
        }
        else if constexpr (requires { buffer.push_back(val); })
        {
            buffer.push_back(val);
            return true;
        }
        else if constexpr (requires { buffer.insert(buffer.end(), val); })
        {
            buffer.insert(buffer.end(), val);
            return true;
        }
        else 
        */
        if constexpr (requires { buffer.append(std::to_address(std::ranges::begin(range)), std::ranges::size(range)); } && std::ranges::sized_range<RANGE>) 
        {
            const auto size = std::ranges::size(range);
            buffer.append(std::to_address(std::ranges::begin(range)), size);
            return size;
        }
        else if constexpr (requires { buffer.write(std::to_address(std::ranges::begin(range)), std::ranges::size(range)); } && std::ranges::sized_range<RANGE>) 
        {
            const auto size = std::ranges::size(range);
            buffer.write(std::to_address(std::ranges::begin(range)), size);
            return size;
        }
        else
        {
            size_t count = 0;
            for (auto&& value : std::forward<RANGE>(range))
            {
                if (!buffer_append(buffer, value))
                    break;
                ++count;
            }
            return count;
        }
    }
 
    template <typename BUFFER, typename CHAR_TYPE>
    requires output_buffer<BUFFER, CHAR_TYPE>
    size_t buffer_append_cstring_ptr(BUFFER& buffer, const CHAR_TYPE* cstr)
    {
        return buffer_append_range(buffer, cstr, cstr + std::char_traits<CHAR_TYPE>::length(cstr));
    }
 
    template <typename BUFFER, typename CHAR_TYPE>
    requires output_buffer<BUFFER, CHAR_TYPE>
    size_t buffer_append_cstring_ptr(BUFFER& buffer, const CHAR_TYPE* cstr, size_t max_len)
    {
        return buffer_append_range(buffer, cstr, cstr + std::min(max_len, std::char_traits<CHAR_TYPE>::length(cstr)));
    }
 
    template <typename BUFFER, size_t N, typename CHAR_TYPE>
    requires output_buffer<BUFFER, CHAR_TYPE>
    size_t buffer_append_cstring(BUFFER& buffer, const CHAR_TYPE(&cstr)[N])
    {
        return buffer_append_range(buffer, cstr, cstr + (N - 1));
    }
 
    template <typename BUFFER, typename ELEMENT_TYPE = buffer_element_type<BUFFER>>
    requires output_buffer<BUFFER, ELEMENT_TYPE>
    size_t buffer_append_utf8(BUFFER& buffer, char32_t cp)
    {
        size_t result = 0;
        if (cp < 0x80)
        {
            result += buffer_append(buffer, static_cast<ELEMENT_TYPE>(cp));
        }
        else if (cp < 0x800) {
            result += buffer_append(buffer, static_cast<ELEMENT_TYPE>((cp >> 6) | 0xc0));
            result += buffer_append(buffer, static_cast<ELEMENT_TYPE>((cp & 0x3f) | 0x80));
        }
        else if (cp < 0x10000) {
            result += buffer_append(buffer, static_cast<ELEMENT_TYPE>((cp >> 12) | 0xe0));
            result += buffer_append(buffer, static_cast<ELEMENT_TYPE>(((cp >> 6) & 0x3f) | 0x80));
            result += buffer_append(buffer, static_cast<ELEMENT_TYPE>((cp & 0x3f) | 0x80));
        }
        else {
            result += buffer_append(buffer, static_cast<ELEMENT_TYPE>((cp >> 18) | 0xf0));
            result += buffer_append(buffer, static_cast<ELEMENT_TYPE>(((cp >> 12) & 0x3f) | 0x80));
            result += buffer_append(buffer, static_cast<ELEMENT_TYPE>(((cp >> 6) & 0x3f) | 0x80));
            result += buffer_append(buffer, static_cast<ELEMENT_TYPE>((cp & 0x3f) | 0x80));
        }
        return result;
    }
 
    template <typename BUFFER, typename STRING_TYPE, typename ELEMENT_TYPE = buffer_element_type<BUFFER>>
    requires output_buffer<BUFFER, ELEMENT_TYPE> && std::ranges::range<STRING_TYPE> && std::same_as<std::ranges::range_value_t<STRING_TYPE>, char32_t>
    size_t buffer_append_utf8(BUFFER& buffer, STRING_TYPE&& str)
    {
        size_t count = 0;
        for (auto cp : str)
            count += buffer_append_utf8(buffer, cp);
        return count;
    }
 
    template <typename BUFFER, typename POD>
    requires std::is_trivially_copyable_v<POD> && bytelike<buffer_element_type<BUFFER>>
    size_t buffer_append_pod(BUFFER& buffer, POD const& pod)
    {
        return buffer_append_range(buffer, as_bytelikes<buffer_element_type<BUFFER>, POD>(pod));
    }
 
    template <typename BUFFER, typename CALLBACK>
    requires std::invocable<CALLBACK, size_t, std::string_view, BUFFER&>
    void callback_format_to(BUFFER& buffer, std::string_view fmt, CALLBACK&& callback)
    {
        size_t aid = 0;
        while (!fmt.empty())
        {
            auto text = consume_until(fmt, '{');
            buffer_append_range(buffer, text);
            if (fmt.empty())
                continue;
            std::ignore = consume(fmt, '{');
 
            if (consume(fmt, '{'))
            {
                buffer_append_range(buffer, '{');
                continue;
            }
            else
            {
                std::string fmt_clause_str = "{";
                auto fmt_clause = string_ops::consume_until_delim(fmt, '}');
                if (!string_ops::consume_at_end(fmt_clause, '}'))
                    throw std::format_error("missing '}' in format string");
                if (!fmt_clause.empty())
                {
                    auto num = string_ops::consume_until(fmt_clause, ':');
                    if (!num.empty())
                        aid = string_ops::stoull(num);
                    fmt_clause_str += fmt_clause;
                }
                fmt_clause_str += '}';
                callback(aid, std::string_view{ fmt_clause_str }, buffer);
                ++aid;
            }
        }
    }
 
}