S3FC project page

S3FC home page

---

               

---

s3_xml_config.cc

Go to the documentation of this file.

/*
 * Stone Three Foundation Class (s3fc) provides a number of utility classes.
 * Copyright (C) 2001 by Stone Three Signal Processing (Pty) Ltd.
 *
 * Authored by Stone Three Signal Processing (Pty) Ltd.
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Please see the file 'COPYING' in the source root directory.
 */

#include <s3fc/s3_macros.h>
#include <s3fc/s3_xml_config.h>
#include <s3fc/s3_exception.h>
#include <fstream>
#include <iostream>

//
s3_xml_exception::s3_xml_exception(const std::string& errstr):
   s3_exception(errstr)
{
}

// constructor
// copied from the ORIGINAL s3_config_basse.cc authored by
//    Jan Pool <jpool@stonethree.com>
s3_xml_config::s3_xml_config(const std::string& n_config_file,
              bool create_file) throw (s3_generic_exception):
   config_file(n_config_file),
   rootnode(0)
{
   S3FC_DBG( std::cerr << "s3_xml_config::s3_xml_config(const string&"
        "n_config_file) " << std::endl);
   if ( create_file )
   {
      // create the file
      try
      {
    std::ofstream a_file( config_file.c_str(), std::ios::out );
    a_file.close();
      }
      catch (const std::exception& e)
      {
    throw s3_generic_exception("s3_xml_config::s3_xml_config Could not create file", e.what() );
      }
   }
   
   // init Xerces
   try
   {
      XMLPlatformUtils::Initialize();
   }
   catch(const XMLException& toCatch)
   {
      throw s3_generic_exception("s3_xml_config(const string&)",
             domstr_to_string(toCatch.getMessage()));
   }
   refresh();
}

// destructor
// copied from the ORIGINAL s3_config_basse.cc authored by
//    Jan Pool <jpool@stonethree.com>
s3_xml_config::~s3_xml_config()
{
   S3FC_DBG( std::cerr << "s3_xml_config::~s3_xml_config" << std::endl);

   // object is going out of scope, so clean up
   delete rootnode;
   rootnode = 0;
   
   // de-init Xerces
   try
   {
      XMLPlatformUtils::Terminate();
   }   
   catch(const XMLException& toCatch)
   {
      throw s3_generic_exception("s3_xml_config()",
              domstr_to_string(toCatch.getMessage()));
   }
}

// return the root node
s3_config_node& s3_xml_config::get_rootnode() const
{
   return *rootnode;
}

void s3_xml_config::refresh() 
{
   // parse XML document into DOM tree
   DOM_Document doc = parse(config_file);
#ifdef DEBUG
   // show the DOM tree
   dump_tree(doc);
#endif   
   
   rootnode = build_tree(doc);
}

void s3_xml_config::set_config_file(const std::string& n_config_file)
{
   config_file = n_config_file;
}

// recursively write contents to file
void s3_xml_config::write_node(const std::string& filename,
                const s3_config_node& node)
{
   std::ofstream fs(filename.c_str(), std::ios::out | std::ios::trunc);
   write_node(fs, node, 0);
   fs.close();
}

//
void s3_xml_config::write_node(std::ostream& os,
                const s3_config_node& node,
                unsigned int depth)
{
   static const int tab_size = 5;
   write_spaces(os, depth*tab_size);
   os << "<" << node.get_name();
   for (std::map<std::string,std::string>::const_iterator ptr =
      node.get_attributes().begin();
    ptr != node.get_attributes().end();
    ptr++) 
   {
      os << " " << ptr->first << "=\"" << ptr->second << "\"";
   }
   os << ">" << std::endl;
   if ( node.get_value().length() )
   {
      write_spaces(os, (depth+1)*tab_size);
      os << node.get_value();
      os << std::endl;
   }
   for (unsigned int i = 0; i < node.get_num_children(); i++)
   {
      write_node(os, node.get_child(i), depth+1);
   }
   write_spaces(os, depth*tab_size);
   os << "</" << node.get_name() << ">" << std::endl;
}

//  write n spaces to os
void s3_xml_config::write_spaces(std::ostream& os, unsigned int n) 
{
   for ( unsigned int i = 0; i < n; i++ )
   {
      os << " ";
   }
}

