meta_copy.hpp

#ifndef META_COPY_HPP
#define META_COPY_HPP

#include "copy_general.hpp"


template<typename T>
struct meta_copy
{
    static inline void meta_copy_(const T & src, T & dst)
    {
        copy_general<T>(src,dst);
    }

    static inline void meta_copy_(const T & src, T && dst)
    {
        copy_general<T>(src,dst);
    }
};

template<typename Tsrc,typename Tdst>
struct meta_copy_d
{
    static inline void meta_copy_d_(const Tsrc & src, Tdst & dst)
    {
        copy_general<Tsrc>(src,dst);
    }

    static inline void meta_copy_d_(const Tsrc & src, Tdst && dst)
    {
        copy_general<Tsrc>(src,dst);
    }
};

template<typename T,size_t N1>
struct meta_copy<T[N1]>
{
    static inline void meta_copy_(const T src[N1], T dst[N1])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            copy_general<T>(src[i1],dst[i1]);
        }
    }
};

template<typename Tsrc, typename Tdst, size_t N1>
struct meta_copy_d<Tsrc[N1],Tdst>
{
    static inline void meta_copy_d_(const Tsrc src[N1], Tdst && dst)
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            copy_general<Tsrc>(src[i1],static_cast<Tsrc&>(dst[i1]));
        }
    }
};

template<typename Tsrc, typename Tdst, size_t N1>
struct meta_copy_d<Tsrc,Tdst[N1]>
{
    static inline void meta_copy_d_(const Tsrc & src, Tdst dst[N1])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            copy_general<Tdst>(static_cast<const Tdst&>(src[i1]),dst[i1]);
        }
    }
};

template<typename Tsrc, typename Tdst, size_t N1>
struct meta_copy_d<Tsrc[N1],Tdst[N1]>
{
    static inline void meta_copy_d_(const Tsrc src[N1], Tdst dst[N1])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            copy_general<Tsrc>(src[i1],dst[i1]);
        }
    }
};

template<typename T,size_t N1,size_t N2>
struct meta_copy<T[N1][N2]>
{
    static inline void meta_copy_(const T src[N1][N2], T dst[N1][N2])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                copy_general<T>(src[i1][i2],dst[i1][i2]);
            }
        }
    }
};

template<typename Tsrc, typename Tdst,size_t N1,size_t N2>
struct meta_copy_d<Tsrc[N1][N2],Tdst>
{
    static inline void meta_copy_d_(const Tsrc src[N1][N2], Tdst && dst)
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                copy_general<Tsrc>(src[i1][i2],static_cast<Tsrc&>(dst[i1][i2]));
            }
        }
    }
};

template<typename Tsrc, typename Tdst, size_t N1, size_t N2>
struct meta_copy_d<Tsrc,Tdst[N1][N2]>
{
    static inline void meta_copy_d_(const Tsrc & src, Tdst dst[N1][N2])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                copy_general<Tdst>(static_cast<const Tdst&>(src[i1][i2]),dst[i1][i2]);
            }
        }
    }
};



template<typename Tsrc, typename Tdst, size_t N1, size_t N2>
struct meta_copy_d<Tsrc[N1][N2],Tdst[N1][N2]>
{
    static inline void meta_copy_d_(const Tsrc src[N1][N2], Tdst dst[N1][N2])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                copy_general<Tsrc>(src[i1][i2],dst[i1][i2]);
            }
        }
    }
};

template<typename T,size_t N1,size_t N2,size_t N3>
struct meta_copy<T[N1][N2][N3]>
{
    static inline void meta_copy_(const T src[N1][N2][N3], T dst[N1][N2][N3])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                for (size_t i3 = 0 ; i3 < N3 ; i3++)
                {
                    copy_general<T>(src[i1][i2][i3],dst[i1][i2][i3]);
                }
            }
        }
    }
};

template<typename T,size_t N1,size_t N2,size_t N3,size_t N4>
struct meta_copy<T[N1][N2][N3][N4]>
{
    static inline void meta_copy_(const T src[N1][N2][N3][N4], T dst[N1][N2][N3][N4])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                for (size_t i3 = 0 ; i3 < N3 ; i3++)
                {
                    for (size_t i4 = 0 ; i4 < N4 ; i4++)
                    {
                        copy_general<T>(src[i1][i2][i3][i4],dst[i1][i2][i3][i4]);
                    }
                }
            }
        }
    }
};

