Line data    Source code

       1             : /****************************************************************************/
       2             : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3             : // Copyright (C) 2012-2024 German Aerospace Center (DLR) and others.
       4             : // This program and the accompanying materials are made available under the
       5             : // terms of the Eclipse Public License 2.0 which is available at
       6             : // https://www.eclipse.org/legal/epl-2.0/
       7             : // This Source Code may also be made available under the following Secondary
       8             : // Licenses when the conditions for such availability set forth in the Eclipse
       9             : // Public License 2.0 are satisfied: GNU General Public License, version 2
      10             : // or later which is available at
      11             : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
      12             : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
      13             : /****************************************************************************/
      14             : /// @file    PlainXMLFormatter.cpp
      15             : /// @author  Daniel Krajzewicz
      16             : /// @author  Michael Behrisch
      17             : /// @date    2012
      18             : ///
      19             : // Static storage of an output device and its base (abstract) implementation
      20             : /****************************************************************************/
      21             : #include <config.h>
      22             : 
      23             : #include <utils/common/ToString.h>
      24             : #include <utils/options/OptionsCont.h>
      25             : #include "PlainXMLFormatter.h"
      26             : 
      27             : 
      28             : // ===========================================================================
      29             : // member method definitions
      30             : // ===========================================================================
      31     1368257 : PlainXMLFormatter::PlainXMLFormatter(const int defaultIndentation)
      32     1368257 :     : myDefaultIndentation(defaultIndentation), myHavePendingOpener(false) {
      33     1368257 : }
      34             : 
      35             : 
      36             : bool
      37        5974 : PlainXMLFormatter::writeHeader(std::ostream& into, const SumoXMLTag& rootElement) {
      38        5974 :     if (myXMLStack.empty()) {
      39        5974 :         OptionsCont::getOptions().writeXMLHeader(into);
      40        5974 :         openTag(into, rootElement);
      41        5974 :         return true;
      42             :     }
      43             :     return false;
      44             : }
      45             : 
      46             : 
      47             : bool
      48       48440 : PlainXMLFormatter::writeXMLHeader(std::ostream& into, const std::string& rootElement,
      49             :                                   const std::map<SumoXMLAttr, std::string>& attrs, bool includeConfig) {
      50       48440 :     if (myXMLStack.empty()) {
      51       37743 :         OptionsCont::getOptions().writeXMLHeader(into, includeConfig);
      52       37743 :         openTag(into, rootElement);
      53      112840 :         for (std::map<SumoXMLAttr, std::string>::const_iterator it = attrs.begin(); it != attrs.end(); ++it) {
      54       75097 :             writeAttr(into, it->first, it->second);
      55             :         }
      56       37743 :         into << ">\n";
      57       37743 :         myHavePendingOpener = false;
      58       37743 :         return true;
      59             :     }
      60             :     return false;
      61             : }
      62             : 
      63             : 
      64             : void
      65    20658557 : PlainXMLFormatter::openTag(std::ostream& into, const std::string& xmlElement) {
      66    20658557 :     if (myHavePendingOpener) {
      67     4164734 :         into << ">\n";
      68             :     }
      69    20658557 :     myHavePendingOpener = true;
      70    20658557 :     into << std::string(4 * (myXMLStack.size() + myDefaultIndentation), ' ') << "<" << xmlElement;
      71    20658557 :     myXMLStack.push_back(xmlElement);
      72    20658557 : }
      73             : 
      74             : 
      75             : void
      76     7297182 : PlainXMLFormatter::openTag(std::ostream& into, const SumoXMLTag& xmlElement) {
      77     7297182 :     openTag(into, toString(xmlElement));
      78     7297182 : }
      79             : 
      80             : 
      81             : bool
      82    20885138 : PlainXMLFormatter::closeTag(std::ostream& into, const std::string& comment) {
      83    20885138 :     if (!myXMLStack.empty()) {
      84    20658542 :         if (myHavePendingOpener) {
      85    16455992 :             into << "/>" << comment << "\n";
      86    16455992 :             myHavePendingOpener = false;
      87             :         } else {
      88     4202550 :             const std::string indent(4 * (myXMLStack.size() + myDefaultIndentation - 1), ' ');
      89     4202550 :             into << indent << "</" << myXMLStack.back() << ">" << comment << "\n";
      90             :         }
      91    20658542 :         myXMLStack.pop_back();
      92    20658542 :         return true;
      93             :     }
      94             :     return false;
      95             : }
      96             : 
      97             : 
      98             : void
      99        1104 : PlainXMLFormatter::writePreformattedTag(std::ostream& into, const std::string& val) {
     100        1104 :     if (myHavePendingOpener) {
     101          80 :         into << ">\n";
     102          80 :         myHavePendingOpener = false;
     103             :     }
     104             :     into << val;
     105        1104 : }
     106             : 
     107             : void
     108       70048 : PlainXMLFormatter::writePadding(std::ostream& into, const std::string& val) {
     109             :     into << val;
     110       70048 : }
     111             : 
     112             : 
     113             : /****************************************************************************/