Xml.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BASE_XML_H
#define ZYPP_BASE_XML_H

#include <iosfwd>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>

#include "zypp/base/Easy.h"
#include "zypp/base/String.h"
#include "zypp/parser/xml/XmlEscape.h"

namespace zypp
{
  namespace xmlout
  {
    using xml::escape;
    using xml::unescape;

    template <class _Tp>
    std::string asXmlNodeAttr( const _Tp & val_r )
    { return str::asString( val_r ); }

    struct NodeAttr : public std::pair<std::string,std::string>
    {
      typedef std::pair<std::string,std::string> Pair;

      template <typename _Type>
      NodeAttr( std::string key_r, const _Type & val_r )
      : Pair( std::move(key_r), asXmlNodeAttr(val_r) )
      {}

      NodeAttr( std::string key_r, std::string val_r )
      : Pair( std::move(key_r), std::move(val_r) )
      {}
    };

    struct Node
    {
      NON_COPYABLE_BUT_MOVE( Node );
      typedef NodeAttr Attr;

      struct OptionalContentType {};    
      static constexpr OptionalContentType optionalContent = OptionalContentType();

      Node( std::ostream & out_r, std::string name_r, const std::initializer_list<Attr> & attrs_r = {} )
      : _out( out_r ), _name( std::move(name_r) ), _hasContent( true )
      { printStart( attrs_r ); }

      Node( std::ostream & out_r, std::string name_r, Attr attr_r )
      : Node( out_r, std::move(name_r), { attr_r } )
      {}

      Node( std::ostream & out_r, std::string name_r, OptionalContentType, const std::initializer_list<Attr> & attrs_r = {} )
      : _out( out_r ), _name( std::move(name_r) ), _hasContent( false )
      { printStart( attrs_r ); }

      Node( std::ostream & out_r, std::string name_r, OptionalContentType, Attr attr_r )
      : Node( out_r, std::move(name_r), optionalContent, { attr_r } )
      {}

      ~Node()
      {
        if ( ! _name.empty() )
        {
          if ( _hasContent )
            _out << "</" << _name << ">";
          else
            _out << "/>";
        }
      }

      std::ostream & operator*()
      {
        if ( ! _hasContent )
        {
          _hasContent = true;
          if ( ! _name.empty() )
            _out << ">";
        }
        return _out;
      }

    private:
      void printStart( const std::initializer_list<Attr> & attrs_r )
      {
        if ( ! _name.empty() )
        {
          _out << "<" << _name;
          for ( const auto & pair : attrs_r )
            _out << " " << pair.first << "=\"" << xml::escape( pair.second ) << "\"";
          if ( _hasContent )
            _out << ">";
        }
      }
    private:
      std::ostream & _out;
      std::string _name;
      bool _hasContent;
    };

    inline std::ostream & node( std::ostream & out_r, const std::string & name_r, const std::initializer_list<Node::Attr> & attrs_r = {} )
    {
      Node( out_r, name_r, Node::optionalContent, attrs_r );
      return out_r;
    }
    inline std::ostream & node( std::ostream & out_r, const std::string & name_r, Node::Attr attr_r )
    { return node( out_r, name_r, { attr_r } ); }

  } // namespace xmlout
} // namespace zypp
#endif // ZYPP_BASE_XML_H