ircproxy  The Ultimate Cyborg

---

PersistXML.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file PersistXML.h
//! @brief This file contains the declaration of class PersistXML.
//
// Copyright (C) 2006, 2007 by
//
// Carlo Wood, Run on IRC <carlo@alinoe.com>
// RSA-1024 0x624ACAD5 1997-01-26                    Sign & Encrypt
// Fingerprint16 = 32 EC A7 B6 AC DB 65 A6  F6 F6 55 DD 1C DC FF 61
//
// This file may be distributed under the terms of the Q Public License
// version 1.0 as appearing in the file LICENSE.QPL included in the
// packaging of this file.

#ifndef PERSISTXML_H
#define PERSISTXML_H

#ifndef USE_PCH
#include <string>
#include <fstream>
#include <stdexcept>
#include <vector>
#include <list>
#include <stack>
#include <sstream>
#include <libxml/parser.h>
#include <boost/shared_ptr.hpp>
#include <boost/optional/optional.hpp>
#include "debug.h"
#endif

#include "exceptions.h"

/*! @brief Exception class used to signal an invalid XML label.
 *
 * This exception is thrown by PersistXML::serialize when the
 * requested label is invalid.
 */
class xml_invalid_label : public virtual std::invalid_argument {
public:
  //! Constructor.
  xml_invalid_label(std::string const& label) : std::invalid_argument("Invalid XML label: \"" + label + "\".") { }
  //! Destructor.
  virtual ~xml_invalid_label() throw() { }
};

/*! @brief Exception class used to signal a failure in parsing an XML document.
 *
 */
class xml_parse_error : public virtual std::runtime_error {
public:
  //! Constructor.
  xml_parse_error(std::string const& message) : std::runtime_error("XML parse error: " + message) { }
  //! Destructor.
  virtual ~xml_parse_error() throw() { }
};

//! Returns true if the label is valid.
extern bool valid_label(std::string const& label);

/*! @brief A class to control output indentation.
 */
class Indentation {
private:
  int M_spaces;         //!< The number of spaces to indent.
public:
  //! Construct a new indentation object of zero spaces.
  Indentation(void) : M_spaces(0) { }
  //! Copy constructor.
  Indentation(Indentation const& indent) : M_spaces(indent.M_spaces) { }
  //! Pre-increment indentation with two spaces.
  Indentation& operator++(void) { M_spaces += 2; return *this; }
  //! Post-increment indentation with two spaces.
  Indentation operator++(int) { Indentation tmp(*this); M_spaces += 2; return tmp; }
  //! Pre-decrement indentation by two spaces.
  Indentation& operator--(void) { M_spaces -= 2; return *this; }
  //! Post-decrement indentation by two spaces.
  Indentation operator--(int) { Indentation tmp(*this); M_spaces -= 2; return tmp; }
  //! Print object to ostream.
  friend std::ostream& operator<<(std::ostream& os, Indentation const& indentation)
  {
    for (int i = 0; i < indentation.M_spaces; ++i)
      os << ' ';
    return os;
  }
};

/*! @brief A persistent object archiver
 *
 * This object represents an archive to which objects
 * can be written to if they support the serialize(PersistXML&)
 * method.
 */
