ZblLogMapData.cpp

Go to the documentation of this file.

#include "ZblLogMapData.h"

namespace Zbl
{

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZblLogMapData)

bool ZblLogMapData::isValidMapType(int mapType)
{
    MarkType marktype = MarkType(mapType);

    switch(marktype)
    {
    case Invalid:
    case Selection:
    case Bookmark:
    case Searchmap:
        return true;
    default:
        return false;
    }
}


bool ZblLogMapData::insertMark(qint64 recordID,
                           qint64 lastRecordID,
                           qint64 seekPosition)
{
    zDebug() << "Insert mark, recordID: " << recordID
             << ", lastRecordID: " << lastRecordID
             << ", seekPosition: " << seekPosition;

    if(lastRecordID == -1)
        lastRecordID = recordID;
    else if(recordID > lastRecordID)
    {
        zDebug() << "Warning: lastRecordID should be less than or equal to "
                    "recordID. Swapping values.";

        qint64 temp = recordID;
        recordID = lastRecordID;
        lastRecordID = temp;
    }

    if(m_map.isEmpty())
    {
        zDebug() << "Creating mark at record ID: " << recordID;

        m_map.insert(recordID, MarkNode(recordID, lastRecordID, seekPosition));

        //emit selectionUpdated();

        return true;
    }

    bool retval = false;

    QMap<qint64, MarkNode>::iterator it = m_map.lowerBound(recordID);

    if(it != m_map.end() && it.key() == recordID)
    {
        // a mark exists at the target location

        zDebug() << "A mark already exists at record ID: " << recordID;

        if(it->m_lastID < lastRecordID)
        {
            // existing mark too small, stretch mark to encompass new size

            zDebug() << "Stretching mark at record ID: " << recordID
                        << ", lastID: " << lastRecordID;

            it->m_lastID = lastRecordID;

            mergeMarkNodes(it);

            //emit selectionUpdated();

            retval = true;
        }

        return retval;
    }

    // Get here if either at end of map or no mark exist at target. Index
    // points to mark after target or end of map so back up to preceeding mark
    // and check it. If no intersection with new mark then create a new mark,
    // otherwise new mark starts within previous mark so check end of new mark
    // and grow previous mark if necessary. If a change was made to the map
    // scan subsequent marks to ensure non-overlapping mark structure is
    // maintained.

    if(it == m_map.begin())
    {
        // new mark does not intersect previous mark
        // so create new mark

        zDebug() << "Creating mark at record ID: " << recordID;

        it = m_map.insert(recordID, MarkNode(recordID, lastRecordID, seekPosition));

        mergeMarkNodes(it);

        //emit selectionUpdated();

        return true;
    }

    it--;

    qint64 recID = it->m_recordID;
    qint64 lastID = it->m_lastID;

    if(recordID > lastID+1)
    {
        // new mark does not intersect previous mark
        // so create new mark

        zDebug() << "Creating mark at record ID: " << recordID;

        it = m_map.insert(recordID, MarkNode(recordID, lastRecordID, seekPosition));

        mergeMarkNodes(it);

        //emit selectionUpdated();

        retval = true;
    }
    else if(lastRecordID > lastID)
    {
        // new mark overflows previous, stretch previous mark
        // to encompass new mark

        zDebug() << "Stretching mark at record ID: " << recID
                    << ", lastID: " << lastRecordID;

        it->m_lastID = lastRecordID;

        mergeMarkNodes(it);

        //emit selectionUpdated();

        retval = true;
    }
    else
    {
        zDebug() << "Existing mark subsumes new mark at record ID: "
                    << recID;
    }

    return retval;

}

bool ZblLogMapData::clear()
{
    if(!m_map.isEmpty())
    {
        m_map.clear();

        //emit selectionUpdated();
        return true;
    }
    return false;
}

void ZblLogMapData::mergeMarkNodes(QMap<qint64, MarkNode>::iterator it)
{
    zDebug() << "Merging nodes at record ID: " << it->m_recordID;

    QMap<qint64, MarkNode>::iterator next = it+1;

    while(next != m_map.end())
    {
        if(it->m_lastID < next->m_recordID)
            break;

        if(next->m_lastID > it->m_lastID)
        {
            zDebug() << "Stretching mark at record ID: " << it->m_recordID
                        << ", lastID: " << next->m_lastID;

            it->m_lastID = next->m_lastID;
        }

        zDebug() << "Removing superfluous mark at record ID: "
                << next->m_recordID;

        next = m_map.erase(next);
    }
}

bool ZblLogMapData::hasMark(qint64 recordID) const
{
    if(m_map.isEmpty())
        return false;

    QMap<qint64, MarkNode>::const_iterator it = m_map.lowerBound(recordID);

    if(it == m_map.begin())
        return (recordID >= it->m_recordID && recordID <= it->m_lastID);

    if(it == m_map.end() || recordID != it->m_recordID)
    {
        it--;
        return recordID <= it->m_lastID;
    }

    return true;
}

qint64 ZblLogMapData::findNextMark(qint64 startID, bool forward) const
{
    QMap<qint64, MarkNode>::const_iterator it;

    if( m_map.isEmpty())
        return -1;

    if(startID == 0 && !forward)
        return -1;

    if(forward)
    {
        if(startID == -1)
            it = m_map.begin();
        else
            startID++;

        it = m_map.lowerBound(startID);

        if(it == m_map.end())
            return -1;
        else
            return it.key();
    }
    else
    {
        if(startID == -1)
            it = m_map.end();
        else
            it = m_map.lowerBound(startID);

        if(--it == m_map.begin())
            return -1;
        else
            return it.key();
    }

    return -1;
}


