ZblTableData.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2015 Bob Dinitto
 *
 * Filename:   ZblTableData.cpp
 * Created on: 3/16/2015
 * Author:     Bob Dinitto
 *
 * Zuble is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include "ZblTableData.h"
#include "ZblException.h"
#include <QSet>

namespace Zbl
{

ZblTableData::ZblTableData()
: m_columnCount(1), m_rowCount(0)
{}

void ZblTableData::dumpData() const
{
    qDebug("format = row/column/role:data;");

    const int truncatePos = 15;

    QList<int>roleList = roles();
    const int roleCount = roleList.count();

    QString outputRow;
    QByteArray outputAscii;


    for(int row=0; row<m_rowCount;row++)
    {
        outputRow.clear();

        for(int col=0; col<m_columnCount;col++)
        {
            for(int rl=0; rl<roleCount;rl++)
            {
                QString outputCell = "%1/%2/%3:%4;";

                int roleNum = roleList.at(rl);
                QVariant data = getValue(roleNum, row, col);

                QString strData = data.toString();

                if(strData.count() > truncatePos)
                {
                    strData.truncate(truncatePos);
                    strData += "...";
                }
                //outputRow += outputCell.arg(row).arg(col).arg(roleNum).arg(strData);
                QString test = outputCell.arg(row).arg(col).arg(roleNum).arg(strData);
                outputRow.append(test);
                //qDebug("%s",test.toUtf8().constData());
                //outputRow = "foo";
                //outputRow.append(":bar");
                //outputRow.append(test);
                //qDebug("%d/%d/%d:%s;", row, col, roleNum, strData.toUtf8().constData());
            }
        }
        outputAscii = outputRow.toUtf8();
        qDebug("%s",outputAscii.constData());
    }
}

void ZblTableData::putValue(int role, int row, int col, const QVariant value)
{
    if(!hasCell(role, row, col))
        throw ZblException(QString("ZblTableData::putValue - nonexistent cell: "
        "role %1, row %2, col %3").arg(role).arg(row).arg(col));

    zDataTable&  dataTable = m_roles[role];

    zDataRow& dataRow = dataTable[row];

    QVariant& dataVariant = dataRow[col];

    dataVariant = value;

}

QVariant ZblTableData::getValue(int role, int row, int col) const
{
    if(!hasCell(role, row, col))
        throw ZblException(QString("ZblTableData::getValue - nonexistent cell: "
        "role %1, row %2, col %3").arg(role).arg(row).arg(col));

    return m_roles.value(role).at(row).at(col);
}

void ZblTableData::putTableColumnRows(
        QVariant rows,
        int startRow,
        int col)
{
    if(!rows.canConvert<zTableRowList>())
        throw ZblException("ZblTableData::putTableColumnRows - Programming Error: "
                           "rows parameter must contain a ZTableRowList object.");

    zTableRowList rowList = rows.value<zTableRowList>();

    const int count = rowList.count();

    for(int row = 0; row < count; row++)
    {
        zTableRow nextRow = rowList.at(row);
        QList<int> roles = nextRow.keys();
        for(int roleIndex = 0; roleIndex < roles.count(); roleIndex++)
        {
            int nextRole = roles.at(roleIndex);
            QVariant nextValue = nextRow.value(nextRole);
            putValue(nextRole, startRow + row, col, nextValue);
        }
    }
}

QVariant ZblTableData::getTableColumnRows(
        QList<int> roles,
        int startRow,
        int col,
        int rowCount) const
{
    qDebug("ZblTableData::getTableColumnRows");

    zTableRowList rows;

    zTableRow tempRow;

    QSet<int> eliminateDuplicates = QSet<int>::fromList(roles);

    QList<int> roleSet = eliminateDuplicates.toList();

    const int roleCount = roleSet.count();

   int lastRow;

    if(startRow + rowCount - 1 > m_rowCount)
        lastRow = m_rowCount - startRow;
    else
        lastRow = startRow + rowCount - 1;

    qDebug("roleCount=%d, startRow=%d, lastRow=%d", roleCount, startRow, lastRow);


    for(int row = startRow; row < lastRow; row++ )
    {
        for(int rol = 0; rol < roleCount; rol++)
        {
            const int nextRole = roleSet.at(rol);
            qDebug("getting data value at row %d, col %d, role %d", row, col, nextRole);
            //tempRow.insert(nextRole, getValue(nextRole, startRow + row, col));
            tempRow.insert(nextRole, getValue(nextRole, row, col));
        }
        rows.append(tempRow);
        tempRow.clear();
    }

    QVariant vReturn = QVariant::fromValue<zTableRowList>(rows);

    return vReturn;
}


bool ZblTableData::hasCell(int role, int row, int col) const
{
    if(!m_roles.contains(role))
        return false;

    return hasCell(row, col);
}

bool ZblTableData::hasCell(int row, int col) const
{
    return(row >= 0 && m_rowCount > row && m_columnCount > col);
}

void ZblTableData::appendRow(zRoleRow data)
{
    pushRow(data, false);
}

void ZblTableData::appendRows(zRoleRowList data)
{
    const int rowCount = data.size();

    if(!rowCount)
        return;

    for(int i=0; i<rowCount; i++)
    {
        zRoleRow row = data.at(i);
        pushRow(row, false);
    }

}

void ZblTableData::prependRow(zRoleRow data)
{
    pushRow(data, true);
}

void ZblTableData::prependRows(zRoleRowList data)
{
    const int rowCount = data.size();

    if(!rowCount)
        return;

    for(int i=rowCount-1; i>=0; i--)
    {
        zRoleRow row = data.at(i);
        pushRow(row, true);
    }
}

void ZblTableData::removeRows(int row, int count)
{
    if(row >= m_rowCount || count <= 0)
        return;

    zRoleTable newRoles;

    QMapIterator<int, zDataTable> iRoles(m_roles);

    while(iRoles.hasNext())
    {
        iRoles.next();

        zDataTable dt = iRoles.value();

        int delCount = count;

        while(delCount--)
            dt.removeAt(row);

        newRoles.insert(iRoles.key(), dt);
    }

    m_roles = newRoles;

    m_rowCount -= count;
}

void ZblTableData::clearData()
{
    if(!m_rowCount)
        return;

    zRoleTable newRoles;

    zDataTable dt;

    QMapIterator<int, zDataTable> iRoles(m_roles);

    while(iRoles.hasNext())
    {
        iRoles.next();
        newRoles.insert(iRoles.key(), dt);
    }

    m_roles = newRoles;

    m_rowCount = 0;
}

void ZblTableData::clearRoles()
{
    m_roles.clear();

    m_rowCount = 0;
}



bool ZblTableData::addRole(int role)
{
    if(m_rowCount > 0)
        throw ZblException("ZblTableData::addRole - ERROR: can't add roles when "
                           "data table contains rows.");

    if(m_roles.contains(role))
        return false;

    zDataTable newTable;

    m_roles.insert(role, newTable);

    return true;
}


int ZblTableData::findNextItemRow(
        int startRow,
        const QString& text,
        int column,
        bool caseSensitive,
        bool forwardDirection,
        bool keySearch) const
{
    // TBD: forwardDirection ignored!

    if(startRow >= m_rowCount || column >= m_columnCount)
        return -1;

    const Qt::CaseSensitivity cs = caseSensitive ?
                Qt::CaseSensitive : Qt::CaseInsensitive;

    int foundRow = -1;
    bool foundFlag = false;

    QList<int>roleKeys(m_roles.keys());

    const int roleCount = roleKeys.count();

    for(int i=0; i < roleCount; i++)
    {
        const zDataTable& nextRoleTable = m_roles[roleKeys.at(i)];

        for(int j=startRow; j < m_rowCount; j++)
        {
            if(foundFlag && foundRow <= j)
                break;

            const zDataRow& nextRoleRow = nextRoleTable[j];

            QString valueString = nextRoleRow[column].toString();

            if(keySearch)
            {
                // text matches the whole column

                if(QString::compare(text, valueString, cs) == 0)
                {
                    foundFlag = true;
                    foundRow = j;
                    break;
                }

            }
            else
            {
                // text matches part of the column

                if(valueString.contains(text, cs))
                {
                    foundFlag = true;
                    foundRow = j;
                    break;
                }
            }
        }
    }

    return foundRow;
}

bool ZblTableData::copyColumn(int fromColumn, int toColumn)
{
    QList<int>roleList = roles();
    const int roleCount = roleList.count();

    for(int row=0; row < m_rowCount; row++)
    {
        for(int rl=0; rl<roleCount;rl++)
        {
            int roleNum = roleList.at(rl);
            QVariant data = getValue(roleNum, row, fromColumn);
            putValue(roleNum, row, toColumn, data);
        }
    }
}


void ZblTableData::pushRow(zRoleRow data, bool front)
{
    // iterate the data map
    //    for each role
    //      append row to data table

    if(data.isEmpty())
        throw ZblException("ZblTableData::appendRow - new row "
                           "contains no roles.");

    const int roleCount = data.size();

    if(roleCount != m_roles.size())
        throw ZblException("ZblTableData::appendRow - new row's "
                           "role count not equivalent to number of data table roles.");

    QList<int> dataKeys = data.keys();

    QList<int> tableKeys = m_roles.keys();

    if(dataKeys != tableKeys)
        throw ZblException("ZblTableData::appendRow - new row's "
                           "role types not equivalent to data table role types.");

    QList<int>::iterator nextKey = dataKeys.begin();
    QList<int>::iterator lastKey = dataKeys.end();

    // ensure the column counts match
    // TBD: optimize performance by taking this check out of loop for appendRows()!

    while(nextKey != lastKey)
    {
        const int roleKey = *nextKey++;

        zDataRow rowData = data.value(roleKey);

        if(rowData.size() != m_columnCount)
            throw ZblException("ZblTableData::appendRow - new row's "
                               "column count not equivalent to number of data table columns.");
    }

    // append the row to the table

    nextKey = dataKeys.begin();

    while(nextKey != lastKey)
    {
        const int roleKey = *nextKey++;

        zDataTable&  dataTable = m_roles[roleKey];

        const zDataRow& dataRow = data.value(roleKey);

        //qDebug("ZblTableData::appendRow - appending role: %s",
        //       dataRow.at(0).toString().toUtf8().constData());

        if(front)
            dataTable.prepend(dataRow);
        else
            dataTable.append(dataRow);
    }

    m_rowCount++;
}


bool ZblTableData::hasRole(int role) const
{
    return m_roles.contains(role);
}

QList<int> ZblTableData::roles() const
{
    return m_roles.keys();
}

int ZblTableData::roleCount() const
{
    return m_roles.count();
}


int ZblTableData::columnCount() const
{
    return m_columnCount;
}

void ZblTableData::setColumnCount(int count)
{
    if(m_rowCount > 0)
        throw ZblException("ZblTableData::setColumnCount - ERROR: can't set column count when "
                           "data table contains rows.");

    m_columnCount = count;
}

int ZblTableData::rowCount() const
{
    return m_rowCount;
}


} //Zbl