PersistXML Class Reference

#include <PersistXML.h>

List of all members.

---

Detailed Description

A persistent object archiver.

This object represents an archive to which objects can be written to if they support the serialize(PersistXML&) method.

Definition at line 95 of file PersistXML.h.

Public Types
enum	openmode_type { not_open, store, load }
	The open mode type of the archive. More...
Public Member Functions
	PersistXML (void)
	Construct a new persistent XML archive object.
	~PersistXML ()
	Destruct the object. An open archive is first finalized.
void	open (std::string filename, openmode_type mode)
	Associate the archive with a file for either reading or writing.
void	close (void)
	Finalize and close the archive.
openmode_type	openmode (void) const
	Return the current state.
template<typename T>
void	serialize (std::string const &label, T &object)
	Serialize object using the xml tag <label></label>.
template<typename T>
void	serialize (std::string const &label, boost::shared_ptr< T > &ptr)
	Serialize the object pointed to by a boost::shared_ptr using the xml tag <label></label>.
template<typename T>
void	serialize (std::string const &label, std::vector< T > &vec)
	Serialize std::vector vec using the xml tag <label></label>.
template<typename T>
void	serialize (std::string const &label, std::list< T > &list)
	Serialize std::list list using the xml tag <label></label>.
template<typename KEY, typename INFO, typename COMPARE>
void	serialize (std::string const &label, std::map< KEY, INFO, COMPARE > &map)
	Serialize std::map map using the xml tag <label></label>.
template<typename T>
void	serialize (std::string const &label, boost::optional< T > &opt)
	Serialize boost::optional opt using the xml tag <label></label>.
template<typename T>
void	serialize_builtin (std::string const &label, T &builtin)
	Serialize builtin type builtin using the xml tag <label></label>.
template<>
void	write_escaped (char const &c)
	Write char c to archive.
template<>
void	write_escaped (std::string const &builtin)
	Write string s to archive.
template<>
void	write_escaped (unsigned char const &c)
	Write unsigned char c to archive.
template<>
void	read_data (std::stringstream &ss, std::string &s)
	Read string s from stringstream ss.
Protected Attributes
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.
Private Member Functions
void	parse_archive (void)
	Parse the archive.
template<typename T>
void	write_escaped (T const &builtin)
	Write builtin-type builtin to archive.
template<typename T>
void	read_data (std::stringstream &ss, T &builtin)
	Read builtin from stringstream ss.
Friends
class	XMLLabel
std::ostream &	operator<< (std::ostream &os, openmode_type openmode)
	For debugging purposes. Write a PersistXML::openmode to os.

---

Member Enumeration Documentation

enum PersistXML::openmode_type

The open mode type of the archive.

Enumerator:

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.

Definition at line 98 of file PersistXML.h.

                     {
    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.
  };

---

Constructor & Destructor Documentation

PersistXML::PersistXML

(

void

)

Construct a new persistent XML archive object.

Definition at line 28 of file PersistXML.cc.

References debug::channels::dc::persist.

                           : M_openmode(not_open)
{
  Dout(dc::persist, "PersistXML::PersistXML(void) is called.");
}

PersistXML::~PersistXML

(

)

Destruct the object. An open archive is first finalized.

Definition at line 33 of file PersistXML.cc.

References close(), M_openmode, not_open, and debug::channels::dc::persist.

{
  Dout(dc::persist, "PersistXML::~PersistXML() is called.");
  if (M_openmode != not_open)
    close();
}

---

Member Function Documentation

void PersistXML::open	(	std::string	filename,
		openmode_type	mode
	)

Associate the archive with a file for either reading or writing.

Definition at line 64 of file PersistXML.cc.

References load, M_archive, M_archivename, M_indent, M_openmode, not_open, parse_archive(), debug::channels::dc::persist, and store.

Referenced by Application::start().

{
  Dout(dc::persist, "PersistXML::open(\"" << filename << "\", " << mode << ") is called.");
  assert(M_openmode == not_open);
  assert(mode == store || mode == load);
  M_archivename = filename;
  if (mode == store)
  {
    M_archive.open(filename.c_str(), std::ios_base::out);
    M_archive << "<?xml version=\"1.0\"?>\n";
    M_archive << M_indent++ << "<archive>\n";
  }
  else
    parse_archive();
  M_openmode = mode;
}

