sprint/xml/uxml.h

Go to the documentation of this file.

/******************************************************************************
*   sprint::xml
*
*   Copyright (C) 2004-2011  Paolo Medici <www.pmx.it>
*
*  This library is free software; you can redistribute it and/or
*  modify it under the terms of the GNU Lesser General Public
*  License as published by the Free Software Foundation; either
*  version 2.1 of the License, or (at your option) any later version.
*
*  This library 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
*  Lesser General Public License for more details.
*
*  You should have received a copy of the GNU Lesser General Public
*  License along with this library; if not, write to the Free Software
*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*
*******************************************************************************/

#ifndef _SPRINT_XML_H
#define _SPRINT_XML_H

#if defined (_MSC_VER)
// avoid bogus warning....
# define _CRT_SECURE_NO_WARNINGS
#endif

#include <string>
#include <vector>
#include <sprint/smart_cast.h>

#ifndef NO_USE_XSTREAM
# include <sprint/io/xstream/xstream.h>
#else
# include <iostream>
#endif

namespace sprint {

namespace xml {

// a forward declaration for the following typedef
struct node;

typedef std::pair<std::string, std::string> attr_t;

typedef std::vector< attr_t > attr_list_t;

typedef std::vector< node > node_list_t;

struct node {
      std::string id;
      std::string text;
      attr_list_t attr;
      node_list_t child;
      
  public:
    
      typedef node_list_t::const_iterator const_iterator;
      typedef node_list_t::iterator iterator;      
      
  private:
      bool add_attr(const std::string & key, const std::string & value);
  
  public:      
      node();
      node(const char *p_id);
      ~node();
      
      const_iterator cbegin() const { return child.begin(); }
      const_iterator cend() const { return child.end(); }

      void add(const node & n) { child.push_back(n); }
      
      bool find_attr(const std::string & key, std::string & value) const;

      template<class T>
      void set_attr(const std::string & key, T value)
      {
            // TODO: check multiple
          add_attr( key, smart_cast<std::string>(value) );
      }
      
      template<class T>
      T get_attr(const std::string & key, T _default) const
      {
        std::string value;
        if(find_attr(key, value))
         return smart_cast<T>(value);
         else
         return _default;
      }
      
      inline bool has_child() const { return !child.empty(); }
      
      inline const node & first_child() const { return child[0]; }
      inline node & first_child() { return child[0]; }
      
      node * find_child_by_class(const char *classid);
      const node * find_child_by_class(const char *classid) const;      
      
      inline node & set_text(const char *txt) { text = txt; return *this; }
      inline node & set_text(const std::string & txt) { text = txt; return *this; }
      };

class document: public node {
public:
      document();
      
      document(const char *file);     
      
#ifndef NO_USE_XSTREAM

      document(sprint::io::xstream & file);     
#else
      document(std::istream & file);     
#endif
      
      ~document();

      bool load(const char *file);

      bool save(const char *file) const;

#ifndef NO_USE_XSTREAM

      bool load(sprint::io::xstream & file);
      bool save(sprint::io::xstream & file) const;
#else

      bool load(std::istream & file);
      bool save(std::ostream & file) const;
#endif

};

} // xml namespace closed       

} // sprint namespace closed

#endif