class PersistXML {
public:
  //! The open mode type of the archive.
  enum openmode_type {
    not_open,           //!< Used internally to mark that the archive is not open.
    store,              //!< Open for writing objects to the archive.
    load                //!< Open for reading objects from the archive.
  };

protected:
  openmode_type M_openmode;                     //!< Whether or not the archive is opened for reading or writing.
  std::string M_archivename;            //!< The name of the XML file used to write the archive to disk.
  std::fstream M_archive;               //!< The file stream of an open archive.
  Indentation M_indent;                 //!< Current XML indentation.
  xmlDocPtr M_doc;                      //!< XML document open for reading.
  xmlNodePtr M_cur;                     //!< Current node in M_doc.
  std::stack<std::vector<xmlNodePtr> > M_parent_nodes;  //!< Stack with parents of current node.

public:
  //! Construct a new persistent XML archive object.
  PersistXML(void);
  //! Destruct the object. An open archive is first finalized.
  ~PersistXML();
  //! Associate the archive with a file for either reading or writing.
  void open(std::string filename, openmode_type mode);
  //! Finalize and close the archive.
  void close(void);
  //! Return the current state.
  openmode_type openmode(void) const { return M_openmode; }

private:
  void parse_archive(void);
  template<typename T>
    void write_escaped(T const& builtin);
  template<typename T>
    void read_data(std::stringstream& ss, T& builtin);

public:
  template<typename T>
    void serialize(std::string const& label, T& object);
  template<typename T>
    void serialize(std::string const& label, boost::shared_ptr<T>& ptr);
  template<typename T>
    void serialize(std::string const& label, std::vector<T>& vec);
  template<typename T>
    void serialize(std::string const& label, std::list<T>& list);
  template<typename KEY, typename INFO, typename COMPARE>
    void serialize(std::string const& label, std::map<KEY, INFO, COMPARE>& map);
  template<typename T>
    void serialize(std::string const& label, boost::optional<T>& opt);
#if 0
  template<typename CONTAINER>
    void serialize(std::string const& label, CONTAINER& object,
        typename CONTAINER::iterator start, typename CONTAINER::iterator end);
#endif
  template<typename T>
    void serialize_builtin(std::string const& label, T& builtin);

  friend class XMLLabel;
  friend std::ostream& operator<<(std::ostream& os, openmode_type openmode);
};

/*! @brief An XML label.
 *
 * Output/input an extra &lt;label&gt;...&lt;/label&gt; pair, increasing the indentation.
 */
class XMLLabel {
private:
  PersistXML& M_xml;            //!< The archive.
  std::string M_label;          //!< The label.
public:
  //! Open \a label archive \a xml.
  XMLLabel(PersistXML& xml, std::string const& label) :
      M_xml(xml), M_label(label) { M_xml.M_archive << M_xml.M_indent++ << '<' << M_label << ">\n"; }
  //! Close the label.
  ~XMLLabel() { M_xml.M_archive << --M_xml.M_indent << "</" << M_label << ">\n"; }
};

//! Serialize \a object using the xml tag &lt;label&gt;&lt;/label&gt;.
template<typename T>
  void PersistXML::serialize(std::string const& label, T& object)
  {
    if (M_openmode == store)
    {
      Dout(dc::persist, "PersistXML::serialize(\"" << label << "\", (" <<
          type_info_of<T>().demangled_name() << ") {" << object << "}) is called.");
      XMLLabel xml_label(*this, label);
      object.serialize(*this);
    }
    else if (M_openmode == load)
    {
      Dout(dc::persist, "PersistXML::serialize(\"" << label << "\", (" <<
          type_info_of<T>().demangled_name() << ") @" << (void*)&object << ") is called.");
      while (M_cur)
      {
        Dout(dc::persist, "M_cur is \"" << M_cur->name << "\".");
        if (!xmlStrcmp(M_cur->name, (xmlChar const*) label.c_str()))
        {
          xmlNodePtr cur = M_cur;
          M_cur = cur->children;
          object.serialize(*this);
          M_cur = cur->next;
          return;
        }
        M_cur = M_cur->next;
      }
      THROW_EXCEPTION(xml_parse_error("Cannot find requested element \"" + label + "\" in current node."), "");
    }
  }

