MsgHandler.h

Go to the documentation of this file.

/****************************************************************************/
// Retrieves messages about the process and gives them further to output
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright 2001-2010 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program 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.
//
/****************************************************************************/
#ifndef MsgHandler_h
#define MsgHandler_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <string>
#include <vector>
#include <iostream>


// ===========================================================================
// class declarations
// ===========================================================================
class AbstractMutex;
class OutputDevice;


// ===========================================================================
// global variable definitions
// ===========================================================================
extern bool gSuppressWarnings;
extern bool gSuppressMessages;


// ===========================================================================
// class definitions
// ===========================================================================
class MsgHandler {
public:
    enum MsgType {
        MT_MESSAGE,
        MT_WARNING,
        MT_ERROR
    };

    static MsgHandler *getMessageInstance();

    static MsgHandler *getWarningInstance();

    static MsgHandler *getErrorInstance();

    static void initOutputOptions(bool gui=false);

    static void cleanupOnEnd();

    void inform(std::string msg, bool addType=true);

    void beginProcessMsg(std::string msg, bool addType=true);

    void endProcessMsg(std::string msg);

    void progressMsg(std::string msg, bool addType=true);

    void clear();

    void addRetriever(OutputDevice *retriever);

    void removeRetriever(OutputDevice *retriever);

    void report2cout(bool value);

    void report2cerr(bool value);

    bool wasInformed() const;

    static void assignLock(AbstractMutex *lock);

    template <class T>
    MsgHandler &operator<<(const T &t) {
        if (myReport2COUT) {
            std::cout << t;
        }
        // report to cerr if wished
        if (myReport2CERR) {
            std::cerr << t;
        }
        // inform all other receivers
        for (RetrieverVector::iterator i=myRetrievers.begin(); i!=myRetrievers.end(); i++) {
            (*(*i)) << t;
        }
        return *this;
    }

protected:
    inline std::string build(const std::string &msg, bool addType) {
        if (addType) {
            switch (myType) {
            case MT_MESSAGE:
                break;
            case MT_WARNING:
                return "Warning: " + msg;
                break;
            case MT_ERROR:
                return "Error: " + msg;
                break;
            default:
                break;
            }
        }
        return msg;
    }


private:
    MsgHandler(MsgType type);

    ~MsgHandler();

private:
    static MsgHandler *myErrorInstance;

    static MsgHandler *myWarningInstance;

    static MsgHandler *myMessageInstance;

    static bool myAmProcessingProcess;

    static AbstractMutex *myLock;

private:
    MsgType myType;

    bool myWasInformed;

    bool myReport2COUT;

    bool myReport2CERR;

    typedef std::vector<OutputDevice*> RetrieverVector;

    RetrieverVector myRetrievers;

private:
    MsgHandler(const MsgHandler &s);

    MsgHandler &operator=(const MsgHandler &s);

};


// ===========================================================================
// global definitions
// ===========================================================================
#define WRITE_WARNING(command) if(!gSuppressWarnings) { MsgHandler::getWarningInstance()->inform(command); }
#define WRITE_MESSAGE(command) if(!gSuppressMessages) { MsgHandler::getMessageInstance()->inform(command); }
#define WRITE_ERROR(command)   MsgHandler::getErrorInstance()->inform(command);
#define MSG_OUT (*MsgHandler::getMessageInstance())

#endif

/****************************************************************************/