---

DAGDBFile.cpp

Go to the documentation of this file.

#include "DAGDBFile.h"
#include "ShockGraph.h"
#include "GestureGraph.h"
#include "Exceptions.h"

#define UNK_GRAPH                       0
#define SHOCK_GRAPH                     1
#define GESTURE_GRAPH           2


int DAGDBFile::GetClassID(const String& strClassName) const
{
        if (strClassName == "ShockGraph")
                return SHOCK_GRAPH;
        else if (strClassName == "GestureGraph")
                return GESTURE_GRAPH;
        
        DBG_MSG1("Warning: Unknown graph class", strClassName);
        return UNK_GRAPH;
}

DAG* DAGDBFile::CreateDAGObj(int nClassID) const
{
        switch (nClassID)
        {
                case SHOCK_GRAPH:
                        return new ShockGraph;
                case GESTURE_GRAPH:
                        return new GestureGraph;
        }

        DBG_MSG1("Warning: Unknown class ID", nClassID);
        return NULL;
}

void DAGDBFile::open(const char* szName, ios_base::openmode nMode)
{
        ASSERT(!IsDBModified());

        // append cannot be specified because we need to overwrite
        // the tail info!
        if (nMode & ios_base::app)
        {
                nMode &= ~ios_base::app;
                nMode |= ios_base::out;
        }

        nMode |= ios_base::in; // We always need to read the tail info

        m_strFileName = szName;
        fstream::open(szName, nMode);

        if (!fail())
        {
                if (!ReadTailInfo())
                {
                        if (!(nMode & ios_base::out))
                        {
                                fstream::close();
                                nMode |= ios_base::out;
                                fstream::open(szName, nMode);
                        }

                        DBG_MSG("Warning: DB tail info has to be rebuilt.");
                        
                        if (!RebuildTailInfo())
                                THROW_EXCEPTION("Cannot read database info.");
                }
        }
}

void DAGDBFile::close()
{
        if (IsDBModified())
                WriteTailInfo();

        m_nDBSize = 0;
        SetDBModified(false);
        m_strFileName.Clear();
        DBInfo().Clear();
        m_dagInfo.Clear();

        fstream::close();
}

bool DAGDBFile::ReadTailInfo()
{
        ASSERT(is_open());
        ASSERT(!IsDBModified());

        MoveToEnd();
        m_nDBSize = tellg();

        if (m_nDBSize > 0)
        {
                MoveTo(m_nDBSize - sizeof(DBINFO));
                
                read((char*) m_pDBInfo, sizeof(DBINFO));

                ASSERT(gcount() == sizeof(DBINFO));

                if (!DBInfo().IsValid())
                        return false;

                MoveTo(DBInfo().m_nTailOffset);
                m_dagInfo.Read(*this);
        }

        return true;
}

void DAGDBFile::WriteTailInfo()
{
        seekp(DBInfo().m_nTailOffset);

        DBInfo().MakeValid();

        m_dagInfo.Write(*this);
        
        write((char*) m_pDBInfo, sizeof(DBINFO));
        flush();

        SetDBModified(false);
}

DAGPtr DAGDBFile::ReadDAG(int nDagId, bool bOnlyDataForMatching /*= false*/)
{
        ASSERT(nDagId < m_dagInfo.GetSize());

        DAGPtr ptrDag;
        DAGINFO info = m_dagInfo[nDagId];
        
        ASSERT(info.nOffset < DBInfo().m_nTailOffset);
        MoveTo(info.nOffset);

        ptrDag = CreateDAGObj(info.nType);
        ASSERT(!ptrDag.IsNull());
        
        try {
                ptrDag->Read(*this, bOnlyDataForMatching);
        }
        catch(ExceptionInfo e)
        {
                e.Print();
                return (DAG*)NULL;
        }

        ptrDag->SetDAGId(nDagId);

        return ptrDag;
}

DAGPtr DAGDBFile::ReadDAG(streamoff nDagOffset, const String& strClassName)
{
        DAGPtr ptrDag;

        ptrDag = CreateDAGObj(GetClassID(strClassName));

        if (!ptrDag.IsNull())
        {
                ASSERT(nDagOffset < DBInfo().m_nTailOffset);
                MoveTo(nDagOffset);

                try {
                        ptrDag->Read(*this);
                }
                catch(ExceptionInfo e)
                {
                        e.Print();
                        return (DAG*)NULL;
                }
        }

        return ptrDag;
}

bool DAGDBFile::AddDAG(const DAG* pDag, bool bReadSaveTailInfo)
{
        DAGINFO info;

        if (bReadSaveTailInfo)
                ReadTailInfo();

        info.nType = GetClassID(pDag->ClassName());
        ASSERT(info.nType != UNK_GRAPH);

        info.nOffset = DBInfo().m_nTailOffset;
        seekp(DBInfo().m_nTailOffset);

        pDag->Write(*this);
        DBInfo().m_nTailOffset = tellp();

        m_dagInfo.AddTail(info);

        if (pDag->GetMaxTSVDimension() > DBInfo().m_nMaxTSVDimension)
                DBInfo().m_nMaxTSVDimension = pDag->GetMaxTSVDimension();

        SetDBModified(true);
        flush();

        if (bReadSaveTailInfo)
                WriteTailInfo();

        return true;
}

bool DAGDBFile::RebuildTailInfo()
{
        String strClassName;
        streampos pos;
        DAGPtr ptrDag;
        DAGINFO dagInfo;

        MoveToEnd();
        DBInfo().m_nTailOffset = tellg();
        DBInfo().m_nMaxTSVDimension = 0;

        MoveToBeg();

        while(!fail())
        {
                pos = tellg();
                strClassName.Read(*this);

                ptrDag = ReadDAG(pos, strClassName);

                if (ptrDag.IsNull())
                        break;

                dagInfo.nOffset = pos;
                dagInfo.nType = GetClassID(strClassName);

                m_dagInfo.AddTail(dagInfo);

                if (ptrDag->GetMaxTSVDimension() > DBInfo().m_nMaxTSVDimension)
                        DBInfo().m_nMaxTSVDimension = ptrDag->GetMaxTSVDimension();
        }

        return SetDBModified(m_dagInfo.GetSize() > 0);
}

---