trivial_buffer.h

Go to the documentation of this file.

#pragma once
 
#include "../utility/assert.h"
 
#include <cstring>
#include <iterator>
#include <memory>
#include <utility>
 
namespace ktl
{
    template<typename T, size_t Size>
    class trivial_buffer
    {
    private:
        static_assert(std::is_default_constructible<T>::value, "Template class needs to be default constructible");
        static_assert(std::is_trivially_copyable<T>::value, "Template class needs to be trivially copyable");
 
    public:
        typedef T* iterator;
        typedef const T* const_iterator;
 
        typedef std::reverse_iterator<T*> reverse_iterator;
        typedef std::reverse_iterator<const T*> const_reverse_iterator;
 
    public:
        trivial_buffer() noexcept {}
 
        explicit trivial_buffer(const T& value)
        {
            std::uninitialized_fill_n<T*, size_t>(reinterpret_cast<T*>(m_Data), Size, value);
        }
 
        trivial_buffer(std::initializer_list<T> initializer)
        {
            KTL_ASSERT(initializer.size() <= Size);
 
            T* dst = reinterpret_cast<T*>(m_Data);
            for (auto value : initializer)
            {
                *dst = value;
                dst++;
            }
        }
 
        explicit trivial_buffer(const T* first, const T* last)
        {
            KTL_ASSERT(last - first == Size);
 
            std::memcpy(m_Data, first, Size * sizeof(T));
        }
 
        trivial_buffer(const trivial_buffer& other) noexcept
        {
            std::memcpy(m_Data, other.m_Data, Size * sizeof(T));
        }
 
        trivial_buffer(trivial_buffer&& other) noexcept
        {
            std::memcpy(m_Data, other.m_Data, Size * sizeof(T));
        }
 
        trivial_buffer& operator=(const trivial_buffer& other) noexcept
        {
            std::memcpy(m_Data, other.m_Data, Size * sizeof(T));
            return *this;
        }
 
        trivial_buffer& operator=(trivial_buffer&& other) noexcept
        {
            std::memcpy(m_Data, other.m_Data, Size * sizeof(T));
            return *this;
        }
 
        T& operator[](size_t index) noexcept { return reinterpret_cast<T*>(m_Data)[index % Size]; }
 
        const T& operator[](size_t index) const noexcept { return reinterpret_cast<T*>(m_Data)[index % Size]; }
 
 
        iterator begin() noexcept { return m_Data; }
 
        const_iterator begin() const noexcept { return m_Data; }
 
        iterator end() noexcept { return m_Data + Size; }
 
        const_iterator end() const noexcept { return m_Data + Size; }
 
        std::reverse_iterator<T*> rbegin() noexcept { return std::reverse_iterator(m_Data + Size); }
 
        std::reverse_iterator<const T*> rbegin() const noexcept { return std::reverse_iterator(m_Data + Size); }
 
        std::reverse_iterator<T*> rend() noexcept { return std::reverse_iterator(m_Data); }
 
        std::reverse_iterator<const T*> rend() const noexcept { return std::reverse_iterator(m_Data); }
 
 
        constexpr size_t size() const noexcept { return Size; }
 
        iterator data() noexcept { return m_Data; }
 
        const_iterator data() const noexcept { return m_Data; }
 
        T& at(size_t index) const noexcept { return reinterpret_cast<T*>(m_Data)[index % Size]; }
 
 
        void assign(const T* first, const T* last)
        {
            KTL_ASSERT(last - first == Size);
 
            std::memcpy(m_Data, first, Size * sizeof(T));
        }
 
    private:
        uint8_t m_Data[Size * sizeof(T)];
    };
}