//! Serialize the object pointed to by a boost::shared_ptr using the xml tag &lt;label&gt;&lt;/label&gt;.
template<typename T>
  void PersistXML::serialize(std::string const& label, boost::shared_ptr<T>& ptr)
  {
    if (!valid_label(label))
      THROW_EXCEPTION(xml_invalid_label(label), "");
    if (M_openmode == store)
    {
      Dout(dc::persist, "PersistXML::serialize(\"" << label << "\", (boost::shared_ptr<" <<
          type_info_of<T>().demangled_name() << ">)) is called.");
      XMLLabel xml_label(*this, label);
      ptr->serialize(*this);
    }
    else if (M_openmode == load)
    {
      Dout(dc::persist, "PersistXML::serialize(\"" << label << "\", (boost::shared_ptr<" <<
          type_info_of<T>().demangled_name() << ">) @" << (void*)&ptr << ") is called.");
      while (M_cur)
      {
        Dout(dc::persist, "M_cur is \"" << M_cur->name << "\".");
        if (!xmlStrcmp(M_cur->name, (xmlChar const*) label.c_str()))
        {
          xmlNodePtr cur = M_cur;
          M_cur = cur->children;
          ptr.reset(new T);
          AllocTag(ptr.get(), "Allocated for a boost::shared_ptr<" << libcwd::type_info_of<T>().demangled_name() << "> by PersistXML");
          ptr->serialize(*this);
          M_cur = cur->next;
          return;
        }
        M_cur = M_cur->next;
      }
      THROW_EXCEPTION(xml_parse_error("Cannot find requested element \"" + label + "\" in current node."), "");
    }
  }

//! Serialize std::vector \a vec using the xml tag &lt;label&gt;&lt;/label&gt;.
template<typename T>
  void PersistXML::serialize(std::string const& label, std::vector<T>& vec)
  {
    if (!valid_label(label))
      THROW_EXCEPTION(xml_invalid_label(label), "");
    if (M_openmode == store)
    {
      Dout(dc::persist, "PersistXML::serialize(\"" << label << "\", (std::vector<" <<
          type_info_of<T>().demangled_name() << ">)) is called.");
      XMLLabel xml_label(*this, label);
      for (typename std::vector<T>::iterator iter = vec.begin(); iter != vec.end(); ++iter)
        this->serialize("item", *iter);
    }
    else if (M_openmode == load)
    {
      Dout(dc::persist, "PersistXML::serialize(\"" << label << "\", (std::vector<" <<
          type_info_of<T>().demangled_name() << ">) @" << (void*)&vec << ") is called.");
      while (M_cur)
      {
        Dout(dc::persist, "M_cur is \"" << M_cur->name << "\".");
        if (!xmlStrcmp(M_cur->name, (xmlChar const*) label.c_str()))
        {
          if (M_cur->children)
          {
            xmlNodePtr cur = M_cur;
            M_cur = cur->children;
            while (M_cur)
            {
              if (!xmlStrcmp(M_cur->name, (xmlChar const*) "item"))
              {
                vec.push_back(T());
                this->serialize("item", vec.back());
              }
              M_cur = M_cur->next;
            }
            M_cur = cur->next;
          }
          return;
        }
        M_cur = M_cur->next;
      }
      if (!M_cur)
        THROW_EXCEPTION(xml_parse_error("Cannot find element \"" + label + "\"."), "");
    }
  }

//! Serialize std::list \a list using the xml tag &lt;label&gt;&lt;/label&gt;.
template<typename T>
  void PersistXML::serialize(std::string const& label, std::list<T>& list)
  {
    if (!valid_label(label))
      THROW_EXCEPTION(xml_invalid_label(label), "");
    if (M_openmode == store)
    {
      Dout(dc::persist, "PersistXML::serialize(\"" << label << "\", (std::list<" <<
          type_info_of<T>().demangled_name() << ">)) is called.");
      XMLLabel xml_label(*this, label);
      for (typename std::list<T>::iterator iter = list.begin(); iter != list.end(); ++iter)
        this->serialize("item", *iter);
    }
    else if (M_openmode == load)
    {
      Dout(dc::persist, "PersistXML::serialize(\"" << label << "\", (std::list<" <<
          type_info_of<T>().demangled_name() << ">) @" << (void*)&list << ") is called.");
      while (M_cur)
      {
        Dout(dc::persist, "M_cur is \"" << M_cur->name << "\".");
        if (!xmlStrcmp(M_cur->name, (xmlChar const*) label.c_str()))
        {
          if (M_cur->children)
          {
            xmlNodePtr cur = M_cur;
            M_cur = cur->children;
            while (M_cur)
            {
              if (!xmlStrcmp(M_cur->name, (xmlChar const*) "item"))
              {
                list.push_back(T());
                this->serialize("item", list.back());
              }
              M_cur = M_cur->next;
            }
            M_cur = cur->next;
          }
          return;
        }
        M_cur = M_cur->next;
      }
      if (!M_cur)
        THROW_EXCEPTION(xml_parse_error("Cannot find element \"" + label + "\"."), "");
    }
  }

