XMLIO.cpp

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS 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.

BIAS 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 BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
// must be first:
//#include "precompiled.h"

#include "XMLIO.hh"
#include <Base/Common/W32Compat.hh>

//#include <Base/Common/BIASpragma.hh>

#include <sstream>
#include <vector>
#include <algorithm>
#include <cctype>
#include <string>

#include <string>
#include <stdlib.h> // getenv

#include <libxml/tree.h>
#include <libxml/encoding.h>
#include <libxml/parser.h>

#include <Base/Common/FileHandling.hh>


using namespace BIAS;
using namespace std;



XMLIO::XMLIO() {

  isInitialized_ = false;
  RootNode_ = NULL;
  CurrNode_ = NULL;
  //Encoding_ = "ISO-8859-1";
  Encoding_ = "UTF-8";
}


XMLIO::~XMLIO() {

  if (isInitialized_) {    
    // do NOT use xmlCleanupParser() here when concurrent threads use XMLIO!
    // see: http://xmlsoft.org/html/libxml-parser.html#xmlCleanupParser
    //xmlCleanupParser();
    xmlFreeDoc(xmlDoc_);
  }
}


void XMLIO::clear() {

  if (isInitialized_) {
    // do NOT use xmlCleanupParser() here when concurrent threads use XMLIO!
    // see: http://xmlsoft.org/html/libxml-parser.html#xmlCleanupParser
    //xmlCleanupParser();
    xmlFreeDoc(xmlDoc_);    
    isInitialized_ = false;
  }
  RootNode_ = NULL;
  CurrNode_ = NULL;
}


xmlNodePtr XMLIO::create(const std::string& RootNodeName) {

    if (xmlValidateName(BAD_CAST RootNodeName.c_str(), 0)!=0) {
    BIASERR("'" << RootNodeName <<
            "'is no valid node name, maybe contains blanks??\n");
    return NULL;
  }

  // Free the all existing XML pointers associated to the current document
  if (isInitialized_) {
    // do NOT use xmlCleanupParser() here when concurrent threads use XMLIO!
    // see: http://xmlsoft.org/html/libxml-parser.html#xmlCleanupParser
    //xmlCleanupParser();
    xmlFreeDoc(xmlDoc_);
    isInitialized_ = false;
  }

  // reate a new XML DOM tree, to which the XML document will be  written
  xmlDoc_ = xmlNewDoc(BAD_CAST XML_DEFAULT_VERSION);
  if (xmlDoc_ == NULL) {
    BIASERR("Error creating the xml document tree\n");
    return NULL;
  }

  // Create a new XML node, to which the XML document will be appended
  CurrNode_ = RootNode_ =
    xmlNewDocNode(xmlDoc_, NULL, BAD_CAST RootNodeName.c_str(), NULL);
  if (RootNode_ == NULL) {
    xmlFreeDoc(xmlDoc_);
    BIASERR("Error creating the root node\n");
    return NULL;
  }

  // Make ELEMENT the root node of the tree
  xmlDocSetRootElement(xmlDoc_, RootNode_);

  isInitialized_ = true;

  return RootNode_;

}


xmlNodePtr XMLIO::addChildNode(const xmlNodePtr ParentNode,
                               const std::string& NewNodeName) {

    if (xmlValidateName(BAD_CAST NewNodeName.c_str(), 0)!=0) {
    BIASERR("'" << NewNodeName <<
            "'is no valid node name, maybe contains blanks??\n");
    return NULL;
  }

  if (!isInitialized_) {
    BIASERR("Not initialized: Please call createXML/loadXML first\n");
    return NULL;
  }

  CurrNode_ = xmlNewChild(ParentNode, NULL,
                          BAD_CAST NewNodeName.c_str(), NULL);
  if (CurrNode_ == NULL) {
    BIASERR("Error creating the child node\n");
    return NULL;
  }

  return CurrNode_;

}

void XMLIO::addAttribute(const xmlNodePtr Node,
                         const std::string& AttributeName,
                         const bool AttributeValue) {
  stringstream stst;
  if (AttributeValue) {
    stst << "true";
  } else {
    stst << "false";
  }
  addAttribute(Node,AttributeName,stst.str());

}

void XMLIO::addAttribute(const xmlNodePtr Node,
                         const std::string& AttributeName,
                         const int AttributeValue) {
  stringstream stst;
  stst << AttributeValue;
  addAttribute(Node,AttributeName,stst.str());

}

