MArrayDimensions.h

Go to the documentation of this file.

 
#ifndef LLU_CONTAINERS_MARRAYDIMENSIONS_H_
#define LLU_CONTAINERS_MARRAYDIMENSIONS_H_
 
#include <initializer_list>
#include <type_traits>
#include <vector>
 
#include "LLU/ErrorLog/ErrorManager.h"
#include "LLU/LibraryData.h"
#include "LLU/Utilities.hpp"
 
namespace LLU {
 
    class MArrayDimensions {
    public:
        MArrayDimensions() = default;
 
        MArrayDimensions(std::initializer_list<mint> dimensions);
 
        template<typename T, typename = typename std::enable_if_t<std::is_integral_v<T>>>
        MArrayDimensions(const T* dimensions, mint rank);
 
        template<typename T, typename = typename std::enable_if_t<std::is_integral_v<T>>>
        explicit MArrayDimensions(const std::vector<T>& dimensions);
 
        template<typename InputIter, typename = enable_if_input_iterator<InputIter>>
        MArrayDimensions(InputIter dimsBegin, InputIter dimsEnd);
 
        mint rank() const noexcept {
            return static_cast<mint>(dims.size());
        }
 
        const mint* data() const noexcept {
            if (dims.empty()) {
                return nullptr;
            }
            return dims.data();
        }
 
        const std::vector<mint>& get() const noexcept {
            return dims;
        }
 
        mint get(mint dim) const {
            if (dim >= rank() || dim < 0) {
                ErrorManager::throwException(ErrorName::MArrayDimensionIndexError, dim);
            }
            return dims[static_cast<decltype(dims)::size_type>(dim)];
        }
 
        mint getIndex(const std::vector<mint>& indices) const;
 
        mint getIndexChecked(const std::vector<mint>& indices) const;
 
        mint getIndexChecked(mint index) const;
 
        mint flatCount() const noexcept {
            return flattenedLength;
        }
 
    private:
        mint flattenedLength = 1;
 
        std::vector<mint> dims;
 
        std::vector<mint> offsets;
 
        void fillOffsets();
 
    private:
        template<typename T>
        mint checkContainerSize(T s) const;
 
        [[nodiscard]] mint totalLengthFromDims() const noexcept;
 
        static constexpr std::size_t MAX_DIM = static_cast<std::size_t>((std::numeric_limits<mint>::max)());
    };
 
    template<typename T, typename>
    MArrayDimensions::MArrayDimensions(const T* dimensions, mint rank) : MArrayDimensions(dimensions, std::next(dimensions, rank)) {}
 
    template<typename T, typename>
    MArrayDimensions::MArrayDimensions(const std::vector<T>& dimensions) : MArrayDimensions(std::cbegin(dimensions), std::cend(dimensions)) {}
 
    template<typename InputIter, typename>
    MArrayDimensions::MArrayDimensions(InputIter dimsBegin, InputIter dimsEnd) {
        if (mint depth = checkContainerSize(std::distance(dimsBegin, dimsEnd)); depth >= 1) {
            auto dimsOk = std::all_of(dimsBegin, dimsEnd - 1, [](auto d) { return (d > 0) && (static_cast<std::size_t>(d) <= MAX_DIM); }) &&
                          (dimsBegin[depth - 1] >= 0) && (static_cast<std::size_t>(dimsBegin[depth - 1]) <= MAX_DIM);
            if (!dimsOk) {
                ErrorManager::throwExceptionWithDebugInfo(ErrorName::DimensionsError, "Invalid input vector with array dimensions");
            }
            dims.reserve(depth);
        }
        std::copy(dimsBegin, dimsEnd, std::back_inserter(dims));
        flattenedLength = totalLengthFromDims();
        fillOffsets();
    }
 
    template<typename T>
    mint MArrayDimensions::checkContainerSize(T s) const {
        if (s < 0 || static_cast<std::size_t>(s) > MAX_DIM) {
            ErrorManager::throwException(ErrorName::DimensionsError);
        }
        return static_cast<mint>(s);
    }
 
} /* namespace LLU */
 
#endif /* LLU_CONTAINERS_MARRAYDIMENSIONS_H_ */