void PersistXML::close

(

void

)

Finalize and close the archive.

Definition at line 81 of file PersistXML.cc.

References M_archive, M_doc, M_indent, M_openmode, not_open, debug::channels::dc::persist, and store.

Referenced by Application::start(), and ~PersistXML().

{
  Dout(dc::persist, "PersistXML::close() is called.");
  assert(M_openmode != not_open);
  if (M_openmode == store)
    M_archive << --M_indent << "</archive>" << std::endl;
  else
    xmlFreeDoc(M_doc);
  M_archive.close();
  M_openmode = not_open;
}

openmode_type PersistXML::openmode

(

void

)

const [inline]

Return the current state.

Definition at line 123 of file PersistXML.h.

References M_openmode.

Referenced by Server::serialize().

{ return M_openmode; }

void PersistXML::parse_archive

(

void

)

[private]

Parse the archive.

Definition at line 41 of file PersistXML.cc.

References M_archivename, M_cur, and M_doc.

Referenced by open().

{
  M_doc = xmlParseFile(M_archivename.c_str());
  
  // Do some sanity checks.
  if (!M_doc)
    throw xml_parse_error("Document not parsed successfully.");
  M_cur = xmlDocGetRootElement(M_doc);
  if (!M_cur)
  {
    xmlFreeDoc(M_doc);
    throw xml_parse_error("Empty document.");
  }
  if (xmlStrcmp(M_cur->name, (xmlChar const*) "archive"))
  {
    xmlFreeDoc(M_doc);
    throw xml_parse_error("Document of the wrong type, root node isn't <archive>.");
  }
  
  // Set M_cur to the first node inside <archive>.
  M_cur = M_cur->xmlChildrenNode;
}

template<typename T>

void PersistXML::write_escaped

(

T const &

builtin

)

[inline, private]

Write builtin-type builtin to archive.

Definition at line 486 of file PersistXML.h.

References M_archive.

Referenced by write_escaped().

{ M_archive << builtin; }

template<typename T>

void PersistXML::read_data	(	std::stringstream &	ss,
		T &	builtin
	)			[inline, private]

Read builtin from stringstream ss.

Definition at line 499 of file PersistXML.h.

{ ss >> builtin; }

template<typename T>

void PersistXML::serialize	(	std::string const &	label,
		T &	object
	)			[inline]

Serialize object using the xml tag <label></label>.

Definition at line 175 of file PersistXML.h.

References load, M_cur, M_openmode, debug::channels::dc::persist, store, and THROW_EXCEPTION.

Referenced by Server::serialize(), serialize(), Network::serialize(), Identity::serialize(), Application::serialize(), and Application::start().

  {
    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."), "");
    }
  }

template<typename T>

void PersistXML::serialize	(	std::string const &	label,
		boost::shared_ptr< T > &	ptr
	)			[inline]

Serialize the object pointed to by a boost::shared_ptr using the xml tag <label></label>.

Definition at line 207 of file PersistXML.h.

References load, M_cur, M_openmode, debug::channels::dc::persist, store, THROW_EXCEPTION, and valid_label().

  {
    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."), "");
    }
  }

template<typename T>

void PersistXML::serialize	(	std::string const &	label,
		std::vector< T > &	vec
	)			[inline]

Serialize std::vector vec using the xml tag <label></label>.

Definition at line 243 of file PersistXML.h.

References load, M_cur, M_openmode, debug::channels::dc::persist, serialize(), store, THROW_EXCEPTION, and valid_label().

  {
    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 + "\"."), "");
    }
  }

template<typename T>

void PersistXML::serialize	(	std::string const &	label,
		std::list< T > &	list
	)			[inline]

Serialize std::list list using the xml tag <label></label>.

Definition at line 290 of file PersistXML.h.

References load, M_cur, M_openmode, debug::channels::dc::persist, serialize(), store, THROW_EXCEPTION, and valid_label().

  {
    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 + "\"."), "");
    }
  }

template<typename KEY, typename INFO, typename COMPARE>

void PersistXML::serialize	(	std::string const &	label,
		std::map< KEY, INFO, COMPARE > &	map
	)			[inline]

Serialize std::map map using the xml tag <label></label>.

