CopyMemArray.hpp

// $Id: CopyMemArray.hpp,v 1.4 2006/05/09 12:30:28 werner Exp $
// $Log: CopyMemArray.hpp,v $
// Revision 1.4  2006/05/09 12:30:28  werner
// Adjustments and fixes for MSYS/MINGW32
//
// Revision 1.3  2004/09/30 11:18:40  werner
// Bugfixes and increased functionality for generic field reading.
//
// Revision 1.2  2004/08/12 15:50:54  werner
// Improvements.
//
// Revision 1.1  2004/07/12 13:30:44  werner
// Outsourcing of the MemCore/VecAl interface into the Field library.
//
// Revision 1.4  2004/07/09 20:15:27  werner
// Added local alignment capability when interpolating vector fields and
// option to compute the interpolated derivative.
//
// Revision 1.3  2004/07/06 17:13:59  werner
// Adjustments for GCC 3.4.0
//
// Revision 1.2  2004/07/06 11:56:04  werner
// The Xerox copier is functioning now for all types and all targets.
//
// Revision 1.1  2004/07/04 17:24:57  werner
// Interfacing MemCore library from VecAl and
// template reduction to runtime interface. Uses the META library.
//
 
#include "MemArray.hpp"
#include <vecal/ipol/CopyMultiArray.hpp>
#include <vecal/ipol/ViewMultiArray.hpp>
#include <vecal/ipol/STLMultiArray.hpp>
 
#include <meta/LIST.hpp>
#include <meta/NativeTypeList.hpp>
 
 
 
#ifndef NDEBUG
#define FAST_COMPILATION
#endif
 
namespace Fiber
{
using namespace VecAl;
 
using namespace MemCore;
using namespace META;
 
 
template <class SrcMemArrayType>
struct  CopyMemArraySourceTypeIterator
{
        SrcMemArrayType&Src;
 
        enum { Dims = SrcMemArrayType::Dims };
 
        const MultiIndex<Dims>        &DstOffset;
        const RefPtr<MemArray<Dims> > &Dst;
        const MultiIndex<Dims>        &SrcOffset;
 
        CopyMemArraySourceTypeIterator(const RefPtr<MemArray<Dims> > &pDst,
                                       const MultiIndex<Dims>        &pDstOffset,
                                       SrcMemArrayType&S,
                                       const MultiIndex<Dims>        &pSrcOffset)
        : Src(S), Dst(pDst)
        , DstOffset(pDstOffset), SrcOffset(pSrcOffset)
        {}
 
        template <typename T>
                struct exec
                {
                        template <typename Storage>
                                struct  DstStorage
                        {
                        static  bool CouldCopy(CopyMemArraySourceTypeIterator&It)
                                {
                                        if (RefPtr<MemArrayStorage<Dims, T, Storage> > D = It.Dst)
                                        {
                                                Xerox<MultiArray<Dims, T, Storage>, SrcMemArrayType>::
							Copy( D->myArray(), It.DstOffset, It.Src, It.SrcOffset);
                                                return true; // copy done.
                                        }
                                        return false; // continue traversal
                                }
                        };
 
                        // return true if the traversal of the list
                        // should be stopped
                static inline bool Break(CopyMemArraySourceTypeIterator&It)
                        {
                                if (DstStorage<	       T*  >::CouldCopy(It) ) return true;
                                if (DstStorage<ViewPtr<T>  >::CouldCopy(It) ) return true;
                        //      if (DstStorage<vector <T>  >::CouldCopy(It) ) return true;
                                if (DstStorage<vector <T*> >::CouldCopy(It) ) return true;
 
 
                        /*
                                if (RefPtr<MemArrayStorage<Dims, T, T*> > D = It.Dst)
                                {
                                        Xerox<MultiArray<Dims, T, T*>, SrcMemArrayType, Dims>::
                                                Copy( D->myArray(), It.DstOffset, It.Src, It.SrcOffset);
                                        return true; // copy done.
                                }
                        */
                                return false; // continue traversal
                        }
                };
};
 
 
 
template <int Dims>
struct  CopyMemArrayIterator
{
        const RefPtr<MemArray<Dims> >   &Dst;
        const MultiIndex<Dims>          &DstOffset;
        const RefPtr<MemArray<Dims> >   &Src;
        const MultiIndex<Dims>          &SrcOffset;
 
 
        CopyMemArrayIterator(const RefPtr<MemArray<Dims> >&pDst, const MultiIndex<Dims>&pDstOffset,
                             const RefPtr<MemArray<Dims> >&pSrc, const MultiIndex<Dims>&pSrcOffset)
        : Dst(pDst), DstOffset(pDstOffset)
        , Src(pSrc), SrcOffset(pSrcOffset)
        {}
 
        template <typename T>
                struct exec
                {
                        template <typename Storage>
                                struct  SrcStorage
                        {
                        static  bool CouldCopy(CopyMemArrayIterator&It)
                                {
                                        if (RefPtr<MemArrayStorage<Dims, T, Storage> > Src = It.Src)
                                        {
                                        typedef MultiArray<Dims, T, Storage> SrcMultiArray_t;
 
                                        CopyMemArraySourceTypeIterator<SrcMultiArray_t>
                                                cm( It.Dst, It.DstOffset, Src->myArray(), It.SrcOffset );
 
                                        bool    ok = FOREACH<CopyMemArraySourceTypeIterator<SrcMultiArray_t>,
                                                             FloatTypeList>::exec( cm );
 
                                                return ok;
                                        }
                                        return false;
                                }
                        };
 
                        // return true if the traversal of the list
                        // should be stopped
                static inline bool Break(CopyMemArrayIterator&It)
                        {
                                if (SrcStorage<const T*		>::CouldCopy(It) ) return true;
                                if (SrcStorage<	     T*		>::CouldCopy(It) ) return true;
                                if (SrcStorage<ViewPtr<const T> >::CouldCopy(It) ) return true;
                                if (SrcStorage<ViewPtr<	     T> >::CouldCopy(It) ) return true;
                                if (SrcStorage<vector <	     T> >::CouldCopy(It) ) return true;
                                if (SrcStorage<vector <	    T*> >::CouldCopy(It) ) return true;
 
 
 
/*                      The above code is identical to the explicit version as here,
                        but leaving the storage type open for iteration.
 
                                if (RefPtr<MemArrayStorage<Dims, T, T*> > Src = It.Src)
                                {
                                CopyMemArraySourceTypeIterator<MultiArray<Dims, T, T*> >
                                        cm( It.Dst, It.DstOffset, Src->myArray(), It.SrcOffset );
 
                                bool    ok = FOREACH<CopyMemArraySourceTypeIterator<MultiArray<Dims, T, T*> >,
                                                     FloatTypeList>::exec( cm );
 
                                        return ok;
                                }
*/
                                return false; // continue traversal
                        }
                };
};
 
 
} /* namespace VecAl */