GLIMSView Source Code Documentation

xmlserializeable.cpp

Go to the documentation of this file.

#include "xmlserializeable.h"
#include <iostream>
#include <iomanip>

#include <qmessagebox.h>

bool XMLSerializeable::writeTextTag( QDomDocument &doc,
                                     QDomElement  &elem,
                                     std::string  tagName,
                                     std::string  text,
                                     std::string  id ) {
  QDomElement newElem = doc.createElement( tagName.c_str() );
  if ( id != "" )
    newElem.setAttribute( "id", (char*)id.c_str() );
  elem.appendChild( newElem );
  QDomText textNode = doc.createTextNode( text.c_str() );
  newElem.appendChild( textNode );
  return true;
}

std::string XMLSerializeable::readTextTag(
                                         QDomElement elem,
                                         std::string tagName,
                                         std::string id ) {
  std::string ret = "";
  if ( elem.isNull() )
    return "";

  QDomNode n = elem.firstChild();
  QDomElement tmp;
  bool isTag = true;
  while ( !n.isNull() ) {
    isTag = true;
    if ( !n.isElement() )
      isTag = false;

    tmp = n.toElement();
    if ( tagName != "" && tagName != (const char*)tmp.tagName() )
      isTag = false;

    if ( id != "" && id != (const char*)tmp.attribute( "id" ) )
      isTag = false;

    if ( isTag ) {
      ret = (const char*)tmp.text();
      break;
    }
    n = n.nextSibling();
  }
  return ret;
}

bool XMLSerializeable::fromXMLFile( std::string fname, std::string docname ) {
  QDomElement e;
  QDomNode node;
  QDomDocument doc;

  QFile f( fname.c_str() );
  if ( !f.open( IO_ReadOnly ) )
    return false;

  if ( !doc.setContent( &f ) ) {
    f.close();
    return false;
  }
  f.close();

  // skip past any fluff and find the root node - dls 5/20/04
  //node = doc.firstChild();
  node = doc.namedItem(docname.c_str());

  if ( !node.isElement() )
    return false;
  e = node.toElement();

  if ( docname != (const char*)e.tagName() )
    return false;

  node = node.firstChild();
  if ( !node.isElement() )
    return false;
  e = node.toElement();

  return fromXML( e );
}

bool XMLSerializeable::toXMLFile( std::string fname, std::string docname ) {
  QDomDocument doc( docname.c_str() );

  // insert XML tag at beginning of file - dls 5/20/04
  QDomNode xmlInstructionNode = doc.createProcessingInstruction ("xml", "version=\"1.0\" encoding=\"UTF-8\"") ;
  doc.insertBefore(xmlInstructionNode, doc.firstChild()) ;

  // create root node, complete with Schema declaration - dls 5/20/04
  QDomElement e = doc.createElement( docname.c_str() );
  e.setAttribute ( "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance") ;
  e.setAttribute ( "xsi:noNamespaceSchemaLocation", "http://astrogeology.usgs.gov/Projects/glimsview/Schema/GLIMSProject/GLIMSProject.xsd") ;
  e.setAttribute ( "version", qDateToString(&mCurrentVersion).c_str() ) ;
  doc.appendChild( e );
  if ( !toXML( doc, e ) )
    return false;

  std::ofstream f( fname.c_str() );
  if ( f ) {
    QString qstr = doc.toString();
    if ( qstr.isNull() )
      return false;

    f.write( (const char*)qstr, qstr.length() );
    f.flush();
  } else {
    return false;
  }
  f.close();
  return true;
}

QDomElement
XMLSerializeable::getElemByTagName( QDomElement &elem,
                                    std::string name ) {
  QDomElement ret;
  QDomNode node = elem;
  QDomElement e;

  while ( node.isElement() && !node.isNull() ) {
    e = node.toElement();
    if ( name == (const char*)e.tagName() )
      return e;
    node = node.nextSibling();
  }
  return ret;
}


std::string XMLSerializeable::qDateToString (const QDate * aQDate) {
  if ( aQDate->isNull() || !(aQDate->isValid()) ) return NULL ;

  // dump date components into a stringstream
  std::stringstream dateStream ;
  dateStream << std::setfill ('0') << std::right
  << std::setw(4) << aQDate->year()      << std::setw(1) << "-"
  << std::setw(2) << aQDate->month()     << std::setw(1) << "-"
  << std::setw(2) << aQDate->day()  ;

  // return the stringstream as a string
  return dateStream.str() ;
}