void XMLIO::addAttribute(const xmlNodePtr Node,
                         const std::string& AttributeName,
                         const double AttributeValue) {
  stringstream stst;
  LOCALE_C_ON
  stst << setprecision(10);
  stst << AttributeValue;
  LOCALE_C_OFF
  addAttribute(Node,AttributeName,stst.str());

}

void XMLIO::addAttribute(const xmlNodePtr Node,
                         const std::string& AttributeName,
                         const std::vector<double> &AttributeValue) {
  stringstream stst;
  LOCALE_C_ON
  stst << setprecision(10);
  for (int i=0; i<(int)AttributeValue.size()-1; i++){
    stst << AttributeValue[i] << " ";
  }
  if (AttributeValue.size()>0)
    stst << AttributeValue[AttributeValue.size()-1];
  addAttribute(Node,AttributeName,stst.str());
  LOCALE_C_OFF

}

void XMLIO::addAttribute(const xmlNodePtr Node,
                         const std::string& AttributeName,
                         const std::vector<int> &AttributeValue) {
  stringstream stst;
  for (int i=0; i<(int)AttributeValue.size()-1; i++){
    stst << AttributeValue[i] << " ";
  }
  if (AttributeValue.size()>0)
    stst << AttributeValue[AttributeValue.size()-1];

  addAttribute(Node,AttributeName,stst.str());

}

void XMLIO::addAttribute(const xmlNodePtr Node,
                         const std::string& AttributeName,
                         const std::string& AttributeValue) {

  if (xmlValidateName(BAD_CAST AttributeName.c_str(), 0)!=0) {
    BIASERR("'" << AttributeName <<
            "'is no valid attribute name, maybe contains blanks??\n");
    return;
  }

  if (!isInitialized_) {
    BIASERR("Not initialized: Please call createXML/loadXML first\n");
    return;
  }

  xmlAttrPtr attPtr;
    attPtr = xmlSetProp(Node, BAD_CAST AttributeName.c_str(),
                      BAD_CAST AttributeValue.c_str());
  if (attPtr == NULL) {
    BIASERR("Error creating the child node\n");
    return;
  }

}

void XMLIO::addAttribute(const xmlNodePtr Node,
                         const std::string& AttributeName,
                         const char* AttributeValue)
{
  std::string toStr(AttributeValue);
  addAttribute(Node, AttributeName, toStr);
}


void XMLIO::addContent(const xmlNodePtr Node, const std::string& Content) {

  if (!isInitialized_) {
    BIASERR("Not initialized: Please call createXML/loadXML first\n");
    return;
  }

  xmlNodeAddContent(Node, BAD_CAST Content.c_str());

}

void XMLIO::addContent(const xmlNodePtr Node, const double Content) {

  if (!isInitialized_) {
    BIASERR("Not initialized: Please call createXML/loadXML first\n");
    return;
  }

  stringstream ss;
  LOCALE_C_ON
  ss << setprecision(10);
  ss << Content;
  LOCALE_C_OFF
  xmlNodeAddContent(Node, BAD_CAST ss.str().c_str());

}

void XMLIO::addContent(const xmlNodePtr Node, const int Content) {

  if (!isInitialized_) {
    BIASERR("Not initialized: Please call createXML/loadXML first\n");
    return;
  }

  stringstream ss;
  ss << Content;
  xmlNodeAddContent(Node, BAD_CAST ss.str().c_str());

}

void XMLIO::addContent(const xmlNodePtr Node, const vector<int> Content) {

  if (!isInitialized_) {
    BIASERR("Not initialized: Please call createXML/loadXML first\n");
    return;
  }

  stringstream ss;
  for (unsigned int i=0; i<Content.size(); i++) {
    ss << Content[i] << " ";
  }
  xmlNodeAddContent(Node, BAD_CAST ss.str().c_str());

}

void XMLIO::addComment(const xmlNodePtr Node, const std::string& Comment) {

  if (!isInitialized_) {
    BIASERR("Not initialized: Please call createXML/loadXML first\n");
    return;
  }
  xmlNodePtr myNode;
  myNode = xmlNewComment(BAD_CAST Comment.c_str());
  xmlAddChild(Node, myNode);

}

void XMLIO::setContent(const xmlNodePtr Node, const std::string& Content) {

  if (!isInitialized_) {
    BIASERR("Not initialized: Please call createXML/loadXML first\n");
    return;
  }

  xmlNodeSetContent(Node, BAD_CAST Content.c_str());

}


