OutputDevice.h

Go to the documentation of this file.

/****************************************************************************/
// Static storage of an output device and its base (abstract) implementation
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2004-2017 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef OutputDevice_h
#define OutputDevice_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <string>
#include <map>
#include <utils/common/ToString.h>
#include <utils/xml/SUMOXMLDefinitions.h>
#include "PlainXMLFormatter.h"
#include "BinaryFormatter.h"


// ===========================================================================
// class definitions
// ===========================================================================
class OutputDevice {
public:

    static OutputDevice& getDevice(const std::string& name);


    static bool createDeviceByOption(const std::string& optionName,
                                     const std::string& rootElement = "",
                                     const std::string& schemaFile = "");


    static OutputDevice& getDeviceByOption(const std::string& name);


    static void closeAll();


    static std::string realString(const double v, const int precision = gPrecision);


public:

    OutputDevice(const bool binary = false, const int defaultIndentation = 0);


    virtual ~OutputDevice();


    virtual bool ok();


    void close();


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


    template <typename E>
    bool writeHeader(const SumoXMLTag& rootElement) {
        if (myAmBinary) {
            return static_cast<BinaryFormatter*>(myFormatter)->writeHeader<E>(getOStream(), rootElement);
        }
        return static_cast<PlainXMLFormatter*>(myFormatter)->writeHeader(getOStream(), rootElement);
    }


    OutputDevice& openTag(const std::string& xmlElement);


    OutputDevice& openTag(const SumoXMLTag& xmlElement);


    bool closeTag();



    void lf() {
        if (!myAmBinary) {
            getOStream() << "\n";
        }
    }


    bool isBinary() const {
        return myAmBinary;
    }


    template <typename T>
    OutputDevice& writeAttr(const SumoXMLAttr attr, const T& val) {
        if (myAmBinary) {
            BinaryFormatter::writeAttr(getOStream(), attr, val);
        } else {
            PlainXMLFormatter::writeAttr(getOStream(), attr, val);
        }
        return *this;
    }


    template <typename T>
    OutputDevice& writeAttr(const std::string& attr, const T& val) {
        if (myAmBinary) {
            BinaryFormatter::writeAttr(getOStream(), attr, val);
        } else {
            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;
    }


    void inform(const std::string& msg, const char progress = 0);


    template <class T>
    OutputDevice& operator<<(const T& t) {
        getOStream() << t;
        postWriteHook();
        return *this;
    }

protected:
    virtual std::ostream& getOStream() = 0;


    virtual void postWriteHook();


private:
    static std::map<std::string, OutputDevice*> myOutputDevices;


private:
    OutputFormatter* myFormatter;

    const bool myAmBinary;

public:
    OutputDevice(const OutputDevice&);

private:

    OutputDevice& operator=(const OutputDevice&);

};


#endif

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