vpXmlParser.cpp

/*
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2024 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 https://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 automatize the creation of xml parser based on the libXML2.
 */
 
#include <visp3/core/vpConfig.h>
 
#ifdef VISP_HAVE_XML2
 
#include <libxml/parser.h>
 
#include <visp3/core/vpXmlParser.h>
#include <visp3/core/vpDebug.h>
#include <visp3/core/vpException.h>
 
#include <iomanip>
#include <sstream>
#include <string>
#include <typeinfo>
 
BEGIN_VISP_NAMESPACE
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 == nullptr) {
    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 == nullptr) {
    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 == nullptr) {
    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 = static_cast<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 == nullptr) {
    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 = static_cast<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 == nullptr) {
    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 == nullptr) {
    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 = static_cast<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 == nullptr) {
    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, nullptr, (xmlChar *)label, (xmlChar *)value);
  xmlAddChild(node, tmp);
}

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

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

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

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

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

void vpXmlParser::xmlWriteBoolChild(xmlNodePtr node, const char *label, bool value)
{
  char str[2];
  snprintf(str, 2, "%d", static_cast<int>(value));
  xmlNodePtr tmp;
  tmp = xmlNewChild(node, nullptr, (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 == nullptr) {
    vpERROR_TRACE("cannot open file");
    throw vpException(vpException::ioError, "cannot open file");
  }
 
  root_node = xmlDocGetRootElement(doc);
  if (root_node == nullptr) {
    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, bool append)
{
  xmlDocPtr doc;
  xmlNodePtr root_node;
 
  doc = xmlReadFile(filename.c_str(), nullptr, XML_PARSE_NOWARNING + XML_PARSE_NOERROR + XML_PARSE_NOBLANKS);
  if (doc == nullptr) {
    doc = xmlNewDoc((xmlChar *)"1.0");
    root_node = xmlNewNode(nullptr, (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(nullptr, (xmlChar *)main_tag.c_str());
      xmlDocSetRootElement(doc, root_node);
    }
  }
 
  root_node = xmlDocGetRootElement(doc);
  if (root_node == nullptr) {
    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);
}
 
void vpXmlParser::cleanup()
{
  xmlCleanupParser();
}
 
END_VISP_NAMESPACE
#elif !defined(VISP_BUILD_SHARED_LIBS)
// Work around to avoid warning: libvisp_core.a(vpXmlParser.cpp.o) has no symbols
void dummy_vpXmlParser() { }
#endif