void XMLIO::setContent(const xmlNodePtr Node, const double Content) {

  if (!isInitialized_) {
    BIASERR("Not initialized: Please call createXML/loadXML first\n");
    return;
  }

  stringstream ss;
  LOCALE_C_ON
  ss << setprecision(10);
  ss << Content;
  LOCALE_C_OFF
  xmlNodeSetContent(Node, BAD_CAST ss.str().c_str());

}


void XMLIO::setContent(const xmlNodePtr Node, const int Content) {

  if (!isInitialized_) {
    BIASERR("Not initialized: Please call createXML/loadXML first\n");
    return;
  }

  stringstream ss;
  ss << Content;
  xmlNodeSetContent(Node, BAD_CAST ss.str().c_str());

}


void XMLIO::setContent(const xmlNodePtr Node, const vector<int> Content) {

  if (!isInitialized_) {
    BIASERR("Not initialized: Please call createXML/loadXML first\n");
    return;
  }

  stringstream ss;
  for (unsigned int i=0; i<Content.size(); i++) {
    ss << Content[i] << " ";
  }
  xmlNodeSetContent(Node, BAD_CAST ss.str().c_str());

}

int XMLIO::write(const std::string& FilenameConst,
                 bool AutoAddCompressionSuffix) const {
  if (!isInitialized_) {
    BIASERR("Not initialized: Please call createXML/loadXML first\n");
    return -1;
  }

  string FileName( FilenameConst ); // const const to add prefix and suffix

  // replace tilde prefix?
  FileHandling::FilenameExpansion(FilenameConst, FileName);

  // add compression suffix?
  if ((xmlGetDocCompressMode(xmlDoc_)>0) && AutoAddCompressionSuffix)
    FileName+=".z" ;

#ifdef BIAS_DEBUG
  //BIASASSERT(this->xmlDoc_!=NULL);
#endif // BIAS_DEBUG

  BIASASSERT(this->xmlDoc_!=NULL);
  LOCALE_C_ON

  int nBytes = xmlSaveFormatFileEnc(FileName.c_str(), this->xmlDoc_,
                    Encoding_.c_str(), 2 );
  LOCALE_C_OFF

  if (nBytes < 0) {
    BIASERR("Error saving XML file " << FileName << " ("
            << FilenameConst << "), wrote " << nBytes << " bytes");
    return -1;
  }

  return 0; // OK
}


xmlNodePtr XMLIO::read(const std::string& FilenameConst) {
  // needed to ensure consistent ,/. behavior in different envs

  std::string Filename(FilenameConst);

  // replace tilde prefix?
  FileHandling::FilenameExpansion(FilenameConst, Filename);

  // Free the all existing XML pointers associated to the current document
  if (isInitialized_) {
    // do NOT use xmlCleanupParser() here when concurrent threads use XMLIO!
    // see: http://xmlsoft.org/html/libxml-parser.html#xmlCleanupParser
    //xmlCleanupParser();
    xmlFreeDoc(xmlDoc_);
    isInitialized_ = false;
  }

  LOCALE_C_ON
    xmlDoc_ = xmlParseFile(Filename.c_str());
  LOCALE_C_OFF

  if (xmlDoc_ == NULL) {
    BIASERR("Error parsing the xml document: '"<<Filename
      <<"' XML syntax error/not well formed? Or file not found? \n");
    //BIASBREAK;
    return NULL;
  }

  RootNode_ = CurrNode_ =  xmlDocGetRootElement(xmlDoc_);
  isInitialized_=true;

  return RootNode_;

}


xmlNodePtr XMLIO::getFirstChild(const xmlNodePtr ParentNode) {

  CurrNode_ = ParentNode->children;
  while (CurrNode_!=NULL) {
    if (CurrNode_->type == XML_ELEMENT_NODE) {
      return CurrNode_;
    }
    CurrNode_ = CurrNode_->next;
  }
  return NULL;

}


xmlNodePtr XMLIO::getNextChild() {
  return getNextChild(NULL);
}


xmlNodePtr XMLIO::getNextChild(const xmlNodePtr SiblingNode) {

  if (SiblingNode!=NULL) {
    CurrNode_ = SiblingNode;
  }

  while (CurrNode_->next!=NULL) {
    CurrNode_ = CurrNode_->next;
    if (CurrNode_->type == XML_ELEMENT_NODE) {
      return CurrNode_;
    }
  }

  return NULL;

}


