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

---

VectorSet.h

Go to the documentation of this file.

#ifndef Impala_Core_Vector_VectorSet_h
#define Impala_Core_Vector_VectorSet_h

#include <vector>
#include "Core/Array/Arrays.h"
#include "Core/Vector/VectorTem.h"
#include "Core/Array/ReadRaw.h"
#include "Core/Array/WriteRaw.h"
#include "Core/Array/SetPart.h"

namespace Impala
{
namespace Core
{
namespace Vector
{


// A set of a variable number of vectors, stored in a Array2dTem.
// Each vector is represented by a variable number of ArrayT::StorType elements.
// Optionally, the set may be treated as consisting of a number of subsets where
// each subset has a fixed number of vectors.
template <class ArrayT>
class VectorSet
{
public:

    typedef typename ArrayT::StorType ElemT;
    typedef VectorTem<ElemT> VectorT;

    typedef VectorTem<ElemT> ColElemType; // for TableTem


    // if (!hasConstVecSize) vecSize is used as an indication only
    // capacity is the (initial) number of vectors
    VectorSet(bool hasConstVecSize, int vecSize, int capacity)
    {
        mHasConstVecSize = hasConstVecSize;
        mVecSize = vecSize;
        mCapacity = capacity;
        mLast = 0;
        mFirst = 0;
        mLength = 0;
        mStorage = new ArrayT(mVecSize, mCapacity, 0, 0);
        if (!mHasConstVecSize)
        {
            mFirst = new Array::Array2dScalarInt32(mCapacity, 1, 0, 0);
            mLength = new Array::Array2dScalarInt32(mCapacity, 1, 0, 0);
        }
    }

    VectorSet(const VectorSet& vs)
    {
        mHasConstVecSize = vs.mHasConstVecSize;
        mVecSize = vs.mVecSize;
        mCapacity = vs.mCapacity;
        mLast = 0;
        mFirst = 0;
        mLength = 0;
        mStorage = new ArrayT(mVecSize, mCapacity, 0, 0);
        if (!mHasConstVecSize)
        {
            mFirst = new Array::Array2dScalarInt32(mCapacity, 1, 0, 0);
            mLength = new Array::Array2dScalarInt32(mCapacity, 1, 0, 0);
        }
    }

    /*
    VectorSet(RawDataSet* dataSet, std::string dir, std::string fileName)
    {
        mFeatVecsA = 0;
        Load(dataSet, dir, fileName);
    }
    */

    virtual
    ~VectorSet()
    {
        if (mFirst)
            delete mFirst;
        if (mLength)
            delete mLength;
        delete mStorage;
    }

    int
    Size() const
    {
        return mLast;
    }

    void
    SetSize(int nr)
    {
        mLast = nr;
    }

    int
    Capacity() const
    {
        return mCapacity;
    }

    bool
    HasConstVectorSize() const
    {
        return mHasConstVecSize;
    }

    // Returns the vector at the indicated position.
    // if (wrapper) the vector is a wrapper so it behaves as a reference!
    VectorT
    GetVector(int id, bool wrapper) const
    {
        if (mHasConstVecSize)
            return VectorT(mVecSize, mStorage->CPB(0, id), wrapper);
        int first = mFirst->Value(id, 0);
        int length = mLength->Value(id, 0);
        return VectorT(length, mStorage->CPB(first, 0), wrapper);
    }

    void
    AddVector(const VectorT& vec)
    {
        // todo : for nonConstVecSize check whether mStorage is big enough,
        //        now only the "number of vectors" is checked
        if (mLast == mCapacity)
            Reserve(Impala::Max(2*mCapacity, 1), true);
        if (!mHasConstVecSize)
        {
            int lastVec = mLast - 1;
            int first = 0;
            if (mLast != 0)
                first = mFirst->Value(lastVec, 0) + mLength->Value(lastVec, 0);
            *(mFirst->CPB(mLast, 0)) = first;
            *(mLength->CPB(mLast, 0)) = vec.Size();
        }
        GetVector(mLast++, true) = vec;
    }

    void
    AddVector(Real64* data, int nrElem) // copies vec
    {
        VectorT vec(nrElem, data, true);
        AddVector(vec);
    }

    // allocates nr new vectors (index [Size(),Size()+nr-1]) and sets the new
    // Size to Size()+nr
    // returns the index of the first new vector
    int
    AllocateVector(int nr)
    {
        if (!mHasConstVecSize)
            return -1;
        if (mLast + nr >= mCapacity)
            Reserve(Impala::Max(2*mCapacity,mCapacity+nr), true);
        int idx = mLast;
        SetSize(mLast + nr);
        return idx;
    }

