DynamicArray.h

/*
 * openSF Integration Libraries (OSFI)
 * Deimos Space, S.L.U.
 * 
 * This file is part of OSFI. OSFI is free software; you can redistribute it
 * and/or modify it under the terms of the 'ESA Software Community Licence Permissive' as
 * published by the European Space Agency; either version 2.4 of the License,
 * or (at your option) any later version. You should have received a
 * copy of the 'ESA Software Community Licence Permissive - v2.4' along with this program
 * or one can be found at <http://eop-cfi.esa.int/index.php/docs-and-mission-data/licensing-documents>.
 *
 */
#ifndef OSFI_CONFM_DYNAMIC_ARRAY
#define OSFI_CONFM_DYNAMIC_ARRAY
 
#include <vector>
#include <exception>
#include <stdexcept>
 
#include "ConFM/base.h"
 
template<typename T> class DynamicArray
{
public:
    DynamicArray() = default;
 
    DynamicArray(int rows, int columns){
        for (int i = 0; i < rows; ++i)
        {
            data.push_back(std::vector<T> (columns));
        }
    }
 
    OSFI_DEPRECATED("Use operator() instead to access elements like mat(i,j)")
    const std::vector<T> & operator[](int i) const {
        return data[i];
    }
 
    typename std::vector<T>::reference operator()(int i, int j) {
        return data[i][j];
    }
 
    typename std::vector<T>::const_reference operator()(int i, int j) const {
        return data[i][j];
    }
 
    typename std::vector<T>::reference at(int i, int j){
        return checkIndices(this->data, i, j);
    }
 
    typename std::vector<T>::const_reference at(int i, int j) const {
        return checkIndices(this->data, i, j);
    }
 
    void resize(int rows, int columns){
        data.resize(rows);
        for (int i = 0; i < rows; ++i)
            data[i].resize(columns);
    }
 
    int getRows() const{
        return data.size();
    }
 
    int getColumns() const{
        if (data.size() > 0)
            return data[0].size();
        else
            return 0;
    }
 
private:
    std::vector<std::vector<T>> data; 
 
    template<typename V>
    static auto derefChecked(V& vec, int i, const char* indexName) -> decltype(vec[i]) {
        try{
            return vec.at(i);
        } catch(...) {
            std::throw_with_nested(std::out_of_range(
                    std::string("While accessing ") + indexName + std::to_string(i)));
        }
    }
    template<typename C>
    static auto checkIndices(C& mat, int i, int j) -> decltype(mat[i][j]) {
        auto& row = derefChecked(mat, i, "row");
        return derefChecked(row, j, "column");
    }
 
    friend bool operator==(const DynamicArray& lhs, const DynamicArray& rhs) {
        return lhs.data == rhs.data;
    }
    // TODO in C++20, == can be replaced with just "= default", and != removed entirely
 
    friend bool operator!=(const DynamicArray& lhs, const DynamicArray& rhs) {
        return !(lhs == rhs);
    }
};
 
#endif // OSFI_CONFM_DYNAMIC_ARRAY