xmlNodePtr XMLIO::getChild(const xmlNodePtr ParentNode,
                           const std::string& ChildName) {

  xmlNodePtr myNode;
  myNode = getFirstChild(ParentNode);
  while(myNode!=NULL) {
    if (ChildName==getNodeName(myNode)) {
      return myNode;
    }
    myNode = getNextChild();
  }

  return NULL;

}

void
XMLIO::GetChildren(const xmlNodePtr ParentNode,
                   const std::string& ChildName,
                   std::vector<xmlNodePtr>& childrenWithSameName)
{
  childrenWithSameName.clear();
  xmlNodePtr currentChildNode;
  currentChildNode = getFirstChild(ParentNode);
  while(currentChildNode!=NULL) {
    if (ChildName==getNodeName(currentChildNode)) {
      childrenWithSameName.push_back(currentChildNode);
    }
    currentChildNode = getNextChild();
  }
}

xmlNodePtr XMLIO::GetChildWithAttributeValueString(const xmlNodePtr ParentNode,
                                                  const std::string& ChildName,
                                                  const std::string& AttributeName,
                                                  const std::string& AttributeValue) {

  xmlNodePtr myNode;
  myNode = getFirstChild(ParentNode);
  while(myNode!=NULL) {
    if (ChildName==getNodeName(myNode)) {
      if(getAttributeValueString(myNode, AttributeName) == AttributeValue) {
        return myNode;
      }
    }
    myNode = getNextChild();
  }

  return NULL;

}



std::string XMLIO::getNodeName(const xmlNodePtr Node) const {

  std::string ret="";

  if ((Node!=NULL) && (Node->name!=NULL)) {
    ret = (char*) Node->name;
  }
  return ret;

}

std::string XMLIO::getNodeContentString(const xmlNodePtr Node) const {

  std::string ret="";
  std::string temp="";
  if (Node->children!=NULL){
    if(Node->children->content!=NULL){
      temp = (char*) Node->children->content;
      int front=0;
      int rear=(int)temp.size()-1;
      while(temp[front]==' ' || (int)temp[front]==32 || (int)temp[front]==10)
        { front++; }
      if (front >=(int)temp.size()) return "";
      while(temp[rear]==' ' || (int)temp[rear]==32 || (int)temp[rear]==10)
        { rear--; }
      if (rear < 0) return "";
      if (front>rear) return "";
      ret.resize(rear-front+1);
      for(int k=front; k<=rear; k++)
        ret[k-front]=temp[k];
    }
  }

  return ret;
}

int XMLIO::getNodeContentInt(const xmlNodePtr Node) const {

  std::string s;
  s = getNodeContentString(Node);
  return atoi(s.c_str());

}

vector<int> XMLIO::getNodeContentVectorInt(const xmlNodePtr Node) const {

  stringstream s(getNodeContentString(Node));
  std::vector<int> ret;
  int temp;
  while (s >> temp){
    ret.push_back(temp);
  }
  return ret;
}


vector<double> XMLIO::getNodeContentVectorDouble(const xmlNodePtr Node) const {

  stringstream s(getNodeContentString(Node));
  std::vector<double> ret;
  double temp;
  LOCALE_C_ON
  while (s >> temp){
    ret.push_back(temp);
  }
  LOCALE_C_OFF
  return ret;
}


double XMLIO::getNodeContentDouble(const xmlNodePtr Node) const {

  std::string s;
  s = getNodeContentString(Node);
  LOCALE_C_ON
    double d = atof(s.c_str());
  LOCALE_C_OFF;
  return d;

}

xmlAttrPtr XMLIO::getFirstAttribute(const xmlNodePtr Node)
{
  CurrAttr_ = Node->properties;
  while (CurrAttr_!=NULL) {
    if (CurrAttr_->type == XML_ATTRIBUTE_NODE) {
      return CurrAttr_;
    }
    CurrAttr_ = CurrAttr_->next;
  }
  return NULL;

}


xmlAttrPtr XMLIO::getNextAttribute() {

  while (CurrAttr_->next!=NULL) {
    CurrAttr_ = CurrAttr_->next;
    if (CurrAttr_->type == XML_ATTRIBUTE_NODE) {
      return CurrAttr_;
    }
  }
  return NULL;

}

xmlAttrPtr XMLIO::getAttributeByName(const xmlNodePtr Node,
                                     const std::string& attribute_name)
{
 
    //find first attribute for node
  xmlAttrPtr result = getFirstAttribute(Node);
  //while AttrPtr is valid search for requested name
  while (result != NULL){
    if (getAttributeName(result) == attribute_name) return result;
    //not found, go to next
    result = getNextAttribute();
  }
  //not found, returning NULL
  return NULL;
}

