PipelineApplication.h

#ifndef PipelineApplication_h
#define PipelineApplication_h
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <vector>
 
#include <QString>
 
#include "IException.h"
 
namespace Isis {
  class Pipeline;
  class PipelineParameter;
 
  class PipelineApplication {
    public:
      PipelineApplication(QString appName, Pipeline *pipe);
      PipelineApplication(QString appName, PipelineApplication *previous);
 
      ~PipelineApplication() {};
 
      enum NameModifierType {
        ConstantStrings
      };
 
      enum CustomParameterValue {
        LastOutput,
        // Implies branches will be merged if this is set as an input parameter.
        LastAppOutputList,
        // Implies branches will NOT be merged if this is set as an input parameter.
        LastAppOutputListNoMerge
      };
 
      const QString &Name() const {
        return p_name;
      }
      const std::vector<QString> &ParamString() const {
        return p_paramString;
      }
      const std::vector<QString> &InputBranches() const {
        return p_inBranches;
      }
      const std::vector<QString> &OutputBranches() const {
        if(!Enabled() && Previous()) {
          return Previous()->OutputBranches();
        }
        else if(Enabled()) {
          return p_outBranches;
        }
        else {
          return p_inBranches;
        }
      }
 
      void Enable() {
        p_enabled = true;
      };
 
      void Disable() {
        p_enabled = false;
      };
 
      const bool &Enabled() const {
        return p_enabled;
      }
 
      void SetInputParameter(const QString &inputParamName, bool supportsVirtualBands);
      void SetInputParameter(const QString &inputParamName, CustomParameterValue value, bool supportsVirtualBands);
 
      void SetOutputParameter(const QString &outputParamName, const QString &outNameModifier, const QString &outFileExtension = "cub");
      void SetOutputParameter(const QString &branch, const QString &outputParamName,
                              const QString &outNameModifier, const QString &outFileExtension);
 
      void AddBranch(const QString &modString, NameModifierType type);
 
      void AddParameter(const QString &inputParamName, const QString &appParamName);
      void AddParameter(const QString &branch, const QString &inputParamName, const QString &appParamName);
 
      void AddConstParameter(const QString &appParamName, const QString &appParamValue);
      void AddConstParameter(const QString &branch, const QString &appParamName, const QString &appParamValue);
 
      void AddParameter(const QString &appParamName, CustomParameterValue value);
      void AddParameter(const QString &branch, const QString &appParamName, CustomParameterValue value);
 
      QString OutputNameModifier() {
        return (!p_outputMod.isEmpty() || !Previous()) ? p_outputMod : Previous()->OutputNameModifier();
      }
      QString OutputExtension() {
        return (!p_outputExtension.isEmpty() || !Previous()) ? p_outputExtension : Previous()->OutputExtension();
      }
      std::vector<QString> &GetOutputs();
 
      std::vector<QString> TemporaryFiles();
 
      void SetNext(PipelineApplication *next) {
        p_next = next;
      }
 
 
      void SetPrevious(PipelineApplication *prev) {
        p_previous = prev;
      }
 
      void BuildParamString();
 
      PipelineApplication *Next() const {
        if(p_next == NULL) return p_next;
        if(!p_next->Enabled()) return p_next->Next();
        return p_next;
      }
 
      PipelineApplication *Previous() const {
        if(p_previous == NULL) return p_previous;
        if(!p_previous->Enabled()) return p_previous->Previous();
        return p_previous;
      }
 
      PipelineApplication *PreviousOutputer() const {
        if(p_previous == NULL) return p_previous;
        if(!p_previous->Enabled()) return p_previous->Previous();
        if(p_previous->p_output.empty()) return p_previous->Previous();
        return p_previous;
      }
 
      bool SupportsVirtualBands();
      void SetVirtualBands(std::vector<QString> bands);
      
      void EnableBranch(QString branch, bool flag) {
        for(int i=0; i<(int)p_inBranches.size(); i++) {
          if (p_inBranches[i].contains(branch))
            p_enableBranch[i] = flag;
        }
      }
      
