Pipeline.h

Go to the documentation of this file.

#ifndef Pipeline_h
#define Pipeline_h

#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