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

---

ColumnTem.h

Go to the documentation of this file.

#ifndef Impala_Core_Column_ColumnTem_h
#define Impala_Core_Column_ColumnTem_h

#include <iostream>

#include "Basis/ILog.h"

namespace Impala
{
namespace Core
{
namespace Column
{


template <class ElemT>
class ColumnTem
{
public:

    typedef ElemT ColElemType;

    ColumnTem()
    {
        mCapacity = 0;
        mData = 0;
    }

    ColumnTem(int n)
    {
        mCapacity = n;
        mData = new ElemT[mCapacity];
    }

    ColumnTem(const ColumnTem& c)
    {
        mCapacity = c.mCapacity;
        mData = new ElemT[mCapacity];
        for (int i=0 ; i<mCapacity ; i++)
            mData[i] = c.mData[i];
    }

    virtual
    ~ColumnTem()
    {
        if (mData)
            delete [] mData; 
    }

    bool
    Valid() const
    {
        return true;
    }

    int
    Capacity() const
    { 
        return mCapacity; 
    }
    int
    Size() const
    { 
        return mCapacity; 
    }

    bool
    Reserve(int newCapacity, bool copyData)
    {
        if (newCapacity == mCapacity)
            return true;
        int common = (newCapacity > mCapacity) ? mCapacity : newCapacity;
        mCapacity = newCapacity;
        ElemT* newData = new ElemT[mCapacity];
        if (newData == 0)
        {
            ILOG_ERROR("ColumnTem: could not resize, no memory");
            return false;
        }
        if (copyData)
            for (int i=0 ; i<common ; i++)
                newData[i] = mData[i];
        delete [] mData;
        mData = newData;
        return true;
    }

    ColumnTem&
    operator=(const ColumnTem& c)
    {
        if (this != &c)
        {
            if (mCapacity != c.mCapacity)
            {
                delete [] mData;
                mCapacity = c.mCapacity;
                mData = new ElemT[mCapacity];
            }
            for (int i=0 ; i<mCapacity ; i++)
                mData[i] = c.mData[i];
        }
        return *this;
    }

    ElemT&
    operator[](int i)
    { 
        //CheckIndex(i, "operator_array");
        return mData[i];
    }

    ElemT&
    Elem(int i)
    { 
        //CheckIndex(i, "Elem");
        return mData[i];
    }

    ElemT
    Get(int i) const
    { 
        //CheckIndex(i, "Get");
        return mData[i];
    }

    void
    Set(int i, ElemT e)
    {
        //CheckIndex(i, "Set");
        mData[i] = e;
    }

    // direct access, use with care

    ElemT*
    GetData()
    { 
        return mData;
    }

    void
    SetData(ElemT* data, int nrElem, bool copy = true)
    {
        if (mData)
            delete mData;
        if (copy)
        {
            mData = new ElemT[nrElem];
            size_t numBytes = nrElem * sizeof(ElemT);
            memcpy(mData, (void*) data, numBytes);
        }
        else
            mData = data;
        mCapacity = nrElem;
    }

    void
    Print(int from=0, int to=-1)
    {
        if (to < 0 || to > mCapacity)
            to = mCapacity - 1;
        for (int i=from ; i<to ; ++i)
            std::cout << mData[i] << std::endl;
        std::cout << std::endl;
    }

private:

    void
    CheckIndex(int index, String tag = "CheckIndex") const
    {
        if (index >= mCapacity)
            ILOG_ERROR("CheckIndex: [" << tag << "] Index out of range: " <<
                       index);
    }

    int    mCapacity; // number of elements
    ElemT* mData;     // data pointer

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT_TEMPL_1(ColumnTem, ElemT, Impala.Core.Column);

} // namespace Column
} // namespace Core
} // namespace Impala

#endif

---