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

---

QuidTable.h

Go to the documentation of this file.

#ifndef Impala_Core_Table_QuidTable_h
#define Impala_Core_Table_QuidTable_h

#include "Basis/Quid.h"
#include "Util/QuickSort.h"
#include "Core/Table/TableTem.h"
#include "Core/Column/Find.h"
#include "Core/Column/IsSorted.h"
#include "Core/Database/RawDataSet.h"

namespace Impala
{
namespace Core
{
namespace Table
{


typedef TableTem<Column::ColumnTem<Quid> > QuidTableBaseType;


class QuidTable : public QuidTableBaseType
{

    typedef TableTem<Column::ColumnTem<Int32>,
                     Column::ColumnTem<Int32>,
                     Column::ColumnTem<Int32> > ObjectGroupIndex;

public:

    QuidTable() : QuidTableBaseType(0)
    {
        mObjectGroups = 0;
        SetInfo("QuidTable");
        SetColName(1, "quid");
    }

    QuidTable(int size) : QuidTableBaseType(size)
    {
        mObjectGroups = 0;
        SetInfo("QuidTable");
        SetColName(1, "quid");
    }

    int
    GetIndex(Quid q)
    {
        Column::ColumnTem<Quid>* column = GetColumn1();
        return Find(column, q, 0, Size());
    }

    bool
    Contains(Quid q)
    {
        return (GetIndex(q) != Size());
    }

    int
    GetFirstQuidObject(int obj)
    {
        for (int i=0 ; i<mObjectGroups->Size() ; i++)
            if (mObjectGroups->Get1(i) == obj)
                return mObjectGroups->Get2(i);
        return Size();
    }

    int
    GetNrQuidsObject(int obj)
    {
        for (int i=0 ; i<mObjectGroups->Size() ; i++)
            if (mObjectGroups->Get1(i) == obj)
                return mObjectGroups->Get3(i);
        return 0;
    }

    void
    UpdateGroups()
    {
        if (mObjectGroups == 0)
        {
            mObjectGroups = new ObjectGroupIndex(0);
            mObjectGroups->SetColName(1, "object");
            mObjectGroups->SetColName(2, "firstQuidIdx");
            mObjectGroups->SetColName(3, "nrQuids");
        }

        if (! Core::Column::IsSortedAscending(GetColumn1(), Size()))
            Util::QuickSort(GetColumn1()->GetData(), 0, Size()-1);
        mObjectGroups->SetEmpty();
        int lastObj = QuidObject(Get1(0));
        int first = 0;
        int nr = 1;
        for (int i=1 ; i<Size() ; i++)
        {
            int obj = QuidObject(Get1(i));
            if (obj != lastObj)
            {
                mObjectGroups->Add(lastObj, first, nr);
                lastObj = obj;
                first = i;
                nr = 1;
            }
            else
            {
                nr++;
            }
        }
        mObjectGroups->Add(lastObj, first, nr);
    }

    int
    Diff(QuidTable* arg) const
    {
        if (Size() != arg->Size())
        {
            ILOG_ERROR("Diff: Size differs: " << Size() << " vs " <<
                       arg->Size());
            //return 1;
        }
        int nDiff = 0;
        for (int i=0 ; i<Size() ; i++)
        {
            if (Get1(i) != arg->Get1(i))
            {
                ILOG_INFO("Quid " << i << " differs " << Get1(i) <<
                           " vs " << arg->Get1(i));
                nDiff++;
            }
        }
        if (nDiff > 0)
            ILOG_ERROR("Found " << nDiff << " differences");
        return nDiff;
    }

    virtual void
    Dump(Database::RawDataSet* dataSet, int from = 0, int to = -1)
    {
        if (to == -1 || to > Size())
            to = Size();
        if (to < from)
            to = from;
        std::cout << "Dumping table from " << from << " to " << to
                  << " (table size=" << Size() << ", capacity=" << Capacity()
                  << ")" << std::endl;
        for (int i=0 ; i<1 ; i++)
            std::cout << i+1 << "=" << GetColName(i+1) << ", ";
        std::cout << std::endl;
        for (int i=from ; i<to ; i++)
        {
            Quid quid = Get1(i);
            if (dataSet)
                std::cout << dataSet->QuidToString(quid, true) << std::endl;
            else
                std::cout << QuidObj(quid) << std::endl;
        }
        std::cout << std::endl;
    }

    void
    DumpGroup()
    {
        mObjectGroups->Dump();
        int maxNr = -1;
        for (int i=0 ; i<mObjectGroups->Size() ; i++)
        {
            int nr = mObjectGroups->Get3(i);
            if (nr > maxNr)
                maxNr = nr;
        }
        std::cout << "maxNr = " << maxNr << std::endl;
    }

    void
    SetQuidSet(int setId)
    {
        for(int i=0 ; i<Size() ; ++i)
        {
            Quid q = Get1(i);
            Set1(i, MakeQuid(QuidClass(q), setId, QuidObject(q), QuidId(q)));
        }
    }
    
private:

    ObjectGroupIndex* mObjectGroups;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(QuidTable, Impala.Core.Table);

} // namespace Table
} // namespace Core
} // namespace Impala

#endif

---