xml_node.hpp

Go to the documentation of this file.

/*
 *
 *                   _/_/_/    _/_/   _/    _/ _/_/_/    _/_/
 *                  _/   _/ _/    _/ _/_/  _/ _/   _/ _/    _/
 *                 _/_/_/  _/_/_/_/ _/  _/_/ _/   _/ _/_/_/_/
 *                _/      _/    _/ _/    _/ _/   _/ _/    _/
 *               _/      _/    _/ _/    _/ _/_/_/  _/    _/
 *
 *             ***********************************************
 *                              PandA Project
 *                     URL: http://panda.dei.polimi.it
 *                       Politecnico di Milano - DEIB
 *                        System Architectures Group
 *             ***********************************************
 *              Copyright (C) 2004-2024 Politecnico di Milano
 *
 *   This file is part of the PandA framework.
 *
 *   The PandA framework 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.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
#ifndef XML_NODE_HPP
#define XML_NODE_HPP

#include "refcount.hpp"
#include "simple_indent.hpp"

#include <iosfwd>
#include <list>
#include <string>
#include <utility>

#include "custom_set.hpp"

REF_FORWARD_DECL(xml_node);
class xml_element;
class xml_text_node;
class xml_comment_node;
class xml_att_decl_node;

#define XML_TAB_SIZE 2

class xml_node
{
 private:
   std::string name;

   int line;

 public:
   explicit xml_node(const std::string& _name) : name(_name), line(0)
   {
   }
   virtual ~xml_node() = default;

   using node_list = std::list<xml_nodeRef>;

   virtual void print(std::ostream& os, bool formatted, simple_indent* pp) const = 0;

   friend std::ostream& operator<<(std::ostream& os, const xml_node& s)
   {
      simple_indent PP(STD_OPENING_CHAR, STD_CLOSING_CHAR, XML_TAB_SIZE);
      s.print(os, true, &PP);
      return os;
   }
   friend std::ostream& operator<<(std::ostream& os, const xml_node* s)
   {
      simple_indent PP(STD_OPENING_CHAR, STD_CLOSING_CHAR, XML_TAB_SIZE);
      s->print(os, true, &PP);
      return os;
   }
   friend std::ostream& operator<<(std::ostream& os, const xml_nodeRef& s)
   {
      simple_indent PP(STD_OPENING_CHAR, STD_CLOSING_CHAR, XML_TAB_SIZE);
      s->print(os, true, &PP);
      return os;
   }

   std::string get_name() const
   {
      return name;
   }

   void set_name(const std::string& _name)
   {
      name = _name;
   }

   int get_line() const;

   void set_line(int _line);

   static void convert_unescaped(std::string& ioString)
   {
      std::string::size_type lPos = 0;
      while((lPos = ioString.find_first_of("&<>'\"", lPos)) != std::string::npos)
      {
         switch(ioString[lPos])
         {
            case '&':
               ioString.replace(lPos++, 1, "&amp;");
               break;
            case '<':
               ioString.replace(lPos++, 1, "&lt;");
               break;
            case '>':
               ioString.replace(lPos++, 1, "&gt;");
               break;
            case '\'':
               ioString.replace(lPos++, 1, "&apos;");
               break;
            case '"':
               ioString.replace(lPos++, 1, "&quot;");
               break;
            default:
            {
               // Do nothing
            }
         }
      }
   }
   static void convert_escaped(std::string& ioString)
   {
      std::string::size_type lPos = 0;
      while((lPos = ioString.find("&amp;", lPos)) != std::string::npos)
      {
         ioString.replace(lPos++, 5, "&");
      }
      lPos = 0;
      while((lPos = ioString.find("&lt;", lPos)) != std::string::npos)
      {
         ioString.replace(lPos++, 4, "<");
      }
      lPos = 0;
      while((lPos = ioString.find("&gt;", lPos)) != std::string::npos)
      {
         ioString.replace(lPos++, 4, ">");
      }
      lPos = 0;
      while((lPos = ioString.find("&apos;", lPos)) != std::string::npos)
      {
         ioString.replace(lPos++, 6, "\'");
      }
      lPos = 0;
      while((lPos = ioString.find("&quot;", lPos)) != std::string::npos)
      {
         ioString.replace(lPos++, 6, "\"");
      }
   }
};

class xml_child : public xml_node
{
 public:
   explicit xml_child(const std::string& _name) : xml_node(_name), first_text(nullptr)
   {
   }

   void print(std::ostream& os, bool formatted, simple_indent* pp) const override
   {
      auto it_end = child_list.end();
      for(auto it = child_list.begin(); it != it_end; ++it)
      {
         (*it)->print(os, formatted, pp);
      }
   }

   xml_element* add_child_element(const std::string& name);

   xml_element* add_child_element(const xml_nodeRef& node);

   xml_text_node* add_child_text(const std::string& content);

   xml_text_node* get_child_text()
   {
      return first_text;
   }

   const xml_text_node* get_child_text() const
   {
      return first_text;
   }

   xml_comment_node* add_child_comment(const std::string& content);

   xml_att_decl_node* add_child_attribute_declaration(const std::string& name);

   void remove_child(xml_node* el)
   {
      child_list.remove(xml_nodeRef(el, null_deleter()));
   }

   node_list const& get_children()
   {
      return child_list;
   }

   const node_list& get_children() const
   {
      return child_list;
   }

   bool has_child() const
   {
      return !child_list.empty();
   }

   const CustomSet<xml_nodeRef> CGetDescendants(const std::string& path) const;

 private:
   node_list child_list;
   xml_text_node* first_text;
};

#endif