EquilengthArrays.hpp

Go to the documentation of this file.

#ifndef JIWOO_EQUILENGTH_ARRAYS_HPP
#define JIWOO_EQUILENGTH_ARRAYS_HPP
 
#include <algorithm>
#include <cstddef>
#include <type_traits>
 
namespace jiwoo {
 
template<typename Value_>
class EquilengthArrays {
public:
    EquilengthArrays() = default;
 
    EquilengthArrays(std::size_t size, std::size_t length) : my_size(size), my_length(length) {
        my_ptr = safely_allocate(
            size,
            length,
            [](std::size_t, Value_*) -> void {}
        );
    }
 
    EquilengthArrays(std::size_t size, std::size_t length, Value_ fill) : my_size(size), my_length(length) {
        my_ptr = safely_allocate(
            size,
            length,
            [&](std::size_t, Value_* ptr) -> void {
                std::fill_n(ptr, length, fill);
            }
        );
    }
 
    EquilengthArrays(const EquilengthArrays& other) : my_size(other.my_size), my_length(other.my_length) {
        my_ptr = safely_allocate(
            my_size,
            my_length,
            [&](std::size_t i, Value_* ptr) -> void {
                std::copy_n(other.my_ptr[i], my_length, ptr);
            }
        );
    }
 
    EquilengthArrays(EquilengthArrays&& other) noexcept : my_ptr(other.my_ptr), my_size(other.my_size), my_length(other.my_length) {
        other.my_size = 0;
        other.my_ptr = NULL;
    }
 
private:
    Value_** my_ptr = NULL;
    std::size_t my_size = 0;
    std::size_t my_length = 0;
 
    template<typename Extra_>
    static Value_** safely_allocate(std::size_t size, std::size_t length, Extra_ extra) {
        Value_** output = new Value_* [size];
 
        std::size_t allocated = 0;
        try {
            for (std::size_t i = 0; i < size; ++i) {
                output[i] = new Value_ [length];
                ++allocated;
                extra(i, output[i]);
            }
        } catch(...) { 
            for (std::size_t x = 0; x < allocated; ++x) {
                delete [] output[x];
            }
            delete[] output;
            throw;
        }
 
        return output;
    }
 
public:
    ~EquilengthArrays() {
        if (my_ptr != NULL) {
            for (std::size_t i = 0; i < my_size; ++i) {
                delete [] my_ptr[i];
            }
            delete [] my_ptr;
        }
    }
 
public:
    EquilengthArrays& operator=(const EquilengthArrays& other) {
        // If the memory is already available and correctly sized, we can just copy it in.
        // We only attempt this if the copy assignment is nothrow, as this ensures we can't crash with a half-copied object.
        // Obviously no copying is necessary at all if it's a self assignment.
        if constexpr(std::is_nothrow_copy_assignable<Value_>::value) {
            if (other.my_size == my_size && other.my_length == my_length) {
                if (other.my_ptr != my_ptr) { 
                    for (std::size_t i = 0; i < my_size; ++i) {
                        std::copy_n(other.my_ptr[i], my_length, my_ptr[i]);
                    }
                }
                return *this;
            }
        }
 
        // One might be tempted to optimize for the situation where 'other.my_size == my_size', and just reallocate the inner arrays.
        // The problem is that, if there's an allocation error and the move assignment fails halfway through the inner arrays,
        // we'll end up with a frankenobject for which 'my_length' is not correct.
 
        // Copy and swap idiom.
        EquilengthArrays tmp(other);
        swap(tmp);
        return *this;
    }
 
    EquilengthArrays& operator=(EquilengthArrays&& other) noexcept {
        // Copy and swap idiom.
        EquilengthArrays tmp(std::move(other));
        swap(tmp);
        return *this;
    }
 
    void swap(EquilengthArrays& other) noexcept {
        std::swap(other.my_size, my_size);
        std::swap(other.my_length, my_length);
        std::swap(other.my_ptr, my_ptr);
    }
 
public:
    std::size_t size() const {
        return my_size;
    }
 
    std::size_t length() const {
        return my_length;
    }
 
    bool empty() const {
        return my_size == 0;
    }
public:
    Value_* operator[](std::size_t i) {
        return my_ptr[i];
    }
 
    const Value_* operator[](std::size_t i) const {
        return my_ptr[i];
    }
 
public:
    Value_* const* get() {
        return my_ptr;
    }
 
    const Value_* const * get() const {
        return my_ptr;
    }
 
public:
    Value_* front() {
        return my_ptr[0];
    }
 
    const Value_* front() const {
        return my_ptr[0];
    }
 
public:
    Value_* back() {
        return my_ptr[my_size - 1];
    }
 
    const Value_* back() const {
        return my_ptr[my_size - 1];
    }
 
public:
    Value_* const* begin() {
        return my_ptr;
    }
 
    const Value_* const* begin() const {
        return my_ptr;
    }
 
public:
    Value_* const* end() {
        return my_ptr + my_size;
    }
 
    const Value_* const* end() const {
        return my_ptr + my_size;
    }
};
 
}
 
#endif