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

---

VecTem.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Element_VecTem_h
#define Impala_Core_Array_Element_VecTem_h

#include <iostream>
#include "Core/Array/Element/Vec3Int32.h"

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


template <class ElemT, int vecSize>
class VecTem
{
public:

    typedef ElemT      ElemType;
    static const int   VecSize() { return vecSize; }

    VecTem()
    {
        mData = new ElemType[vecSize];
        mIsWrapper = false;
    }

    VecTem(ElemType a0)
    {
        mData = new ElemType[vecSize];
        mIsWrapper = false;
        mData[0] = a0;
        for (int i=1 ; i<vecSize ; i++)
            mData[i] = 0;
    }

    VecTem(ElemType a0, ElemType a1)
    {
        mData = new ElemType[vecSize];
        mIsWrapper = false;
        mData[0] = a0;
        mData[1] = a1;
        for (int i=2 ; i<vecSize ; i++)
            mData[i] = 0;
    }

    VecTem(ElemType a0, ElemType a1, ElemType a2)
    {
        mData = new ElemType[vecSize];
        mIsWrapper = false;
        mData[0] = a0;
        mData[1] = a1;
        mData[2] = a2;
        for (int i=3 ; i<vecSize ; i++)
            mData[i] = 0;
    }

    VecTem(ElemType* a, bool isWrapper)
    {
        mIsWrapper = isWrapper;
        mData = (mIsWrapper) ? a : new ElemType[vecSize];
        if (!mIsWrapper)
            for (int i=0 ; i<vecSize ; i++)
                mData[i] = a[i];
    }

    VecTem(const VecTem<ElemType,vecSize>& v)
    {
        mIsWrapper = v.mIsWrapper;
        mData = (mIsWrapper) ? v.mData : new ElemType[vecSize];
        if (!mIsWrapper)
            for (int i=0 ; i<vecSize ; i++)
                mData[i] = v.mData[i];
    }

    ~VecTem()
    {
        if (!mIsWrapper)
            delete [] mData;
    }

    VecTem<ElemT, vecSize>&
    operator=(const VecTem<ElemT, vecSize>& v)
    {
        if (this != &v)
        {
            for (int i=0 ; i<vecSize ; i++)
                mData[i] = v.mData[i];
        }
        return *this;
    }

    VecTem<ElemT, vecSize>&
    operator=(const Vec3Int32& v)
    {
        mData[0] = v.X();
        mData[1] = v.Y();
        mData[2] = v.Z();
        return *this;
    }

    ElemType&
    operator[](int i) const
    { 
        return mData[i];
    }

    /*
    int
    operator==(const Vec3Real64& v) const
    {
        return (mValues[0] == v.mValues[0]) && (mValues[1] == v.mValues[1]) &&
               (mValues[2] == v.mValues[2]);
    }
    */

private:

    ElemType* mData;
    bool      mIsWrapper;

};

template <class ElemT, int vecSize>
inline std::ostream&
operator<<(std::ostream& os, const VecTem<ElemT,vecSize>& v)
{
    os << "(";
    for (int i=0 ; i<vecSize-1 ; i++)
        os << v[i] << ",";
    return os << v[vecSize-1] << ")";
}

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

#endif

---