multiarray.h

Go to the documentation of this file.

#ifndef CPP_UTILITIES_MULTI_ARRAY_H
#define CPP_UTILITIES_MULTI_ARRAY_H
 
#include <array>
#include <tuple>
#include <vector>
 
namespace CppUtilities {
 
namespace Detail {
template <class Tuple, std::size_t N> struct DimensionsHelper {
    static std::size_t requiredSize(const Tuple &dimensionSizes)
    {
        return DimensionsHelper<Tuple, N - 1>::requiredSize(dimensionSizes) * static_cast<std::size_t>(std::get<N - 1>(dimensionSizes));
    }
    static std::size_t offset(const Tuple &dimensions, const Tuple &indices, std::size_t factor)
    {
        return DimensionsHelper<Tuple, N - 1>::offset(dimensions, indices, factor * static_cast<std::size_t>(std::get<N - 1>(dimensions)))
            + (factor * static_cast<std::size_t>(std::get<N - 1>(indices)));
    }
};
template <class Tuple> struct DimensionsHelper<Tuple, 1> {
    static std::size_t requiredSize(const Tuple &dimensionSizes)
    {
        return static_cast<std::size_t>(std::get<0>(dimensionSizes));
    }
    static std::size_t offset(const Tuple &, const Tuple &indices, std::size_t factor)
    {
        return factor * static_cast<std::size_t>(std::get<0>(indices));
    }
};
} // namespace Detail
 
template <typename Allocator> struct VectorBasedMultiArray {
    template <typename T> using Type = std::vector<T, Allocator>;
    template <typename T> static constexpr Type<T> init(std::size_t requiredSize)
    {
        return Type<T>(requiredSize);
    }
};
 
template <> struct VectorBasedMultiArray<void> {
    template <typename T> using Type = std::vector<T, std::allocator<T>>;
    template <typename T> static constexpr Type<T> init(std::size_t requiredSize)
    {
        return Type<T>(requiredSize);
    }
};
 
template <std::size_t size> struct ArrayBasedMultiArray {
    template <typename T> using Type = std::array<T, size>;
    template <typename T> static constexpr Type<T> init(std::size_t)
    {
        return Type<T>();
    }
};
 
struct NoneOwningMultiArray {
    template <typename T> using Type = T *;
    template <typename T> static constexpr Type<T> init(std::size_t)
    {
        return nullptr;
    }
};
 
template <typename T, typename UnderlyingContainer, typename... Dimensions> class MultiArray {
public:
    MultiArray(Dimensions... dimensionSizes);
    std::size_t totalSize() const;
    static constexpr std::size_t dimensionCount();
    template <std::size_t index> std::size_t dimensionSize() const;
    T &at(Dimensions... indices);
    const T &at(Dimensions... indices) const;
    T *data();
    const T *data() const;
    typename UnderlyingContainer::template Type<T> &buffer();
 
private:
    using HelperType = Detail::DimensionsHelper<std::tuple<Dimensions...>, dimensionCount()>;
    const std::tuple<Dimensions...> m_dims;
    const std::size_t m_size;
    typename UnderlyingContainer::template Type<T> m_buff;
};
 
template <typename T, typename UnderlyingContainer, typename... Dimensions>
MultiArray<T, UnderlyingContainer, Dimensions...>::MultiArray(Dimensions... dimensionSizes)
    : m_dims(std::make_tuple(dimensionSizes...))
    , m_size(HelperType::requiredSize(m_dims))
    , m_buff(UnderlyingContainer::template init<T>(m_size))
{
}
 
template <typename T, typename UnderlyingContainer, typename... Dimensions>
std::size_t MultiArray<T, UnderlyingContainer, Dimensions...>::totalSize() const
{
    return m_size;
}
 
template <typename T, typename UnderlyingContainer, typename... Dimensions>
constexpr std::size_t MultiArray<T, UnderlyingContainer, Dimensions...>::dimensionCount()
{
    return std::tuple_size<std::tuple<Dimensions...>>::value;
}
 
template <typename T, typename UnderlyingContainer, typename... Dimensions>
template <std::size_t index>
std::size_t MultiArray<T, UnderlyingContainer, Dimensions...>::dimensionSize() const
{
    return static_cast<std::size_t>(std::get<index>(m_dims));
}
 
template <typename T, typename UnderlyingContainer, typename... Dimensions>
T &MultiArray<T, UnderlyingContainer, Dimensions...>::at(Dimensions... indices)
{
    return m_buff[HelperType::offset(m_dims, std::make_tuple(indices...), 1)];
}
 
template <typename T, typename UnderlyingContainer, typename... Dimensions>
const T &MultiArray<T, UnderlyingContainer, Dimensions...>::at(Dimensions... indices) const
{
    return m_buff[HelperType::offset(m_dims, std::make_tuple(indices...), 1)];
}
 
template <typename T, typename UnderlyingContainer, typename... Dimensions> T *MultiArray<T, UnderlyingContainer, Dimensions...>::data()
{
    return m_buff.data();
}
 
template <typename T, typename UnderlyingContainer, typename... Dimensions> const T *MultiArray<T, UnderlyingContainer, Dimensions...>::data() const
{
    return m_buff.data();
}
 
template <typename T, typename UnderlyingContainer, typename... Dimensions>
typename UnderlyingContainer::template Type<T> &MultiArray<T, UnderlyingContainer, Dimensions...>::buffer()
{
    return m_buff;
}
 
template <typename ValueType, typename... DimensionSizes> inline auto makeMultiArray(DimensionSizes... dimensionSizes)
{
    return MultiArray<ValueType, VectorBasedMultiArray<void>, DimensionSizes...>(dimensionSizes...);
}
 
template <typename ValueType, std::size_t size, typename... DimensionSizes> inline auto makeFixedSizeMultiArray(DimensionSizes... dimensionSizes)
{
    return MultiArray<ValueType, ArrayBasedMultiArray<size>, DimensionSizes...>(dimensionSizes...);
}
 
template <typename ValueType, typename... DimensionSizes> inline auto makeNoneOwningMultiArray(DimensionSizes... dimensionSizes)
{
    return MultiArray<ValueType, NoneOwningMultiArray, DimensionSizes...>(dimensionSizes...);
}
 
} // namespace CppUtilities
 
#endif // CPP_UTILITIES_MULTI_ARRAY_H