MemBuffer.hh

Go to the documentation of this file.

#ifndef MEMBUFFER_HH
#define MEMBUFFER_HH

#include "noncopyable.hh"
#include <algorithm>
#include <new>      // for bad_alloc
#include <cstdlib>
#include <cassert>

namespace openmsx {

template<typename T> class MemBuffer //: private noncopyable
{
public:
        MemBuffer()
                : dat(nullptr)
                , sz(0)
        {
        }

        explicit MemBuffer(size_t size)
                : dat(static_cast<T*>(malloc(size * sizeof(T))))
                , sz(size)
        {
                if (size && !dat) {
                        throw std::bad_alloc();
                }
        }

        MemBuffer(T* data, size_t size)
                : dat(data)
                , sz(size)
        {
        }

        MemBuffer(MemBuffer&& other)
                : dat(other.dat)
                , sz(other.sz)
        {
                other.dat = nullptr;
        }

        MemBuffer& operator=(MemBuffer&& other)
        {
                std::swap(dat, other.dat);
                std::swap(sz , other.sz);
                return *this;
        }

        ~MemBuffer()
        {
                free(dat);
        }

        const T* data() const { return dat; }
              T* data()       { return dat; }

        const T& operator[](size_t i) const
        {
                assert(i < sz);
                return dat[i];
        }
        T& operator[](size_t i)
        {
                assert(i < sz);
                return dat[i];
        }

        size_t size() const { return sz; }

        bool empty() const { return sz == 0; }

        void resize(size_t size)
        {
                if (size) {
                        auto newDat = static_cast<T*>(realloc(dat, size * sizeof(T)));
                        if (!newDat) {
                                throw std::bad_alloc();
                        }
                        dat = newDat;
                        sz = size;
                } else {
                        // realloc() can handle zero-size allocactions,
                        // but then we anyway still need to check for
                        // 'size == 0' for the error handling.
                        clear();
                }
        }

        void clear()
        {
                free(dat);
                dat = nullptr;
                sz = 0;
        }

        const T* begin() const { return dat; }
              T* begin()       { return dat; }
        const T* end()   const { return dat + sz; }
              T* end()         { return dat + sz; }

        void swap(MemBuffer& other)
        {
                std::swap(dat, other.dat);
                std::swap(sz , other.sz );
        }

private:
        T* dat;
        size_t sz;
};

} // namespace openmsx

namespace std {
        template<typename T>
        void swap(openmsx::MemBuffer<T>& l, openmsx::MemBuffer<T>& r)
        {
                l.swap(r);
        }
}

#endif