//! Serialize std::map \a map using the xml tag &lt;label&gt;&lt;/label&gt;.
template<typename KEY, typename INFO, typename COMPARE>
  void PersistXML::serialize(std::string const& label, std::map<KEY, INFO, COMPARE>& map)
  {
    typedef std::map<KEY, INFO, COMPARE> container_type;
    if (!valid_label(label))
      THROW_EXCEPTION(xml_invalid_label(label), "");
    if (M_openmode == store)
    {
      Dout(dc::persist, "PersistXML::serialize(\"" << label << "\", (std::map<" <<
          type_info_of<KEY>().demangled_name() << ", " <<
          type_info_of<INFO>().demangled_name() << ">)) is called.");
      XMLLabel xml_label(*this, label);
      for (typename container_type::iterator iter = map.begin(); iter != map.end(); ++iter)
      {
        this->serialize("key", const_cast<KEY&>(iter->first));
        this->serialize("info", iter->second);
      }
    }
    else if (M_openmode == load)
    {
      Dout(dc::persist, "PersistXML::serialize(\"" << label << "\", (std::map<" <<
          type_info_of<KEY>().demangled_name() << ", " <<
          type_info_of<INFO>().demangled_name() << ">) @" << (void*)&map << ") is called.");
      while (M_cur)
      {
        Dout(dc::persist, "M_cur is \"" << M_cur->name << "\".");
        if (!xmlStrcmp(M_cur->name, (xmlChar const*) label.c_str()))
        {
          if (M_cur->children)
          {
            xmlNodePtr cur = M_cur;
            M_cur = cur->children;
            while (M_cur)
            {
              Dout(dc::persist, "M_cur is \"" << M_cur->name << "\".");
              if (!xmlStrcmp(M_cur->name, (xmlChar const*) "key"))
              {
                KEY key;
                this->serialize("key", key);
                std::pair<typename container_type::iterator, bool> result =
                    map.insert(typename container_type::value_type(key, INFO()));
                if (!result.second)
                  THROW_EXCEPTION(xml_parse_error("Duplicated key for map."), "");
                M_cur = M_cur->next;
                while (M_cur)
                {
                  Dout(dc::persist, "M_cur is \"" << M_cur->name << "\".");
                  if (!xmlStrcmp(M_cur->name, (xmlChar const*) "key"))
                  {
                    M_cur = NULL;
                    break;
                  }
                  if (!xmlStrcmp(M_cur->name, (xmlChar const*) "info"))
                  {
                    this->serialize("info", result.first->second);
                    Dout(dc::persist, "Inserted in map: " << *result.first);
                    break;
                  }
                  M_cur = M_cur->next;
                }
                if (!M_cur)
                  THROW_EXCEPTION(xml_parse_error("Missing element \"info\"."), "");
              }
              M_cur = M_cur->next;
            }
          }
          return;
        }
        M_cur = M_cur->next;
      }
      if (!M_cur)
        THROW_EXCEPTION(xml_parse_error("Cannot find element \"" + label + "\"."), "");
    }
  }

//! Serialize boost::optional \a opt using the xml tag &lt;label&gt;&lt;/label&gt;.
template<typename T>
  void PersistXML::serialize(std::string const& label, boost::optional<T>& opt)
  {
    if (M_openmode == store)
    {
      Dout(dc::persist, "PersistXML::serialize(\"" << label << "\", (boost::optional<" <<
          type_info_of<T>().demangled_name() << ">)) is called.");
      if (opt)
        this->serialize(label, *opt);
      else
      {
        std::string unknown("unknown");
        this->serialize(label, unknown);
      }
    }
    else if (M_openmode == load)
    {
      Dout(dc::persist, "PersistXML::serialize(\"" << label << "\", (boost::optional<" <<
          type_info_of<T>().demangled_name() << ">) @" << (void*)&opt << ") is called.");
      bool unknown = false;
      // Peek ahead (look for the label).
      while (M_cur)
      {
        Dout(dc::persist, "M_cur is \"" << M_cur->name << "\".");
        if (!xmlStrcmp(M_cur->name, (xmlChar const*) label.c_str()))
        {
          unknown = (M_cur->children->type == XML_TEXT_NODE &&
                     !strcmp((char*)M_cur->children->name, "text") &&
                     !strcmp((char*)M_cur->children->content, "unknown"));
          break;
        }
        M_cur = M_cur->next;
      }
      if (!M_cur)
        THROW_EXCEPTION(xml_parse_error("Cannot find element \"" + label + "\"."), "");
      // Read the content.
      if (unknown)
      {
        std::string unknown;
        this->serialize(label, unknown);
        ASSERT(unknown == "unknown");
        opt = boost::none;
      }
      else
      {
        T value;
        this->serialize(label, value);
        opt = value;
      }
    }
  }

