QAlgorithm.h

Go to the documentation of this file.

// QAlgorithm: a class for Qt/C++ implementing generic algorithm logic.
// Copyright (C) 2018  Filippo Santarelli
//
// This program 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 3 of the License, or
// (at your option) any later version.
//
// This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
//
// Contact me at: filippo2.santarelli@gmail.com
//

#ifndef QAlgorithm_h
#define QAlgorithm_h

#include <QtCore>
#include <QtConcurrent/qtconcurrentrun.h>
#include "qa_macros.h"

class QAlgorithm;

typedef QSharedPointer<QAlgorithm> QAShrAlgorithm;
typedef QMap<QString, QVariant> QAPropertyMap;
typedef QMultiMap<QString, QString> QAPropagationRules;
typedef QMap<QAShrAlgorithm, bool> QACompletionMap;
typedef QMap<QAShrAlgorithm, QSet<QAShrAlgorithm>> QAFlatRepresentation;

Q_DECLARE_METATYPE(QAPropertyMap)
Q_DECLARE_METATYPE(QAPropagationRules)
Q_DECLARE_METATYPE(QAShrAlgorithm)

class QAlgorithm : public QObject, public QRunnable 
{
    
    Q_OBJECT
    
    QA_PARAMETER(bool, KeepInput, false)
    QA_PARAMETER(QAPropagationRules, PropagationRules, QAPropagationRules())
    QA_PARAMETER(bool, ParallelExecution, true)
    
    Q_PROPERTY(bool finished READ isFinished NOTIFY justStarted)
    Q_PROPERTY(bool started READ isStarted NOTIFY justFinished)
    Q_PROPERTY(QACompletionMap ancestors READ getAncestors)
    Q_PROPERTY(QACompletionMap descendants READ getDescendants)
    
    QACompletionMap ancestors;
    
    QACompletionMap descendants;
    
    bool finished = false;
    
    void setFinished();
    
    bool started = false;
    
    void setStarted();
    
    static quint32 print_counter;
    
    QFuture<void> result;
    QFutureWatcher<void> watcher;
    
protected:
    
    virtual void setup();
    
    virtual void init(){};
    
    QAShrAlgorithm findAncestor(const QAlgorithm* ancestor) const;
    
    QAShrAlgorithm findAncestor(const QAShrAlgorithm ancestor) const;
    
    QAShrAlgorithm findDescendant(const QAlgorithm* descendant) const;
    
    QAShrAlgorithm findDescendant(const QAShrAlgorithm descendant) const;
    
    QAShrAlgorithm findSharedThis() const;
    
public:
    QAlgorithm(QObject* parent = Q_NULLPTR);
    
    virtual void run() = 0;
    
    QACompletionMap getAncestors() const;
    
    QACompletionMap getDescendants() const;
    
    bool allInputsReady() const;
    
    bool isStarted() const;

    bool isFinished() const;
    
    virtual bool getInput(QAShrAlgorithm parent);
    
    virtual void setParameters(const QAPropertyMap& parameters);
    
    void printGraph(const QString& path = QString()) const;
    
    QString printName() const;
    
    QAFlatRepresentation flattenTree(QAFlatRepresentation tree = QAFlatRepresentation()) const;
    
    void printTree(const QAFlatRepresentation& tree = QAFlatRepresentation()) const;
    
    static void setConnection(QAShrAlgorithm ancestor, QAShrAlgorithm descendant);
    
    static void closeConnection(QAShrAlgorithm ancestor, QAShrAlgorithm descendant);
    
    static bool checkConnection(const QAShrAlgorithm ancestor, const QAShrAlgorithm descendant);
    
    static bool isRemovableConnection(const QAShrAlgorithm p1, const QAShrAlgorithm p2);
    
    static void improveTree(QAlgorithm* leaf);
    
    static std::pair<QString, QVariant> makePropagationRules(std::initializer_list<std::pair<QString,QString>> lst);
    
    public Q_SLOTS:
    
    Q_SLOT void parallelExecution();

    Q_SLOT void serialExecution();
    
    Q_SLOT void abort(QString message = "Unknown Error") const;
    
    Q_SLOT void propagateExecution();
    
Q_SIGNALS:
    Q_SIGNAL void justFinished();

    Q_SIGNAL void justStarted();
    
    Q_SIGNAL void raise(QString message) const;
};

QAShrAlgorithm operator>>(QAShrAlgorithm ancestor, QAShrAlgorithm descendant);

QAShrAlgorithm operator<<(QAShrAlgorithm descendant, QAShrAlgorithm ancestor);

QDebug operator<<(QDebug debug, const QAlgorithm& c);

QDataStream& operator<<(QDataStream& stream, const QAlgorithm& c);

QDataStream& operator>>(QDataStream& stream, QAlgorithm& c);

#endif /* QAlgorithm_h */