|| || || || || || || ||

---

FuncSet.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_FuncSet_h
#define Impala_Core_Array_Pattern_FuncSet_h

#include "Basis/NativeTypes.h"
#include "Core/Array/Pattern/ArrayFunc.h"
#include "Core/Array/Pattern/PtrFunc.h"
#include "Core/Array/Element/E1Cast.h"
#include <memory.h>

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Pattern
{


template <class DstStorT, class SrcStorT>
void
FuncSet_Row(DstStorT* dstPtr, SrcStorT* srcPtr, Int64 nr)
{
    while (--nr >= 0)
        *dstPtr++ = (DstStorT) *srcPtr++;
}

template<>
inline void
FuncSet_Row<Real64, Real64>(Real64* dstPtr, Real64* srcPtr, Int64 nr)
{
    memcpy(dstPtr, srcPtr, sizeof(Real64) * nr);
}

template<class DstArrayT, class SrcArrayT>
void
FuncSet(DstArrayT* dst, SrcArrayT* src, Int64 srcX, Int64 srcY,
        Int64 width, Int64 height, Int64 dstX, Int64 dstY)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;

    if (DstArrayT::ElemSize() == SrcArrayT::ElemSize())
    {
        for (Int64 y=0 ; y<height ; y++)
        {
            DstStorT* dPtr = ArrayCPB(dst, dstX, dstY + y);
            SrcStorT* sPtr = ArrayCPB(src, srcX, srcY + y);
            FuncSet_Row(dPtr, sPtr, width * SrcArrayT::ElemSize());
        }
    }
    else
    {
        for (Int64 y=0 ; y<height ; y++)
        {
            DstStorT* dPtr = ArrayCPB(dst, dstX, dstY + y);
            SrcStorT* sPtr = ArrayCPB(src, srcX, srcY + y);
            for (Int64 x=0 ; x<width ; x++)
            {
                PtrWrite(dPtr, Element::E1Cast(PtrRead(sPtr, SrcArithT()),
                                               DstArithT()));
                dPtr += DstArrayT::ElemSize();
                sPtr += SrcArrayT::ElemSize();
            }
        }
    }
}

} // namespace Pattern
} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---