MsgHandler.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2003-2018 German Aerospace Center (DLR) and others.
// This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v20.html
// SPDX-License-Identifier: EPL-2.0
/****************************************************************************/
// Retrieves messages about the process and gives them further to output
/****************************************************************************/
#ifndef MsgHandler_h
#define MsgHandler_h


// ===========================================================================
// included modules
// ===========================================================================
#include <config.h>

#include <string>
#include <vector>
#include <iostream>
#include <utils/gui/div/GUIIOGlobals.h>


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


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

    static MsgHandler* getMessageInstance();

    static MsgHandler* getWarningInstance();

    static MsgHandler* getErrorInstance();

    static MsgHandler* getDebugInstance();

    static MsgHandler* getGLDebugInstance();

    static void enableDebugMessages(bool enable);

    static void enableDebugGLMessages(bool enable);

    static inline bool writeDebugMessages() {
        return myWriteDebugMessages;
    }

    static inline bool writeDebugGLMessages() {
        return myWriteDebugGLMessages;
    }

    static void removeRetrieverFromAllInstances(OutputDevice* out);

    static void initOutputOptions();

    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 clear();

    void addRetriever(OutputDevice* retriever);

    void removeRetriever(OutputDevice* retriever);

    bool isRetriever(OutputDevice* retriever) const;

    bool wasInformed() const;

    static void assignLock(AbstractMutex* lock);

    template <class T>
    MsgHandler& operator<<(const T& t) {
        // inform all other receivers
        for (auto i : myRetrievers) {
            (*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;
                case MT_DEBUG:
                    return "Debug: " + msg;
                    break;
                case MT_GLDEBUG:
                    return "GLDebug: " + msg;
                    break;
                default:
                    break;
            }
        }
        return msg;
    }


private:
    MsgHandler(MsgType type);

    ~MsgHandler();

    static MsgHandler* myDebugInstance;

    static MsgHandler* myGLDebugInstance;

    static MsgHandler* myErrorInstance;

    static MsgHandler* myWarningInstance;

    static MsgHandler* myMessageInstance;

    static bool myAmProcessingProcess;

    static AbstractMutex* myLock;

private:
    MsgType myType;

    bool myWasInformed;

    typedef std::vector<OutputDevice*> RetrieverVector;

    RetrieverVector myRetrievers;

private:
    MsgHandler(const MsgHandler& s) = delete;

    MsgHandler& operator=(const MsgHandler& s) = delete;

    static bool myWriteDebugMessages;
    static bool myWriteDebugGLMessages;
};





// ===========================================================================
// global definitions
// ===========================================================================
#define WRITE_WARNING(msg) MsgHandler::getWarningInstance()->inform(msg);
#define WRITE_MESSAGE(msg) MsgHandler::getMessageInstance()->inform(msg);
#define PROGRESS_BEGIN_MESSAGE(msg) MsgHandler::getMessageInstance()->beginProcessMsg((msg) + std::string("..."));
#define PROGRESS_DONE_MESSAGE() MsgHandler::getMessageInstance()->endProcessMsg("done.");
#define PROGRESS_TIME_MESSAGE(before) MsgHandler::getMessageInstance()->endProcessMsg("done (" + toString(SysUtils::getCurrentMillis() - before) + "ms).");
#define PROGRESS_FAILED_MESSAGE() MsgHandler::getMessageInstance()->endProcessMsg("failed.");
#define WRITE_ERROR(msg)   MsgHandler::getErrorInstance()->inform(msg);
#define WRITE_DEBUG(msg) if(MsgHandler::writeDebugMessages()){MsgHandler::getDebugInstance()->inform(msg);};
#define WRITE_GLDEBUG(msg) if(MsgHandler::writeDebugGLMessages()){MsgHandler::getGLDebugInstance()->inform(msg);};

#endif

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