Application.hh File Reference

#include <cstdlib>
#include <string>
#include <iostream>
#include <vector>
#include <signal.h>
#include <map>

Include dependency graph for Application.hh:

Go to the source code of this file.

Classes
class	Application
class	Application::UnixSignalHandler

Macros
#define	UNKNOWN_FUNCTION   "[?]"
#define	__func__   UNKNOWN_FUNCTION
#define	abortWithError(message)
#define	assert(condition)
#define	debugLog(text)
#define	CATCH_ANY(XXX__)
#define	verboseLogC(text, neededVerbosity)
#define	verboseLog(text)   verboseLogC(text, 1)
#define	PRINT_VAR(VARIABLE__)

Variables
const int	DEFAULT_MAX_OUTPUT_LINES = 200
	default value of maximum amount of output lines saved from popen() output in runShellCommandAndGetOutput()
const int	MAX_OUTPUT_LINE_LENGTH = 512
	maximum length of an output line saved from popen() output in runShellCommandAndGetOutput()

Detailed Description

Declaration of Application class and services of standalone applications.

Application is a class for generic services that are project-wide applicable to standalone applications or modules. These services include assertion, program exiting, debugging to a log file, catching unexpected exceptions and "control-c", SIGFPE and SIGSEGV signal handling.

Author

Atte Oksman 2003 (oksman-no.spam-cs.tut.fi)

Pekka Jääskeläinen 2005-2012 (pjaaskel-no.spam-cs.tut.fi)

Definition in file Application.hh.

Macro Definition Documentation

__func__

#define __func__   UNKNOWN_FUNCTION

Definition at line 67 of file Application.hh.

abortWithError

#define abortWithError

(

message

)

Value:

    Application::writeToErrorLog(__FILE__, __LINE__, __func__, message); \
    Application::abortProgram();

