application.h

Go to the documentation of this file.

//
//  Copyright (c) Benjamin Kaufmann 2004
//
//  This is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version. 
// 
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this file; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//
// NOTE: ProgramOptions is inspired by Boost.Program_options
//       see: www.boost.org/libs/program_options
//
#ifndef APP_OPTIONS_H_INCLUDED
#define APP_OPTIONS_H_INCLUDED

#ifdef _MSC_VER
#pragma warning (disable : 4200) // nonstandard extension used : zero-sized array
#pragma once
#endif

#include <string>
#include <utility>
#include "program_options.h"
#include <stdio.h>
#include <signal.h>

namespace ProgramOptions {
typedef std::vector<std::string> StringSeq;
// Application base class
#define WRITE_STDERR(type,sys,msg) ( fflush(stdout), fprintf(stderr, "*** %-5s: (%s): %s\n", (type),(sys),(msg)), fflush(stderr) )
class Application {
public:
        typedef std::pair<const char*, unsigned> HelpOpt;

        virtual const char* getName()       const   = 0;
        virtual const char* getVersion()    const   = 0;
        virtual const int*  getSignals()    const { return 0; }
        virtual const char* getUsage()      const { return "[options]"; }
        virtual HelpOpt     getHelpOption() const { return HelpOpt("Print help information and exit", 1); }
        virtual PosOption   getPositional() const { return 0; }
        virtual void        error(const char* msg) const { WRITE_STDERR("ERROR", getName(), msg); }
        virtual void        info(const char*  msg) const { WRITE_STDERR("Info",  getName(), msg); }
        virtual void        warn(const char*  msg) const { WRITE_STDERR("Warn",  getName(), msg); }
        

        int main(int argc, char** argv);
        void setExitCode(int n);
        int  getExitCode() const;
        static Application* getInstance();
        virtual void        printHelp(const OptionContext& root);
        virtual void        printVersion();
        virtual void        printUsage();
protected:

        virtual void        initOptions(OptionContext& root) = 0;
        virtual void        validateOptions(const OptionContext& root, const ParsedOptions& parsed, const ParsedValues& values) = 0;
        virtual void        setup() = 0;
        virtual void        run()   = 0;
        virtual void        shutdown();
        virtual void        onUnhandledException();
        virtual bool        onSignal(int);
protected:
        Application();
        virtual ~Application();
        void     shutdown(bool hasError);
        void     exit(int exitCode) const;
        unsigned verbose() const;
        void     setVerbose(unsigned v);
        void     killAlarm();
        int      blockSignals();
        void     unblockSignals(bool deliverPending);
        void     processSignal(int sigNum);
private:
        bool getOptions(int argc, char** argv);
        int                   exitCode_;  // application's exit code
        unsigned              timeout_;   // active time limit or 0 for no limit
        unsigned              verbose_;   // active verbosity level
        bool                  fastExit_;  // force fast exit?
        volatile sig_atomic_t blocked_;   // temporarily block signals?
        volatile sig_atomic_t pending_;   // pending signal or 0 if no pending signal
        static Application*   instance_s; // running instance (only valid during run()).
        static void sigHandler(int sig);  // signal/timeout handler
};

}
#endif