XmlDocument.cpp

Go to the documentation of this file.

/*
Copyright 2007, 2008, 2009, 2010, 2011 Instituto de Sistemas e Robotica, Instituto Superior Tecnico

This file is part of MeRMaID.

MeRMaID 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 3 of the License, or
(at your option) any later version.

MeRMaID 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 MeRMaID.  If not, see <http://www.gnu.org/licenses/>.
*/



/**
 * @Filename XmlDocument.cpp
 * @Description Implementation of the XmlDocument class
 * @Status Finished
 * @Version $Id: XmlDocument.cpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer Nelson Ramos (nmsra@mega.ist.utl.pt)
 */

#include "config.h"

#include "XmlDocument.hpp"

#include <Exception.hpp>
#include <FilePathSearch.hpp>

#include "XmlElement.hpp"
#include "XmlEntityLoader.hpp"

using namespace mermaid::support::xml;
using mermaid::support::errorhandling::Exception;
using mermaid::support::system::FilePathSearch;



XmlDocument::XmlDocument()
{
  isWellFormed_ = false;
  isValid_ = false;
  rootElement_ = shared_ptr<XmlElement>();
}



XmlDocument::XmlDocument (const XmlDocument& xd)
{
  copyFrom (xd);
}



XmlDocument * XmlDocument::clone()
{
  return new XmlDocument (*this);
}



XmlDocument::~XmlDocument()
{
  cleanUp();
}



XmlDocument& XmlDocument::operator= (const XmlDocument & xd)
{
  // make sure not same object
  if (this != &xd) {
    cleanUp();
    copyFrom (xd);
  }
  return *this;
}



void XmlDocument::parseFile (string name, bool enforceDtdValidation)
{
  // cleanup before parsing, to avoid bugs with 2 successive parses
  cleanUp();
  
  xmlNodePtr rootElementNode;
  
  // get the file's full path
  string fileFullPath = FilePathSearch::getFullPathForFile (name);
  
  xmlSetExternalEntityLoader (&XmlEntityLoader::loaderFunction);
  xmlParserCtxtPtr parserCtxtPtr = xmlNewParserCtxt();
  xmlDocPtr docPtr;
  if (enforceDtdValidation == true) {
    docPtr = xmlCtxtReadFile (parserCtxtPtr,
                              fileFullPath.data(),
                              NULL,
                              XML_PARSE_DTDVALID
                              | XML_PARSE_NOERROR
                              | XML_PARSE_NOWARNING);
  }
  else {
    docPtr = xmlCtxtReadFile (parserCtxtPtr,
                              name.data(),
                              NULL,
                              XML_PARSE_NOERROR
                              | XML_PARSE_NOWARNING);
  }
  
  
  if ( (parserCtxtPtr->wellFormed == 0) || (docPtr == NULL)) {
    throw Exception ("XmlDocument::parseFile : impossible to read file or "
                     "document is not well formed : file=" + name);
  }
  
  rootElementNode = xmlDocGetRootElement (docPtr);
  
  if (rootElementNode == NULL) {
    xmlFreeDoc (docPtr);
    throw Exception ("XmlDocument::parseFile : could not retrieve "
                     "root element");
  }
  
  xmlNodePtr rootNodePtr = rootElementNode; // libxml2
  
  // non-libxml2 data
  isWellFormed_ = (parserCtxtPtr->wellFormed != 0);
  isValid_ = (parserCtxtPtr->valid != 0);;
  
  if ( (enforceDtdValidation == true) && (isValid_ == false)) {
    // throw Exception("XmlDocument::parseFile : validation of XML file failed : file=" + name);
  }
  
  rootElement_ = shared_ptr<XmlElement> (new XmlElement (rootNodePtr));
  
  if (parserCtxtPtr != NULL) {
    xmlFreeParserCtxt (parserCtxtPtr);
  }
  
  if (docPtr != NULL) {
    xmlFreeDoc (docPtr);
  }
}



void XmlDocument::parseString (string xml)
{
  // cleanup before parsing, to avoid bugs with 2 successive parses
  cleanUp();
  
  xmlNodePtr rootElementNode;
  
  xmlParserCtxtPtr parserCtxtPtr = xmlNewParserCtxt();
  xmlDocPtr docPtr = xmlCtxtReadMemory (parserCtxtPtr,
                                        xml.data(),
                                        xml.size(),
                                        NULL,
                                        NULL,
                                        0);
                                        
  if ( (parserCtxtPtr->wellFormed == 0) || (docPtr == NULL)) {
    throw Exception ("XmlDocument::parseString : could not read string or XML "
                     "is not well formed");
  }
  
  rootElementNode = xmlDocGetRootElement (docPtr);
  
  if (rootElementNode == NULL) {
    xmlFreeDoc (docPtr);
    throw Exception ("XmlDocument::parseString : could not retrieve root element");
  }
  
  xmlNodePtr rootNodePtr = rootElementNode; // libxml2
  
  // non-libxml2 data
  isWellFormed_ = (parserCtxtPtr->wellFormed != 0);
  isValid_ = (parserCtxtPtr->valid != 0);;
  rootElement_ = shared_ptr<XmlElement> (new XmlElement (rootNodePtr));
  
  if (parserCtxtPtr != NULL) {
    xmlFreeParserCtxt (parserCtxtPtr);
  }
  
  if (docPtr != NULL) {
    xmlFreeDoc (docPtr);
  }
}



shared_ptr<XmlElement> XmlDocument::getRootElement()
{
  if (this->isWellFormed()) {
    return rootElement_;
  }
  else {
    throw Exception ("XmlDocument::getRootElement() : no root "
                     "element available");
  }
}



bool XmlDocument::isWellFormed()
{
  return isWellFormed_;
}



bool XmlDocument::isValid()
{
  return isValid_;
}



void XmlDocument::copyFrom (const XmlDocument& xd)
{
  isWellFormed_ = xd.isWellFormed_;
  isValid_ = xd.isValid_;
  rootElement_ = xd.rootElement_;
}



void XmlDocument::cleanUp()
{
  rootElement_ = shared_ptr<XmlElement>();
}