Views/NumericArray.hpp

Go to the documentation of this file.

 
#ifndef LLU_CONTAINERS_VIEWS_NUMERICARRAY_HPP
#define LLU_CONTAINERS_VIEWS_NUMERICARRAY_HPP
 
#include "LLU/Containers/Generic/NumericArray.hpp"
#include "LLU/Containers/Interfaces.h"
#include "LLU/Containers/Iterators/IterableContainer.hpp"
 
namespace LLU {
 
    class NumericArrayView : public NumericArrayInterface {
    public:
        NumericArrayView() = default;
 
        NumericArrayView(const GenericNumericArray& gNA) : na {gNA.getContainer()} {}    // NOLINT: implicit conversion is useful and harmless
 
        NumericArrayView(MNumericArray mna) : na {mna} {}    // NOLINT:
 
        mint getRank() const override {
            return LibraryData::NumericArrayAPI()->MNumericArray_getRank(na);
        }
 
        mint const* getDimensions() const override {
            return LibraryData::NumericArrayAPI()->MNumericArray_getDimensions(na);
        }
 
        mint getFlattenedLength() const override {
            return LibraryData::NumericArrayAPI()->MNumericArray_getFlattenedLength(na);
        }
 
        numericarray_data_t type() const final {
            return LibraryData::NumericArrayAPI()->MNumericArray_getType(na);
        }
 
        void* rawData() const noexcept override {
            return LibraryData::NumericArrayAPI()->MNumericArray_getData(na);
        }
 
    private:
        MNumericArray na = nullptr;
    };
 
    template<typename T>
    class NumericArrayTypedView : public NumericArrayView, public IterableContainer<T> {
    public:
        NumericArrayTypedView() = default;
 
        NumericArrayTypedView(const GenericNumericArray& gNA) : NumericArrayView(gNA) {    // NOLINT: implicit conversion is useful and harmless
            if (NumericArrayType<T> != type()) {
                ErrorManager::throwException(ErrorName::NumericArrayTypeError);
            }
        }
 
        NumericArrayTypedView(NumericArrayView nav) : NumericArrayView(std::move(nav)) {    // NOLINT
            if (NumericArrayType<T> != type()) {
                ErrorManager::throwException(ErrorName::NumericArrayTypeError);
            }
        }
 
        NumericArrayTypedView(MNumericArray mna) : NumericArrayView(mna) {    // NOLINT
            if (NumericArrayType<T> != type()) {
                ErrorManager::throwException(ErrorName::NumericArrayTypeError);
            }
        }
 
    private:
        T* getData() const noexcept override {
            return static_cast<T*>(rawData());
        }
 
        mint getSize() const noexcept override {
            return getFlattenedLength();
        }
    };
 
    template<typename NumericArrayT, typename F>
    auto asTypedNumericArray(NumericArrayT&& na, F&& callable) {
        switch (na.type()) {
            case MNumericArray_Type_Bit8: return std::forward<F>(callable)(NumericArrayTypedView<std::int8_t> {std::forward<NumericArrayT>(na)});
            case MNumericArray_Type_UBit8: return std::forward<F>(callable)(NumericArrayTypedView<std::uint8_t> {std::forward<NumericArrayT>(na)});
            case MNumericArray_Type_Bit16: return std::forward<F>(callable)(NumericArrayTypedView<std::int16_t> {std::forward<NumericArrayT>(na)});
            case MNumericArray_Type_UBit16: return std::forward<F>(callable)(NumericArrayTypedView<std::uint16_t> {std::forward<NumericArrayT>(na)});
            case MNumericArray_Type_Bit32: return std::forward<F>(callable)(NumericArrayTypedView<std::int32_t> {std::forward<NumericArrayT>(na)});
            case MNumericArray_Type_UBit32: return std::forward<F>(callable)(NumericArrayTypedView<std::uint32_t> {std::forward<NumericArrayT>(na)});
            case MNumericArray_Type_Bit64: return std::forward<F>(callable)(NumericArrayTypedView<std::int64_t> {std::forward<NumericArrayT>(na)});
            case MNumericArray_Type_UBit64: return std::forward<F>(callable)(NumericArrayTypedView<std::uint64_t> {std::forward<NumericArrayT>(na)});
            case MNumericArray_Type_Real32: return std::forward<F>(callable)(NumericArrayTypedView<float> {std::forward<NumericArrayT>(na)});
            case MNumericArray_Type_Real64: return std::forward<F>(callable)(NumericArrayTypedView<double> {std::forward<NumericArrayT>(na)});
            case MNumericArray_Type_Complex_Real32:
                return std::forward<F>(callable)(NumericArrayTypedView<std::complex<float>> {std::forward<NumericArrayT>(na)});
            case MNumericArray_Type_Complex_Real64:
                return std::forward<F>(callable)(NumericArrayTypedView<std::complex<double>> {std::forward<NumericArrayT>(na)});
            default: ErrorManager::throwException(ErrorName::NumericArrayTypeError);
        }
    }
 
    // Specialization of asTypedNumericArray for MNumericArray
    template<typename F>
    auto asTypedNumericArray(MNumericArray na, F&& callable) {
        return asTypedNumericArray(NumericArrayView {na}, std::forward<F>(callable));
    }
}  // namespace LLU
 
#endif    // LLU_CONTAINERS_VIEWS_NUMERICARRAY_HPP