// parse the XML document into a DOM tree
// copied from the ORIGINAL s3_config_base.cc authored by
//    Jan Pool <jpool@stonethree.com>
DOM_Document s3_xml_config::parse(const std::string& filename)
   throw (s3_generic_exception, s3_xml_exception)
{   
   DOMParser parser;
   // install our own ErrorHandler - this throws an s3_xml_exception
   // when presented with any warnings, errors or fatal errors
   s3_xml_config::error_handler err_handler;
   try
   {
      parser.setErrorHandler(&err_handler);
      parser.setValidationScheme(DOMParser::Val_Auto);
      parser.setDoNamespaces(false);
      parser.setExitOnFirstFatalError(true);
      parser.parse( filename.c_str() );
   }
   // intercept and rethrow parse errors
   catch (const s3_xml_exception& e)
   {
      throw e;
   }
   // the following should catch most expected errors
   catch (const XMLException& e)
   {
      throw s3_generic_exception("s3_xml_config::parse() " 
             "caught XMLException",
             domstr_to_string(e.getMessage()));
   }
   catch (const DOM_DOMException& e)
   {
      throw s3_generic_exception("s3_xml_config::parse() "
             "caught DOM_DOMException",
             domstr_to_string(e.msg));
   }
   catch (const SAXParseException& e)
   {
      // this should not really occur as all SAXParseExceptions should
      // be caught by our error handler, converted to s3_xml_exceptions and
      // rethrown.
      std::stringstream ss;
      ss << "s3_xml_config::parse():"
    << " caught SAXParseException: ";
      ss << "" << domstr_to_string(e.getMessage()) << "";
      ss << " in file ";
      if ( e.getSystemId() )
      {
    ss << "'" << domstr_to_string(e.getSystemId()) << "'";
      }
      else
      {
    ss << "<unknown>";
      }
      ss << " line " << e.getLineNumber() << ", column "
    << e.getColumnNumber();
      std::cerr << ss.str() << std::endl << std::flush;
   }
   // catch-all if we really don't know why
   catch (...)
   {
      throw s3_generic_exception("s3_xml_config::parse(): ",
             "An unkown parsing error occured");
   }
   DOM_Document doc = parser.getDocument();
   return doc;
}

s3_config_node* s3_xml_config::build_tree(const DOM_Node& node)
{
   
   // name, value, attr
   std::string name = get_name(node);
   std::string value = get_value(node);
   std::map<std::string, std::string> attributes = get_attributes(node);
   std::vector<s3_config_node*> c = get_children(node);
   // deep copy into list
   std::vector<s3_config_node> children;
   for (std::vector<s3_config_node*>::iterator it = c.begin();
   it != c.end();
   ++it) 
   {
      children.push_back(**it);
   }
   return new s3_config_node(name, 
              value, 
              0,
              attributes, 
              children);
}

// get and convert name
std::string s3_xml_config::get_name(const DOM_Node& node)
{
   return domstr_to_string(node.getNodeName());
}

// copied from the ORIGINAL s3_config_basse.cc authored by
//    Gerhard Esterhuizen <gesterhuizen@stonethree.com>
std::string s3_xml_config::get_value(const DOM_Node& node)
{
   DOM_NodeList dlst = node.getChildNodes();
   std::string val;
   for (unsigned int i = 0; i < dlst.getLength(); i++)
   {
      if (dlst.item(i).getNodeType() == DOM_Node::TEXT_NODE)
      {
    std::string tmpval = domstr_to_string(dlst.item(i).getNodeValue());
    // cut whitespace from beginning
    int strt_i = tmpval.find_first_not_of(" \t\n\r");
    int end_i = tmpval.find_last_not_of(" \t\n\r");
    if ( strt_i != -1 )
    {
       if ( val.length() )
       {
          val += " ";
          val += tmpval.substr(strt_i, end_i-strt_i+1);
       }
       else
       {
          val = tmpval.substr(strt_i, end_i-strt_i+1);
       }
    }
      }
   } 
   return val;
   //   return domstr_to_string(node.getNodeValue());
}