template<typename T,size_t N1,size_t N2,size_t N3,size_t N4,size_t N5>
struct meta_copy<T[N1][N2][N3][N4][N5]>
{
    static inline void meta_copy_(const T src[N1][N2][N3][N4][N5], T dst[N1][N2][N3][N4][N5])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                for (size_t i3 = 0 ; i3 < N3 ; i3++)
                {
                    for (size_t i4 = 0 ; i4 < N4 ; i4++)
                    {
                        for (size_t i5 = 0 ; i5 < N5 ; i5++)
                        {
                            copy_general<T>(src[i1][i2][i3][i4][i5],dst[i1][i2][i3][i4][i5]);
                        }
                    }
                }
            }
        }
    }
};

template<typename T,size_t N1,size_t N2,size_t N3,size_t N4,size_t N5, size_t N6>
struct meta_copy<T[N1][N2][N3][N4][N5][N6]>
{
    static inline void meta_copy_(const T src[N1][N2][N3][N4][N5][N6], T dst[N1][N2][N3][N4][N5][N6])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                for (size_t i3 = 0 ; i3 < N3 ; i3++)
                {
                    for (size_t i4 = 0 ; i4 < N4 ; i4++)
                    {
                        for (size_t i5 = 0 ; i5 < N5 ; i5++)
                        {
                            for (size_t i6 = 0 ; i6 < N6 ; i6++)
                            {
                                copy_general<T>(src[i1][i2][i3][i4][i5][i6],dst[i1][i2][i3][i4][i5][i6]);
                            }
                        }
                    }
                }
            }
        }
    }
};