    // for the "ColumnTem interface"
    VectorT
    Get(int i) const
    {
        return GetVector(i, false); // just to be safe, true is more efficient
    }

    // for the "ColumnTem interface"
    void
    Set(int i, VectorT v)
    {
        GetVector(i, true) = v;
    }

    // for the "ColumnTem interface"
    bool
    Valid() const
    {
        return true;
    }

    bool
    Reserve(int newCapacity, bool copyData)
    {
        if (newCapacity == mCapacity)
            return true;
        int common = (newCapacity > mCapacity) ? mCapacity : newCapacity;
        mCapacity = newCapacity;
        ArrayT* newStorage = new ArrayT(mVecSize, mCapacity, 0, 0);
        if (newStorage == 0)
        {
            std::cout << "VectorSet: could not resize, no memory" << std::endl;
            return false;
        }
        Array::Array2dScalarInt32* newFirst;
        Array::Array2dScalarInt32* newLength;
        if (!mHasConstVecSize)
        {
            newFirst = new Array::Array2dScalarInt32(mCapacity, 1, 0, 0);
            newLength = new Array::Array2dScalarInt32(mCapacity, 1, 0, 0);
            if ((newFirst == 0) || (newLength == 0))
            {
                std::cout << "VectorSet: could not resize, no memory" << std::endl;
                return false;
            }
        }
        if (copyData)
        {
            Array::SetPart(newStorage, mStorage, 0, 0, mVecSize, common, 0, 0);
            if (!mHasConstVecSize)
            {
                Array::SetPart(newFirst, mFirst, 0, 0, common, 1, 0, 0);
                Array::SetPart(newLength, mLength, 0, 0, common, 1, 0, 0);
            }
        }
        delete mStorage;
        mStorage = newStorage;
        if (!mHasConstVecSize)
        {
            delete mFirst;
            delete mLength;
            mFirst = newFirst;
            mLength = newLength;
        }
        if (mLast > mCapacity)
            mLast = mCapacity;
        return true;
    }

    virtual void
    Dump(int from = 0, int to = -1)
    {
        Dump(from, to, std::cout);
    }
    
    virtual void
    Dump(int from, int to, std::ostream& os)
    {
        if (to == -1)
            to = Size();
        if (to < from)
            to = from;
        os << "Dumping VectorSet from " << from << " to " << to
           << " (set size=" << Size() << ", capacity=" << Capacity()
           << ")" << std::endl;
        for (int i=from ; i<to ; i++)
            os << "  " << i << " = " << GetVector(i, true) << std::endl;
        os << std::endl;
    }

    // direct access, use with care

    ArrayT*
    GetStorage()
    {
        return mStorage;
    }

    const ArrayT*
    GetStorage() const
    {
        return mStorage;
    }

    void
    SetStorage(ArrayT* storage)
    {
        if (mStorage)
            delete mStorage;
        mStorage = storage;
        if (mHasConstVecSize)
        {
            mVecSize = mStorage->CW();
            mCapacity = mStorage->CH();
        }
        else
        {
            std::cout << "SetStorage: warning: only works on const size" << std::endl;
        }
    }

    ElemT*
    GetVectorData(int id)
    {
        if (mHasConstVecSize)
            return mStorage->CPB(0, id);
        int first = mFirst->Value(id, 0);
        return mStorage->CPB(first, 0);
    }

    const ElemT*
    GetVectorData(int id) const
    {
        if (mHasConstVecSize)
            return mStorage->CPB(0, id);
        int first = mFirst->Value(id, 0);
        return mStorage->CPB(first, 0);
    }

    int
    GetVectorLength(int id) const
    {
        if (mHasConstVecSize)
            return mVecSize;
        return mLength->Value(id, 0);
    }

private:

    bool mHasConstVecSize;
    int  mVecSize;
    int  mCapacity;
    int  mLast;

    ArrayT* mStorage;

    // if (!mHasConstVecSize) store first element of each vector and its length
    Array::Array2dScalarInt32* mFirst;
    Array::Array2dScalarInt32* mLength;

};

typedef VectorSet<Array::Array2dScalarReal64> ColumnVectorSet;
    
} // namespace Vector
} // namespace Core
} // namespace Impala

#endif

---