u8_buffer.hpp

Go to the documentation of this file.

// Copyright 2024 Man Group Operations Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <ranges>
#include <type_traits>
 
#include "sparrow/buffer/allocator.hpp"
#include "sparrow/buffer/buffer.hpp"
#include "sparrow/buffer/buffer_adaptor.hpp"
#include "sparrow/debug/copy_tracker.hpp"
#include "sparrow/utils/ranges.hpp"
 
namespace sparrow
{
    namespace copy_tracker
    {
        template <typename T>
        std::string key_u8_buffer()
        {
            return "u8_buffer<" + std::string(typeid(T).name()) + ">";
        }
    }
 
    namespace detail
    {
        template <class T>
        class holder
        {
        public:
 
            using inner_type = T;

            template <class... Args>
            constexpr holder(Args&&... args) noexcept
                : value(std::forward<Args>(args)...)
            {
            }
 
            T value;

            [[nodiscard]] constexpr T extract_storage() && noexcept
            {
                return std::move(value);
            }

            [[nodiscard]] constexpr const T& storage() const noexcept
            {
                return value;
            }

            [[nodiscard]] constexpr T& storage() noexcept
            {
                return value;
            }

            constexpr void assign(T&& other)
            {
                value = std::move(other);
            }
        };
    }

    template <class T>
    class u8_buffer : private detail::holder<buffer<std::uint8_t>>,
                      public buffer_adaptor<T, buffer<std::uint8_t>&>
    {
    public:
 
        using buffer_type = buffer<std::uint8_t>;
        using holder_type = detail::holder<buffer_type>;
        using buffer_adaptor_type = buffer_adaptor<T, buffer_type&>;
        using holder_type::extract_storage;
        using default_allocator = buffer_type::default_allocator;

        constexpr u8_buffer(u8_buffer&& other) noexcept;

        constexpr u8_buffer(const u8_buffer& other);

        u8_buffer& operator=(u8_buffer&& other) = delete;

        u8_buffer& operator=(u8_buffer& other) = delete;

        ~u8_buffer() = default;

        constexpr explicit u8_buffer(std::size_t n);

        constexpr u8_buffer(std::size_t n, const T& val);

        template <std::ranges::input_range R>
            requires(
                !std::same_as<u8_buffer<T>, std::decay_t<R>>
                && std::convertible_to<std::ranges::range_value_t<R>, T>
            )
        constexpr explicit u8_buffer(R&& range);

        constexpr u8_buffer(std::initializer_list<T> ilist);

        template <allocator A>
        constexpr u8_buffer(T* data_ptr, std::size_t count, const A& a);
    };
 
    template <class T>
    constexpr u8_buffer<T>::u8_buffer(u8_buffer&& other) noexcept
        : holder_type(std::move(other).extract_storage())
        , buffer_adaptor_type(holder_type::value)
    {
    }
 
    template <class T>
    constexpr u8_buffer<T>::u8_buffer(const u8_buffer& other)
        : holder_type(other.storage())
        , buffer_adaptor_type(holder_type::value)
    {
        copy_tracker::increase(copy_tracker::key_u8_buffer<T>());
    }
 
    template <class T>
    constexpr u8_buffer<T>::u8_buffer(std::size_t n)
        : holder_type{n * sizeof(T), typename buffer_type::default_allocator{}}
        , buffer_adaptor_type(holder_type::value)
    {
    }
 
    template <class T>
    constexpr u8_buffer<T>::u8_buffer(std::size_t n, const T& val)
        : u8_buffer(n)
    {
        std::fill(this->begin(), this->end(), val);
    }
 
    template <class T>
    template <std::ranges::input_range R>
        requires(
            !std::same_as<u8_buffer<T>, std::decay_t<R>> && std::convertible_to<std::ranges::range_value_t<R>, T>
        )
    constexpr u8_buffer<T>::u8_buffer(R&& range)
        : u8_buffer(range_size(range))
    {
        sparrow::ranges::copy(range, this->begin());
    }
 
    template <class T>
    constexpr u8_buffer<T>::u8_buffer(std::initializer_list<T> ilist)
        : u8_buffer(ilist.size())
    {
        std::copy(ilist.begin(), ilist.end(), this->begin());
    }
 
    template <class T>
    template <allocator A>
    constexpr u8_buffer<T>::u8_buffer(T* data_ptr, std::size_t count, const A& a)
        : holder_type{reinterpret_cast<uint8_t*>(data_ptr), count * sizeof(T), a}
        , buffer_adaptor_type(holder_type::value)
    {
    }
}