ArrayList.hpp

 
//
// $Id: ArrayList.hpp,v 1.2 2005/01/17 14:47:28 werner Exp $
// $Log: ArrayList.hpp,v $
// Revision 1.2  2005/01/17 14:47:28  werner
// Improved documentation.
//
// Revision 1.1  2004/08/31 14:10:42  werner
// On-demand loading array classes separated from Field class, and introduced
// transparent multidimensional arrays with on-demand loaded slices.
//
 
#ifndef __FIELD_ARRAYLIST_HPP
#define __FIELD_ARRAYLIST_HPP
 
#include <vecal/ipol/CopyMultiArray.hpp>
#include <vecal/ipol/ViewMultiArray.hpp>
#include "MemArray.hpp"
#include "CreativeArray.hpp"
 
namespace Fiber
{
using namespace VecAl;
 
 
template <class T, class S=T*>
class ArrayList
{
public:
        typedef MultiArray<1, T,  S>  M1D;
 
 
        typedef MultiArray<2, T,  S>  M2D;
 
        typedef MultiArray<2, T, CreativeArray<2, T, S, S> >  M2D_1D;
 
 
        typedef MultiArray<3, T, S>   M3D;
 
        typedef MultiArray<3, T, CreativeArray<3, T, S, S> > M3D_2D;
 
        typedef MultiArray<3, T, CreativeArray<3, T, S, CreativeArray<2, T, S, S> > > M3D_2D_1D;
 
 
        typedef MultiArray<4, T, S>   M4D;
 
        typedef MultiArray<4, T, CreativeArray<4, T, S, S> > M4D_3D;
 
        typedef MultiArray<4, T, CreativeArray<4, T, S, CreativeArray<3, T, S, S> > > M4D_3D_2D;
 
        typedef MultiArray<4, T, CreativeArray<4, T, S, CreativeArray<3, T, S, CreativeArray<2, T, S, S> > > > M4D_3D_2D_1D;
 
};
 
#if 0
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
                        }
                };
};
#endif
 
} /* namespace VecAl */
 
 
#endif // __FIELD_ARRAYLIST_HPP