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

---

E1Cast.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Element_E1Cast_h
#define Impala_Core_Array_Element_E1Cast_h

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

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Element
{


/*
template <class DstArrayT, class SrcArrayT>
inline typename DstArrayT::ArithType
E1Cast(typename SrcArrayT::ArithType v)
{
    return static_cast<typename DstArrayT::ArithType>(v);
}
*/

/* MSVC doesn't support overloading on return type only
template <class DstArithT, class SrcArithT>
inline DstArithT
E1Cast(const SrcArithT& v)
{
    return static_cast<DstArithT>(v);
}
*/

template <class DstArithT, class SrcArithT>
inline DstArithT
E1Cast(const SrcArithT& v, DstArithT)
{
    return static_cast<DstArithT>(v);
}


// template specializations for DstArithT == Int32

/* VC6.0 doesn't handle this one
template <>
inline Int32
E1Cast<Int32,Vec3Real64>(Vec3Real64 v)
{
    return v.X();
}
*/

template <>
inline Int32
E1Cast<Int32,Vec3Int32>(const Vec3Int32& v, Int32)
{
    return v.X();
}

template <>
inline Int32
E1Cast<Int32,Vec3Real64>(const Vec3Real64& v, Int32)
{
    return static_cast<Int32>(v.X());
}

template <>
inline Int32
E1Cast<Int32,Complex64>(const Complex64& v, Int32)
{
    return static_cast<Int32>(v.X());
}


// template specializations for DstArithT == Real64

template <>
inline Real64
E1Cast<Real64,Vec3Int32>(const Vec3Int32& v, Real64)
{
    return v.X();
}

template <>
inline Real64
E1Cast<Real64,Vec3Real64>(const Vec3Real64& v, Real64)
{
    return v.X();
}

template <>
inline Real64
E1Cast<Real64,Complex64>(const Complex64& v, Real64)
{
    return v.X();
}

/*
template <>
inline Real64
E1Cast<Real64,VecN<Real64,5> >(const VecN<Real64,5>& v, Real64)
{
    return v[0];
}
*/


// template specializations for DstArithT == Vec3Int32

/* VC6.0 doesn't handle this one
template <>
inline Vec3Int32
E1Cast<Vec3Int32,Real64>(Real64 v)
{
    return Vec3Int32(v, v, v);
}
*/

template <>
inline Vec3Int32
E1Cast<Vec3Int32,Int32>(const Int32& v, Vec3Int32)
{
    return Vec3Int32(v, v, v);
}

template <>
inline Vec3Int32
E1Cast<Vec3Int32,Vec3Real64>(const Vec3Real64& v, Vec3Int32)
{
    return Vec3Int32(static_cast<Int32>(v.X()), static_cast<Int32>(v.Y()), static_cast<Int32>(v.Z()));
}

template <>
inline Vec3Int32
E1Cast<Vec3Int32,Real64>(const Real64& v, Vec3Int32)
{
    return Vec3Int32(static_cast<Int32>(v), static_cast<Int32>(v), static_cast<Int32>(v));
}


// template specializations for DstArithT == Vec3Real64

/* VC6.0 doesn't handle this one
template <>
inline Vec3Real64
E1Cast<Vec3Real64,Int32>(Int32 v)
{
    return Vec3Real64(v, v, v);
}
*/

template <>
inline Vec3Real64
E1Cast<Vec3Real64,Int32>(const Int32& v, Vec3Real64)
{
    return Vec3Real64(v, v, v);
}

template <>
inline Vec3Real64
E1Cast<Vec3Real64,Real64>(const Real64& v, Vec3Real64)
{
    return Vec3Real64(v, v, v);
}

template <>
inline Vec3Real64
E1Cast<Vec3Real64,Vec3Int32>(const Vec3Int32& v, Vec3Real64)
{
    return Vec3Real64(v.X(), v.Y(), v.Z());
}


// template specializations for DstArithT == Complex64

template <>
inline Complex64
E1Cast<Complex64,Int32>(const Int32& v, Complex64)
{
    return Complex64(v, v);
}

template <>
inline Complex64
E1Cast<Complex64,Real64>(const Real64& v, Complex64)
{
    return Complex64(v, v);
}

// template specializations for DstArithT == VecN<Real64,5>

/*
template <>
inline VecN<Real64,5>
E1Cast<VecN<Real64,5>,Vec3Int32>(const Vec3Int32& v, VecN<Real64,5>)
{
    return VecN<Real64,5>(v.X(), v.Y(), v.Z());
}
*/

} // namespace Element
} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---