template<typename T,size_t N1,size_t N2,size_t N3,size_t N4,size_t N5, size_t N6, size_t N7>
struct meta_copy<T[N1][N2][N3][N4][N5][N6][N7]>
{
    static inline void meta_copy_(const T src[N1][N2][N3][N4][N5][N6][N7], T dst[N1][N2][N3][N4][N5][N6][N7])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                for (size_t i3 = 0 ; i3 < N3 ; i3++)
                {
                    for (size_t i4 = 0 ; i4 < N4 ; i4++)
                    {
                        for (size_t i5 = 0 ; i5 < N5 ; i5++)
                        {
                            for (size_t i6 = 0 ; i6 < N6 ; i6++)
                            {
                                for (size_t i7 = 0 ; i7 < N7 ; i7++)
                                {
                                    copy_general<T>(src[i1][i2][i3][i4][i5][i6][i7],dst[i1][i2][i3][i4][i5][i6][i7]);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
};

template<typename T,size_t N1,size_t N2,size_t N3,size_t N4,size_t N5, size_t N6, size_t N7, size_t N8>
struct meta_copy<T[N1][N2][N3][N4][N5][N6][N7][N8]>
{
    static inline void meta_copy_(const T src[N1][N2][N3][N4][N5][N6][N7][N8], T dst[N1][N2][N3][N4][N5][N6][N7][N8])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                for (size_t i3 = 0 ; i3 < N3 ; i3++)
                {
                    for (size_t i4 = 0 ; i4 < N4 ; i4++)
                    {
                        for (size_t i5 = 0 ; i5 < N5 ; i5++)
                        {
                            for (size_t i6 = 0 ; i6 < N6 ; i6++)
                            {
                                for (size_t i7 = 0 ; i7 < N7 ; i7++)
                                {
                                    for (size_t i8 = 0 ; i8 < N8 ; i8++)
                                    {
                                        copy_general<T>(src[i1][i2][i3][i4][i5][i6][i7][i8],dst[i1][i2][i3][i4][i5][i6][i7][i8]);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
};

template<typename T,size_t N1,size_t N2,size_t N3,size_t N4,size_t N5, size_t N6, size_t N7, size_t N8, size_t N9>
struct meta_copy<T[N1][N2][N3][N4][N5][N6][N7][N8][N9]>
{
    static inline void meta_copy_(const T src[N1][N2][N3][N4][N5][N6][N7][N8][N9], T dst[N1][N2][N3][N4][N5][N6][N7][N8][N9])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                for (size_t i3 = 0 ; i3 < N3 ; i3++)
                {
                    for (size_t i4 = 0 ; i4 < N4 ; i4++)
                    {
                        for (size_t i5 = 0 ; i5 < N5 ; i5++)
                        {
                            for (size_t i6 = 0 ; i6 < N6 ; i6++)
                            {
                                for (size_t i7 = 0 ; i7 < N7 ; i7++)
                                {
                                    for (size_t i8 = 0 ; i8 < N8 ; i8++)
                                    {
                                        for (size_t i9 = 0 ; i9 < N9 ; i9++)
                                        {
                                            copy_general<T>(src[i1][i2][i3][i4][i5][i6][i7][i8][i9],dst[i1][i2][i3][i4][i5][i6][i7][i8][i9]);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
};

template<typename T,size_t N1,size_t N2,size_t N3,size_t N4,size_t N5, size_t N6, size_t N7, size_t N8, size_t N9, size_t N10>
struct meta_copy<T[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10]>
{
    static inline void meta_copy_(const T src[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10], T dst[N1][N2][N3][N4][N5][N6][N7][N8][N9][N10])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                for (size_t i3 = 0 ; i3 < N3 ; i3++)
                {
                    for (size_t i4 = 0 ; i4 < N4 ; i4++)
                    {
                        for (size_t i5 = 0 ; i5 < N5 ; i5++)
                        {
                            for (size_t i6 = 0 ; i6 < N6 ; i6++)
                            {
                                for (size_t i7 = 0 ; i7 < N7 ; i7++)
                                {
                                    for (size_t i8 = 0 ; i8 < N8 ; i8++)
                                    {
                                        for (size_t i9 = 0 ; i9 < N9 ; i9++)
                                        {
                                            for (size_t i10 = 0 ; i10 < N10 ; i10++)
                                            {
                                                copy_general<T>(src[i1][i2][i3][i4][i5][i6][i7][i8][i9][i10],dst[i1][i2][i3][i4][i5][i6][i7][i8][i9][i10]);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
};



template<template<typename,typename> class op, typename T>
struct meta_copy_op
{
    static inline void meta_copy_op_(const T & src, T & dst)
    {
        copy_general_op<op,T>(src,dst);
    }

    static inline void meta_copy_op_(const T & src, T && dst)
    {
        copy_general_op<op,T>(src,dst);
    }
};


template<template<typename,typename> class op, typename T,size_t N1>
struct meta_copy_op<op,T[N1]>
{
    static inline void meta_copy_op_(const T src[N1], T dst[N1])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            copy_general_op<op,T>(src[i1],dst[i1]);
        }
    }
};

template<template<typename,typename> class op, typename T,size_t N1,size_t N2>
struct meta_copy_op<op,T[N1][N2]>
{
    static inline void meta_copy_op_(const T src[N1][N2], T dst[N1][N2])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                copy_general_op<op,T>(src[i1][i2],dst[i1][i2]);
            }
        }
    }
};


template<template<typename,typename> class op, typename T,size_t N1,size_t N2,size_t N3>
struct meta_copy_op<op,T[N1][N2][N3]>
{
    static inline void meta_copy_op_(const T src[N1][N2][N3], T dst[N1][N2][N3])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            for (size_t i2 = 0 ; i2 < N2 ; i2++)
            {
                for (size_t i3 = 0 ; i3 < N3 ; i3++)
                {
                    copy_general_op<op,T>(src[i1][i2][i3],dst[i1][i2][i3]);
                }
            }
        }
    }
};


template<template<typename,typename> class op, typename Tsrc, typename Tdst>
struct meta_copy_op_d
{
    static inline void meta_copy_op_d_(const Tsrc & src, Tdst & dst)
    {
        copy_general_op<op,Tsrc>(src,dst);
    }

    static inline void meta_copy_op_d_(const Tsrc & src, Tdst && dst)
    {
        copy_general_op<op,Tsrc>(src,dst);
    }
};

template<template<typename,typename> class op,typename Tsrc, typename Tdst, size_t N1>
struct meta_copy_op_d<op,Tsrc[N1],Tdst>
{
    static inline void meta_copy_op_d_(const Tsrc src[N1], Tdst && dst)
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            copy_general_op<op,Tsrc>(src[i1],static_cast<Tsrc&>(dst[i1]));
        }
    }
};

template<template<typename,typename> class op, typename Tsrc, typename Tdst, size_t N1>
struct meta_copy_op_d<op,Tsrc,Tdst[N1]>
{
    static inline void meta_copy_op_d_(const Tsrc & src, Tdst dst[N1])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            copy_general_op<op,Tdst>(static_cast<const Tdst&>(src[i1]),dst[i1]);
        }
    }
};

template<template<typename,typename> class op, typename Tsrc, typename Tdst, size_t N1>
struct meta_copy_op_d<op,Tsrc[N1],Tdst[N1]>
{
    static inline void meta_copy_op_d_(const Tsrc src[N1], Tdst dst[N1])
    {
        for (size_t i1 = 0 ; i1 < N1 ; i1++)
        {
            copy_general_op<op,Tdst>(src[i1],dst[i1]);
        }
    }
};

#endif