QtXmlElement.cxx

Go to the documentation of this file.

#include "QtXmlElement.h"

#include <qstring.h>

#ifdef SSTREAM_DEFECT
#include <strstream>
using std::ostrstream;
#else
#include <sstream>
using std::ostringstream;
#endif

#include <cassert>

using std::list;
using std::string;

QtXmlElement::QtXmlElement ( const QtXmlElement & element )
  : QtXmlNode ( element )
{
#if QT_VERSION < 0x040000
  QDomElement * elem = dynamic_cast < QDomElement * > ( element.m_node );
  assert ( elem != 0 );
#else
  QDomElement * elem = reinterpret_cast < QDomElement * > ( element.m_node );
#endif

  // make copy of pointer so we don't have to cast in the implementation.
  m_element = new QDomElement ( *elem );
  m_node = m_element;
}

QtXmlElement::QtXmlElement ( const QDomElement & element )
  : QtXmlNode ( )
{
  // make copy of pointer so we don't have to cast in the implementation.
  m_element = new QDomElement ( element );
  m_node = m_element;
}

QtXmlElement::
~QtXmlElement()
{
  delete m_element;
}

string 
QtXmlElement::tagName () const
{
  QString tagname = m_element -> tagName ();

  return string ( tagname.latin1() );
}

int QtXmlElement::getID () const
{
  QString value = m_element -> attribute ( "id" );
  if ( value == QString::null ) return 0;

  bool ok;
  int id = value.toInt ( &ok );
  if ( ok == false ) id = 0;

  return id;
}

#ifdef CLONE_DEFECT
XmlElement *
#else
QtXmlElement *
#endif 
QtXmlElement::
getNode ( const std::string & tagName ) const
{

  QString tagname ( tagName.c_str () );
  QDomNode node = m_element -> namedItem ( tagname );
  if ( node.isNull () ) return 0;

  QDomElement element = node.toElement ();
  assert ( element.isNull () == false );
  return new QtXmlElement ( element );
}

void
QtXmlElement::
fillNodeList ( const std::string & tagName, 
               std::list < XmlElement * > & nodeList ) const
{
  QString tag_name ( tagName.c_str () );
  QDomNodeList nodelist = m_element -> elementsByTagName ( tag_name );
  unsigned int size ( nodelist.count () );
  for ( unsigned int i = 0; i < size; i++ ) {
    QDomNode node = nodelist.item ( i );
    QDomElement element = node.toElement ();
    nodeList.push_back ( new QtXmlElement ( element ) );
  }

}

void
QtXmlElement::
setAttribute ( const std::string & name, int value )
{
  assert ( ! name.empty () );
  m_element -> setAttribute ( name.c_str(), value );
}


void
QtXmlElement::
setAttribute ( const std::string & name, bool yes )
{
  assert ( ! name.empty () );

  unsigned int value = yes ? 1 : 0;
  m_element -> setAttribute ( name.c_str(), value );
}

void
QtXmlElement::
setAttribute ( const std::string & name, unsigned int value )
{
  assert ( ! name.empty () );
  m_element -> setAttribute ( name.c_str(), value );
}

void
QtXmlElement::
setAttribute ( const std::string & name, float value )
{
  assert ( ! name.empty () );
  double v = value; // Qt only supports double converstion to string

  setAttribute ( name, v );
}

void
QtXmlElement::
setAttribute ( const std::string & name, double value )
{
  assert ( ! name.empty () );
  // The following lead to a double 36. to be converted to "35.:" for
  // a ViewBase X coordinate.
   m_element -> setAttribute ( name.c_str(), value );
//#ifdef SSTREAM_DEFECT
//  ostrstream strm_text;
//#else
//  std::ostringstream strm_text;
//#endif
//  strm_text << value << std::ends;
//  m_element -> setAttribute ( name.c_str(), strm_text.str() );
}

void
QtXmlElement::
setAttribute ( const std::string & name,
               const std::string & value )
{
  assert ( ! name.empty () );
  m_element -> setAttribute ( name.c_str(), value.c_str() );
}

bool
QtXmlElement::
attribute ( const std::string & name, int & value ) const
{
  QString rstring = m_element -> attribute ( name.c_str() );
  if (  rstring == QString::null ) return false;

  bool ok;
  int val = rstring.toInt ( & ok );
  if ( ! ok ) return false;

  value = val;

  return true;
}

bool
QtXmlElement::
attribute ( const std::string & name, bool & value ) const
{
  QString rstring = m_element -> attribute ( name.c_str() );
  if (  rstring == QString::null ) return false;

  bool ok;
  int val = rstring.toInt ( & ok );
  if ( ! ok ) return false;

  value = ( val = 1 ) ? true : false;

  return true;
}

bool
QtXmlElement::
attribute ( const std::string & name, unsigned int & value ) const
{
  QString rstring = m_element -> attribute ( name.c_str() );
  if (  rstring == QString::null ) return false;

  bool ok;
  int val = rstring.toUInt ( & ok );
  if ( ! ok ) return false;

  value = val;

  return true;
}

bool
QtXmlElement::
attribute ( const std::string & name, float & value ) const
{
  QString rstring = m_element -> attribute ( name.c_str() );
  if (  rstring == QString::null ) return false;

  bool ok;
  float val = rstring.toFloat ( & ok );
  if ( ! ok ) return false;

  value = val;

  return true;
}

bool
QtXmlElement::
attribute ( const std::string & name, double & value ) const
{
  QString rstring = m_element -> attribute ( name.c_str() );
  if (  rstring == QString::null ) return false;

  bool ok;
  float val = rstring.toDouble ( & ok );
  if ( ! ok ) return false;

  value = val;

  return true;
}

bool
QtXmlElement::
attribute ( const std::string & name, std::string & value ) const
{
  QString val = m_element -> attribute ( name.c_str() );
  if ( val == QString::null ) return false;

  value = val.latin1 ();

  return true;
}

const string &
QtXmlElement::
getText () const
{
  static string text; // don't initialize it.
  QString t = m_element -> text ();
  text = t.latin1 ();

  return text;
}

---