bool ZblLogMapData::removeMark(qint64 recordID, qint64 lastRecordID)
{
    zDebug() << "Remove mark, recordID: " << recordID
             << ", lastRecordID: " << lastRecordID;

    if(m_map.isEmpty())
    {
        zDebug() << "Warning: removeMark called for empty log map.";
        return false;
    }

    bool retval = false;

    if(lastRecordID == -1)
        lastRecordID = recordID;
    else if(recordID > lastRecordID)
    {
        zDebug() << "Warning: lastRecordID should be less than or equal to "
                    "recordID. Swapping values.";

        qint64 temp = recordID;
        recordID = lastRecordID;
        lastRecordID = temp;
    }

    QMap<qint64, MarkNode>::iterator it = m_map.lowerBound(recordID);

    if(it == m_map.end())
    {
        // no mark at target location, check previous
        it--;

        if(it->m_recordID > lastRecordID)
            retval = false; // no overlap of previous
        else if(lastRecordID >= it->m_lastID)
            retval = truncateRange(it, lastRecordID-1); // top overlapps previous
        else
            retval = splitRange(it, recordID-1, lastRecordID+1); // entire range overlaps previous
    }
    else if(it.key() == recordID)
    {
        // a mark exists at the target location

        zDebug() << "A mark exists at record ID: " << recordID;

        if(it->m_lastID == lastRecordID)
        {
            // existing mark matches removed mark

            zDebug() << "Removing mark at record ID: " << recordID
                        << ", lastID: " << lastRecordID;

            m_map.remove(it.key());

            retval =  true;
        }
        else if(it->m_lastID < lastRecordID)
        {
            // existing mark smaller than remove mark

            retval = removeRange(it, recordID, lastRecordID);
        }
        else
        {
            // existing mark larger than remove mark,
            // remove existing and insert tail

            retval = decapitateRange(it, lastRecordID+1);
        }

    }
    else
    {
        // no mark exists at target location

        // check subsequent mark for overlap

        if(it->m_recordID <= lastRecordID)
        {
            retval = decapitateRange(it, lastRecordID+1);
        }
        else
        {
            // check previous mark for overlap

            if(it == m_map.begin())
            {
                retval = false; // no previous mark
            }
            else
            {
                it--;

                if(it->m_lastID < recordID)
                    retval = false; // no overlap of previous

                else if(lastRecordID >= it->m_lastID)
                    retval = truncateRange(it, lastRecordID-1); // top overlapps previous
                else
                    retval = splitRange(it, recordID-1, lastRecordID+1); // entire range overlaps previous
            }
        }
    }

    //if(retval)
    //    emit selectionUpdated();

    return retval;
}

bool ZblLogMapData::removeRange(QMap<qint64, MarkNode>::iterator it, qint64 recordID, qint64 lastRecordID)
{
    // loop removing marks that fall within the range

    bool markRemoved = false;

   while(it->m_recordID <= lastRecordID && it->m_lastID <= lastRecordID)
    {
       m_map.remove(it.key());
       markRemoved = true;
       it++;
       if(it == m_map.end())
           return markRemoved;
    }

   // remove top of mark that overlaps the range, if any

   if(it->m_recordID <= lastRecordID)
   {
       if(decapitateRange(it, lastRecordID+1))
       markRemoved = true;
   }

   return markRemoved;
}

bool ZblLogMapData::decapitateRange(QMap<qint64, MarkNode>::iterator it, qint64 newStartID)
{
    if(newStartID == it->m_recordID)
        return false;

    if(newStartID < it->m_recordID || newStartID > it->m_lastID)
    {
        zWarning() << "newStartID parameter exceeds range of iterator item.";
        return false;
    }

    qint64 lastExtantID = it->m_lastID;

    m_map.remove(it.key());

    insertMark(newStartID,lastExtantID,-1);

    return true;
}

bool ZblLogMapData::truncateRange(QMap<qint64, MarkNode>::iterator it, qint64 newEndID)
{
    if(newEndID < it->m_recordID || newEndID > it->m_lastID)
    {
        zWarning() << "newEndID parameter exceeds range of iterator item.";
        return false;
    }

    it->m_lastID = newEndID;

    return true;
}

bool ZblLogMapData::splitRange(QMap<qint64, MarkNode>::iterator it, qint64 endHeadID, qint64 startTailID)
{
    if(endHeadID < it->m_recordID || endHeadID > it->m_lastID)
    {
        zWarning() << "endHeadID parameter exceeds range of iterator item.";
        return false;
    }

    if(startTailID < it->m_recordID || startTailID > it->m_lastID)
    {
        zWarning() << "startTailID parameter exceeds range of iterator item.";
        return false;
    }

    qint64 lastExtantID = it->m_lastID;

    //m_map.remove(it.key());

    truncateRange(it, endHeadID);

    insertMark(startTailID,lastExtantID,-1);

    return true;
}

ZblLogLinkList ZblLogMapData::getLogLinkList() const
{
    ZblLogLinkList links;

    QMap<qint64, MarkNode>::const_iterator it = m_map.begin();

    for(qint64 index=0; it != m_map.end(); it++)
    {
        qint64 linkID = it->getFirstID();
        qint64 linkPos = it->getSeekPos();
        zDebug() << "link key = " << it.key() << ", ID = " << linkID
                 << ", seek = " << linkPos;

        links.addLink(linkID, linkPos);
    }
    return links;
}




ZblLogMapData::MarkType ZblLogMapData::getMapType() const
{
    return m_markType;
}


} // Zbl