Definition at line 337 of file PersistXML.h.

References load, M_cur, M_openmode, debug::channels::dc::persist, serialize(), store, THROW_EXCEPTION, and valid_label().

  {
    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 + "\"."), "");
    }
  }

template<typename T>

void PersistXML::serialize	(	std::string const &	label,
		boost::optional< T > &	opt
	)			[inline]

Serialize boost::optional opt using the xml tag <label></label>.

Definition at line 413 of file PersistXML.h.

References ASSERT, load, M_cur, M_openmode, debug::channels::dc::persist, serialize(), store, and THROW_EXCEPTION.

  {
    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;
      }
    }
  }

template<typename T>

void PersistXML::serialize_builtin	(	std::string const &	label,
		T &	builtin
	)			[inline]

Serialize builtin type builtin using the xml tag <label></label>.

Definition at line 506 of file PersistXML.h.

References M_openmode, debug::channels::dc::persist, and store.

  {
    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 + "\"."), "");
    }
  }

void PersistXML::write_escaped

(

char const &

c

)

[inline]

Write char c to archive.

Definition at line 116 of file PersistXML.cc.

References M_archive.

  {
    switch (c)
    {
      default:
        M_archive.put(c);
        break;
      case '<':
        M_archive << "&lt;";
        break;
      case '>':
        M_archive << "&gt;";
        break;
      case '&':
        M_archive << "&amp;";
        break;
      case '"':
        M_archive << "&quot;";
        break;
      case '\'':
        M_archive << "&apos;";
        break;
    }
  }

void PersistXML::write_escaped

(

std::string const &

builtin

)

[inline]

Write string s to archive.

Definition at line 142 of file PersistXML.cc.

References write_escaped().

  {
    std::stringstream str;
    str << builtin;
    std::istreambuf_iterator<char> const end;
    for (std::istreambuf_iterator<char> iter(str); iter != end; ++iter)
      write_escaped(*iter);
  } 

template<>

void PersistXML::write_escaped

(

unsigned char const &

c

)

[inline]

Write unsigned char c to archive.

Definition at line 492 of file PersistXML.h.

References write_escaped().

{ write_escaped(reinterpret_cast<char const&>(c)); }

template<>

void PersistXML::read_data	(	std::stringstream &	ss,
		std::string &	s
	)			[inline]

Read string s from stringstream ss.

Definition at line 502 of file PersistXML.h.

{ s = ss.str(); }

---

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	os,
		PersistXML::openmode_type	openmode
	)			[friend]

For debugging purposes. Write a PersistXML::openmode to os.

Definition at line 175 of file debug_ostream_operators.cc.

{
  return os << debug::openmode_name(openmode);
}

---

Member Data Documentation

openmode_type PersistXML::M_openmode [protected]

Whether or not the archive is opened for reading or writing.

Definition at line 105 of file PersistXML.h.

Referenced by close(), open(), openmode(), serialize(), serialize_builtin(), and ~PersistXML().

std::string PersistXML::M_archivename [protected]

The name of the XML file used to write the archive to disk.

Definition at line 106 of file PersistXML.h.

Referenced by open(), and parse_archive().

std::fstream PersistXML::M_archive [protected]

The file stream of an open archive.

Definition at line 107 of file PersistXML.h.

Referenced by close(), open(), write_escaped(), XMLLabel::XMLLabel(), and XMLLabel::~XMLLabel().

Indentation PersistXML::M_indent [protected]

Current XML indentation.

Definition at line 108 of file PersistXML.h.

Referenced by close(), open(), XMLLabel::XMLLabel(), and XMLLabel::~XMLLabel().

xmlDocPtr PersistXML::M_doc [protected]

XML document open for reading.

Definition at line 109 of file PersistXML.h.

Referenced by close(), and parse_archive().

xmlNodePtr PersistXML::M_cur [protected]

Current node in M_doc.

Definition at line 110 of file PersistXML.h.

Referenced by parse_archive(), and serialize().

std::stack<std::vector<xmlNodePtr> > PersistXML::M_parent_nodes [protected]

Stack with parents of current node.

Definition at line 111 of file PersistXML.h.

---

The documentation for this class was generated from the following files:

• PersistXML.h
• PersistXML.cc