// Specializations.

//! \internal Helper macro to define serialization specializations for the builtin types.
#define SERIALIZE_BUILTINTYPE(type) \
  template<> inline void PersistXML::serialize(std::string const& label, type& builtin) \
    { this->serialize_builtin(label, builtin); }

SERIALIZE_BUILTINTYPE(std::string);
SERIALIZE_BUILTINTYPE(signed char);
SERIALIZE_BUILTINTYPE(unsigned char);
SERIALIZE_BUILTINTYPE(short);
SERIALIZE_BUILTINTYPE(unsigned short);
SERIALIZE_BUILTINTYPE(int);
SERIALIZE_BUILTINTYPE(unsigned int);
SERIALIZE_BUILTINTYPE(long);
SERIALIZE_BUILTINTYPE(unsigned long);
SERIALIZE_BUILTINTYPE(float);
SERIALIZE_BUILTINTYPE(double);
SERIALIZE_BUILTINTYPE(bool);

//! Write builtin-type \a builtin to archive.
template<typename T>
  inline void PersistXML::write_escaped(T const& builtin) { M_archive << builtin; }
//! Write char \a c to archive.
template<>
  void PersistXML::write_escaped(char const& c);
//! Write unsigned char \a c to archive.
template<>
  inline void PersistXML::write_escaped(unsigned char const& c) { write_escaped(reinterpret_cast<char const&>(c)); }
//! Write string \a s to archive.
template<>
  void PersistXML::write_escaped(std::string const& s);

//! Read \a builtin from stringstream \a ss.
template<typename T>
  inline void PersistXML::read_data(std::stringstream& ss, T& builtin) { ss >> builtin; }
//! Read string \a s from stringstream \a ss.
template<>
  inline void PersistXML::read_data(std::stringstream& ss, std::string& s) { s = ss.str(); }

//! Serialize builtin type \a builtin using the xml tag &lt;label&gt;&lt;/label&gt;.
template<typename T>
  void PersistXML::serialize_builtin(std::string const& label, T& builtin)
  {
    if (M_openmode == store)
    {
      Dout(dc::persist, "PersistXML::serialize_builtin<" <<
          type_info_of<T>().demangled_name() << ">(\"" << label << "\", " << builtin << ") is called.");
      M_archive << M_indent << '<' << label << '>';
      write_escaped(builtin);
      M_archive << "</" << label << ">\n";
    }
    else if (M_openmode == load)
    {
      Dout(dc::persist, "PersistXML::serialize_builtin<" <<
          type_info_of<T>().demangled_name() << ">(\"" << label << "\", @" << (void*)&builtin << ") is called.");
      while (M_cur)
      {
        Dout(dc::persist, "M_cur is \"" << M_cur->name << "\".");
        if (!xmlStrcmp(M_cur->name, (xmlChar const*) label.c_str()))
        {
          if (M_cur->children)
          {
            std::stringstream is;
            is << M_cur->children->content;
            read_data(is, builtin);
          }
          else
            builtin = T();      // Should only be used for std::string.
          return;
        }
        M_cur = M_cur->next;
      }
      if (!M_cur)
        THROW_EXCEPTION(xml_parse_error("Cannot find element \"" + label + "\"."), "");
    }
  }

#endif // PERSISTXML_H

---