data_type_traits.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main author:     Suneth Warnakulasuriya
//
 
#pragma once
 
// System includes
#include <algorithm>
#include <string>
#include <type_traits>
#include <vector>
 
// Project includes
#include "containers/array_1d.h"
#include "includes/ublas_interface.h"
 
namespace Kratos {
 
template<class TDataType> class DataTypeTraits
{
public:
 
    using ContainerType = TDataType;
 
    using ValueType = TDataType;
 
    using PrimitiveType = TDataType;
 
    static constexpr bool IsContiguous = true;
 
    static constexpr bool IsDynamic = false;
 
    static constexpr unsigned int Dimension = 0;
 
 
    template<unsigned int TCheckIndex>
    static constexpr bool IsDimensionDynamic()
    {
        return IsDimensionDynamicImpl<TCheckIndex, 0>();
    }
 
    template<class TIndexType = unsigned int>
    static inline TIndexType Size(const ContainerType&)
    {
        return 1;
    }
 
    template<class TIndexType = unsigned int>
    static inline std::vector<TIndexType> Shape(const ContainerType&)
    {
        return {};
    }
 
    template<class TIndexType = unsigned int>
    static inline void Shape(
        const ContainerType&,
        TIndexType* pShapeBegin,
        TIndexType* pShapeEnd)
    {
        KRATOS_ERROR_IF_NOT(std::distance(pShapeBegin, pShapeEnd) == 0)
            << "Invalid dimensions given to fill for primitive data type [ Expected dimension == 0, provided shape = "
            << std::vector<TIndexType>(pShapeBegin, pShapeEnd) << " ].\n";
    }
 
    template<class TIndexType = unsigned int>
    static inline bool Reshape(
        ContainerType& rValue,
        const std::vector<TIndexType>& rShape)
    {
        return Reshape(rValue, rShape.data(), rShape.data() + rShape.size());
    }
 
    template<class TIndexType = unsigned int>
    static inline bool Reshape(
        ContainerType&,
        TIndexType const * pShapeBegin,
        TIndexType const * pShapeEnd)
    {
        KRATOS_ERROR_IF_NOT(std::distance(pShapeBegin, pShapeEnd) == 0)
            << "Invalid shape/dimension given for primitive data type [ Expected shape = [], provided shape = "
            << std::vector<TIndexType>(pShapeBegin, pShapeEnd) << " ].\n";
        return false;
    }
 
    inline static PrimitiveType const * GetContiguousData(const ContainerType& rValue)
    {
        return &rValue;
    }
 
    inline static PrimitiveType * GetContiguousData(ContainerType& rValue)
    {
        return &rValue;
    }
 
    inline static void CopyToContiguousData(
        PrimitiveType* pContiguousDataBegin,
        const ContainerType& rValue)
    {
        *pContiguousDataBegin = rValue;
    }
 
    inline static void CopyFromContiguousData(
        ContainerType& rValue,
        PrimitiveType const * pContiguousDataBegin)
    {
        rValue = *pContiguousDataBegin;
    }
 
 
private:
 
    template<unsigned int TCheckIndex, unsigned int TCurrentIndex = 0>
    static constexpr bool IsDimensionDynamicImpl()
    {
        if constexpr(TCheckIndex == 0) {
            return false;
        } else {
            static_assert(TCheckIndex != TCheckIndex, "Invalid dimension index.");
        }
    }
 
 
    template<class T>
    friend class DataTypeTraits;
 
};
 
template<class TDataType, std::size_t TSize> class DataTypeTraits<array_1d<TDataType, TSize>>
{
public:
 
    using ContainerType = array_1d<TDataType, TSize>;
 
    using ValueType = TDataType;
 
    using ValueTraits = DataTypeTraits<ValueType>;
 
    using PrimitiveType = typename ValueTraits::PrimitiveType;
 
    static constexpr bool IsDynamic = ValueTraits::IsDynamic;
 
    // boost ublas makes the underlying data structure contiguous for
    // any ValueType which are not dynamic recursively.
    static constexpr bool IsContiguous = !IsDynamic;
 
    static constexpr unsigned int Dimension = ValueTraits::Dimension + 1;
 
 
    template<unsigned int TCheckIndex>
    static constexpr bool IsDimensionDynamic()
    {
        return IsDimensionDynamicImpl<TCheckIndex, 0>();
    }
 
    template<class TIndexType = unsigned int>
    static inline TIndexType Size(const ContainerType& rContainer)
    {
        if constexpr(TSize == 0) {
            return 0;
        } else {
            return TSize * ValueTraits::template Size<TIndexType>(rContainer[0]);
        }
    }
 
    template<class TIndexType = unsigned int>
    static inline std::vector<TIndexType> Shape(const ContainerType& rContainer)
    {
        std::vector<TIndexType> shape(Dimension);
        Shape(rContainer, shape.data(), shape.data() + Dimension);
        return shape;
    }
 
    template<class TIndexType = unsigned int>
    static inline void Shape(
        const ContainerType& rContainer,
        TIndexType* pShapeBegin,
        TIndexType* pShapeEnd)
    {
        KRATOS_ERROR_IF_NOT(std::distance(pShapeBegin, pShapeEnd) >= 1)
            << "Invalid dimensions given to fill for primitive data type [ Expected dimension >= 1, provided shape = "
            << std::vector<TIndexType>(pShapeBegin, pShapeEnd) << " ].\n";
 
        if constexpr(TSize > 0) {
            ValueTraits::Shape(rContainer[0], pShapeBegin + 1, pShapeEnd);
        } else {
            ValueTraits::Shape(ValueType{}, pShapeBegin + 1, pShapeEnd);
        }
        pShapeBegin[0] = TSize;
    }
 
    template<class TIndexType = unsigned int>
    static inline bool Reshape(
        ContainerType& rContainer,
        const std::vector<TIndexType>& rShape)
    {
        return Reshape(rContainer, rShape.data(), rShape.data() + rShape.size());
    }
 
    template<class TIndexType = unsigned int>
    static inline bool Reshape(
        ContainerType& rContainer,
        TIndexType const * pShapeBegin,
        TIndexType const * pShapeEnd)
    {
        KRATOS_ERROR_IF_NOT(std::distance(pShapeBegin, pShapeEnd) >= 1 && *pShapeBegin == static_cast<TIndexType>(TSize))
            << "Invalid shape/dimension given for array_1d data type [ Expected shape = " << Shape(rContainer) << ", provided shape = "
            << std::vector<TIndexType>(pShapeBegin, pShapeEnd) << " ].\n";
 
        bool is_reshaped = false;
 
        if constexpr(ValueTraits::IsDynamic) {
            std::for_each(rContainer.begin(), rContainer.end(), [&is_reshaped, pShapeBegin, pShapeEnd](auto& rValue) {
                is_reshaped = ValueTraits::Reshape(rValue, pShapeBegin + 1, pShapeEnd) || is_reshaped;
            });
        }
 
        return is_reshaped;
    }
 
    inline static PrimitiveType const * GetContiguousData(const ContainerType& rValue)
    {
        if constexpr(IsContiguous) {
            if constexpr(std::is_same_v<PrimitiveType, ValueType>) {
                return rValue.data().data();
            } else {
                // since the underlying data structure for recusive static data types
                // is contiguous in ublas types, we can do the following to get the
                // contiguous array.
                if constexpr(TSize > 0) {
                    return reinterpret_cast<PrimitiveType const *>(&rValue[0]);
                } else {
                    // not returning nullptr so, the return value can be subjected to
                    // arithmetic operations
                    return 0;
                }
            }
        } else {
            static_assert(!std::is_same_v<TDataType, TDataType>, "This should be only called if the rValue is contiguous only.");
        }
    }
 
    inline static PrimitiveType * GetContiguousData(ContainerType& rValue)
    {
        if constexpr(IsContiguous) {
            if constexpr(std::is_same_v<PrimitiveType, ValueType>) {
                return rValue.data().data();
            } else {
                // since the underlying data structure for recusive static data types
                // is contiguous in ublas types, we can do the following to get the
                // contiguous array.
                if constexpr(TSize > 0) {
                    return reinterpret_cast<PrimitiveType*>(&rValue[0]);
                } else {
                    // not returning nullptr so, the return value can be subjected to
                    // arithmetic operations
                    return 0;
                }
            }
        } else {
            static_assert(!std::is_same_v<TDataType, TDataType>, "This should be only called if the rValue is contiguous only.");
        }
    }
 
    inline static void CopyToContiguousData(
        PrimitiveType* pContiguousDataBegin,
        const ContainerType& rContainer)
    {
        const auto stride = ValueTraits::Size(rContainer[0]);
        for (unsigned int i = 0; i < TSize; ++i) {
            ValueTraits::CopyToContiguousData(pContiguousDataBegin + i * stride, rContainer[i]);
        }
    }
 
    inline static void CopyFromContiguousData(
        ContainerType& rContainer,
        PrimitiveType const * pContiguousDataBegin)
    {
        const auto stride = ValueTraits::Size(rContainer[0]);
        for (unsigned int i = 0; i < TSize; ++i) {
            ValueTraits::CopyFromContiguousData(rContainer[i], pContiguousDataBegin + i * stride);
        }
    }
 
 
private:
 
    template<unsigned int TCheckIndex, unsigned int TCurrentIndex>
    static constexpr bool IsDimensionDynamicImpl()
    {
        if constexpr(TCheckIndex == TCurrentIndex) {
            return false;
        } else {
            return ValueTraits::template IsDimensionDynamicImpl<TCheckIndex, TCurrentIndex + 1>();
        }
    }
 
 
    template<class T>
    friend class DataTypeTraits;
 
};
 
template<class TDataType> class DataTypeTraits<DenseVector<TDataType>>
{
public:
 
    using ContainerType = DenseVector<TDataType>;
 
    using ValueType = TDataType;
 
    using ValueTraits = DataTypeTraits<ValueType>;
 
    using PrimitiveType = typename ValueTraits::PrimitiveType;
 
    static constexpr bool IsDynamic = true;
 
    // boost ublas makes the underlying data structure contiguous for
    // any ValueType which are not dynamic recursively.
    static constexpr bool IsContiguous = !ValueTraits::IsDynamic;
 
    static constexpr unsigned int Dimension = ValueTraits::Dimension + 1;
 
 
    template<unsigned int TCheckIndex>
    static constexpr bool IsDimensionDynamic()
    {
        return IsDimensionDynamicImpl<TCheckIndex, 0>();
    }
 
    template<class TIndexType = unsigned int>
    static inline TIndexType Size(const ContainerType& rValue)
    {
        return (rValue.empty() ? 0 : rValue.size() * ValueTraits::template Size<TIndexType>(rValue[0]));
    }
 
    template<class TIndexType = unsigned int>
    static inline std::vector<TIndexType> Shape(const ContainerType& rContainer)
    {
        std::vector<TIndexType> shape(Dimension);
        Shape(rContainer, shape.data(), shape.data() + Dimension);
        return shape;
    }
 
    template<class TIndexType = unsigned int>
    static inline void Shape(
        const ContainerType& rContainer,
        TIndexType* pShapeBegin,
        TIndexType* pShapeEnd)
    {
        KRATOS_ERROR_IF_NOT(std::distance(pShapeBegin, pShapeEnd) >= 1)
            << "Invalid dimensions given to fill for primitive data type [ Expected dimension >= 1, provided shape = "
            << std::vector<TIndexType>(pShapeBegin, pShapeEnd) << " ].\n";
 
        if (rContainer.empty()) {
            ValueTraits::Shape(ValueType{}, pShapeBegin + 1, pShapeEnd);
        } else {
            ValueTraits::Shape(rContainer[0], pShapeBegin + 1, pShapeEnd);
        }
        pShapeBegin[0] = rContainer.size();
    }
 
    template<class TIndexType = unsigned int>
    static inline bool Reshape(
        ContainerType& rContainer,
        const std::vector<TIndexType>& rShape)
    {
        return Reshape(rContainer, rShape.data(), rShape.data() + rShape.size());
    }
 
    template<class TIndexType = unsigned int>
    static inline bool Reshape(
        ContainerType& rContainer,
        TIndexType const * pShapeBegin,
        TIndexType const * pShapeEnd)
    {
        KRATOS_ERROR_IF_NOT(std::distance(pShapeBegin, pShapeEnd) >= 1)
            << "Invalid shape/dimension given for DenseVector data type [ Expected = " << Shape(rContainer) << ", provided = "
            << std::vector<TIndexType>(pShapeBegin, pShapeEnd) << " ].\n";
 
        bool is_reshaped = false;
 
        if (rContainer.size() != *pShapeBegin) {
            rContainer.resize(*pShapeBegin, false);
            is_reshaped = true;
        }
 
        if constexpr(ValueTraits::IsDynamic) {
            std::for_each(rContainer.begin(), rContainer.end(), [&is_reshaped, pShapeBegin, pShapeEnd](auto& rValue) {
                is_reshaped = ValueTraits::Reshape(rValue, pShapeBegin + 1, pShapeEnd) || is_reshaped;
            });
        }
 
        return is_reshaped;
    }
 
    inline static PrimitiveType const * GetContiguousData(const ContainerType& rValue)
    {
        if constexpr(IsContiguous) {
            if constexpr(std::is_same_v<PrimitiveType, ValueType>) {
                return rValue.data().begin();
            } else {
                // since the underlying data structure for recusive static data types
                // is contiguous in ublas types, we can do the following to get the
                // contiguous array.
                if (rValue.size() > 0) {
                    return reinterpret_cast<PrimitiveType const *>(&rValue[0]);
                } else {
                    // not returning nullptr so, the return value can be subjected to
                    // arithmetic operations
                    return 0;
                }
            }
        } else {
            static_assert(!std::is_same_v<TDataType, TDataType>, "GetContiguousData should only be called if rValue is contiguous.");
        }
    }
 
    inline static PrimitiveType * GetContiguousData(ContainerType& rValue)
    {
        if constexpr(IsContiguous) {
            if constexpr(std::is_same_v<PrimitiveType, ValueType>) {
                return rValue.data().begin();
            } else {
                // since the underlying data structure for recusive static data types
                // is contiguous in ublas types, we can do the following to get the
                // contiguous array.
                if (rValue.size() > 0) {
                    return reinterpret_cast<PrimitiveType*>(&rValue[0]);
                } else {
                    // not returning nullptr so, the return value can be subjected to
                    // arithmetic operations
                    return 0;
                }
            }
        } else {
            static_assert(!std::is_same_v<TDataType, TDataType>, "GetContiguousData should only be called if rValue is contiguous.");
        }
    }
 
    inline static void CopyToContiguousData(
        PrimitiveType* pContiguousDataBegin,
        const ContainerType& rContainer)
    {
        if (rContainer.size() != 0) {
            const auto stride = ValueTraits::Size(rContainer[0]);
            for (unsigned int i = 0; i < rContainer.size(); ++i) {
                ValueTraits::CopyToContiguousData(pContiguousDataBegin + i * stride, rContainer[i]);
            }
        }
    }
 
    inline static void CopyFromContiguousData(
        ContainerType& rContainer,
        PrimitiveType const * pContiguousDataBegin)
    {
        if (rContainer.size() != 0) {
            const auto stride = ValueTraits::Size(rContainer[0]);
            for (unsigned int i = 0; i < rContainer.size(); ++i) {
                ValueTraits::CopyFromContiguousData(rContainer[i], pContiguousDataBegin + i * stride);
            }
        }
    }
 
 
private:
 
    template<unsigned int TCheckIndex, unsigned int TCurrentIndex>
    static constexpr bool IsDimensionDynamicImpl()
    {
        if constexpr(TCheckIndex == TCurrentIndex) {
            return true;
        } else {
            return ValueTraits::template IsDimensionDynamicImpl<TCheckIndex, TCurrentIndex + 1>();
        }
    }
 
 
    template<class T>
    friend class DataTypeTraits;
 
};
 
template<class TDataType> class DataTypeTraits<DenseMatrix<TDataType>>
{
public:
 
    using ContainerType = DenseMatrix<TDataType>;
 
    using ValueType = TDataType;
 
    using ValueTraits = DataTypeTraits<ValueType>;
 
    using PrimitiveType = typename ValueTraits::PrimitiveType;
 
    static constexpr bool IsDynamic = true;
 
    // boost ublas makes the underlying data structure contiguous for
    // any ValueType which are not dynamic recursively.
    static constexpr bool IsContiguous = !ValueTraits::IsDynamic;
 
    static constexpr unsigned int Dimension = ValueTraits::Dimension + 2;
 
 
    template<unsigned int TCheckIndex>
    static constexpr bool IsDimensionDynamic()
    {
        return IsDimensionDynamicImpl<TCheckIndex, 0>();
    }
 
    template<class TIndexType = unsigned int>
    static inline TIndexType Size(const ContainerType& rValue)
    {
        return (rValue.size1() == 0 || rValue.size2() == 0 ? 0 : rValue.size1() * rValue.size2() * ValueTraits::template Size<TIndexType>(rValue.data()[0]));
    }
 
    template<class TIndexType = unsigned int>
    static inline std::vector<TIndexType> Shape(const ContainerType& rContainer)
    {
        std::vector<TIndexType> shape(Dimension);
        Shape(rContainer, shape.data(), shape.data() + Dimension);
        return shape;
    }
 
    template<class TIndexType = unsigned int>
    static inline void Shape(
        const ContainerType& rContainer,
        TIndexType* pShapeBegin,
        TIndexType* pShapeEnd)
    {
        KRATOS_ERROR_IF_NOT(std::distance(pShapeBegin, pShapeEnd) >= 2)
            << "Invalid dimensions given to fill for primitive data type [ Expected dimension >= 2, provided shape = "
            << std::vector<TIndexType>(pShapeBegin, pShapeEnd) << " ].\n";
 
        if (rContainer.size1() > 0 && rContainer.size2() > 0) {
            ValueTraits::Shape(rContainer(0, 0), pShapeBegin + 2, pShapeEnd);
        } else {
            ValueTraits::Shape(ValueType{}, pShapeBegin + 2, pShapeEnd);
        }
        pShapeBegin[0] = rContainer.size1();
        pShapeBegin[1] = rContainer.size2();
    }
 
    template<class TIndexType = unsigned int>
    static inline bool Reshape(
        ContainerType& rContainer,
        const std::vector<TIndexType>& rShape)
    {
        return Reshape(rContainer, rShape.data(), rShape.data() + rShape.size());
    }
 
    template<class TIndexType = unsigned int>
    static inline bool Reshape(
        ContainerType& rContainer,
        TIndexType const * pShapeBegin,
        TIndexType const * pShapeEnd)
    {
        KRATOS_ERROR_IF_NOT(std::distance(pShapeBegin, pShapeEnd) >= 2)
            << "Invalid shape/dimension given for DenseMatrix data type [ Expected = " << Shape(rContainer) << ", provided = "
            << std::vector<TIndexType>(pShapeBegin, pShapeEnd) << " ].\n";
 
        bool is_reshaped = false;
 
        if (rContainer.size1() != pShapeBegin[0] || rContainer.size2() != pShapeBegin[1]) {
            rContainer.resize(pShapeBegin[0], pShapeBegin[1], false);
            is_reshaped = true;
        }
 
        if constexpr(ValueTraits::IsDynamic) {
            std::for_each(rContainer.data().begin(), rContainer.data().end(), [&is_reshaped, pShapeBegin, pShapeEnd](auto& rValue) {
                is_reshaped = ValueTraits::Reshape(rValue, pShapeBegin + 2, pShapeEnd) || is_reshaped;
            });
        }
 
        return is_reshaped;
    }
 
    inline static PrimitiveType const * GetContiguousData(const ContainerType& rValue)
    {
        if constexpr(IsContiguous) {
            if constexpr(std::is_same_v<PrimitiveType, ValueType>) {
                return rValue.data().begin();
            } else {
                // since the underlying data structure for recusive static data types
                // is contiguous in ublas types, we can do the following to get the
                // contiguous array.
                if (rValue.size1() > 0 && rValue.size2() > 0) {
                    return reinterpret_cast<PrimitiveType const*>(&rValue(0, 0));
                } else {
                    // not returning nullptr so, the return value can be subjected to
                    // arithmetic operations
                    return 0;
                }
            }
        } else {
            static_assert(!std::is_same_v<TDataType, TDataType>, "GetContiguousData should only be called if rValue is contiguous.");
        }
    }
 
    inline static PrimitiveType * GetContiguousData(ContainerType& rValue)
    {
        if constexpr(IsContiguous) {
            if constexpr(std::is_same_v<PrimitiveType, ValueType>) {
                return rValue.data().begin();
            } else {
                // since the underlying data structure for recusive static data types
                // is contiguous in ublas types, we can do the following to get the
                // contiguous array.
                if (rValue.size1() > 0 && rValue.size2() > 0) {
                    return reinterpret_cast<PrimitiveType*>(&rValue(0, 0));
                } else {
                    // not returning nullptr so, the return value can be subjected to
                    // arithmetic operations
                    return 0;
                }
            }
        } else {
            static_assert(!std::is_same_v<TDataType, TDataType>, "GetContiguousData should only be called if rValue is contiguous.");
        }
    }
 
    inline static void CopyToContiguousData(
        PrimitiveType* pContiguousDataBegin,
        const ContainerType& rContainer)
    {
        if (rContainer.size1() != 0 && rContainer.size2() != 0) {
            const auto stride = ValueTraits::Size(rContainer(0, 0));
            for (unsigned int i = 0; i < rContainer.size1() * rContainer.size2(); ++i) {
                ValueTraits::CopyToContiguousData(pContiguousDataBegin + i * stride, rContainer.data()[i]);
            }
        }
    }
 
    inline static void CopyFromContiguousData(
        ContainerType& rContainer,
        PrimitiveType const * pContiguousDataBegin)
    {
        if (rContainer.size1() != 0 && rContainer.size2() != 0) {
            const auto stride = ValueTraits::Size(rContainer(0, 0));
            for (unsigned int i = 0; i < rContainer.size1() * rContainer.size2(); ++i) {
                ValueTraits::CopyFromContiguousData(rContainer.data()[i], pContiguousDataBegin + i * stride);
            }
        }
    }
 
 
private:
 
    template<unsigned int TCheckIndex, unsigned int TCurrentIndex>
    static constexpr bool IsDimensionDynamicImpl()
    {
        if constexpr(TCheckIndex == TCurrentIndex || TCheckIndex == TCurrentIndex + 1) {
            return true;
        } else {
            return ValueTraits::template IsDimensionDynamicImpl<TCheckIndex, TCurrentIndex + 2>();
        }
    }
 
 
    template<class T>
    friend class DataTypeTraits;
 
};
 
template<> class DataTypeTraits<std::string>
{
public:
 
    using ContainerType = std::string;
 
    using ValueType = char;
 
    using PrimitiveType = char;
 
    static constexpr bool IsContiguous = true;
 
    static constexpr bool IsDynamic = true;
 
    static constexpr unsigned int Dimension = 1;
 
 
    template<unsigned int TCheckIndex>
    static constexpr bool IsDimensionDynamic()
    {
        return IsDimensionDynamicImpl<TCheckIndex, 0>();
    }
 
    template<class TIndexType = unsigned int>
    static inline TIndexType Size(const ContainerType& rValue)
    {
        return rValue.size();
    }
 
    template<class TIndexType = unsigned int>
    static inline std::vector<TIndexType> Shape(const ContainerType& rContainer)
    {
        std::vector<TIndexType> shape(Dimension);
        Shape(rContainer, shape.data(), shape.data() + Dimension);
        return shape;
    }
 
    template<class TIndexType = unsigned int>
    static inline void Shape(
        const ContainerType& rContainer,
        TIndexType* pShapeBegin,
        TIndexType* pShapeEnd)
    {
        KRATOS_ERROR_IF_NOT(std::distance(pShapeBegin, pShapeEnd) == 1)
            << "Invalid dimensions given to fill for std::string data type [ Expected dimension == 1, provided shape = "
            << std::vector<TIndexType>(pShapeBegin, pShapeEnd) << " ].\n";
        pShapeBegin[0] = rContainer.size();
    }
 
    template<class TIndexType = unsigned int>
    static inline bool Reshape(
        ContainerType& rContainer,
        const std::vector<TIndexType>& rShape)
    {
        return Reshape(rContainer, rShape.data(), rShape.data() + rShape.size());
    }
 
    template<class TIndexType = unsigned int>
    static inline bool Reshape(
        ContainerType& rContainer,
        TIndexType const * pShapeBegin,
        TIndexType const * pShapeEnd)
    {
        KRATOS_ERROR_IF_NOT(std::distance(pShapeBegin, pShapeEnd) == 1)
            << "Invalid shape/dimension given for std::string data type [ Expected = "
            << Shape(rContainer) << ", provided = "
            << std::vector<TIndexType>(pShapeBegin, pShapeEnd) << " ].\n";
 
        bool is_reshaped = false;
 
        if (rContainer.size() != pShapeBegin[0]) {
            rContainer.resize(pShapeBegin[0], false);
            is_reshaped = true;
        }
 
        return is_reshaped;
    }
 
    inline static PrimitiveType const * GetContiguousData(const ContainerType& rValue)
    {
        return rValue.data();
    }
 
    inline static PrimitiveType * GetContiguousData(ContainerType& rValue)
    {
        return rValue.data();
    }
 
    inline static void CopyToContiguousData(
        PrimitiveType* pContiguousDataBegin,
        const ContainerType& rContainer)
    {
        std::copy(rContainer.begin(), rContainer.end(), pContiguousDataBegin);
    }
 
    inline static void CopyFromContiguousData(
        ContainerType& rContainer,
        PrimitiveType const * pContiguousDataBegin)
    {
        std::copy(pContiguousDataBegin, pContiguousDataBegin + rContainer.size(), rContainer.begin());
    }
 
 
private:
 
    template<unsigned int TCheckIndex, unsigned int TCurrentIndex>
    static constexpr bool IsDimensionDynamicImpl()
    {
        if constexpr(TCheckIndex == TCurrentIndex) {
            return true;
        } else {
            static_assert(TCheckIndex != TCheckIndex, "Invalid dimension index.");
        }
    }
 
 
    template<class T>
    friend class DataTypeTraits;
 
};
 
template<class TDataType> class DataTypeTraits<std::vector<TDataType>>
{
public:
 
    using ContainerType = std::vector<TDataType>;
 
    using ValueType = TDataType;
 
    using ValueTraits = DataTypeTraits<ValueType>;
 
    using PrimitiveType = typename ValueTraits::PrimitiveType;
 
    static constexpr bool IsContiguous = std::is_same_v<PrimitiveType, ValueType>;
 
    static constexpr bool IsDynamic = true;
 
    static constexpr unsigned int Dimension = ValueTraits::Dimension + 1;
 
 
    template<unsigned int TCheckIndex>
    static constexpr bool IsDimensionDynamic()
    {
        return IsDimensionDynamicImpl<TCheckIndex, 0>();
    }
 
    template<class TIndexType = unsigned int>
    static inline TIndexType Size(const ContainerType& rValue)
    {
        return (rValue.empty() ? 0 : rValue.size() * ValueTraits::template Size<TIndexType>(rValue[0]));
    }
 
    template<class TIndexType = unsigned int>
    static inline std::vector<TIndexType> Shape(const ContainerType& rContainer)
    {
        std::vector<TIndexType> shape(Dimension);
        Shape(rContainer, shape.data(), shape.data() + Dimension);
        return shape;
    }
 
    template<class TIndexType = unsigned int>
    static inline void Shape(
        const ContainerType& rContainer,
        TIndexType* pShapeBegin,
        TIndexType* pShapeEnd)
    {
        KRATOS_ERROR_IF_NOT(std::distance(pShapeBegin, pShapeEnd) >= 1)
            << "Invalid dimensions given to fill for primitive data type [ Expected dimension >= 1, provided shape = "
            << std::vector<TIndexType>(pShapeBegin, pShapeEnd) << " ].\n";
 
        if (rContainer.empty()) {
            ValueTraits::Shape(ValueType{}, pShapeBegin + 1, pShapeEnd);
        } else {
            ValueTraits::Shape(rContainer[0], pShapeBegin + 1, pShapeEnd);
        }
        pShapeBegin[0] = rContainer.size();
    }
 
    template<class TIndexType = unsigned int>
    static inline bool Reshape(
        ContainerType& rContainer,
        const std::vector<TIndexType>& rShape)
    {
        return Reshape(rContainer, rShape.data(), rShape.data() + rShape.size());
    }
 
    template<class TIndexType = unsigned int>
    static inline bool Reshape(
        ContainerType& rContainer,
        TIndexType const * pShapeBegin,
        TIndexType const * pShapeEnd)
    {
        KRATOS_ERROR_IF_NOT(std::distance(pShapeBegin, pShapeEnd) >= 1)
            << "Invalid shape/dimension given for std::vector data type [ Expected = " << Shape(rContainer) << ", provided = "
            << std::vector<TIndexType>(pShapeBegin, pShapeEnd) << " ].\n";
 
        bool is_reshaped = false;
 
        if (rContainer.size() != pShapeBegin[0]) {
            rContainer.resize(pShapeBegin[0]);
            is_reshaped = true;
        }
 
        if constexpr(ValueTraits::IsDynamic) {
            std::for_each(rContainer.begin(), rContainer.end(), [&is_reshaped, pShapeBegin, pShapeEnd](auto& rValue) {
                is_reshaped = ValueTraits::Reshape(rValue, pShapeBegin + 1, pShapeEnd) || is_reshaped;
            });
        }
 
        return is_reshaped;
    }
 
    inline static PrimitiveType const * GetContiguousData(const ContainerType& rValue)
    {
        if constexpr(IsContiguous) {
            return rValue.data();
        } else {
            static_assert(!std::is_same_v<TDataType, TDataType>, "GetContiguousData should only be called if rValue is contiguous.");
        }
    }
 
    inline static PrimitiveType * GetContiguousData(ContainerType& rValue)
    {
        if constexpr(IsContiguous) {
            return rValue.data();
        } else {
            static_assert(!std::is_same_v<TDataType, TDataType>, "GetContiguousData should only be called if rValue is contiguous.");
        }
    }
 
    inline static void CopyToContiguousData(
        PrimitiveType* pContiguousDataBegin,
        const ContainerType& rContainer)
    {
        if (rContainer.size() != 0) {
            const auto stride = ValueTraits::Size(rContainer[0]);
            for (unsigned int i = 0; i < rContainer.size(); ++i) {
                ValueTraits::CopyToContiguousData(pContiguousDataBegin + i * stride, rContainer[i]);
            }
        }
    }
 
    inline static void CopyFromContiguousData(
        ContainerType& rContainer,
        PrimitiveType const * pContiguousDataBegin)
    {
        if (rContainer.size() != 0) {
            const auto stride = ValueTraits::Size(rContainer[0]);
            for (unsigned int i = 0; i < rContainer.size(); ++i) {
                ValueTraits::CopyFromContiguousData(rContainer[i], pContiguousDataBegin + i * stride);
            }
        }
    }
 
 
private:
 
    template<unsigned int TCheckIndex, unsigned int TCurrentIndex>
    static constexpr bool IsDimensionDynamicImpl()
    {
        if constexpr(TCheckIndex == TCurrentIndex) {
            return true;
        } else {
            return ValueTraits::template IsDimensionDynamicImpl<TCheckIndex, TCurrentIndex + 1>();
        }
    }
 
 
    template<class T>
    friend class DataTypeTraits;
 
};
 
}; // namespace Kratos