MArray.hpp

Go to the documentation of this file.

 
#ifndef LLU_CONTAINERS_MARRAY_HPP_
#define LLU_CONTAINERS_MARRAY_HPP_
 
#include <initializer_list>
#include <ostream>
#include <type_traits>
#include <utility>
#include <vector>
 
#include "LLU/Containers/Iterators/IterableContainer.hpp"
#include "LLU/Containers/MArrayDimensions.h"
#include "LLU/LibraryData.h"
#include "LLU/Utilities.hpp"
 
namespace LLU {
 
    template<typename T>
    class MArray : public IterableContainer<T> {
        template<typename>
        friend class MArray;
 
    public:
        MArray() = default;
 
        explicit MArray(MArrayDimensions d) : dims(std::move(d)) {}
 
        template<typename U>
        explicit MArray(const MArray<U>& other) : dims(other.dims) {}
 
        mint rank() const noexcept {
            return dims.rank();
        }
 
        [[nodiscard]] bool empty() const noexcept {
            return dims.flatCount() == 0;
        }
 
        mint dimension(mint index) const {
            return dims.get(index);
        }
 
        const MArrayDimensions& dimensions() const {
            return dims;
        }
 
        using IterableContainer<T>::operator[];
 
        T& operator[](const std::vector<mint>& indices) {
            return (*this)[dims.getIndex(indices)];
        }
 
        const T& operator[](const std::vector<mint>& indices) const {
            return (*this)[dims.getIndex(indices)];
        }
 
        T& at(mint index);
 
        const T& at(mint index) const;
 
        T& at(const std::vector<mint>& indices);
 
        const T& at(const std::vector<mint>& indices) const;
 
    private:
        MArrayDimensions dims;
 
        mint getSize() const noexcept override {
            return dims.flatCount();
        }
    };
 
    template<typename T>
    T& MArray<T>::at(mint index) {
        return (*this)[dims.getIndexChecked(index)];
    }
 
    template<typename T>
    const T& MArray<T>::at(mint index) const {
        return (*this)[dims.getIndexChecked(index)];
    }
 
    template<typename T>
    T& MArray<T>::at(const std::vector<mint>& indices) {
        return (*this)[dims.getIndexChecked(indices)];
    }
 
    template<typename T>
    const T& MArray<T>::at(const std::vector<mint>& indices) const {
        return (*this)[dims.getIndexChecked(indices)];
    }
 
    template<typename T>
    std::ostream& operator<<(std::ostream& os, const MArray<T>& c) {
        os << "{ ";
        for (auto elem : c) {
            os << elem << " ";
        }
        os << "}";
        return os;
    }
 
} /* namespace LLU */
 
#endif /* LLU_CONTAINERS_MARRAY_HPP_ */