Definition at line 72 of file Application.hh.

                      { \
        abortWithError("Assertion failed: " #condition); \
    }
#endif
 
#endif
 
// provide an easy way to "debug print"
#define debugLog(text) \
    Application::writeToErrorLog(__FILE__, __LINE__, __func__, \
        std::string("DEBUG: ") + std::string(text))
 
// provide an easy way to print out exception data
#define CATCH_ANY(XXX__) \
    try { XXX__; } \
    catch (const Exception& e) { \
   debugLog(e.errorMessage() + " in " + \
        e.fileName() + ":" + \
        e.procedureName() + ":" + \
        Conversion::toString(e.lineNum())); } \
    catch ( ... ) { debugLog("Unknown exception"); }
 
// easy way to do conditional verbose logging
#define verboseLogC(text, neededVerbosity) \
    if (Application::verboseLevel() >= neededVerbosity) { \
       Application::logStream() << text << std::endl; }
 
// provide an easy way to verbose log printing
#define verboseLog(text) verboseLogC(text, 1)
 
// provide an easy way to print out the contents of a variable
#define PRINT_VAR(VARIABLE__) \
    Application::logStream() << #VARIABLE__ << " == " \
    << VARIABLE__ << std::endl
 
/// default value of maximum amount of output lines saved from popen() output
/// in runShellCommandAndGetOutput()
const int DEFAULT_MAX_OUTPUT_LINES = 200;
 
/// maximum length of an output line saved from popen() output in
/// runShellCommandAndGetOutput()
const int MAX_OUTPUT_LINE_LENGTH = 512;
 
/**
 * A project-wide class for basic application services.
 *
 * Provides application services such as program exit and abort. It also
 * provides generic debugging aids like error logging and handling of
 * unexpected exceptions.
 *
 * Initialization of this toolkit happens when any function is called the
 * first time.
 *
 * Should be used by every standalone application of the toolset.
 */
class CmdLineOptions;
 
class Application {
public:
    static void initialize(int argc, char* argv[]);
    static void initialize();
    static void finalize();
 
    static void writeToErrorLog(
        const std::string fileName,
        const int lineNumber,
        const std::string functionName,
        const std::string message,
        const int neededVerbosity = 0);
 
    static void exitProgram(const int status = EXIT_SUCCESS);
    static void abortProgram() __attribute__((noreturn));
 
    static void unexpectedExceptionHandler();
 
    static bool shellCommandsExists(
        const std::string& commands);
    static int runShellCommandSilently(
        const std::string& command);
    static int runShellCommandAndGetOutput(
        const std::string& command,
        std::vector<std::string>& outputLines,
        std::size_t maxOutputLines  = DEFAULT_MAX_OUTPUT_LINES,
        bool includeStdErr = false);
 
    static std::ostream& logStream();
    static std::ostream& warningStream();
    static std::ostream& errorStream();
 
    static int verboseLevel() {
        return verboseLevel_;
    }
    static bool increasedVerbose() {
        return verboseLevel() > VERBOSE_LEVEL_DEFAULT;
    }
    static bool spamVerbose() {
        return verboseLevel() > VERBOSE_LEVEL_INCREASED;
    }
 
    static void setVerboseLevel(const int level = VERBOSE_LEVEL_DEFAULT) {
        verboseLevel_ = level;
    }
 
    static void setCmdLineOptions(CmdLineOptions* options_);
    static CmdLineOptions* cmdLineOptions();
    static int argc() { return argc_; }
    static char** argv() { return argv_; }
    static bool isInstalled();
    static std::string installationDir();
 
    /// ---------------------
 
    /**
     * An interface for classes that can receive notification when a Unix
     * signal occurs.
     */
    class UnixSignalHandler {
    public:
        /**
         * Executed when the Unix signal occurs.
         *
         * @param data Data of the signal.
         */
        virtual void execute(int data, siginfo_t *info) = 0;
        virtual ~UnixSignalHandler() {}
    };
    
    // Unix signal handler set/reset functions
    static void setSignalHandler(int signalNum, UnixSignalHandler& handler);
    static UnixSignalHandler* getSignalHandler(int signalNum);
    static void restoreSignalHandler(int signalNum);
 
    static std::string TCEVersionString();
 
    /// Default verbose level - do not print anything unnecessary
    static const int VERBOSE_LEVEL_DEFAULT = 0;
    /// Increased verbose level - print information about modules etc
    static const int VERBOSE_LEVEL_INCREASED = 1;
    /// More Increased verbose level - spam about ddg heights of loops
    static const int VERBOSE_LEVEL_SPAM = 2;
 
    /// Use Loop Optimizations
    static const bool LOOP_OPT_DEFAULT = false;
 
private:
    static void signalRedirector(int data, siginfo_t *info, void *context);
 
    /// True when initialize() is called. Ensures that initialization is
    /// done only once.
    static bool initialized_;
 
    /// The stream for debug logging.
    static std::ostream* logStream_;
 
    /// The stream for user error notifications.
    static std::ostream* errorStream_;
 
    /// The stream for user error notifications.
    static std::ostream* warningStream_;
 
    /// Signal handlers in a map associated by their signal numbers
    static std::map<int, UnixSignalHandler*> signalHandlers_;
 
    /// Verbose level directs how much output will be printed to console
    static int verboseLevel_;
    
    /// Holds command line options passed to program
    static CmdLineOptions* cmdLineOptions_;
 
    /// The original argc and argv given to the main program, if applicable.
    static int argc_;
    static char** argv_;
 
    /// Path to the TCE installation root
    static std::string installationRoot_;
};
 
#endif

assert

#define assert

(

condition

)

Value:

    if (!(condition)) { \
        abortWithError("Assertion failed: " #condition); \
    }

Definition at line 86 of file Application.hh.

                      { \
        abortWithError("Assertion failed: " #condition); \
    }

CATCH_ANY

#define CATCH_ANY

(

XXX__

)

Value:

    try { XXX__; } \
    catch (const Exception& e) { \
   debugLog(e.errorMessage() + " in " + \
        e.fileName() + ":" + \
        e.procedureName() + ":" + \
        Conversion::toString(e.lineNum())); } \
    catch ( ... ) { debugLog("Unknown exception"); }

Definition at line 100 of file Application.hh.

        { XXX__; } \
    catch (const Exception& e) { \
   debugLog(e.errorMessage() + " in " + \
        e.fileName() + ":" + \
        e.procedureName() + ":" + \
        Conversion::toString(e.lineNum())); } \
    catch ( ... ) { debugLog("Unknown exception"); }

debugLog

#define debugLog

(

text

)

Value:

    Application::writeToErrorLog(__FILE__, __LINE__, __func__, \
        std::string("DEBUG: ") + std::string(text))

Definition at line 95 of file Application.hh.

                        : ") + std::string(text))

PRINT_VAR

#define PRINT_VAR

(

VARIABLE__

)

Value:

    Application::logStream() << #VARIABLE__ << " == " \
    << VARIABLE__ << std::endl

Definition at line 118 of file Application.hh.

UNKNOWN_FUNCTION

#define UNKNOWN_FUNCTION   "[?]"

Definition at line 58 of file Application.hh.

verboseLog

#define verboseLog

(

text

)

verboseLogC(text, 1)

Definition at line 115 of file Application.hh.

verboseLogC

#define verboseLogC	(		text,
			neededVerbosity
	)

Value:

    if (Application::verboseLevel() >= neededVerbosity) { \
       Application::logStream() << text << std::endl; }

Definition at line 110 of file Application.hh.

                                                      { \
       Application::logStream() << text << std::endl; }

Variable Documentation

DEFAULT_MAX_OUTPUT_LINES

const int DEFAULT_MAX_OUTPUT_LINES = 200

default value of maximum amount of output lines saved from popen() output in runShellCommandAndGetOutput()

Definition at line 124 of file Application.hh.

MAX_OUTPUT_LINE_LENGTH

const int MAX_OUTPUT_LINE_LENGTH = 512

maximum length of an output line saved from popen() output in runShellCommandAndGetOutput()

Definition at line 128 of file Application.hh.

Referenced by Application::runShellCommandAndGetOutput(), and Application::runShellCommandSilently().