Program.h

#ifndef CARMA_UTIL_PROGRAM_H
#define CARMA_UTIL_PROGRAM_H

#include <cstdlib>
#include <cstdio>
#include <string>
#include <map>
#include <memory>

#include <sys/types.h>

#include "carma/util/FacilityType.h"

// Declaration of carma_main.  See comments in Program.cc for more info.
int carma_main( int argc, char ** argv );

namespace log4cpp {

class Category;

}  // namespace log4cpp


namespace carma {

namespace corba {

    class Server;
    class Client;

} // namespace carma::corba

namespace util {

class Orb;
class ProcessMonitorClient;
class Trace;


typedef struct {
    const char * const key;

    const char * const val;

    const char * const type;

    const char * const usageValue;

    const char * const help;
} KeyTabEntry;


class Program;

class ProgramBase {
    friend int ::carma_main( int argc, char ** argv );

    public:

      bool parameterWasSpecified( const ::std::string & key );

      bool getBoolParameter( const ::std::string & key );

      double getDoubleParameter( const ::std::string & key );

      int getIntParameter( const ::std::string & key );

      ::std::string getStringParameter( const ::std::string & key );

      ::std::string getParameterRawValueString( const ::std::string & key );


      int getDebugLevel( ) const;

      bool DebugLevel( int level = 0 ) const;


      void setInstanceLogname( const ::std::string & logname );

      ::std::string getLogname(  ) const;

      ::std::string getLogHostname( ) const;


      bool haveImrHostname( ) const;

      ::std::string getImrHostname( ) const;


      bool orbInit(Orb* orb);

      carma::corba::Server & getCorbaServer();
      carma::corba::Client & getCorbaClient();


      bool imrTerminationRequested( );

      // class static methods

      static log4cpp::Category & getLogger( );

      static log4cpp::Category * getLoggerIfAvailable( );

      static carma::util::Trace * getTraceObject( );

      static carma::util::Trace * getTraceObjectIfAvailable( );


      static bool getUseDBMS( ) ;


      static ::std::string getArg0( );


      static int getExtraArgc( );

      static char ** getExtraArgv( );


      static ::std::string getConfDir( );

      static ::std::string getConfFile( const ::std::string & filename );


      static ::std::string getRootDir( );

      static ::std::string getExecutableDir( );

      static ::std::string getExecutable( );

     static pid_t getPid( );

     static ::std::string getHostname( bool shorten );

     static ::std::string getCwd( );

     int getTraceLevel( ) const;

     void adjustTraceLevel( int newTraceLevel );

     int getNiceLevel( ) const;
     
     bool getUseGMT() const; 

     ::std::string getUsageString( ) const;

    protected:

        ProgramBase( );

        ~ProgramBase( );

    private:

        typedef enum {
            // Please note that these states are in a particular order.

            BEING_CONSTRUCTED_STATE,
            CONSTRUCTED_STATE,

            ADDING_KEY_DEFINITIONS_STATE,
            KEY_DEFINITIONS_ADDED_STATE,

            PARSING_COMMAND_LINE_STATE,
            COMMAND_LINE_PARSED_STATE,

            INITIALISING_SYSTEM_KEYWORD_MEMBERS_STATE,
            SYSTEM_KEYWORD_MEMBERS_INITIALISED_STATE,

            LOGGER_AVAILABLE_STATE,
            TRACE_OBJECT_AVAILABLE_STATE,

            FULLY_INITIALISED_STATE,
            
            // most of our time is spent in here between these two states

            BEING_DESTRUCTED_STATE,
            DESTRUCTED_STATE
        } StateType;

        typedef enum {
            BOOL_PARAM_TYPE,
            DOUBLE_PARAM_TYPE,
            INT_PARAM_TYPE,
            STRING_PARAM_TYPE
        } ParamType;

        typedef enum {
            NORMAL_PARAM_SPECIFY_TYPE,
            MANDATORY_PARAM_SPECIFY_TYPE,
            NO_DEFAULT_PARAM_SPECIFY_TYPE
        } ParamSpecifyType;

        typedef struct {
            bool              system;              // system keyword?
            ::size_t          declIndex;           // index in decl order

            ::std::string     defaultValueString;  // default value string
            ParamType         type;                // type
            ::std::string     usageValue;          // usage value
            ::std::string     help;                // help
            ParamSpecifyType  specifyType;         // "normal", "mandatory", or
                                                   // "no default"

            ::std::string     valueString;         // value string
            bool              valueSpecified;      // user specified on
                                                   // command line?
            bool              valueSpecifiedWasChecked;
            bool              valueWasRead;        // value was read
        } ParameterInfo;