void XMLIO::
GetChildren(const xmlNodePtr ParentNode,
            std::vector<xmlNodePtr>& children)
{
  children.clear();
  xmlNodePtr child = getFirstChild(ParentNode);
  while (child != NULL){
    children.push_back(child);
    child = getNextChild();
  }
}

void XMLIO::
GetAttributes(const xmlNodePtr ParentNode,
              std::vector<xmlAttrPtr>& attributes)
{
  attributes.clear();
  xmlAttrPtr attr = getFirstAttribute(ParentNode);
  while (attr != NULL){
    attributes.push_back(attr);
    attr = getNextAttribute();
  }
}

std::string XMLIO::getAttributeName(const xmlAttrPtr Attribute) const {

  std::string ret="";
  if (Attribute->name!=NULL) {
    ret = (char*) Attribute->name;
  }
  return ret;
}


bool XMLIO::getAttributeValueBool(const xmlAttrPtr Attribute) const {

  std::string s;
  s = getAttributeValueString(Attribute);
  // transfrom to lower case letters for comparison
  s = FileHandling::LowerCase(s);
  if (s == "true") {
    return true;
  } else if (s == "false" || s.empty()) {
    return false;
  } else {
    BIASERR("Undefined boolean value \"" << s << "\" found! Using \"false\" instead!");
    return false;
  }
}

std::string XMLIO::getAttributeValueString(const xmlAttrPtr Attribute) const {

  std::string ret="";
  if (Attribute->children!=NULL) {
    if (Attribute->children->content!=NULL) {
      ret = (char*) Attribute->children->content;
    }
  }
  return ret;
}


int XMLIO::getAttributeValueInt(const xmlAttrPtr Attribute) const {

  std::string s;
  s = getAttributeValueString(Attribute);
  return atoi(s.c_str());
}


double XMLIO::getAttributeValueDouble(const xmlAttrPtr Attribute) const {

  std::string s;
  s = getAttributeValueString(Attribute);
  LOCALE_C_ON
    double d = atof(s.c_str());
  LOCALE_C_OFF
  return d;
}

std::vector<double> XMLIO::
getAttributeValueVecDbl(const xmlAttrPtr Attribute) const {

  stringstream s(getAttributeValueString(Attribute));
  std::vector<double> tempVec;
  LOCALE_C_ON
  double temp;
  while (s >> temp){
    tempVec.push_back(temp);
  }
  LOCALE_C_OFF
  return tempVec;
}

std::vector<int> XMLIO::
getAttributeValueVecInt(const xmlAttrPtr Attribute) const {

  stringstream s(getAttributeValueString(Attribute));
  std::vector<int> tempVec;
  int temp;
  while (s >> temp){
    tempVec.push_back(temp);
  }
  return tempVec;
}

std::string XMLIO::getAttributeValueString(const xmlNodePtr Node,
                                    const std::string& AttributeName) const{
  std::string ret="";
  char* pc;
  pc = (char*) xmlGetProp(Node, BAD_CAST AttributeName.c_str());
  if (pc!=NULL) {
    ret=pc;
    xmlFree(pc);
  }
  return ret;
}


bool XMLIO::getAttributeValueBool(const xmlNodePtr Node,
                                  const std::string& AttributeName) const {
  std::string temp="";
  char* pc;
  pc = (char*) xmlGetProp(Node, BAD_CAST AttributeName.c_str());
  if (pc!=NULL) {
    temp=pc;
    xmlFree(pc);
  }
  // transfrom to lower case letters for comparison
  temp = FileHandling::LowerCase(temp);
  if (temp == "true") {
    return true;
  } else if (temp == "false" || temp.empty()) {
    return false;
  } else {
    //BIASERR("Undefined boolean value \"" << temp << "\" found for attribute \""
    //        << AttributeName << "\"! Using \"false\" instead!");
    return false;
  }
}

int XMLIO::getAttributeValueInt(const xmlNodePtr Node,
                                const std::string& AttributeName) const {
  std::string ret="";
  char* pc;
  pc = (char*) xmlGetProp(Node, BAD_CAST AttributeName.c_str());
  if (pc!=NULL) {
    ret=pc;
    xmlFree(pc);
  }
  return atoi(ret.c_str());
}


