ircproxy  The Ultimate Cyborg

---

PersistXML.cc

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file PersistXML.cc
//! @brief This file contains the implementation of class PersistXML.
//
// Copyright (C) 2005 - 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 USE_PCH
#include "sys.h"
#include <cassert>
#include <fstream>
#include <iterator>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include "debug.h"
#endif

#include "PersistXML.h"

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

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

//! Parse the archive.
void PersistXML::parse_archive(void)
{
  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;
}

void PersistXML::open(std::string filename, openmode_type mode)
{
  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)
{
  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;
}

bool valid_label(std::string const& label)
{
  if (label.size() == 0)
    return false;
  char first_char = label[0];
  if (first_char != '_' && !std::isalpha(first_char))
    return false;
  if (label.size() >= 3 &&
      std::tolower(first_char) == 'x' &&
      std::tolower(label[1]) == 'm' &&
      std::tolower(label[2]) == 'l')
    return false;
  std::string::const_iterator iter = label.begin();
  while (++iter != label.end())
  {
    char next_character = *iter;
    if (!std::isalpha(next_character) && !std::isdigit(next_character) && !std::ispunct(next_character))
      return false;
  }
  return true;
}

template<>
  void PersistXML::write_escaped(char const& c)
  {
    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;
    }
  }

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

---