MsgHandlerSynchronized.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>
 
#ifdef HAVE_FOX
#include "fxheader.h"
#endif
#include <string>
#include <vector>
#include <iostream>
#include <utils/common/MsgHandler.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class OutputDevice;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MsgHandlerSynchronized : public MsgHandler {
public:
    static MsgHandler* create(MsgType type) {
        return new MsgHandlerSynchronized(type);
    }
 
    void inform(std::string msg, bool addType = true) {
        FXMutexLock locker(myLock);
        MsgHandler::inform(msg, addType);
    }
 
    void beginProcessMsg(std::string msg, bool addType = true) {
        FXMutexLock locker(myLock);
        MsgHandler::beginProcessMsg(msg, addType);
    }
 
    void endProcessMsg(std::string msg) {
        FXMutexLock locker(myLock);
        MsgHandler::endProcessMsg(msg);
    }
 
    void clear(bool resetInformed = true) {
        FXMutexLock locker(myLock);
        MsgHandler::clear(resetInformed);
    }
 
    void addRetriever(OutputDevice* retriever) {
        FXMutexLock locker(myLock);
        MsgHandler::addRetriever(retriever);
    }
 
    void removeRetriever(OutputDevice* retriever) {
        FXMutexLock locker(myLock);
        MsgHandler::removeRetriever(retriever);
    }
 
protected:
    bool aggregationThresholdReached(const std::string& format) {
        FXMutexLock locker(myLock);
        return MsgHandler::aggregationThresholdReached(format);
    }
 
private:
    MsgHandlerSynchronized(MsgType type) :
        MsgHandler(type), myLock(true) {
    }
 
    ~MsgHandlerSynchronized() {
    }
 
    FXMutex myLock;
 
private:
    MsgHandlerSynchronized(const MsgHandlerSynchronized& s) = delete;
 
    MsgHandlerSynchronized& operator=(const MsgHandlerSynchronized& s) = delete;
};