double XMLIO::getAttributeValueDouble(const xmlNodePtr Node,
                                      const std::string& AttributeName) const {
  std::string ret="";
  char* pc;
  pc = (char*) xmlGetProp(Node, BAD_CAST AttributeName.c_str());
  if (pc!=NULL) {
    ret=pc;
    xmlFree(pc);
  }
  LOCALE_C_ON
  double retValue = atof(ret.c_str());
  LOCALE_C_OFF
  return retValue;
}

std::vector<double> XMLIO::
getAttributeValueVecDbl(const xmlNodePtr Node,
                        const std::string& AttributeName) const {
  stringstream s("");
  char* pc;
  std::vector<double> tempVec;
  double temp;
  pc = (char*) xmlGetProp(Node, BAD_CAST AttributeName.c_str());
  if (pc!=NULL) {
    s.str(pc);
    xmlFree(pc);
  }
  while (s >> temp){
    tempVec.push_back(temp);
  }
  return tempVec;
}

std::vector<int> XMLIO::
getAttributeValueVecInt(const xmlNodePtr Node,
                        const std::string& AttributeName) const {
  stringstream s("");
  char* pc;
  std::vector<int> tempVec;
  int temp;
  pc = (char*) xmlGetProp(Node, BAD_CAST AttributeName.c_str());
  if (pc!=NULL) {
    s.str(pc);
    xmlFree(pc);
  }
  while (s >> temp){
    tempVec.push_back(temp);
  }
  return tempVec;
}

int XMLIO::SetCompression(int level) {
  int ret = -1;
  if (isInitialized_) {
    // Cleanup function for the XML library.
    ret = xmlGetDocCompressMode(xmlDoc_);
    if (level>9) level = 9;
    if (level<0) level = 0;
    xmlSetDocCompressMode(xmlDoc_, level);
  } else {
    BIASERR("No document yet! Ignored compression level");
  }
  return ret;
}


int XMLIO::WriteToString(string &str)
{

  if (!isInitialized_) {
    BIASERR("Not initialized: Please call createXML/loadXML first\n");
    return -1;
  }

  xmlChar *xmlbuff;
  int buffersize;
  LOCALE_C_ON
  xmlDocDumpFormatMemory(xmlDoc_, &xmlbuff, &buffersize, 1);
  LOCALE_C_OFF
  str.replace(0, buffersize, (char *) xmlbuff);
  xmlFree(xmlbuff);
  return buffersize;
}


xmlNodePtr XMLIO::ReadFromString(const string &str)
{

  if (isInitialized_) {
    // do NOT use xmlCleanupParser() here when concurrent threads use XMLIO!
    // see: http://xmlsoft.org/html/libxml-parser.html#xmlCleanupParser
    //xmlCleanupParser();

    xmlFreeDoc(xmlDoc_);
    isInitialized_ = false;
  }
  LOCALE_C_ON
  xmlDoc_ = xmlReadMemory(str.c_str(), (int)str.length(), "noname.xml", NULL, 0);
  LOCALE_C_OFF
  if (xmlDoc_ == NULL) {
  BIASERR("Error parsing the xml document, was not well formed (ReadFromString)");
    return NULL;
  }

  RootNode_ = CurrNode_ =  xmlDocGetRootElement(xmlDoc_);
  isInitialized_=true;

  return RootNode_;

}


int XMLIO::IsoLatin1ToUtf8(const std::string& isoLatin1, std::string& utf8)
{
  utf8 = "";
  int res = 0;
  int inlen = (int)isoLatin1.length();
  int outlen = 2*inlen;
  unsigned char *outbuf = new unsigned char[outlen+1];
  res = isolat1ToUTF8(outbuf, &outlen, BAD_CAST isoLatin1.c_str(), &inlen);
  if (res >= 0) {
    for (int i = 0; i < outlen; i++) { utf8 += outbuf[i]; }
  res = 0;
  } else {
  res = -1;
  }
  delete[] outbuf;
  return res;
}


int XMLIO::Utf8ToIsoLatin1(const std::string& utf8, std::string& isoLatin1)
{
  isoLatin1 = "";
  int res = 0;
  int inlen = (int)utf8.length();
  int outlen = 2*inlen;
  unsigned char *outbuf = new unsigned char[outlen+1];
  res = UTF8Toisolat1(outbuf, &outlen, BAD_CAST utf8.c_str(), &inlen);
  if (res >= 0) {
    for (int i = 0; i < outlen; i++) { isoLatin1 += outbuf[i]; }
  res = 0;
  } else {
  res = -1;
  }
  delete[] outbuf;
  return res;
}