vpXmlParser.cpp

/****************************************************************************
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2017 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See http://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Tool to automatise the creation of xml parser based on the libXML2
 *
 * Authors:
 * Romain Tallonneau
 *
 *****************************************************************************/
 
#include <visp3/core/vpXmlParser.h>
#include <visp3/core/vpConfig.h>

#ifdef VISP_HAVE_XML2

#include <visp3/core/vpException.h>
#include <visp3/core/vpDebug.h>
#include <libxml/parser.h>

#include <string>
#include <sstream>
#include <iomanip>
#include <typeinfo>

vpXmlParser::vpXmlParser() : nodeMap(), main_tag("config")
{
}

vpXmlParser::~vpXmlParser()
{
  //xmlCleanupParser();
}

vpXmlParser::vpXmlParser(const vpXmlParser& _twin)
 : nodeMap(), main_tag("config")
{
  main_tag = _twin.main_tag;
  nodeMap = _twin.nodeMap;
}

/* utilities functions to read/write data from an xml document */

char* 
vpXmlParser::xmlReadCharChild (xmlDocPtr doc, xmlNodePtr node)
{
  if(node ->xmlChildrenNode == NULL){
    std::string errorMsg = "Empty node " + std::string((char*)node->name) + ", cannot read char*";
    std::cerr << errorMsg << std::endl;
    throw vpException(vpException::fatalError, errorMsg);
  }
  return (char *) xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
}

std::string
vpXmlParser::xmlReadStringChild (xmlDocPtr doc, xmlNodePtr node)
{
  if(node ->xmlChildrenNode == NULL){
    std::string errorMsg = "Empty node " + std::string((char*)node->name) + ", cannot read std::string";
    std::cerr << errorMsg << std::endl;
    throw vpException(vpException::fatalError, errorMsg);
  }
  char* dataCh = (char*)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
  std::string dataStr = dataCh;
  xmlFree(dataCh);
  return dataStr;
}

int 
vpXmlParser::xmlReadIntChild (xmlDocPtr doc, xmlNodePtr node)
{
  if(node ->xmlChildrenNode == NULL){
    std::string errorMsg = "Empty node " + std::string((char*)node->name) + ", cannot read int";
    std::cerr << errorMsg << std::endl;
    throw vpException(vpException::fatalError, errorMsg);
  }
  char * val_char;
  char * control_convert;
  int val_int;

  val_char = (char *) xmlNodeListGetString(doc, node ->xmlChildrenNode, 1);
  val_int = (int)strtol ((char *)val_char, &control_convert, 10);

  if (val_char == control_convert){
    xmlFree((xmlChar*) val_char);
    throw vpException(vpException::ioError, "cannot parse entry to int");
  }
  xmlFree((xmlChar*) val_char);

  return val_int;
}

unsigned int 
vpXmlParser::xmlReadUnsignedIntChild (xmlDocPtr doc, xmlNodePtr node)
{
  if(node ->xmlChildrenNode == NULL){
    std::string errorMsg = "Empty node " + std::string((char*)node->name) + ", cannot read unsigned int";
    std::cerr << errorMsg << std::endl;
    throw vpException(vpException::fatalError, errorMsg);
  }
  char * val_char;
  char * control_convert;
  unsigned int val_uint;

  val_char = (char *) xmlNodeListGetString(doc, node ->xmlChildrenNode, 1);
  val_uint = (unsigned int)strtoul ((char *)val_char, &control_convert, 10);

  if (val_char == control_convert){
    xmlFree((xmlChar*) val_char);
    throw vpException(vpException::ioError, "cannot parse entry to int");
  }
  xmlFree((xmlChar*) val_char);

  return val_uint;
}

double 
vpXmlParser::xmlReadDoubleChild (xmlDocPtr doc, xmlNodePtr node)
{
  if(node ->xmlChildrenNode == NULL){
    std::string errorMsg = "Empty node " + std::string((char*)node->name) + ", cannot read double";
    std::cerr << errorMsg << std::endl;
    throw vpException(vpException::fatalError, errorMsg);
  }
  char * val_char;
  char * control_convert;
  double val_double;

  val_char = (char *) xmlNodeListGetString(doc, node ->xmlChildrenNode, 1);
  val_double = strtod ((char *)val_char, &control_convert);

  if (val_char == control_convert){
    xmlFree((xmlChar*) val_char);
    throw vpException(vpException::ioError, "cannot parse entry to double");
  }
  xmlFree((xmlChar*) val_char);
  return val_double;
}

float
vpXmlParser::xmlReadFloatChild (xmlDocPtr doc, xmlNodePtr node)
{
  if(node ->xmlChildrenNode == NULL){
    std::string errorMsg = "Empty node " + std::string((char*)node->name) + ", cannot read float";
    std::cerr << errorMsg << std::endl;
    throw vpException(vpException::fatalError, errorMsg);
  }
  char * val_char;
  char * control_convert;
  float val_float;

  val_char = (char *) xmlNodeListGetString(doc, node ->xmlChildrenNode, 1);
#if defined(VISP_HAVE_FUNC_STRTOF)
  val_float = strtof ((char *)val_char, &control_convert);
#else
  val_float = (float) strtod ((char *)val_char, &control_convert);
#endif

  if (val_char == control_convert){
    xmlFree((xmlChar*) val_char);
    throw vpException(vpException::ioError, "cannot parse entry to float");
  }
  xmlFree((xmlChar*) val_char);
  return val_float;
}

