cxCompositeTimedAlgorithm.cpp

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/

#include "cxCompositeTimedAlgorithm.h"

#include <QStringList>
#include "cxTypeConversions.h"
#include "cxLogger.h"

namespace cx
{

CompositeTimedAlgorithm::CompositeTimedAlgorithm(QString name) :
        TimedBaseAlgorithm(name, 20)
{
}

void CompositeTimedAlgorithm::append(TimedAlgorithmPtr child)
{
        mChildren.push_back(child);
}

//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------


CompositeSerialTimedAlgorithm::CompositeSerialTimedAlgorithm(QString name) :
        CompositeTimedAlgorithm(name),
        mCurrent(-1)
{
}

QString CompositeSerialTimedAlgorithm::getProduct() const
{
        if (mCurrent >= 0 && mCurrent < mChildren.size())
        {
                return mChildren[mCurrent]->getProduct();
        }
        return "composite";
}

void CompositeSerialTimedAlgorithm::clear()
{
        // if already started, ignore
        if (mCurrent>=0)
        {
                reportError("Attempt to restart CompositeSerialTimedAlgorithm while running failed.");
                return;
        }

        mChildren.clear();
        mCurrent = -1;
}

void CompositeSerialTimedAlgorithm::execute()
{
        // if already started, ignore
        if (mCurrent>=0)
                return;
        this->startTiming();
        mCurrent = -1;
        emit started(0);
        this->jumpToNextChild();
}

void CompositeSerialTimedAlgorithm::jumpToNextChild()
{
        // teardown old child
        if (mCurrent >= 0 && mCurrent < mChildren.size())
        {
                disconnect(mChildren[mCurrent].get(), SIGNAL(finished()), this, SLOT(jumpToNextChild()));
        }
        ++mCurrent;
        // setup and run next child
        if (mCurrent >= 0 && mCurrent < mChildren.size())
        {
                connect(mChildren[mCurrent].get(), SIGNAL(finished()), this, SLOT(jumpToNextChild()));
                emit productChanged();
                mChildren[mCurrent]->execute();
        }

        // check for finished
        if (mCurrent>=mChildren.size())
        {
                mCurrent = -1;
                this->stopTiming();
                emit finished();
        }
}

bool CompositeSerialTimedAlgorithm::isFinished() const
{
    return mCurrent == -1;
}

bool CompositeSerialTimedAlgorithm::isRunning() const
{
    return mCurrent >= 0;
}

//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------

CompositeParallelTimedAlgorithm::CompositeParallelTimedAlgorithm(QString name) :
        CompositeTimedAlgorithm(name)
{
}

QString CompositeParallelTimedAlgorithm::getProduct() const
{
        QStringList products;
        for (unsigned i=0; i<mChildren.size(); ++i)
        {
                products << mChildren[i]->getProduct();
        }

        if (products.isEmpty())
                return "composite parallel";

        return products.join(", ");
}

void CompositeParallelTimedAlgorithm::clear()
{

        // if already started, ignore
        if (!this->isFinished())
        {
                reportError("Attempt to restart CompositeSerialTimedAlgorithm while running failed.");
                return;
        }

        mChildren.clear();
}

void CompositeParallelTimedAlgorithm::execute()
{
        emit aboutToStart();
        emit started(0);
        for (unsigned i=0; i<mChildren.size(); ++i)
        {
                connect(mChildren[i].get(), SIGNAL(finished()), this, SLOT(oneFinished()));
        }
        for (unsigned i=0; i<mChildren.size(); ++i)
        {
                mChildren[i]->execute();
        }
}

void CompositeParallelTimedAlgorithm::oneFinished()
{
        emit productChanged();

        if (this->isFinished())
                emit finished();
}

bool CompositeParallelTimedAlgorithm::isFinished() const
{
        int count = 0;
        for (unsigned i=0; i<mChildren.size(); ++i)
        {
                if (mChildren[i]->isFinished())
                        ++count;
        }
        return (count==mChildren.size());
}

bool CompositeParallelTimedAlgorithm::isRunning() const
{
    return !this->isFinished();
}



}