SpeedNumCube/sncprojects/lib/SNCCore/importproxy.cpp

#include "importproxy.h"

ImportProxy::ImportProxy(NumberListModel *oldModel)
{

    this->stop =false;
    this->oldModel = oldModel;
    this->batchSize = 1;
    this->resAvailable = 0;
    this->counter = 0;
    this->readFinished = false;
    this->all_file_size = 0;
    this->current_file_size = 0;
    this->step1Progress = 30;
    this->step2Progress = 70;
    this->threadAlive = 5;
    this->threadDead = 0;
    this->bufferAppendedTimes = 0;
    this->bufferTakedTimes = 0;
}
ImportProxy::~ImportProxy()
{
    qDebug()<<QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss")\
           <<"ImportProxy Destroyed.";
}
void ImportProxy::setFetchList(QStringList list)
{
    this->fetchList = list;
}
void ImportProxy::abort()
{
    this->stop = true;
}
void ImportProxy::onChildTaskFinished(QStringList segments,QList<QStringList> numbers)
{

    QMutexLocker locker(&mutex);
    if(segments.size()!=0)
    {
        this->segments.append(segments);
        this->numbers.append(numbers);
    }
    this->counter++;
    if(readFinished)
    {

        double s1 = counter;
        double s2 = resAvailable;
        emit progressUpdated(step1Progress+step2Progress*s1/s2);
        //qDebug()<<step1Progress+step2Progress*s1/s2;
    }
}
void ImportProxy::onBufferAppended()
{
    QMutexLocker locker(&mutex);
    bufferAppendedTimes++;
}
void ImportProxy::onBufferTaked()
{
    QMutexLocker locker(&mutex);
    bufferTakedTimes++;
}
void ImportProxy::onProduced(int strSize)
{
    this->resAvailable++;
    this->current_file_size += strSize;
    double s1 = this->current_file_size;
    double s2 = this->all_file_size;
    emit progressUpdated(step1Progress*s1/s2);
}
void ImportProxy::onThreadDestroy()
{
    QMutexLocker locker(&mutex);
    this->threadDead++;
}
void ImportProxy::onProducerFinished()
{
   readFinished = true;
   emit progressUpdated(step1Progress);
}
void ImportProxy::run()
{
    emit progressMaxUpdated(100);
    mutex2 = new QMutex();
    buffer = new QList<QStringList>();
    setFetchMaxSize();
    ImportProducer *producer = new ImportProducer(this->fetchList,buffer,mutex2);
    producer->setBuildType(this->buildType);
    connect(producer,SIGNAL(produced(int )),this,SLOT(onProduced(int )));
    connect(producer,SIGNAL(producerFinished()),this,SLOT(onProducerFinished()));
    connect(producer,SIGNAL(bufferAppended()),this,SLOT(onBufferAppended()));
    producer->start();
    QList<ImportConsumer*> consumers;
    for(int i=0;i<5;i++)
    {
        ImportConsumer *consumer = new ImportConsumer(buffer,mutex2);
        consumer->setBuildType(this->buildType);
        consumers.append(consumer);
        connect(consumer,SIGNAL(threadDestroy()),this,SLOT(onThreadDestroy()));
        connect(consumer,SIGNAL(childTaskFinished(QStringList,QList<QStringList>)),
                         this,SLOT(onChildTaskFinished(QStringList,QList<QStringList>)));
        connect(consumer,SIGNAL(bufferTaked()),this,SLOT(onBufferTaked()));
        consumer->start();
    }
    while(!stop)
    {
        msleep(100);
        if(producer->isFinished()&&readFinished)//文件读取完成
        {
            //if(resAvailable == counter && resAvailable!=0)//号码处理完成
            if(bufferAppendedTimes==bufferTakedTimes)
            {
                for(int i=0;i<consumers.size();i++)
                {
                    consumers[i]->abort();
                }
                for(int i=0;i<consumers.size();i++)
                {
                    consumers[i]->wait();
                }
                for(int i=0;i<consumers.size();i++)
                {
                    delete consumers[i];
                }
                delete this->mutex2;
                appendModel();
                emit progressMaxUpdated(1);
                emit progressUpdated(1);
                emit numberBuilt(newModel);
                break;
            }
        }
    }
    producer->wait();
    delete producer;
}
void ImportProxy::appendModel()
{
    newModel = new  NumberListModel();
    if(oldModel){
        segments.append(oldModel->getSegments());
        numbers.append(oldModel->getNumbers());
        oldModel->clear();
    }
    newModel->setNumberList(segments,numbers);
}
void ImportProxy::setBuildType(NumberBuildType buildType)
{
    this->buildType = buildType;
    if(this->buildType==NumberFromFileImport)
    {
        this->step1Progress = 95;
        this->step2Progress = 5;
    }
    else if(this->buildType==NumberFromFileExtract || this->buildType==NumberFromContent)
    {
        this->step1Progress = 5;
        this->step2Progress = 95;
    }
}
void ImportProxy::setFetchMaxSize()
{
    if(this->buildType==NumberFromFileImport || this->buildType == NumberFromFileExtract)
    {
        for(int i=0;i<this->fetchList.size();i++)
        {
            QFileInfo fileinfo(this->fetchList.at(i));
            this->all_file_size+=fileinfo.size();
        }
    }
    else if(this->buildType==NumberFromContent)
    {

        for(int i=0;i<this->fetchList.size();i++)
        {
            this->all_file_size += this->fetchList.at(i).size();
        }
    }
}