bool
vpXmlParser::xmlReadBoolChild (xmlDocPtr doc, xmlNodePtr node)
{
  if(node ->xmlChildrenNode == NULL){
    std::string errorMsg = "Empty node " + std::string((char*)node->name) + ", cannot read bool";
    std::cerr << errorMsg << std::endl;
    throw vpException(vpException::fatalError, errorMsg);
  }
  char * val_char;
  bool val_bool;

  val_char = (char *) xmlNodeListGetString(doc, node ->xmlChildrenNode, 1);
  val_bool = val_char[0] != '0'; //reading only 1st character : bool xml storage is '0' or '1'

  xmlFree((xmlChar*) val_char);
  return val_bool;
}

void 
vpXmlParser::xmlWriteCharChild(xmlNodePtr node, const char* label, const char* value)
{
  xmlNodePtr tmp;
  tmp = xmlNewChild(node, NULL, (xmlChar*)label, (xmlChar*)value);
  xmlAddChild(node, tmp);  
}

void
vpXmlParser::xmlWriteStringChild(xmlNodePtr node, const char* label, const std::string& value)
{
  xmlNodePtr tmp;
  tmp = xmlNewChild(node, NULL, (xmlChar*)label, (xmlChar*)value.c_str());
  xmlAddChild(node, tmp);
}


void 
vpXmlParser::xmlWriteIntChild(xmlNodePtr node, const char* label, const int value)
{
  char str[100];
  sprintf(str, "%d", value);
  xmlNodePtr tmp;
  tmp = xmlNewChild(node, NULL, (xmlChar*)label, (xmlChar*)str);
  xmlAddChild(node, tmp); 
}

void 
vpXmlParser::xmlWriteUnsignedIntChild(xmlNodePtr node, const char* label, const unsigned int value)
{
  char str[100];
  sprintf(str, "%u", value);
  xmlNodePtr tmp;
  tmp = xmlNewChild(node, NULL, (xmlChar*)label, (xmlChar*)str);
  xmlAddChild(node, tmp); 
}


void 
vpXmlParser::xmlWriteDoubleChild(xmlNodePtr node, const char* label, const double value)
{
  char str[100];
  sprintf(str, "%lf", value);
  xmlNodePtr tmp;
  tmp = xmlNewChild(node, NULL, (xmlChar*)label, (xmlChar*)str);
  xmlAddChild(node, tmp); 
}

void
vpXmlParser::xmlWriteFloatChild(xmlNodePtr node, const char* label, const float value)
{
  char str[100];
  sprintf(str, "%f", value);
  xmlNodePtr tmp;
  tmp = xmlNewChild(node, NULL, (xmlChar*)label, (xmlChar*)str);
  xmlAddChild(node, tmp);
}

void
vpXmlParser::xmlWriteBoolChild(xmlNodePtr node, const char* label, const bool value)
{
  char str[2];
  sprintf(str, "%d", (int)value);
  xmlNodePtr tmp;
  tmp = xmlNewChild(node, NULL, (xmlChar*)label, (xmlChar*)str);
  xmlAddChild(node, tmp);
}

/* -------------------------------------------------------------------------- */
/*                                MAIN METHODS                                */
/* -------------------------------------------------------------------------- */

void 
vpXmlParser::parse(const std::string& filename)
{
  xmlDocPtr doc;
  xmlNodePtr root_node;

  doc = xmlParseFile(filename.c_str());
  if(doc == NULL){
    vpERROR_TRACE("cannot open file");
    throw vpException(vpException::ioError, "cannot open file");
  }

  root_node = xmlDocGetRootElement(doc);
  if(root_node == NULL){
    vpERROR_TRACE("cannot get root element");
    throw vpException(vpException::ioError, "cannot get root element");
  }

  readMainClass(doc, root_node);

  xmlFreeDoc(doc);
}

void 
vpXmlParser::save(const std::string& filename, const bool append)
{
  xmlDocPtr doc;
  xmlNodePtr root_node;

  doc = xmlReadFile(filename.c_str(), NULL, XML_PARSE_NOWARNING + XML_PARSE_NOERROR + XML_PARSE_NOBLANKS);
  if (doc == NULL){
    doc = xmlNewDoc ((xmlChar*)"1.0");
    root_node = xmlNewNode(NULL, (xmlChar*)main_tag.c_str());
    xmlDocSetRootElement(doc, root_node);
  }
  else{
    if(!append){
      xmlFreeDoc(doc);
      if (remove(filename.c_str()) != 0)
        throw vpException(vpException::ioError, "Cannot remove existing xml file");

        doc = xmlNewDoc ((xmlChar*)"1.0");
        root_node = xmlNewNode(NULL, (xmlChar*)main_tag.c_str());
        xmlDocSetRootElement(doc, root_node);
    }
  }

  root_node = xmlDocGetRootElement(doc);
  if (root_node == NULL)
  {
    vpERROR_TRACE("problem to get the root node");
    throw vpException(vpException::ioError, "problem to get the root node");
  }

    writeMainClass(root_node);

  xmlSaveFormatFile(filename.c_str(), doc, 1);
  xmlFreeDoc(doc);
}

#elif !defined(VISP_BUILD_SHARED_LIBS)
// Work arround to avoid warning: libvisp_core.a(vpXmlParser.cpp.o) has no symbols
void dummy_vpXmlParser() {};
#endif