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 _DYNAMIC_ARRAY_
#define _DYNAMIC_ARRAY_
 
#include <vector>
#include <exception>
#include <stdexcept>
 
#include "ConFM/base.h"
 
template<typename T> class DynamicArray
{
public:
 
    DynamicArray(){};
 
    DynamicArray(int rows, int columns){
        for (int i = 0; i < rows; ++i)
        {
            data.push_back(std::vector<T> (columns));
        }
    }
 
    OSFI_DEPRECATED("Use operator(i,j) instead to access elements")
    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 C>
    static auto checkIndices(C& vec, int i, int j) -> decltype(vec[i][j]) {
        try{
            auto& row = vec.at(i);
            try{
                return row.at(j);
            } catch(...){
                std::throw_with_nested(std::out_of_range("While accessing column" + std::to_string(j)));
            }
        } catch(const std::nested_exception&) {
            throw;  // Forward the inner exception
        } catch(...){
            std::throw_with_nested(std::out_of_range("While accessing row" +  std::to_string(i)));
        }
    }
 
};
 
template<typename T>
bool operator == (const DynamicArray<T> &y, const DynamicArray<T> &x){
    if (x.getRows() != y.getRows() || x.getColumns() != y.getColumns())
        return false; // dimensions don't match
    for (int i = 0; i < x.getRows(); i++){
        for(int j = 0; j < x.getColumns(); j++){
            if (x(i,j) != y(i,j)) // Mismatch at (i,j), no need to check any further
                return false;
        }
    }
    return true;
}
 
template<typename T>
bool operator != (const DynamicArray<T> &y, const DynamicArray<T> &x){
    return !(x==y);
}
 
#endif // _DYNAMIC_ARRAY_