Pipeline.h

#ifndef Pipeline_h
#define Pipeline_h
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <vector>
 
#include <QString>
 
#include "PipelineApplication.h"
 
namespace Isis {
  class FileName;
 
  class Pipeline {
    public:
      Pipeline(const QString &procAppName = "");
      ~Pipeline();
 
      void Prepare();
      void Run();
 
      void SetInputFile(const char *inputParam);
      void SetInputFile(const QString &inputParam);
      void SetInputFile(const char *inputParam, const char *virtualBandsParam);
      void SetInputFile(const QString &inputParam, const QString &virtualBandsParam);
      void SetInputListFile(const char *inputParam);
      void SetInputListFile(const QString &inputParam);
      void SetInputFile(const FileName &inputFileName);
      void SetInputListFile(const FileName &inputFileName);
 
      void SetOutputFile(const char *outputParam);
      void SetOutputFile(const QString &outputParam);
      void SetOutputFile(const FileName &outputFile);
      void SetOutputListFile(const char *outputFileNameParam);
      void SetOutputListFile(const QString &outputFileNameParam);
      void SetOutputListFile(const FileName &outputFileNameList);
      void KeepTemporaryFiles(bool keep);
      bool KeepTemporaryFiles() {
        return p_keepTemporary;
      }
 
      void AddPause();
      void AddToPipeline(const QString &appname);
      void AddToPipeline(const QString &appname, const QString &identifier);
      PipelineApplication &Application(const QString &identifier);
      PipelineApplication &Application(const int &index);
 
      void SetFirstApplication(const QString &appname);
      void SetLastApplication(const QString &appname);
 
      friend std::ostream &operator<<(std::ostream &os, Pipeline &pipeline);
 
      QString Name() const {
        return p_procAppName;
      }
      int Size() const {
        return (int)p_apps.size();
      }
 
      QString OriginalInput(unsigned int branch) {
        return ((branch < p_originalInput.size()) ? p_originalInput[branch] : "");
      }
 
      int OriginalInputSize() {
         return p_originalInput.size();
      }
 
      int OriginalBranchesSize() {
        if (p_originalBranches.size() > 0){
          return p_originalBranches.size();
        }
        return p_inputBranches.size();
      }
 
      std::vector<QString> OriginalBranches() {
        if (p_originalBranches.size() > 0){
          return p_originalBranches;
        }
        return p_inputBranches;
      }
 
      QString FinalOutput(int branch = 0, bool addModifiers = true);
      QString TemporaryFolder();
 
      void EnableAllApplications();
 
      void AddOriginalBranch(QString branch){
        int size = (int)p_inputBranches.size();
        if (size == 1) {
          p_originalBranches.push_back(branch);
        }
        else {
          for (int i=0; i<size; i++) {
            p_originalBranches.push_back(p_inputBranches[i] + "." + branch);
          }
        }
      }
 
      void SetContinue(bool pbFlag) {
        p_continue = pbFlag;
      };
 
    private:
      int p_pausePosition;
      QString p_procAppName; 
      std::vector<QString> p_originalInput; 
      std::vector<QString> p_inputBranches; 
      std::vector<QString> p_originalBranches; 
      std::vector<QString> p_finalOutput; 
      std::vector<QString> p_virtualBands;
      bool p_keepTemporary; 
      bool p_addedCubeatt; 
      std::vector< PipelineApplication * > p_apps; 
      std::vector< QString > p_appIdentifiers; 
      bool p_outputListNeedsModifiers;
      bool p_continue; 
  };
};
 
#endif