Application.h

Go to the documentation of this file.

// $Id: $
//-----------------------------------------------------------------------------
//
//  Package    : Application
//  Description: Object defining the application instance itself.
//
//  Author(s)  : F. Machefert -
//  Date       : January 20, 2007
//
//-----------------------------------------------------------------------------

#ifndef INC_APPMGR_H
#define INC_APPMGR_H 1

// Include files
#include "Hierarchy.h"
#include "StatusCode.h"
#include "Object.h"

class Options;
class Console;
class DLLMgr;
class Computer;
class Element;
class Processus;
class ProcDataBase;
class Server;


class State {
 public:
  int nRun;
  int nEventMax;
  int nEvent;
  int nErrors;
  char status[16];
};

class Config {
 public:
  char config[10000];
  //  char currentElement[256];
  //  char processList[1000];
  /*   char children[10000]; */
};

typedef StatusCode ( *RunSvc  )( );
typedef StatusCode ( *PlotSvc )( );

class Application : public Object {
 public:
  Application( );

  virtual ~Application( ); 

  StatusCode initialize();

  StatusCode run ( std::string procName,
           Element* element=0,
           int nEvt = 1);

  StatusCode finalize ();

  Options* options () {
    return m_options;
  }

  Computer* computer () {
    //    info("Computer"+ itos((int)(m_computer)));
    return m_computer;
  }

  DLLMgr* dllMgr () {
    return m_dllMgr;
  }

  ProcDataBase* procDb () {
    return m_procDb;
  }

  StatusCode loadHistoryFile();

  StatusCode bookkeeping();

  void banner ();

  void exit   ();

  void setCurrent (Hierarchy* current) {
    m_current = current;
  }

  Hierarchy* current () {
    return m_current;
  }


  StatusCode cd (std::string path) {
    Hierarchy* newcurrent = m_current->child(path);
    if (0!=newcurrent) {
      setCurrent(newcurrent);
      return StatusCode::SUCCESS;
    }
    else {
      return StatusCode::FAILURE;
    }
  }


  std::string hostname(){
    return m_hostName;
  }

  void treeRecursive( Hierarchy*,
              std::string );

  StatusCode create( std::string, std::string);

  StatusCode makeDir (std::string);

  State* state ();

  Config* config ();

  void setState ( std::string state = std::string("") );

  void setConfig ();

  char* status () {
    return m_state->status;
  }

  void network(std::string);

  void server();

  void setProcessus (Processus* processus) {
    m_processus = processus;
  }

  Processus* processus () {
    return m_processus;
  }

  StatusCode runSvc( ) {
    RunSvc svc = m_runSvc;
    return svc();
  }

  void setRunSvc( RunSvc svc ) {
    m_runSvc = svc;
  }

  StatusCode plotSvc( ) {
    PlotSvc svc = m_plotSvc;
    return svc();
  }

  void setPlotSvc( PlotSvc svc ) {
    m_plotSvc = svc;
  }

  void setVersion (std::string version) {
    m_version = version;
  }

  std::string version () {
    return m_version;
  }

  void setCtrl ( std::string control){
    m_ctrl = control;
  }

  std::string ctrl() {
    return m_ctrl;
  }

  StatusCode svcRunning ( );

  StatusCode prepare ( std::string procName,
               Element* element=0,
               int nEvt = 1);

  StatusCode loop ( );

  StatusCode terminate ( );

  StatusCode svcPlot ( );

 protected:
  std::string m_accountName;
  std::string m_hostName;
  std::string m_osName;
  std::string m_osVersion;
  std::string m_prompt;
  std::string m_version;
  bool m_isRunning;
  Hierarchy    *m_current;

 private:
  Options      *m_options;
  DLLMgr       *m_dllMgr;
  ProcDataBase *m_procDb;
  Computer     *m_computer;

  Processus    *m_processus;

  State        *m_state;         //< Current state of the application
  Config       *m_config;        //< Current config of the application

  RunSvc m_runSvc;               //< Current Processing Service
  PlotSvc m_plotSvc;             //< Current Plotting Service

  Server       *m_server;
  bool m_network;
  std::string m_ctrl;

};

#endif // INC_APPMGR_H