      bool BranchEnabled(int branch){
        if (branch >= 0 && branch >= (int)p_enableBranch.size())
          return false;
        return p_enableBranch[branch] ;
      }
      
      void SetContinue(bool pbFlag){
        p_continue = pbFlag;
      };
      
      bool Continue(void) {
        return p_continue;
      };
      
    private:
      bool FutureOutputFileCreated();
      bool LastApplicationWithOutput();
      Pipeline *GetPipeline() {
        return p_pipeline;
      }
 
      bool Branches() {
        if(p_inBranches.size() >= p_outBranches.size()) return false;
        return true;
      }
 
      bool Merges() {
        if(p_inBranches.size() == 1) return false;
        if(p_outBranches.size() == 1) return true;
        return false;
      }
 
      bool StringStartsWith(QString from, QString compare) {
        if(compare.size() > from.size()) return false;
 
        for(int index = 0; index < compare.size(); index++)
          if(from[index] != compare[index]) return false;
 
        return true;
      }
 
      QString CalculateInputFile(int branch);
      QString CalculateOutputFile(int branch);
      QString GetRealLastOutput(bool skipOne = false);
      PipelineParameter &GetInputParameter(int branch);
 
      int FindBranch(QString name, bool input = true);
 
      bool p_continue;
      bool p_enabled; 
      bool p_supportsVirtualBands; 
      QString p_name; 
      std::vector<QString> p_outputs;     
      std::vector<QString> p_tempFiles;   
      std::vector<QString> p_paramString; 
      std::vector<QString> p_inBranches;  
      std::vector<QString> p_outBranches; 
      std::vector<bool>    p_enableBranch; 
      
      std::vector<PipelineParameter> p_output; 
      QString p_outputMod; 
      QString p_outputExtension; 
      std::vector<QString> p_virtualBands; 
 
      std::vector<PipelineParameter> p_input; 
      std::vector<PipelineParameter> p_params; 
 
      PipelineApplication *p_previous; 
      PipelineApplication *p_next; 
      Pipeline *p_pipeline; 
  };
 
  class PipelineParameter {
    public:
      PipelineParameter(QString paramName) {
        p_paramName = paramName;
        p_special = (PipelineApplication::CustomParameterValue) - 1;
        p_branch = -1;
      }
 
 
      PipelineParameter(QString paramName, QString value) {
        p_paramName = paramName;
        p_paramValue = value;
        p_special = (PipelineApplication::CustomParameterValue) - 1;
        p_branch = -1;
      }
 
 
      PipelineParameter(int branch, QString paramName) {
        p_branch = branch;
        p_paramName = paramName;
        p_special = (PipelineApplication::CustomParameterValue) - 1;
      }
 
 
      PipelineParameter(int branch, QString paramName, QString paramValue) {
        p_branch = branch;
        p_paramValue = paramValue;
        p_paramName = paramName;
        p_special = (PipelineApplication::CustomParameterValue) - 1;
      }
 
 
      PipelineParameter(QString paramName, PipelineApplication::CustomParameterValue special) {
        p_paramName = paramName;
        p_special = special;
        p_branch = -1;
      }
 
 
      PipelineParameter(int branch, QString paramName, PipelineApplication::CustomParameterValue special) {
        p_paramName = paramName;
        p_special = special;
        p_branch = branch;
      }
 
 
      bool AppliesToBranch(int branch) {
        return (p_branch == -1 || p_branch == branch);
      }
 
      QString Name() {
        return p_paramName;
      }
      QString Value() {
        return p_paramValue;
      }
      bool IsSpecial() {
        return (p_special != (PipelineApplication::CustomParameterValue) - 1);
      };
      PipelineApplication::CustomParameterValue Special() {
        return p_special;
      }
      bool AffectsAllBranches() {
        return p_branch == -1;
      }
 
    private:
      int p_branch; 
      QString p_paramName; 
      QString p_paramValue; 
      PipelineApplication::CustomParameterValue p_special; 
  };
};
#endif