OutputDevice.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2004-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
/****************************************************************************/
// Static storage of an output device and its base (abstract) implementation
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <map>
#include <cassert>
#include <utils/common/ToString.h>
#include <utils/xml/SUMOXMLDefinitions.h>
#include "PlainXMLFormatter.h"
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class OutputDevice {
public:
 
    static OutputDevice& getDevice(const std::string& name, bool usePrefix = true);
 
 
    static bool createDeviceByOption(const std::string& optionName,
                                     const std::string& rootElement = "",
                                     const std::string& schemaFile = "");
 
 
    static OutputDevice& getDeviceByOption(const std::string& name);
 
    static void flushAll();
 
    static void closeAll(bool keepErrorRetrievers = false);
 
 
    static std::string realString(const double v, const int precision = gPrecision);
 
 
public:
 
    OutputDevice(const int defaultIndentation = 0, const std::string& filename = "");
 
 
    virtual ~OutputDevice();
 
 
    virtual bool ok();
 
    virtual bool isNull() {
        return false;
    }
 
    const std::string& getFilename();
 
    void close();
 
 
    void setPrecision(int precision = gPrecision);
 
    int precision();
 
    int getPrecision() {
        return (int)getOStream().precision();
    }
 
    bool writeXMLHeader(const std::string& rootElement,
                        const std::string& schemaFile,
                        std::map<SumoXMLAttr, std::string> attrs = std::map<SumoXMLAttr, std::string>(),
                        bool includeConfig = true);
 
 
    template <typename E>
    bool writeHeader(const SumoXMLTag& rootElement) {
        return static_cast<PlainXMLFormatter*>(myFormatter)->writeHeader(getOStream(), rootElement);
    }
 
 
    OutputDevice& openTag(const std::string& xmlElement);
 
 
    OutputDevice& openTag(const SumoXMLTag& xmlElement);
 
 
    bool closeTag(const std::string& comment = "");
 
 
 
    void lf() {
        getOStream() << "\n";
    }
 
 
    template <typename T>
    OutputDevice& writeAttr(const SumoXMLAttr attr, const T& val) {
        PlainXMLFormatter::writeAttr(getOStream(), attr, val);
        return *this;
    }
 
    inline bool useAttribute(const SumoXMLAttr attr, SumoXMLAttrMask attributeMask) const {
        return attributeMask.test(attr);
    }
 
    template <typename T>
    OutputDevice& writeOptionalAttr(const SumoXMLAttr attr, const T& val, long long int attributeMask) {
        assert((int)attr <= 63);
        if (attributeMask == 0 || useAttribute(attr, attributeMask)) {
            PlainXMLFormatter::writeAttr(getOStream(), attr, val);
        }
        return *this;
    }
    template <typename T>
    OutputDevice& writeOptionalAttr(const SumoXMLAttr attr, const T& val, SumoXMLAttrMask attributeMask) {
        assert((int)attr <= (int)attributeMask.size());
        if (attributeMask.none() || useAttribute(attr, attributeMask)) {
            PlainXMLFormatter::writeAttr(getOStream(), attr, val);
        }
        return *this;
    }
 
 
    template <typename T>
    OutputDevice& writeAttr(const std::string& attr, const T& val) {
        PlainXMLFormatter::writeAttr(getOStream(), attr, val);
        return *this;
    }
 
    OutputDevice& writeNonEmptyAttr(const SumoXMLAttr attr, const std::string& val) {
        if (val != "" && val != "default") {
            writeAttr(attr, val);
        }
        return *this;
    }
 
 
    OutputDevice& writePreformattedTag(const std::string& val) {
        myFormatter->writePreformattedTag(getOStream(), val);
        return *this;
    }
 
    OutputDevice& writePadding(const std::string& val) {
        myFormatter->writePadding(getOStream(), val);
        return *this;
    }
 
    void inform(const std::string& msg, const bool progress = false);
 
 
    template <class T>
    OutputDevice& operator<<(const T& t) {
        getOStream() << t;
        postWriteHook();
        return *this;
    }
 
    void flush() {
        getOStream().flush();
    }
 
    bool wroteHeader() const {
        return myFormatter->wroteHeader();
    }
 
protected:
    virtual std::ostream& getOStream() = 0;
 
 
    virtual void postWriteHook();
 
 
private:
    static std::map<std::string, OutputDevice*> myOutputDevices;
 
    static int myPrevConsoleCP;
 
protected:
    const std::string myFilename;
 
private:
    OutputFormatter* const myFormatter;
 
private:
    OutputDevice(const OutputDevice&) = delete;
 
    OutputDevice& operator=(const OutputDevice&) = delete;
 
};