        typedef ::std::map< ::std::string, ParameterInfo > ParameterInfoMap;

        void verifyStateIsInRange( StateType rangeBegin,
                                   StateType rangeEnd ) const;

        void verifyStateIsInitializingSystemKeywordMembers( ) const;

        void verifyStateIsNormal( ) const;

      static int run( Program & program );

      int initializeCarma( );


      void terminateCarma( );

      void show( );

      void addKey( const KeyTabEntry & kt,
                   bool                system,
                   ::size_t            declIndex );

      void docKeys( bool system, bool declOrder ) const;

      ::std::string getDescriptionString( ) const;


      ::std::string getParameterValueString( const ::std::string & key,
                                             bool                  system,
                                             ParamType             type,
                                             bool                  checkType );

      bool parameterWasSpecified( const ::std::string & key,
                                  bool                  system );

      bool getBoolParameter( const ::std::string & key,
                             bool                  system );

      double getDoubleParameter( const ::std::string & key,
                                 bool                  system );

      int getIntParameter( const ::std::string & key,
                           bool                  system );

      ::std::string getStringParameter( const ::std::string & key,
                                        bool                  system );

      ::std::string getParameterRawValueString( const ::std::string & key,
                                                bool                  system );

      static void docKey( const ::std::string & name,
                          const ParameterInfo & parameterInfo );


      void setLogger( );

      void setTrace( );

      void setCorba( );

      log4cpp::Category & getDefaultLogger( ) const;


      static ParamType convertParameterType( const ::std::string & s );

      void advanceState( StateType newState );

      void renice( void );

      class Config;

      // class static data members
      static const KeyTabEntry  kSystemKeywords_[ ];

      static const char * const kUsage_;        // one line usage
      static const KeyTabEntry  kKeywords_[ ];  // {key,val,type,help} tuples
                                                // for program keys
      static const char * const kVersion_;      // one line version
      static const char * const kDescription_;  // multiple line description

      static const bool         kHaveInitialLoggerInfo_;
      static const char * const kInitialFacilityName_;
      static const char * const kInitialLogname_;

      // instance data members
      StateType            state_;

      ::std::string        progname_;       // short program name without path

      ParameterInfoMap     parameterInfoMap_;

      bool                 syslog_;         // true or false
      log4cpp::Category *  logger_;         // logger set up as specified by
                                            // system key values
      ::std::string        logFileName_;    // pathname for file log
      ::std::string        logHostName_;    // logger is hosted on this machine
                                            // default for logHostName is
                                            // gethostname(3)
      int                  corbaRrtt_;     
      bool                 imrHostnameWasSpecified_;// IMR info
      ::std::string        imrHostnameSpecified_;

      ::std::auto_ptr<carma::corba::Server> corbaServer_;
      ::std::auto_ptr<carma::util::ProcessMonitorClient> processMonitorClient_;

      int                  debugLevel_;     // debug level (0 or larger)
      bool                 daemonize_;      // program is a daemon ?

      int                  nice_;           // Nice value for managing 
                                            // resource usage.  Higher
                                            // value is nicer, lower value
                                            // means higher priority 
                                            // (less than zero requires
                                            // root permission).
      bool                 useGMT_;         // Use GMT timezone for program                                      
      int                  traceLevel_;     // trace level
                                            // (>=0 ; 0 means no tracing)
      bool                 traceVerbose_;   // trace verbosity
                                            // (true means maximum, false means
                                            //  log4cpp::SimpleLayout)
      ::std::string        traceFile_;      // file (including stdout/syslog)
                                            // where trace output will go
      carma::util::Trace * traceObject_;    // trace object

      const carma::util::facilityType facility_;  // Default syslog facility

      ::std::string        logname_;        // logname for Logger Category.
      bool                 instanceLognameSet_;
      
      bool                 useDBMS_;
};  // class carma::util::ProgramBase


class Program : public ProgramBase {
    friend class ProgramBase;
    friend int ::carma_main( int argc, char ** argv );

    public:

        static Program & getProgram( );

    private:

        Program( );

        ~Program( );

        int main( );

};  // class carma::util::Program


}  // namespace carma::util
}  // namespace carma

#endif