pipeline.h

#pragma once
 
#include <QProcess>
#include <QVector>
#include <QWidget>
#include <mutex>
 
#include "ipipeline.h"
#include "result.h"

class Pipeline : public QObject, public maki::IPipeline
{
  Q_OBJECT
public:
  enum class State
  {
    Unknown,   
    Idle,      
    Running,   
    Aborting,  
    Done,      
    Error      
  };
 
  struct ProcessInfo
  {
    QString name = "";              
    State status = State::Unknown;  
  };
 
  struct GroupInfo
  {
    QString name = "";                    
    QVector<ProcessInfo> processes = {};  
  };
 
  struct Info
  {
    QString current = "";               
    QString currentPath = "";           
    QVector<GroupInfo> groupInfo = {};  
  };

  Pipeline(QObject* parent = nullptr);

  ~Pipeline();

  VoidResult add(QProcess* process, maki::OnFail onFail,
                 std::function<void(int& exitCode, QProcess::ExitStatus& status)> callback = nullptr) override;

  VoidResult start();

  QString name() const;

  void setName(const QString& name);

  int size() const;

  bool isRunning() const;

  VoidResult abort(bool syncAbort = false);
 
  void startGroup(const QString& groupName) override;
  void endGroup() override;
 
  QWidget* progressWidget(bool subMenu = false) const;
 
signals:
  void startingProcess(const Info& info, const QString& process, const QStringList& arguments);

  void processStarted(const Info& info, const QString& process, const QStringList& arguments);

  void finished(const Info& info, int exitCode, QProcess::ExitStatus status);

  void finishedLast(const Info& info, int exitCode, const QString& message);

  void startingPipeline(const Info& info);

  void startingGroup(const Info& info, const QString& groupName);

  void finishedGroup(const Info& info, const QString& groupName, int exitCode, const QString& message);

  void readyReadStandardOutput(const QByteArray& message);

  void readyReadStandardError(const QByteArray& message);

  void errorOccurred(const Info& info, QProcess::ProcessError error, const QString& message);
 
private slots:
  void onReadyReadStandardOutput();

  void onReadyReadStandardError();

  void onFinished(int exitCode, QProcess::ExitStatus status);

  void onErrorOccurred(QProcess::ProcessError error);
 
private:
  struct PipelineProcess
  {
    QProcess* process = nullptr;

    maki::OnFail onFail = maki::OnFail::STOP;

    std::function<void(int& exitCode, QProcess::ExitStatus& status)> onFinish;

    State state = State::Unknown;
  };

  struct PipelineGroup
  {
    QString name = "";

    std::vector<std::shared_ptr<PipelineProcess>> processes;
 
    int size() const
    {
      return processes.size();
    }
 
    bool isEmpty() const
    {
      return processes.size() == 0;
    }
 
    int getNextIndex()
    {
      for (int i = 0; i < (int)processes.size(); ++i)
        if (processes.at(i)->state == State::Idle)
          return i;
 
      return -1;
    }
  };

  mutable std::mutex mStateMutex;
  State mState;

  QString mName;

  std::shared_ptr<PipelineProcess> mRunningProcess;
 
  uint32_t mGroupIndex;
  QString mCurrentGroup;
  std::vector<std::shared_ptr<PipelineGroup>> mGroups;

  void startNextOrEnd(int exitCode, QProcess::ExitStatus status);

  bool handleInputData(QByteArray& data) const;
 
  void clearGroups();
  int getIndexOfGroup(const QString& name) const;
  int getIndexofFirstNonEmptyGroup() const;
  std::shared_ptr<Pipeline::PipelineGroup> getGroup();
 
  VoidResult start(const QString& groupName, bool first = false);
 
  Info constructInfo() const;
 
  QString getRunningTask(GroupInfo info) const;
  bool tasksInError(GroupInfo info) const;
  int getCompleteTasks(GroupInfo info) const;
 
  void finishAbort();
};