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 as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 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/vpConfig.h>
#include <visp3/core/vpXmlParser.h>

#ifdef VISP_HAVE_XML2

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

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

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

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

vpXmlParser::vpXmlParser(const vpXmlParser &_twin) : nodeMap(_twin.nodeMap), main_tag(_twin.main_tag) {}

/* 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