array.h

Go to the documentation of this file.

 
#pragma once
#include <b8/assert.h>
#include <cstddef>
#include <stdio.h>
#include <stdlib.h>
#include <trace.h>
 
namespace ArrayOptions {
    enum InitializationOption {
        Fill,   
        NoFill  
    };
}
 
template <typename T, size_t Capacity>
class b8array {
private:
    T* _buff = nullptr;  
    size_t _size = 0;    
 
    void alloc() {
        _buff = new T[Capacity + 1];
    }
 
    void clone(const b8array& obj) {
        if (_buff) {
            delete[] _buff;
        }
        _size = obj._size;
        alloc();
        for (size_t nn = 0; nn < _size; ++nn) {
            _buff[nn] = obj._buff[nn];
        }
    }
 
public:
    b8array(ArrayOptions::InitializationOption option = ArrayOptions::NoFill) {
        alloc();
        if (option == ArrayOptions::Fill) {
            T t{};
            for (size_t ii = 0; ii < Capacity; ++ii) {
                push_back(t);
            }
        }
    }
 
    b8array(std::initializer_list<T> il) {
        alloc();
        size_t index = 0;
        for (const auto& val : il) {
            _ASSERT(index < Capacity, "Capacity exceeded by initializer list");
            if (index < Capacity) {
                _buff[index++] = val;
                _size++;
            }
        }
    }
 
    b8array(const b8array& obj) {
        clone(obj);
    }
 
    b8array& operator=(const b8array& obj) {
        if (this != &obj) {
            clone(obj);
        }
        return *this;
    }
 
    ~b8array() {
        if (_buff) {
            delete[] _buff;
        }
    }
 
    bool empty() const {
        return _size == 0;
    }
 
    T* begin() {
        return _buff;
    }
 
    const T* cbegin() const {
        return _buff;
    }
 
    const T* cend() const {
        return _buff + _size;
    }
 
    T* end() {
        return _buff + _size;
    }
 
    const T* begin() const {
        return _buff;
    }
 
    const T* end() const {
        return _buff + _size;
    }
 
    T* erase(T* it_) {
        _ASSERT(it_ >= _buff && it_ < _buff + _size, "Invalid iterator");
        if (it_ < _buff || it_ >= _buff + _size) {
            return _buff + _size;
        }
        for (T* p = it_; p < _buff + _size - 1; ++p) {
            *p = *(p + 1);
        }
        --_size;
        return it_;
    }
 
    void clear() {
        _size = 0;
    }
 
    size_t size() const {
        return _size;
    }
 
    void push_back(const T& x_) {
        _ASSERT(_size < Capacity, "over flow");
        _buff[_size++] = x_;
    }
 
    T& at(int n_) {
        _ASSERT(n_ >= 0, "array exception");
        _ASSERT(n_ < static_cast<int>(size()), "array exception");
        return _buff[n_];
    }
 
    const T& at(int n_) const {
        _ASSERT(n_ >= 0, "array exception");
        _ASSERT(n_ < static_cast<int>(size()), "array exception");
        return _buff[n_];
    }
    T& operator[](int n_) {
        _ASSERT(n_ >= 0, "array exception");
        _ASSERT(n_ < static_cast<int>(size()), "array exception");
        return _buff[n_];
    }
 
    const T& operator[](int n_) const {
        _ASSERT(n_ >= 0, "array exception");
        _ASSERT(n_ < static_cast<int>(size()), "array exception");
        return _buff[n_];
    }
};