MsgHandler.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2003-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Retrieves messages about the process and gives them further to output
/****************************************************************************/
#pragma once
#include <config.h>
#include <string>
#include <vector>
#include <map>
#include <utils/common/StringUtils.h>
#include <utils/common/Translation.h>
#include <utils/iodevices/OutputDevice.h>
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MsgHandler {
public:
    enum class MsgType {
        MT_MESSAGE,
        MT_WARNING,
        MT_ERROR,
        MT_DEBUG,
        MT_GLDEBUG
    };
 
private:
    typedef MsgHandler* (*Factory)(MsgType);
 
public:
    static void setFactory(Factory func) {
        // clean old instances
        cleanupOnEnd();
        myFactory = func;
    }
 
    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 std::string insertLineBreaks(std::string msg, int lineWidth);
 
    static void removeRetrieverFromAllInstances(OutputDevice* out);
 
    static void setupI18n(const std::string& locale = "");
 
    static void initOutputOptions();
 
    static void cleanupOnEnd();
 
    virtual void inform(std::string msg, bool addType = true);
 
    // variadic function
    template<typename T, typename... Targs>
    void informf(const std::string& format, T value, Targs... Fargs) {
        if (!aggregationThresholdReached(format)) {
            inform(StringUtils::format(format, value, Fargs...), true);
        }
    }
 
    virtual void beginProcessMsg(std::string msg, bool addType = true);
 
    virtual void endProcessMsg2(bool success, long duration = -1);
 
    virtual void endProcessMsg(std::string msg);
 
    virtual void clear(bool resetInformed = true);
 
    virtual void addRetriever(OutputDevice* retriever);
 
    virtual void removeRetriever(OutputDevice* retriever);
 
    bool isRetriever(OutputDevice* retriever) const;
 
    bool wasInformed() const;
 
    template <class T>
    MsgHandler& operator<<(const T& t) {
        // inform all other receivers
        for (OutputDevice* o : myRetrievers) {
            (*o) << t;
        }
        return *this;
    }
 
protected:
 
    std::string buildTimestampPrefix(void) const;
    std::string buildProcessIdPrefix(void) const;
 
    inline std::string build(const std::string& msg, bool addType) {
        std::string prefix;
        if (myWriteTimestamps) {
            prefix += buildTimestampPrefix();
        }
        if (myWriteProcessId) {
            prefix += buildProcessIdPrefix();
        }
        if (addType) {
            switch (myType) {
                case MsgType::MT_MESSAGE:
                    break;
                case MsgType::MT_WARNING:
                    prefix += myWarningPrefix;
                    break;
                case MsgType::MT_ERROR:
                    prefix += myErrorPrefix;
                    break;
                case MsgType::MT_DEBUG:
                    prefix += "Debug: ";
                    break;
                case MsgType::MT_GLDEBUG:
                    prefix += "GLDebug: ";
                    break;
                default:
                    break;
            }
        }
        return prefix + msg;
    }
 
    virtual bool aggregationThresholdReached(const std::string& format) {
        return myAggregationThreshold >= 0 && myAggregationCount[format]++ >= myAggregationThreshold;
    }
 
    void setAggregationThreshold(const int thresh) {
        myAggregationThreshold = thresh;
    }
 
    MsgHandler(MsgType type);
 
    virtual ~MsgHandler();
 
private:
    static Factory myFactory;
 
    static MsgHandler* myDebugInstance;
 
    static MsgHandler* myGLDebugInstance;
 
    static MsgHandler* myErrorInstance;
 
    static MsgHandler* myWarningInstance;
 
    static MsgHandler* myMessageInstance;
 
    static bool myAmProcessingProcess;
 
private:
    MsgType myType;
 
    bool myWasInformed;
 
    int myAggregationThreshold;
 
    std::map<const std::string, int> myAggregationCount;
 
    std::vector<OutputDevice*> myRetrievers;
 
    std::vector<std::string> myInitialMessages;
 
    static bool myWriteDebugMessages;
 
    static bool myWriteDebugGLMessages;
 
    static bool myWriteTimestamps;
 
    static bool myWriteProcessId;
 
    static std::string myErrorPrefix;
 
    static std::string myWarningPrefix;
 
private:
    MsgHandler(const MsgHandler& s) = delete;
 
    MsgHandler& operator=(const MsgHandler& s) = delete;
};
 
 
// ===========================================================================
// global definitions
// ===========================================================================
#define WRITE_WARNING(msg) MsgHandler::getWarningInstance()->inform(msg);
#define WRITE_WARNINGF(...) MsgHandler::getWarningInstance()->informf(__VA_ARGS__);
#define WRITE_MESSAGE(msg) MsgHandler::getMessageInstance()->inform(msg);
#define WRITE_MESSAGEF(...) MsgHandler::getMessageInstance()->informf(__VA_ARGS__);
#define PROGRESS_BEGIN_MESSAGE(msg) MsgHandler::getMessageInstance()->beginProcessMsg((msg) + std::string(" ..."));
#define PROGRESS_DONE_MESSAGE() MsgHandler::getMessageInstance()->endProcessMsg2(true);
#define PROGRESS_BEGIN_TIME_MESSAGE(msg) SysUtils::getCurrentMillis(); MsgHandler::getMessageInstance()->beginProcessMsg((msg) + std::string(" ..."));
#define PROGRESS_TIME_MESSAGE(before) MsgHandler::getMessageInstance()->endProcessMsg2(true, SysUtils::getCurrentMillis() - before);
#define PROGRESS_FAILED_MESSAGE() MsgHandler::getMessageInstance()->endProcessMsg2(false);
#define WRITE_ERROR(msg) MsgHandler::getErrorInstance()->inform(msg);
#define WRITE_ERRORF(...) MsgHandler::getErrorInstance()->informf(__VA_ARGS__);
#define WRITE_DEBUG(msg) if(MsgHandler::writeDebugMessages()){MsgHandler::getDebugInstance()->inform(msg);};
#define WRITE_GLDEBUG(msg) if(MsgHandler::writeDebugGLMessages()){MsgHandler::getGLDebugInstance()->inform(msg);};
#ifdef HAVE_INTL
// basic translation
#define TL(string) gettext(string)
// complex translation ("This % an %", "is", "example")
#define TLF(string, ...) StringUtils::format(gettext(string), __VA_ARGS__)
#else
// basic translation
#define TL(string) (string)
// complex translation ("This % an %", "is", "example")
#define TLF(string, ...) StringUtils::format(string, __VA_ARGS__)
#endif