MemBuffer.hh

Go to the documentation of this file.

#ifndef MEMBUFFER_HH
#define MEMBUFFER_HH
 
#include "MemoryOps.hh"
#include <algorithm>
#include <new>      // for bad_alloc
#include <cstddef>
#include <cstdlib>
#include <cassert>
 
namespace openmsx {
 
template<typename T, size_t ALIGNMENT = 0> class MemBuffer
{
public:
        MemBuffer()
                : dat(nullptr)
#ifdef DEBUG
                , sz(0)
#endif
        {
        }
 
        explicit MemBuffer(size_t size)
                : dat(static_cast<T*>(my_malloc(size * sizeof(T))))
#ifdef DEBUG
                , sz(size)
#endif
        {
        }
 
        MemBuffer(MemBuffer&& other) noexcept
                : dat(other.dat)
#ifdef DEBUG
                , sz(other.sz)
#endif
        {
                other.dat = nullptr;
        }
 
        MemBuffer& operator=(MemBuffer&& other) noexcept
        {
                std::swap(dat, other.dat);
#ifdef DEBUG
                std::swap(sz , other.sz);
#endif
                return *this;
        }
 
        ~MemBuffer()
        {
                my_free(dat);
        }
 
        [[nodiscard]] const T* data() const { return dat; }
        [[nodiscard]]       T* data()       { return dat; }
 
        [[nodiscard]] const T& operator[](size_t i) const
        {
#ifdef DEBUG
                assert(i < sz);
#endif
                return dat[i];
        }
        [[nodiscard]] T& operator[](size_t i)
        {
#ifdef DEBUG
                assert(i < sz);
#endif
                return dat[i];
        }
 
        [[nodiscard]] bool empty() const { return !dat; }
 
        void resize(size_t size)
        {
                if (size) {
                        dat = static_cast<T*>(my_realloc(dat, size * sizeof(T)));
#ifdef DEBUG
                        sz = size;
#endif
                } else {
                        clear();
                }
        }
 
        void clear()
        {
                my_free(dat);
                dat = nullptr;
#ifdef DEBUG
                sz = 0;
#endif
        }
 
        void swap(MemBuffer& other) noexcept
        {
                std::swap(dat, other.dat);
#ifdef DEBUG
                std::swap(sz , other.sz );
#endif
        }
 
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]] void* my_malloc(size_t bytes)
        {
                void* result;
                if constexpr (SIMPLE_MALLOC) {
                        result = malloc(bytes);
                        if (!result && bytes) throw std::bad_alloc();
                } else {
                        // already throws bad_alloc in case of error
                        result = MemoryOps::mallocAligned(ALIGNMENT, bytes);
                }
                return result;
        }
 
        void my_free(void* p)
        {
                if constexpr (SIMPLE_MALLOC) {
                        free(p);
                } else {
                        MemoryOps::freeAligned(p);
                }
        }
 
        [[nodiscard]] void* my_realloc(void* old, size_t bytes)
        {
                void* result;
                if constexpr (SIMPLE_MALLOC) {
                        result = realloc(old, bytes);
                        if (!result && bytes) throw std::bad_alloc();
                } else {
                        result = MemoryOps::mallocAligned(ALIGNMENT, bytes);
                        if (!result && bytes) throw std::bad_alloc();
                        MemoryOps::freeAligned(old);
                }
                return result;
        }
 
private:
        T* dat;
#ifdef DEBUG
        size_t sz;
#endif
};
 
} // namespace openmsx
 
namespace std {
        template<typename T>
        void swap(openmsx::MemBuffer<T>& l, openmsx::MemBuffer<T>& r) noexcept
        {
                l.swap(r);
        }
}
 
#endif