---

more/diag/xml.h

Go to the documentation of this file.

//  Copyright (C) 2000--2001  Petter Urkedal (petter.urkedal@matfys.lth.se)

//  This file 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 2 of the License, or
//  (at your option) any later version.

//  This file 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, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.

//  $Id: xml.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $
//  STATUS. Experimental. This interface may be changed or removed!


#include <more/gen/nary_tree.h>
#include <more/gen/utility.h>
#include <string>
#include <map>


namespace more
{

  typedef char xml_char_type;
  typedef std::basic_string<xml_char_type> xml_string_type;

  struct _xml_node_base : handle_data
  {
      virtual ~_xml_node_base() {}
  };

  struct xml_namespace_node
  {
      xml_string_type const& url() const { return m_url; }
    private:
      xml_string_type m_url;
  };

  struct xml_text_node : _xml_node_base
  {
      xml_text_node() {}
      xml_text_node(xml_string_type s) : m_contents(s) {}
      virtual ~xml_text_node() {}

      xml_string_type const& contents() const { return m_contents; }

    private:
      xml_string_type m_contents;
  };

  struct xml_element_node : _xml_node_base
  {
      typedef std::map<xml_string_type, xml_string_type>
              attribute_container;
      typedef attribute_container::iterator attribute_iterator;
      typedef attribute_container::const_iterator const_attribute_iterator;

      xml_element_node() {}

      explicit xml_element_node(xml_string_type name)
          : m_ns(0), m_name(name) {}

      virtual ~xml_element_node() {}

      xml_string_type const& name() const { return m_name; }

      attribute_iterator insert_attribute(xml_string_type k, xml_string_type v)
        { m_attr.insert(std::make_pair(k, v)); }

    private:
      xml_namespace_node* m_ns;
      xml_string_type m_name;
      attribute_container m_attr;
  };

  struct _xml_node_handle : handle<_xml_node_base>
  {
      _xml_node_handle() {}
      _xml_node_handle(_xml_node_handle const& x) : handle<_xml_node_base>(x) {}
      _xml_node_handle(_xml_node_base* x) : handle<_xml_node_base>(x) {}

      xml_text_node* as_text()
        { return dynamic_cast<xml_text_node*>(data()); }
      xml_text_node const* as_text() const
        { return dynamic_cast<xml_text_node*>(data()); }
      xml_element_node* as_element()
        { return dynamic_cast<xml_element_node*>(data()); }
      xml_element_node const* as_element() const
        { return dynamic_cast<xml_element_node*>(data()); }
  };

  struct xml_document : nary_tree<_xml_node_handle>
  {
      typedef nary_tree<_xml_node_handle> container;
      typedef container::const_iterator const_iterator;
      typedef container::iterator iterator;

      xml_document(std::string file_name);
  };

}

---