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

---

AnnotationTableSet.h

Go to the documentation of this file.

#ifndef Impala_Core_Table_AnnotationTableSet_h
#define Impala_Core_Table_AnnotationTableSet_h

#include <vector>
#include "Core/Table/KeywordList.h"
#include "Core/Table/AnnotationTable.h"
#include "Core/Table/Copy.h"
#include "Core/Table/Append.h"
#include "Core/Table/Select.h"

namespace Impala
{
namespace Core
{
namespace Table
{


// basically a wrapper around std::vector of AnnotationTables.
class AnnotationTableSet
{
public:

    AnnotationTableSet()
    {
    }

    AnnotationTableSet(KeywordList labels, int tableSize)
    {
        for (size_t i=0 ; i<labels.size() ; i++)
        {
            AnnotationTable* tab = new AnnotationTable(labels[i], 0);
            Add(tab);
        }
    }

    ~AnnotationTableSet()
    {
        // no destruction of elements, as std::vector doesn't do it either
        //for (int i=0 ; i<mTables.size() ; i++)
        //    delete mTables[i];
    }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    static AnnotationTableSet*
    MakeFromFile(Database::RawDataSet* dataSet, CString labelSet,
                 bool readTables, int quidClass)
    {
        String fName = dataSet->GetFilePathAnnotation(labelSet, false, false);
        if (fName.empty())
        {
            ILOG_ERROR("Unable to read labels");
            return 0;
        }
        Util::Database* db = dataSet->GetDatabase();
        std::vector<String> labels;
        Util::DatabaseReadStrings(labels, fName, db);

        AnnotationTableSet* res = new AnnotationTableSet();
        int nrRead = 0;
        for (int i=0 ; i<labels.size() ; i++)
        {
            AnnotationTable* table = 0;
            if (readTables)
            {
                fName = dataSet->GetFilePathAnnotation(quidClass, labelSet,
                                                       labels[i] + ".tab",
                                                       false, true);
                if (! fName.empty())
                {
                    table = AnnotationTable::MakeFromFile(labels[i], fName, db);
                    nrRead++;
                }
            }
            if (table == 0)
            {
                table = new AnnotationTable(labels[i], 0);
            }
            res->Add(table);
        }
        if (readTables && (nrRead == 0))
            ILOG_ERROR("No tables found");
        return res;
    }
#endif // REPOSITORY_USED

    void
    Delete() // requires "explicit call to destructor"
    {
        for (int i=0 ; i<mTables.size() ; i++)
            delete mTables[i];
        mTables.clear();
    }

    int
    Size()
    {
        return mTables.size();
    }

    void
    Add(AnnotationTable* table)
    {
        mTables.push_back(table);
    }

    KeywordList
    GetLabels() const
    {
        KeywordList res;
        for (int i=0 ; i<mTables.size() ; i++)
            res.push_back(GetLabel(i));
        return res;
    }

    String
    GetLabel(int i) const
    {
        return mTables[i]->GetLabel();
    }

    AnnotationTable*
    GetTable(int i) const
    {
        return mTables[i];
    }

    // return table with given label
    AnnotationTable*
    GetTable(CString label)
    {
        for (int i=0 ; i<mTables.size() ; i++)
            if (GetLabel(i) == label)
                return mTables[i];
        return 0;
    }

    // Merge sets by appending to existing tables
    void
    Merge(AnnotationTableSet* arg)
    {
        for (int i=0 ; i<arg->Size() ; i++)
        {
            AnnotationTable* argTab = arg->GetTable(i);
            String label = arg->GetLabel(i);
            AnnotationTable* thisTab = GetTable(label);
            if (thisTab == 0)
            {
                thisTab = new AnnotationTable(argTab->GetLabel(), 0);
                Copy(thisTab, argTab);
                Add(thisTab);
            }
            else
            {
                Append(thisTab, argTab);
            }
        }
    }

    void
    Correct(AnnotationTableSet* corrections)
    {
        for (int i=0 ; i<corrections->Size() ; i++)
        {
            AnnotationTable* corTab = corrections->GetTable(i);
            String label = corrections->GetLabel(i);
            AnnotationTable* thisTab = GetTable(label);
            if (thisTab == 0)
            {
                thisTab = new AnnotationTable(corTab->GetLabel(), 0);
                Copy(thisTab, corTab);
                Add(thisTab);
            }
            else
            {
                thisTab->Correct(corTab);
            }
        }
    }

    int
    Diff(AnnotationTableSet* arg)
    {
        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 (GetLabel(i) != arg->GetLabel(i))
            {
                ILOG_DEBUG("Label " << i << " differs " << GetLabel(i) <<
                           " vs " << arg->GetLabel(i));
                nDiff++;
            }
            else if (GetTable(i)->Diff(arg->GetTable(i)) > 0)
            {
                ILOG_DEBUG("Table " << i << " differs ");
                nDiff++;
            }
        }
        if (nDiff > 0)
            ILOG_ERROR("Found " << nDiff << " differences");
        return nDiff;
    }

    QuidTable*
    GetUniqueQuids()
    {
        AnnotationTable* allAnno = new AnnotationTable();
        for (int i=0 ; i<Size() ; i++)
        {
            SelectUniqueOnCol(allAnno, GetTable(i), 1, false);
        }
        QuidTable* quids = new QuidTable();
        Copy(quids, allAnno);
        delete allAnno;
        return quids;
    }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    bool
    SaveTables(Database::RawDataSet* dataSet, String conceptSet, bool report)
    {
        bool ok = true;
        for (int i=0 ; i<Size() ; i++)
        {
            AnnotationTable* annoTable = GetTable(i);
            if (annoTable->Size() == 0)
                continue;
            int qClass = annoTable->GetQuidClass();
            String fName = dataSet->GetFilePathAnnotation(qClass, conceptSet,
                                                          GetLabel(i) + ".tab",
                                                          true, false);
            if (fName.empty())
            {
                ok = false;
                continue;
            }
            Write(annoTable, fName, dataSet->GetDatabase(), true);
            if (report)
                annoTable->DumpSummary();
        }
        return ok;
    }
#endif // REPOSITORY_USED

    void
    Dump(bool doTable)
    {
        for (int i=0 ; i<mTables.size() ; i++)
        {
            std::cout << "AnnotationTable " << i << ", label = " << GetLabel(i)
                      << std::endl;
            if (doTable)
                GetTable(i)->Dump();
        }
    }

private:

    std::vector<AnnotationTable*> mTables;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(AnnotationTableSet, Impala.Core.Table);

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

#endif

---