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

---

PtrFunc.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_PtrFunc_h
#define Impala_Core_Array_Pattern_PtrFunc_h

#include "Basis/NativeTypes.h"
#include "Core/Array/Element/ArithTypes.h"

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


/*
template <class ArithT, class StorT>
inline ArithT
PtrRead(StorT* ptr, ArithT)
{
    return *ptr;
}
*/

inline Int32
PtrRead(Int8* ptr, Int32)
{
    return *ptr;
}

inline Int32
PtrRead(UInt8* ptr, Int32)
{
    return *ptr;
}

inline Int32
PtrRead(Int32* ptr, Int32)
{
    return *ptr;
}

inline UInt64
PtrRead(UInt64* ptr, UInt64)
{
    return *ptr;
}

inline Real64
PtrRead(Real64* ptr, Real64)
{
    return *ptr;
}

inline Element::Vec3Int32
PtrRead(UInt8* ptr, Element::Vec3Int32)
{
    return Element::Vec3Int32(ptr[0], ptr[1], ptr[2]);
}

inline Element::Vec2Real64
PtrRead(Real64* ptr, Element::Vec2Real64)
{
    return Element::Vec2Real64(ptr[0], ptr[1]);
}

inline Element::Vec3Real64
PtrRead(Real64* ptr, Element::Vec3Real64)
{
    return Element::Vec3Real64(ptr[0], ptr[1], ptr[2]);
}

inline Element::Complex64
PtrRead(Real64* ptr, Element::Complex64)
{
    return Element::Complex64(ptr[0], ptr[1]);
}

/* This kind of template class with specialization is too diffucult for VC6
template <class ArrayT>
inline void
PtrWrite(typename ArrayT::StorType* ptr, typename ArrayT::ArithType v)
{
    *ptr = v;
}

// Specialization for ArrayVec3Real64
template <>
inline void
PtrWrite<Array2dVec3Real64>(Real64* ptr, Element::Vec3Real64 v)
{
    *ptr++ = v.X();
    *ptr++ = v.Y();
    *ptr++ = v.Z();
}
*/

inline void
PtrWrite(Int8* ptr, Int32 v)
{
    *ptr = v;
}

inline void
PtrWrite(UInt8* ptr, Int32 v)
{
    *ptr = v;
}

inline void
PtrWrite(Int32* ptr, Int32 v)
{
    *ptr = v;
}

inline void
PtrWrite(UInt64* ptr, UInt64 v)
{
    *ptr = v;
}

inline void
PtrWrite(Real64* ptr, Real64 v)
{
    *ptr = v;
}

inline void
PtrWrite(UInt8* ptr, const Element::Vec3Int32& v)
{
    *ptr++ = v.X();
    *ptr++ = v.Y();
    *ptr++ = v.Z();
}

inline void
PtrWrite(Int32* ptr, const Element::Vec3Int32& v)
{
    *ptr++ = v.X();
    *ptr++ = v.Y();
    *ptr++ = v.Z();
}

inline void
PtrWrite(Real64* ptr, const Element::Vec2Real64& v)
{
    *ptr++ = v.X();
    *ptr++ = v.Y();
}

inline void
PtrWrite(Real64* ptr, const Element::Vec3Real64& v)
{
    *ptr++ = v.X();
    *ptr++ = v.Y();
    *ptr++ = v.Z();
}

inline void
PtrWrite(Real64* ptr, const Element::Complex64& v)
{
    *ptr++ = v.X();
    *ptr++ = v.Y();
}

/*
template <class ElemT, int vecSize>
inline void
PtrWrite(ElemT* ptr, const VecN<ElemT,vecSize>& v)
{
    for (int i=0 ; i<vecSize ; i++)
        *ptr++ = v[i];
}
*/

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

#endif

---