ModelArrayRef.hpp

Go to the documentation of this file.

 
#ifndef MODELARRAYREF2_HPP
#define MODELARRAYREF2_HPP
 
#include "ModelArray.hpp"
#include <vector>
 
namespace Nextsim {
const bool RW = true;
const bool RO = false;
 
typedef ModelArray* ModelArrayReference;
typedef const ModelArray* ModelArrayConstReference;
typedef std::vector<ModelArrayReference> MARBackingStore;
typedef std::vector<ModelArrayConstReference> MARConstBackingStore;
 
template <auto arrayName, typename S, bool access = RO> class ModelArrayRef {
public:
    ModelArrayRef(const S& backingStoreIn)
        : backingStore(backingStoreIn)
    {
    }
 
    const double& operator[](const ModelArray::MultiDim& dims)
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator[](dims);
    }
    const double& operator[](size_t index) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator[](index);
    }
    const double& operator()(size_t i) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i);
    }
    const double& operator()(size_t i, size_t j) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j);
    }
    const double& operator()(size_t i, size_t j, size_t k) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j, k);
    }
    const double& operator()(size_t i, size_t j, size_t k, size_t l) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j, k, l);
    }
    const double& operator()(size_t i, size_t j, size_t k, size_t l, size_t m) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j, k, l, m);
    }
    const double& operator()(size_t i, size_t j, size_t k, size_t l, size_t m, size_t n) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j, k, l, m, n);
    }
    const double& operator()(
        size_t i, size_t j, size_t k, size_t l, size_t m, size_t n, size_t p) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j, k, l, m, n, p);
    }
    const double& operator()(
        size_t i, size_t j, size_t k, size_t l, size_t m, size_t n, size_t p, size_t q) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j, k, l, m, n, p, q);
    }
 
    const double& zIndexAndLayer(size_t hIndex, size_t layer)
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->zIndexAndLayer(hIndex, layer);
    }
 
    const ModelArray& data() const
    {
        checkMaybeThrow();
        return *backingStore[static_cast<size_t>(arrayName)];
    }
    operator const ModelArray&() const { return data(); }
 
    ModelArray operator+(const ModelArray& addend) const { return data() + addend; }
    ModelArray operator-(const ModelArray& subtrahend) const { return data() - subtrahend; }
    ModelArray operator*(const ModelArray& multiplier) const { return data() * multiplier; }
    ModelArray operator/(const ModelArray& divisor) const { return data() / divisor; }
 
    ModelArray operator+(double addend) const { return data() + addend; }
    ModelArray operator-(double subtrahend) const { return data() - subtrahend; }
    ModelArray operator*(double multiplier) const { return data() * multiplier; }
    ModelArray operator/(double divisor) const { return data() / divisor; }
 
private:
    const S& backingStore;
 
    void checkMaybeThrow() const
    {
#ifdef DEBUG_MODELARRAYREF
        // To activate the debuggin version of this function, add
        // target_compile_definitions(target PRIVATE DEBUG_MODELARRAYREF)
        // to the target in the relevant CMakeLists.txt
        if (!backingStore[static_cast<size_t>(arrayName)])
            throw std::invalid_argument(
                "No registered ModelArray at " + std::to_string(static_cast<size_t>(arrayName)));
#else
 
#endif
    }
};
 
template <auto arrayName> class ModelArrayRef<arrayName, MARBackingStore, RW> {
public:
    ModelArrayRef(const MARBackingStore& backingStoreIn)
        : backingStore(backingStoreIn)
    {
    }
 
    double& operator[](const ModelArray::MultiDim& dims)
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator[](dims);
    }
    double& operator[](size_t index) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator[](index);
    }
    double& operator()(size_t i) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i);
    }
    double& operator()(size_t i, size_t j) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j);
    }
    double& operator()(size_t i, size_t j, size_t k) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j, k);
    }
    double& operator()(size_t i, size_t j, size_t k, size_t l) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j, k, l);
    }
    double& operator()(size_t i, size_t j, size_t k, size_t l, size_t m) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j, k, l, m);
    }
    double& operator()(size_t i, size_t j, size_t k, size_t l, size_t m, size_t n) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j, k, l, m, n);
    }
    double& operator()(size_t i, size_t j, size_t k, size_t l, size_t m, size_t n, size_t p) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j, k, l, m, n, p);
    }
    double& operator()(
        size_t i, size_t j, size_t k, size_t l, size_t m, size_t n, size_t p, size_t q) const
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->operator()(i, j, k, l, m, n, p, q);
    }
 
    double& zIndexAndLayer(size_t hIndex, size_t layer)
    {
        checkMaybeThrow();
        return backingStore[static_cast<size_t>(arrayName)]->zIndexAndLayer(hIndex, layer);
    }
 
    ModelArray& data() const
    {
        checkMaybeThrow();
        return *backingStore[static_cast<size_t>(arrayName)];
    }
    operator ModelArray&() const { return data(); }
 
private:
    const MARBackingStore& backingStore;
 
    void checkMaybeThrow() const
    {
#ifdef DEBUG_MODELARRAYREF
        if (!backingStore[static_cast<size_t>(arrayName)])
            throw std::invalid_argument(
                "No registered ModelArray at " + std::to_string(static_cast<size_t>(arrayName)));
#else
 
#endif
    }
};
}
#endif /* MODELARRAYREF2_HPP */