IX/include/Application.H

Go to the documentation of this file.

#ifndef __APPLICATION_H__
#define __APPLICATION_H__

#include "Profiler.H"
#include "Global.H"
#include "ComLine.H"

namespace ix { namespace app {

    typedef profiler::ProfilerObj                                   Profiler;
    typedef global::GlobalObj<std::string,std::string,Profiler>     Global;
    
    class program2 : public Global
    {
    public:
      program2() : Global() {};
      program2(Global &inglob) : Global(inglob) {};
      program2(int narg,char **args) : Global(narg,args){};
      program2(const std::string &name) : Global(name){};
      program2(const std::string &name,int id) : Global(name,id){};
      virtual int Initialize(){return(0);};
      virtual int Run(){return(0);};
      virtual int Finalize(){return(Global::Finalize());};
      virtual ~program2(){};
    };

    template<typename CommandLineT>
    class command_line_program : public program2
    {
    protected:
      CommandLineT commandLine;
    public:
      command_line_program() : program2() {};
      command_line_program(Global &inglob) : program2(inglob) {};
      command_line_program(const std::string &name) : program2(name){};
      command_line_program(const std::string &name,int id) : program2(name,id){};
      command_line_program(CommandLineT &incom) : program2(), commandLine(incom) {};
      command_line_program(CommandLineT &incom,Global &inglob) : program2(inglob), 
                                                                 commandLine(incom) {};
      command_line_program(int narg,char **args) : program2(narg,args)
      {
        commandLine.Record((const char **)args);
      };
      virtual int Initialize()
      {
        commandLine.Initialize();
        return(commandLine.ProcessOptions());
      };
      CommandLineT &CommandLine() {return commandLine; };
      virtual int Run(){return(0);};
      virtual int Finalize(){return(program2::Finalize());};
      virtual ~command_line_program(){};
    };
    
    class command_line : public ix::util::ComLineObject
    {
    public:
      command_line() : ix::util::ComLineObject() {};
      command_line(const char *args[]) : ix::util::ComLineObject(args) {};
      command_line(command_line &inComLine) : ix::util::ComLineObject(inComLine) {};
      virtual void Initialize() {
        AddOption('d',"debuglevel",1);
        AddOption('h',"help");
        AddOption('v',"verblevel",1);
        AddOption('p',"enable-profiling",1);
        AddHelp('h',"Produces this long help message");
        AddHelp('d',"Set the debugging level for the program.(default=1)");
        AddHelp('p',std::string("Enable profiling. Profiling level > 1 enables")+
                std::string(" profiling\n\t\tbarriers. (default=1)"));
        AddHelp('v',std::string("Set the verbosity level for the program.")+
                std::string(" Anything\n\t\tlarger than 2 is debugging level.")+
                std::string("\n\t\tExamples:\n\t\t\t-v (defaults to 1)\n\t\t\t")+
                std::string("-v 0 (silence)\n\t\t\t--verblevel=2")+
                std::string(" (high verbosity)"));
        SetDescription(std::string("This text should describe the program."));
      };
    };

    typedef global::Program<Global,command_line>                    ProgramType;

    class program : public ProgramType
    {
  
    public:
      program(int narg,char **args) :
        ProgramType(narg,args){};
      program(Global &inglob) :
        ProgramType(inglob){};
      program(command_line &incom) :
        ProgramType(incom){};
      program(command_line &incom,Global &inglob) :
        ProgramType(incom,inglob){};
      virtual int Initialize()
      {
        if(ProgramType::Initialize()){
          ErrOut("Failed to initialize.\n");
          ErrOut(CommandLine().ErrorReport()+std::string("\n"));
          ErrOut("Use -h,--help for usage help.\n\n");
          ErrOut(CommandLine().ShortUsage()+std::string("\n"));
          return(1);
        }
        if(!CommandLine().GetOption('h').empty()){
          StdOut(CommandLine().LongUsage());
          return(1);
        }
        // Verbosity level processing intent:
        // 0 - be silent
        // 1 - normal verbosity
        // 2 - increased verbosity
        // 3 - debug mode engaged (debug stream engaged for root process)
        // 4+ - debug mode (with debugging logged on all processors)
        std::string sverb(CommandLine().GetOption('v'));
        if(!sverb.empty()){
          if(sverb == ".true.")
            SetVerbLevel(1);
          else {
            std::istringstream Istr(sverb);
            int verbLevel;
            Istr >> verbLevel;
            SetVerbLevel(verbLevel);
            if(verbLevel > 1){
              SetDebugStream(ErrStream());
              SetDebugLevel(verbLevel - 1);
            }
          }
        }
        // Process profiling control
        std::string sprof(CommandLine().GetOption('p'));
        if(!sprof.empty()){
          if(sprof == ".true.")
            Profiling(true);
          else {
            std::istringstream Istr(sprof);
            int profLevel;
            Istr >> profLevel;
            if(profLevel == 0)
              Profiling(false);
            if(profLevel >= 1){
              Profiling(true);
            }
          }
        }
        // Process profiling control
        std::string sdebug(CommandLine().GetOption('d'));
        if(!sdebug.empty()){
          if(sdebug == ".true.")
            SetDebugLevel(1);
          else {
            std::istringstream Istr(sdebug);
            int debugLevel;
            Istr >> debugLevel;
            if(debugLevel >= 1)
              SetDebugLevel(debugLevel);
          }
        }
        return(0);
      };
      virtual int Run(){return(0);};
      virtual int Finalize()
      {
        if(OutStreamReady())
          Report(OutStream());
        if(ProgramType::Finalize()){
          ErrOut("Failed to finalize.\n");
          DumpErrors(ErrStream());
          return(1);
        }
        return(0);
      };
      virtual ~program(){};
    };

    template<typename ProgramType>
    int ProgramDriver(ProgramType &applicationProgram){
      //      ProgramType applicationProgram(nargs,args);
      int errCode = applicationProgram.Initialize();
      if(errCode < 0){
        applicationProgram.ErrOut("Failed to initialize.\n");
        return(1);
      } else if (errCode) {
        return(1);
      } else {
        applicationProgram.DebugOut("Initialized.\n",1);
      }
      if(applicationProgram.Run()){
        applicationProgram.ErrOut("Failed to run.\n");
        return(1);
      } else {
        applicationProgram.DebugOut("Ran.\n",1);
      }
      if(applicationProgram.Finalize()){
        applicationProgram.ErrOut("Failed to finalize.\n");
        return(1);
      } else {
        applicationProgram.DebugOut("Finalized.\n",1);
      }
      return(0);
    }
    
  }
}

#endif