// copied from the ORIGINAL s3_config_basse.cc authored by
//    Gerhard Esterhuizen <gesterhuizen@stonethree.com>
std::map<std::string, std::string> s3_xml_config::get_attributes(
   const DOM_Node& node)
{
   std::map<std::string, std::string> m;
   DOM_NamedNodeMap attrs = node.getAttributes();
   if ( attrs != 0 )
   {
      for ( unsigned int i = 0; i < attrs.getLength(); i++ ) 
      {
    DOM_Node n = attrs.item(i);
    std::string name = domstr_to_string(n.getNodeName());
    std::string value = domstr_to_string(n.getNodeValue());
    m[name] = value;
      }
   }
   return m;
}

// adapted from the ORIGINAL s3_config_basse.cc authored by
//    Gerhard Esterhuizen <gesterhuizen@stonethree.com>
// extract DOM nodes with type ELEMENT_NODE
std::vector<s3_config_node*> s3_xml_config::get_children(const DOM_Node& node)
{
   // DOM list of immediate children
   DOM_NodeList dlst = node.getChildNodes();
   std::vector<s3_config_node*> lst;
   for (unsigned int i = 0; i < dlst.getLength(); i++)
   {
      if (dlst.item(i).getNodeType() == DOM_Node::ELEMENT_NODE)
      {
    lst.push_back( build_tree(dlst.item(i)) );
      }
   }
   return lst;
}

// copied from the ORIGINAL s3_config_basse.cc authored by
//    Jan Pool <jpool@stonethree.com>
std::string s3_xml_config::domstr_to_string(const DOMString& dstr)
{
   const char* c = dstr.transcode();
   std::string str(c);
   // caller owns char* returned by transcode !
#ifndef _WIN32 // Might leak.
   delete c;
#endif
   return str;
}
  
#ifdef DEBUG
//
void s3_xml_config::dump_DOM_tree(const DOM_Node& node) const
{
   S3FC_DBG( std::cerr << "Node type is: " << node.getNodeType() << std::endl);
   switch (node.getNodeType())
   {
   case DOM_Node::ELEMENT_NODE:
   {
      
      S3FC_DBG( std::cerr << "Element: " << node.getNodeName() << std::endl);
      
      // The NamedNodeMap holds the attributes of the element.
      DOM_NamedNodeMap attrib = node.getAttributes();

      for (int i = 0; i < static_cast<int>(attrib.getLength()); i++)
      {
    S3FC_DBG( std::cerr << "Attrib: " << attrib.item(i).getNodeName() <<
         " = " << attrib.item(i).getNodeValue() << std::endl );
      }
      
      break;
   }
   case DOM_Node::TEXT_NODE:
      S3FC_DBG( std::cerr <<  node.getNodeValue() << std::endl);
      break;
   default:
      D ( std::cerr << "Node type is: " << node.getNodeType() << std::endl );
      break;
   }

   DOM_NodeList  child_list = node.getChildNodes();

   if (child_list.getLength() > 0)
   {
      for (int i = 0; i < static_cast<int>(child_list.getLength()); i++)
      {
    dump_tree(child_list.item(i));
      }
   }
}
#endif

//
void s3_xml_config::error_handler::warning(const SAXParseException& e)
{
   assemble_and_throw(e, "warning");
}

//
void s3_xml_config::error_handler::error(const SAXParseException& e)
{
   assemble_and_throw(e, "error");
}

//
void s3_xml_config::error_handler::fatalError(const SAXParseException& e)
{
   assemble_and_throw(e, "fatal error");
}

//
void s3_xml_config::error_handler::resetErrors()
{
   return;
}

//
void s3_xml_config::error_handler::assemble_and_throw(
   const SAXParseException& e,
   const std::string& type)
{
      std::stringstream ss;
      ss << "XML Parser reported " << type << ": ";
      ss << domstr_to_string(e.getMessage());
      ss << " in file ";
      if ( e.getSystemId() )
      {
    ss << "'" << domstr_to_string(e.getSystemId()) << "'";
      }
      else
      {
    ss << "<unknown>";
      }
      ss << " line " << e.getLineNumber() << ", column "
    << e.getColumnNumber();
      throw s3_xml_exception(ss.str());
}

//
std::ostream& operator<<(std::ostream& str, const DOMString& s)
{
   char* buf = s.transcode();
   str << buf;
   delete [] buf;
   return str;
}

---

Send comments to: s3fc@stonethree.com