SpeedNumCube/sncprojects/lib/SNCCore/numberlistmodel.cpp

#include "numberlistmodel.h"

NumberListModel::NumberListModel(QObject *parent) :
    QAbstractListModel(parent)
{
    this->displayCount = 0;
    this->totalCount = 0;
}
int NumberListModel::rowCount(const QModelIndex & /* parent */) const
{
    return displayCount;
}

void NumberListModel::clear()
{
    this->displayCount = 0;
    this->totalCount = 0;
    this->segments.clear();
    this->numbers.clear();
    this->orderIndex.clear();
    this->indexMap.clear();
    this->rowsIndex.clear();
    this->colsIndex.clear();
    beginResetModel();
    endResetModel();
}
//void NumberListModel::optimize()
//{

//    int length=segments.size();

//    for(int i=0;i<length;i++)
//    {
//        emit optimizeProgressMaxUpdated(length);
//        emit optimizeProgressCurrentUpdated(i+1);
//        for (int j=i+1;j<length;j++)
//        {
//            if (segments.at(j) == segments.at(i) )
//            {
//                numbers[i].append(numbers[j]);
//                numbers.removeAt(j);
//                segments.removeAt(j);
//                j--;
//            }
//            length = segments.size();
//        }

//    }
//    setMapIndex();
//}
void NumberListModel::mergeSegment()
{
    int length=segments.size();
    heapSort(length);
    for(int i=0;i<length;i++)
    {
        emit optimizeProgressMaxUpdated(length);
        emit optimizeProgressCurrentUpdated(i+1);
        int j = i+1;
        if(j < length)
        {
            if (segments.at(j) == segments.at(i) )
            {
                numbers[i].append(numbers[j]);
                numbers.removeAt(j);
                segments.removeAt(j);
                i--;
                length = segments.size();
            }
        }
    }
    //setMapIndex();
}
void NumberListModel::setNumberList(QStringList segments,QList<QStringList> numbers)
{
    this->displayCount = 0;
    this->totalCount = 0;
    this->segments.clear();
    this->numbers.clear();
    this->orderIndex.clear();
    this->segments = segments;
    this->numbers = numbers;
    for(int i=0;i<this->numbers.size();i++)
    {
        totalCount = totalCount + this->numbers.at(i).size();        
    }
    for(int i=0;i<totalCount;i++)
    {
        orderIndex.append(i);
    }
    //setMapIndex();
    beginResetModel();
    endResetModel();
    if (canFetchMore(QModelIndex()))
        fetchMore(QModelIndex());
}
QList<int> NumberListModel::getOrderIndex()
{
    return orderIndex ;
}
void NumberListModel::setOrderIndex(QList<int> orderIndex)
{
    this->orderIndex = orderIndex;
    this->displayCount = 0;
    beginResetModel();
    endResetModel();
    if (canFetchMore(QModelIndex()))
        fetchMore(QModelIndex());
}
void NumberListModel::quickSortSegment()
{
    heapSort(segments.size());
    //setMapIndex();
}
int NumberListModel::getCount()
{
    return totalCount ;
}
QStringList NumberListModel::getSegments()
{
    return segments ;
}
QList<QStringList> NumberListModel::getNumbers()
{
    return numbers ;
}
QVariant NumberListModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid())
        return QVariant();
    if (index.row() >= totalCount || index.row() < 0)
        return QVariant();
    switch(role)
    {
        case Qt::DisplayRole://return alias instead of url
            return QVariant(getNumber(index.row()));
            break;
        case Qt::EditRole:
            return QVariant(getNumber(index.row()));
            break;
    }
    return QVariant();
}

 bool NumberListModel::canFetchMore(const QModelIndex & /* index */) const
 {
     if (displayCount < totalCount)
         return true;
     else
         return false;
 }

 void NumberListModel::fetchMore(const QModelIndex & /* index */)
 {

     if(totalCount==0)
         return ;
     int remainder = totalCount - displayCount;
     int itemsToFetch = qMin(100, remainder);
     beginInsertRows(QModelIndex(), displayCount, displayCount+itemsToFetch-1);

     displayCount += itemsToFetch;

     endInsertRows();

     //emit numberPopulated(itemsToFetch);
 }

 void NumberListModel::setMapIndex()
 {
    rowsIndex.clear();
    colsIndex.clear();
    int currow = 0;
    int curcol = 0;
    int row = 0;
    int col = 0;
    if(this->numbers.size()==0)
        return ;
    int numCount = this->numbers.at(0).size();
    for(int i=0;i<this->getCount();i++)
    {
        if( i > numCount -1)//must skip next row;
        {
            currow++;
            curcol = 0;
            numCount += this->numbers.at(currow).size();
        }
        row = currow;
        col = curcol++;
        rowsIndex << row;
        colsIndex << col;
    }
 }
QString NumberListModel::getNumberEx(int index) const
{
    int realrow = orderIndex.at(index);
    if(realrow<colsIndex.size()&&realrow<rowsIndex.size())
    {

        int row = rowsIndex.at(realrow);
        int col = colsIndex.at(realrow);
        return this->segments.at(row)+this->numbers.at(row).at(col);
    }
    else
        return "";
}
QString NumberListModel::getNumber(int shadowRow) const
{

    int totalRow;
    int lastTotalRow;
    int curRow;
    lastTotalRow = 0;
    curRow =0;

    int row = orderIndex.at(shadowRow);
    QTime t;
    t.start();

    for(int i=0;i<this->numbers.size();i++)
    {
        totalRow = lastTotalRow + numbers.at(i).size();
        if(row>totalRow-1)
        {
            lastTotalRow = totalRow;
            continue;
        }
        else
        {
            curRow = row-lastTotalRow;
            int tt = t.elapsed();
            if(tt>0)
                ;//qDebug()<<tt<<i;
            return segments.at(i)+numbers.at(i).at(curRow);
        }
        lastTotalRow = totalRow;

    }

}
void NumberListModel::heapAdjust(int i,int nLength)
{
    int nChild=0;
    QString temp;
    QStringList tmplist;

    for (temp = segments[i]; 2 * i + 1 < nLength; i = nChild)
    {
        temp = segments[i];
        tmplist = numbers[i];
        nChild = 2 * i + 1;//左边的叶子节点
        //得到较大的叶子节点
        if (nChild < nLength - 1)
        {
            if( segments[nChild + 1] > segments[nChild])
            {
                ++nChild;
            }
        }
        //如果较大的叶子节点比父节点大，则交换两个节点的数据
        //同时继续向下寻找交换后的数据是否又比子节点小i = nChild
        if (temp < segments[nChild])
        {
            segments[i]= segments[nChild];
            numbers[i] = numbers[nChild];
            segments[nChild] = temp;
            numbers[nChild] = tmplist;
        }//建立大根堆成功，中止返回
        else
        {
            break;
        }

    }
    //qDebug()<<i;
    return ;
}
void NumberListModel::heapSort(int length)
{
    // 调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素
    for (int i = length / 2 - 1; i >= 0; --i)
    {
        heapAdjust(i,length);
    }
    // 从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
    for (int i = length - 1; i > 0; --i)
    {
        // 把第一个元素和当前的最后一个元素交换，
        // 保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
        swap(0,i);
        // 不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值
        heapAdjust(0,i);

    }
    return ;
}
void NumberListModel::swap(int i,int j)
{
    QString tmp = segments[i];
    QStringList tmplist = numbers[i];
    segments[i] = segments[j];
    numbers[i]= numbers[j];
    segments[j] = tmp;
    numbers[j] = tmplist;
    return ;
}