buffer.h

Go to the documentation of this file.

 
#pragma once
#include <cstring>
#include <cstdint>
#include <cassert>
#include <initializer_list>
 
template<typename T>
struct Buffer {
    T *buf;
    size_t len;
    size_t size;
    operator T*() { return buf; }
    //XXX: how about a slice into a buffer?
 
    T& at(size_t ix) {
        assert(ix < len);
        return buf[ix];
    }
    T& operator[](size_t ix) {
        assert(ix < size);
        return buf[ix];
    }
    T& operator[](size_t ix) const {
        assert(ix < size);
        return buf[ix];
    }
    Buffer& append(T b) {
        assert(len < size);
        buf[len++] = b;
        return *this;
    }
    Buffer& append(std::initializer_list<T> list) {
        for (auto v: list) append(v);
        return *this;
    }
    T* begin() { return &buf[0]; }
    T* begin() const { return &buf[0]; }
    T* end() { return &buf[len]; }
    T* end() const { return &buf[len]; }
 
    /* Rule of Five */
    ~Buffer() {
        delete[] buf; buf = nullptr; len = 0; size = 0;
    }
    Buffer(const T *src, size_t len, size_t sz=0) : buf{}, len(0), size(sz) {
        if (sz == 0) size = len;
        buf = new T[size];
        for (size_t i = 0; i < len; ++i) append(src[i]);
    }
    Buffer(std::initializer_list<T> list) : buf{new T[list.size()]}, len(0), size(list.size()) {
        append(list);
    }
    Buffer(size_t sz=0) : buf{new T[sz]}, len(0), size(sz) { }
    Buffer(const Buffer &b) : buf{new T[b.size]}, len(0), size(b.size) {
        for (auto el : b) append(el);
    }
    Buffer& operator=(const Buffer &b) {
        if (this == &b) return *this; // copy to self
        if (!size || size != b.size) { // necessary to realloc
            delete[] buf;
            buf = new T[b.size];
            size = b.size;
        }
        assert(buf != nullptr);
        assert(size >= b.len);
        len = 0;
        for (auto el: b) append(el);
        return *this;
    }
    Buffer(Buffer &&b) noexcept : buf(b.buf), len(b.len), size(b.size) {
        b.buf = nullptr;
        b.len = 0;
        b.size = 0;
    }
    Buffer& operator=(Buffer &&b) noexcept {
        if (this == &b) return *this; // move to self
        delete[] buf;
        buf = b.buf;
        len = b.len;
        size = b.size;
        b.len = 0;
        b.size = 0;
        b.buf = nullptr;
        return *this;
    }
};