std::string XMLSerializeable::qDateTimeToString (const QDateTime * aQDateTime) {
  if ( aQDateTime->isNull() || !aQDateTime->isValid() ) return NULL ;

  QDate aQDate = aQDateTime->date() ;
  QTime aQTime = aQDateTime->time() ;

  // dump date components into a stringstream
  std::stringstream dateTimeStream ;
  dateTimeStream << qDateToString (&aQDate)
  << std::setfill ('0') << std::right
  << std::setw(1) << "T"
  << std::setw(2) << aQTime.hour()     << std::setw(1) << ":"
  << std::setw(2) << aQTime.minute()   << std::setw(1) << ":"
  << std::setw(2) << aQTime.second() ;

  // return the stringstream as a string
  return dateTimeStream.str() ;
}



bool XMLSerializeable::stringToQDate (const std::string aStrDate, QDate * aQDate) {

  std::string aStrDateCopy = aStrDate ;

  // check format to make certain it appears to be YYYY-MM-DD
  if ( aStrDateCopy.length() < 10 ) return false ;

  if ( aStrDateCopy[4] != '-' ||
       aStrDateCopy[7] != '-' ) {
    return false ;
  }

  for ( unsigned int i = 0 ; i < aStrDateCopy.length() ; i++ ) {
    if ( aStrDateCopy[i] < '0' || aStrDateCopy[i] > '9' ) {
      aStrDateCopy[i] = ' ' ;
    }
  }

  std::stringstream dateStream  ;
  dateStream << aStrDateCopy ;

  int year  = 0 ;
  int month = 0 ;
  int day   = 0 ;
  dateStream >> year >> month >> day ;

  if ( !aQDate ) {
    return false ;
  }
  aQDate->setYMD(year, month, day) ;

  return true ;

}

bool XMLSerializeable::stringToQDateTime (const std::string aStrDateTime, QDateTime * aQDateTime) {

  QDate aQDate = aQDateTime->date() ;
  QTime aQTime = aQDateTime->time() ;

  // make certain there's enough characters for YYYY-MM-DDTHH:MM:SS
  if ( aStrDateTime.length() < 19 ) return false ;

  if ( !stringToQDate (aStrDateTime, &aQDate) ) return false ;

  aQDateTime->setDate (aQDate) ;

  // check format to make certain it appears to be THH:MM:SS

  if ( aStrDateTime[10] != 'T' ||
       aStrDateTime[13] != ':' ||
       aStrDateTime[16] != ':' ) {
    return false ;
  }

  char * aStrDateTimeCopy = new char[aStrDateTime.length()] ;
  strcpy (aStrDateTimeCopy, aStrDateTime.c_str()) ;
  for ( unsigned int i = 0 ; i < aStrDateTime.length() ; i++ ) {
    if ( aStrDateTimeCopy[i] < '0' || aStrDateTimeCopy[i] > '9' ) {
      aStrDateTimeCopy[i] = ' ' ;
    }
  }

  std::stringstream timeStream  ;
  timeStream << aStrDateTimeCopy[11] ;
  int hour = 0 ;
  int minutes = 0 ;
  int seconds = 0 ;
  timeStream >> hour >> minutes >> seconds ;
  aQTime.setHMS (hour, minutes, seconds) ;
  aQDateTime->setTime (aQTime) ;

  delete aStrDateTimeCopy ;

  return true ;

}


void XMLSerializeable::setCurrentVersion (std::string versionString) {
  mCurrentVersion = *(new QDate(2100, 1, 1)) ;
  stringToQDate (versionString, &mCurrentVersion) ;
}

void XMLSerializeable::setCurrentVersion (QDate versionQDate) {
  mCurrentVersion = versionQDate ;
}

QDate XMLSerializeable::getCurrentVersion () {
  return mCurrentVersion ;
}

std::string XMLSerializeable::getCurrentVersionStr () {
  return qDateToString(&mCurrentVersion) ;
}

---

Home | Search | Disclaimers & Privacy | Contact Us GLIMSView Maintainer: dsoltesz@usgs.gov