OutputDevice.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2004-2026 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 "CSVFormatter.h"
#ifdef HAVE_PARQUET
#include "ParquetFormatter.h"
#endif
#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 = "",
                                     const int maximumDepth = 2);
 
 
    static OutputDevice& getDeviceByOption(const std::string& name);
 
    static void flushAll();
 
    static void closeAll(bool keepErrorRetrievers = false);
 
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();
 
    bool isXML() const {
        return myFormatter->getType() == OutputFormatterType::XML;
    }
 
    void setFormatter(OutputFormatter* formatter) {
        delete myFormatter;
        myFormatter = formatter;
    }
 
    void setPrecision(int precision = gPrecision);
 
    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);
 
    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) {
        if (myFormatter->getType() == OutputFormatterType::XML) {
            PlainXMLFormatter::writeAttr(getOStream(), attr, val);
#ifdef HAVE_PARQUET
        } else if (myFormatter->getType() == OutputFormatterType::PARQUET) {
            static_cast<ParquetFormatter*>(myFormatter)->writeAttr(getOStream(), attr, val);
#endif
        } else {
            static_cast<CSVFormatter*>(myFormatter)->writeAttr(getOStream(), attr, val);
        }
        return *this;
    }
 
    static const SumoXMLAttrMask parseWrittenAttributes(const std::vector<std::string>& attrList, const std::string& desc,
            const std::map<std::string, SumoXMLAttrMask>& special = std::map<std::string, SumoXMLAttrMask>());
 
    template <typename T>
    OutputDevice& writeOptionalAttr(const SumoXMLAttr attr, const T& val, const SumoXMLAttrMask& attributeMask, const bool isNull = false) {
        assert((int)attr <= (int)attributeMask.size());
        if (attributeMask.none() || attributeMask.test(attr)) {
            if (myFormatter->getType() == OutputFormatterType::XML) {
                if (!isNull) {
                    PlainXMLFormatter::writeAttr(getOStream(), attr, val);
                }
#ifdef HAVE_PARQUET
            } else if (myFormatter->getType() == OutputFormatterType::PARQUET) {
                static_cast<ParquetFormatter*>(myFormatter)->writeAttr(getOStream(), attr, val, isNull);
#endif
            } else {
                if (isNull) {
                    static_cast<CSVFormatter*>(myFormatter)->writeNull(getOStream(), attr);
                } else {
                    static_cast<CSVFormatter*>(myFormatter)->writeAttr(getOStream(), attr, val);
                }
            }
        }
        return *this;
    }
 
    template <typename Func>
    OutputDevice& writeFuncAttr(const SumoXMLAttr attr, const Func& valFunc, const SumoXMLAttrMask& attributeMask, const bool isNull = false) {
        assert((int)attr <= (int)attributeMask.size());
        if (attributeMask.none() || attributeMask.test(attr)) {
            if (myFormatter->getType() == OutputFormatterType::XML) {
                if (!isNull) {
                    PlainXMLFormatter::writeAttr(getOStream(), attr, valFunc());
                }
#ifdef HAVE_PARQUET
            } else if (myFormatter->getType() == OutputFormatterType::PARQUET) {
                static_cast<ParquetFormatter*>(myFormatter)->writeAttr(getOStream(), attr, valFunc(), isNull);
#endif
            } else {
                if (isNull) {
                    static_cast<CSVFormatter*>(myFormatter)->writeNull(getOStream(), attr);
                } else {
                    static_cast<CSVFormatter*>(myFormatter)->writeAttr(getOStream(), attr, valFunc());
                }
            }
        }
        return *this;
    }
 
    template <typename T>
    OutputDevice& writeAttr(const std::string& attr, const T& val) {
        if (myFormatter->getType() == OutputFormatterType::XML) {
            PlainXMLFormatter::writeAttr(getOStream(), attr, val);
#ifdef HAVE_PARQUET
        } else if (myFormatter->getType() == OutputFormatterType::PARQUET) {
            static_cast<ParquetFormatter*>(myFormatter)->writeAttr(getOStream(), attr, val);
#endif
        } else {
            static_cast<CSVFormatter*>(myFormatter)->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& writeTime(const SumoXMLAttr attr, const SUMOTime val) {
        myFormatter->writeTime(getOStream(), 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();
    }
 
    void setExpectedAttributes(const SumoXMLAttrMask& expected, const int depth = 2) {
        myFormatter->setExpectedAttributes(expected, depth);
    }
 
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;
 
    bool myWriteMetadata;
 
    OutputFormatter* myFormatter;
 
private:
    OutputDevice(const OutputDevice&) = delete;
 
    OutputDevice& operator=(const OutputDevice&) = delete;
 
};