Method process

src/peprocessor.cpp:133–336

bool PairEndProcessor::process(){
    if(!mOptions->split.enabled)
        initOutput();

    std::thread* readerLeft = NULL;
    std::thread* readerRight = NULL;
    std::thread* readerInterveleaved = NULL;

    mLeftInputLists = new SingleProducerSingleConsumerList<ReadPack*>*[mOptions->thread];
    mRightInputLists = new SingleProducerSingleConsumerList<ReadPack*>*[mOptions->thread];

    ThreadConfig** configs = new ThreadConfig*[mOptions->thread];
    for(int t=0; t<mOptions->thread; t++){
        mLeftInputLists[t] = new SingleProducerSingleConsumerList<ReadPack*>();
        mRightInputLists[t] = new SingleProducerSingleConsumerList<ReadPack*>();
        configs[t] = new ThreadConfig(mOptions, t, true);
        configs[t]->setInputListPair(mLeftInputLists[t], mRightInputLists[t]);
        initConfig(configs[t]);
    }

    if(mOptions->interleavedInput)
        readerInterveleaved= new std::thread(std::bind(&PairEndProcessor::interleavedReaderTask, this));
    else {
        readerLeft = new std::thread(std::bind(&PairEndProcessor::readerTask, this, true));
        readerRight = new std::thread(std::bind(&PairEndProcessor::readerTask, this, false));
    }

    std::thread** threads = new thread*[mOptions->thread];
    for(int t=0; t<mOptions->thread; t++){
        threads[t] = new std::thread(std::bind(&PairEndProcessor::processorTask, this, configs[t]));
    }

    std::thread* leftWriterThread = NULL;
    std::thread* rightWriterThread = NULL;
    std::thread* unpairedLeftWriterThread = NULL;
    std::thread* unpairedRightWriterThread = NULL;
    std::thread* mergedWriterThread = NULL;
    std::thread* failedWriterThread = NULL;
    std::thread* overlappedWriterThread = NULL;
    if(mLeftWriter)
        leftWriterThread = new std::thread(std::bind(&PairEndProcessor::writerTask, this, mLeftWriter));
    if(mRightWriter)
        rightWriterThread = new std::thread(std::bind(&PairEndProcessor::writerTask, this, mRightWriter));
    if(mUnpairedLeftWriter)
        unpairedLeftWriterThread = new std::thread(std::bind(&PairEndProcessor::writerTask, this, mUnpairedLeftWriter));
    if(mUnpairedRightWriter)
        unpairedRightWriterThread = new std::thread(std::bind(&PairEndProcessor::writerTask, this, mUnpairedRightWriter));
    if(mMergedWriter)
        mergedWriterThread = new std::thread(std::bind(&PairEndProcessor::writerTask, this, mMergedWriter));
    if(mFailedWriter)
        failedWriterThread = new std::thread(std::bind(&PairEndProcessor::writerTask, this, mFailedWriter));
    if(mOverlappedWriter)
        overlappedWriterThread = new std::thread(std::bind(&PairEndProcessor::writerTask, this, mOverlappedWriter));

    if(readerInterveleaved) {
        readerInterveleaved->join();
    } else {
        readerLeft->join();