MemBuffer.hh

Go to the documentation of this file.

#ifndef MEMBUFFER_HH
#define MEMBUFFER_HH
 
#include "MemoryOps.hh"
 
#include <algorithm>
#include <cstddef>
#include <cstdlib>
#include <cassert>
#include <new>      // for bad_alloc
#include <span>
#include <type_traits>
 
namespace openmsx {
 
template<typename T, size_t ALIGNMENT = 0> class MemBuffer
{
        static_assert(std::is_trivially_copyable_v<T>);
        static_assert(std::is_trivially_destructible_v<T>);
public:
        MemBuffer()
                : dat(nullptr)
                , sz(0)
        {
        }
 
        explicit MemBuffer(size_t size)
                : dat(static_cast<T*>(my_malloc(size * sizeof(T))))
                , sz(size)
        {
        }
 
        MemBuffer(MemBuffer&& other) noexcept
                : dat(other.dat)
                , sz(other.sz)
        {
                other.dat = nullptr;
                other.sz = 0;
        }
 
        MemBuffer& operator=(MemBuffer&& other) noexcept
        {
                std::swap(dat, other.dat);
                std::swap(sz , other.sz);
                return *this;
        }
 
        ~MemBuffer()
        {
                my_free(dat);
        }
 
        [[nodiscard]] const T* data() const { return dat; }
        [[nodiscard]]       T* data()       { return dat; }
 
        [[nodiscard]]       T* begin()       { return data(); }
        [[nodiscard]] const T* begin() const { return data(); }
        [[nodiscard]]       T* end()         { return data() + size(); }
        [[nodiscard]] const T* end()   const { return data() + size(); }
 
        [[nodiscard]] const T& operator[](size_t i) const
        {
                assert(i < sz);
                return dat[i];
        }
        [[nodiscard]] T& operator[](size_t i)
        {
                assert(i < sz);
                return dat[i];
        }
 
        [[nodiscard]] bool empty() const { return sz == 0; }
        [[nodiscard]] size_t size() const { return sz; }
 
        [[nodiscard]] T& front()
        {
                assert(!empty());
                return dat[0];
        }
        [[nodiscard]] const T& front() const
        {
                assert(!empty());
                return dat[0];
        }
        [[nodiscard]] T& back()
        {
                assert(!empty());
                return dat[sz - 1];
        }
        [[nodiscard]] const T& back() const
        {
                assert(!empty());
                return dat[sz - 1];
        }
 
        [[nodiscard]] operator std::span<      T>()       { return {data(), size()}; }
        [[nodiscard]] operator std::span<const T>() const { return {data(), size()}; }
 
        [[nodiscard]] std::span<const T> first(size_t n) const
        {
                assert(n <= sz);
                return std::span{*this}.first(n);
        }
        [[nodiscard]] std::span<T> first(size_t n)
        {
                assert(n <= sz);
                return std::span{*this}.first(n);
        }
        [[nodiscard]] std::span<const T> subspan(size_t offset, size_t n = std::dynamic_extent) const
        {
                assert(offset <= sz);
                assert(n == std::dynamic_extent || (offset + n <= sz));
                return std::span{*this}.subspan(offset, n);
        }
        [[nodiscard]] std::span<T> subspan(size_t offset, size_t n = std::dynamic_extent)
        {
                assert(offset <= sz);
                assert(n == std::dynamic_extent || (offset + n <= sz));
                return std::span{*this}.subspan(offset, n);
        }
 
        void resize(size_t size)
        {
                if (size) {
                        dat = static_cast<T*>(my_realloc(dat, size * sizeof(T)));
                        sz = size;
                } else {
                        clear();
                }
        }
 
        void clear()
        {
                my_free(dat);
                dat = nullptr;
                sz = 0;
        }
 
private:
        // If the requested alignment is less or equally strict than the
        // guaranteed alignment by the standard malloc()-like functions
        // we use those. Otherwise we use platform specific functions to
        // request aligned memory.
        // A valid alternative would be to always use the platform specific
        // functions. The only disadvantage is that we cannot use realloc()
        // in that case (there are no, not even platform specific, functions
        // to realloc memory with bigger than default alignment).
        static constexpr bool SIMPLE_MALLOC = ALIGNMENT <= alignof(std::max_align_t);
 
        [[nodiscard]] static void* my_malloc(size_t bytes)
        {
                if constexpr (SIMPLE_MALLOC) {
                        void* result = malloc(bytes);
                        if (!result && bytes) throw std::bad_alloc();
                        return result;
                } else {
                        // already throws bad_alloc in case of error
                        return MemoryOps::mallocAligned(ALIGNMENT, bytes);
                }
        }
 
        static void my_free(void* p)
        {
                if constexpr (SIMPLE_MALLOC) {
                        free(p);
                } else {
                        MemoryOps::freeAligned(p);
                }
        }
 
        [[nodiscard]] void* my_realloc(void* old, size_t bytes)
        {
                if constexpr (SIMPLE_MALLOC) {
                        void* result = realloc(old, bytes);
                        if (!result && bytes) throw std::bad_alloc();
                        return result;
                } else {
                        void* result = MemoryOps::mallocAligned(ALIGNMENT, bytes);
                        if (!result && bytes) throw std::bad_alloc();
                        MemoryOps::freeAligned(old);
                        return result;
                }
        }
 
private:
        T* dat;
        size_t sz;
};
 
} // namespace openmsx
 
#endif