XmlElement.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 XmlElement.cpp
 * @Description Implementation of the XmlElement class
 * @Status Implementing
 * @Version $Id: XmlElement.cpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer Nelson Ramos (nmsra@mega.ist.utl.pt)
 */

#include "config.h"

#include "XmlElement.hpp"

#include <string>
#include <sstream>

#include <libxml/xmlmemory.h>
#include <libxml/parser.h>

#include <Exception.hpp>

#include "XmlItem.hpp"

using namespace mermaid::support::xml;
using std::string;
using std::stringstream;
using mermaid::support::errorhandling::Exception;



XmlElement::XmlElement()
{
  name_ = string ("UNNAMED");
  charData_ = XmlCharDataVector();
  childrenElements_ = XmlElementVector();
  attributes_ = XmlAttributeVector();
  items_ = XmlItemVector();
}



XmlElement::XmlElement (const XmlElement& e)
{
  copyFrom (e);
}



XmlElement::XmlElement (string xml)
{
  xmlNodePtr rootElementNode;
  
  xmlParserCtxtPtr parserCtxtPtr = xmlNewParserCtxt();
  xmlDocPtr docPtr = xmlCtxtReadMemory (parserCtxtPtr,
                                        xml.data(),
                                        xml.size(),
                                        NULL,
                                        NULL,
                                        0);
                                        
  if ( (parserCtxtPtr->wellFormed == 0) || (docPtr == NULL)) {
    XmlElement();
    throw Exception ("XmlElement::XmlElement(string xml) : unable to "
                     "build from string: \"" + xml + "\"");
  }
  
  rootElementNode = xmlDocGetRootElement (docPtr);
  
  if (rootElementNode == NULL) {
    xmlFreeDoc (docPtr);
    XmlElement();
    throw Exception ("XmlElement::XmlElement(string xml) : unable to "
                     "build from string: \"" + xml + "\"");
  }
  this->buildFromLibxml2Node (rootElementNode);
  
  if (parserCtxtPtr != NULL) {
    xmlFreeParserCtxt (parserCtxtPtr);
  }
  
  if (docPtr != NULL) {
    xmlFreeDoc (docPtr);
  }
}



XmlElement::XmlElement (xmlNodePtr node)
{
  this->buildFromLibxml2Node (node);
}



void XmlElement::buildFromLibxml2Node (xmlNodePtr node)
{
  // read name
  name_ = string ( (char*) node->name);
  
  // get all children items
  xmlNodePtr child = node->children;
  while (child != NULL) {
    if (child->type == XML_ELEMENT_NODE) {
      shared_ptr<XmlElement> e =
        shared_ptr<XmlElement> (new XmlElement (child));
      if (e == false) {
        throw Exception ("XmlElement::buildFromLibxml2Node : unable to "
                         "create XmlElement");
      }
      childrenElements_.push_back (e);
      items_.push_back (static_cast<XmlItem*> (e.get()));
      //! @todo remove dereferencing of shared_ptr
    }
    else if ( (child->type == XML_TEXT_NODE)
              || (child->type == XML_CDATA_SECTION_NODE)) {
      shared_ptr<XmlCharData> c =
        shared_ptr<XmlCharData> (new XmlCharData ( (char*) child->content));
      if (c == false) {
        throw Exception ("XmlElement::buildFromLibxml2Node : unable to "
                         "create XmlCharData");
      }
      charData_.push_back (c);
      items_.push_back (static_cast<XmlItem*> (c.get()));
      //! @todo remove dereferencing of shared_ptr
    }
    child = child->next;
  }
  
  // get all attributes
  xmlAttrPtr attr = node->properties;
  while ( (attr != NULL)) {
    if (attr->type == XML_ATTRIBUTE_NODE) {
      attributes_.push_back (
        shared_ptr<XmlAttribute> (new XmlAttribute (attr)));
    }
    attr = attr->next;
  }
}



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



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



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



const string XmlElement::getName() const
{
  return name_;
}



XmlCharDataVector XmlElement::getCharData()
{
  return charData_;
}



shared_ptr<XmlCharData> XmlElement::getFirstNonBlankCharData()
{
  XmlCharDataVector vector = this->getCharData();
  
  for (XmlCharDataVector::iterator it = vector.begin();
       it != vector.end();
       it++) {
    shared_ptr<XmlCharData> xc = *it;
    
    if (!xc->isBlank()) {
      return xc;
    }
  }
  
  return shared_ptr<XmlCharData>();
}



XmlElementVector XmlElement::getChildrenElements()
{
  return childrenElements_;
}



const XmlAttributeVector XmlElement::getAttributes() const
{
  return attributes_;
}



XmlElement::operator string() const
{
  stringstream ss;
  ss << "<";
  ss << this->getName();
  
  XmlAttributeVector attributes = this->getAttributes();
  
  if (attributes.size() > 0) {
    ss << " ";
    XmlAttributeVector::iterator it;
    
    for (it = attributes.begin(); it != attributes.end(); it++) {
      shared_ptr<XmlAttribute> a = *it;
      ss << a->getName();
      ss << "=\"";
      ss << a->getValue();
      ss << "\" ";
    }
  }
  
  ss << ">";
  
  XmlItemVector::const_iterator it;
  
  for (it = items_.begin(); it != items_.end(); it++) {
    XmlItem * i = *it;
    ss << ( (string) *i);
  }
  
  ss << "</";
  ss << this->getName();
  ss << ">";
  
  return ss.str();
}



const bool XmlElement::isXmlElement() const
{
  return true;
}



void XmlElement::copyFrom (const XmlElement& e)
{
  name_ = e.name_;
  
  // copy XmlItems
  for (XmlItemVector::const_iterator iit = e.items_.begin();
       iit != e.items_.end();
       iit++) {
    XmlItem * i = *iit;
    if (i->isXmlElement()) {
      XmlElement * xe = (XmlElement*) i;
      XmlElement * ne = new XmlElement (*xe);
      this->childrenElements_.push_back (shared_ptr<XmlElement> (ne));
      this->items_.push_back ( (XmlItem*) ne);
    }
    else if (i->isXmlCharData()) {
      XmlCharData * xc = (XmlCharData*) i;
      XmlCharData * nc = new XmlCharData (*xc);
      this->charData_.push_back (shared_ptr<XmlCharData> (nc));
      this->items_.push_back ( (XmlItem*) nc);
    }
    else {
      throw Exception ("XmlElement::copyFrom : got unidentifiable item");
    }
  }
  
  // copy attributes
  XmlAttributeVector::const_iterator ait;
  for (ait = e.attributes_.begin(); ait != e.attributes_.end(); ait++) {
    shared_ptr<XmlAttribute> a = *ait;
    XmlAttribute * na = new XmlAttribute (*a);
    attributes_.push_back (shared_ptr<XmlAttribute> (na));
  }
}



void XmlElement::cleanUp()
{
  name_ = string ("UNNAMED");
  charData_ = XmlCharDataVector();
  childrenElements_ = XmlElementVector();
  attributes_ = XmlAttributeVector();
  items_ = XmlItemVector();
}