Allocation.h

Go to the documentation of this file.

#pragma once

 
#include <cstddef>
#include <memory>
#include <optional>
#include <utility>
#include <vector>
 
#include <EmrysFilter/Core/Macros.h>
 
namespace Emrys
{


using DefaultAllocator = std::allocator<std::byte>;

struct Capacity
{
    Eigen::Index count;  
};
 
namespace internal
{

template <typename Allocator, typename T>
using ReBound = typename std::allocator_traits<Allocator>::template rebind_alloc<T>;

template <typename T, typename Allocator>
class Buffer : public std::vector<T, ReBound<Allocator, T>>
{
public:
 
    using Base = std::vector<T, ReBound<Allocator, T>>;  
    using Base::Base;                                    
 
    Buffer() = default;  

    Buffer(Base const & vector)
        : Base(vector, vector.get_allocator())
    {}

    Buffer(Base && vector) noexcept
        : Base(std::move(vector))
    {}

    Buffer(Buffer const & other)
        : Buffer(other, other.get_allocator())
    {}

    Buffer(Buffer const & other, typename Base::allocator_type const & allocator)
        : Base(allocator)
    {
        this->reserve(other.capacity());
        this->assign(other.begin(), other.end());
    }
 
    Buffer(Buffer &&) noexcept = default;  

    Buffer &
    operator=(Buffer const &) = default;

    Buffer &
    operator=(Buffer &&) = default;
 
    ~Buffer() = default;
};

template <typename T, typename Allocator>
[[nodiscard]] Buffer<T, Allocator>
bufferOf(Allocator const & allocator)
{
    return Buffer<T, Allocator>(ReBound<Allocator, T>(allocator));
}

template <typename T>
struct AllocatorTypeOf
{};

template <typename T>
    requires requires { typename T::allocator_type; }
struct AllocatorTypeOf<T>
{
    using allocator_type = typename T::allocator_type;  
};
 
}  // namespace internal
 
}  // namespace Emrys