xmltraversal.h

// -*- C++ -*-
#ifndef XMLTRAVERSAL
#define XMLTRAVERSAL

#include <QHostAddress>
#include "trace.hpp"
#include "base.hpp"

class UTILITYSHARED_EXPORT XMLTraversal {
        QStack<QDomNode> savePoints;
public:
  
  class UTILITYSHARED_EXPORT  iterator {
  public:
    iterator() ; // end iterator
    iterator(const QDomNode&) ; // begin iterator
    iterator(const iterator&) ;
    iterator operator ++() ;
    iterator operator ++(int) ;
    bool operator==(const iterator&) const ;
    bool operator!=(const iterator&) const ;
    QDomElement operator*() const ;
    QDomElement operator->() const ;
  private:
    iterator(const QDomNode&, const QDomNode&) ;
    QDomNode elt_ ;
    QDomNode cur_ ;
  } ;

  XMLTraversal() ;
  XMLTraversal(QString ) ;
  XMLTraversal(QDomDocument) ;
  XMLTraversal(QByteArray );
  XMLTraversal(XMLTraversal &x) { setDocument(x.document());}
  // =============================================
  //   Various accessors
  // =============================================

  bool isValid() const ;

  bool exists(const QString& path) const ;

  QString pwd() const ;

  QDomNode currentNode(const QString& path=QString()) const ;
  QDomElement currentElement()
  {
        if(cur_path_node_.isElement()) return cur_path_node_.toElement();
        return QDomElement();
  }

  QString attribute(const QString& name) const ;

  bool hasAttribute(const QString& attrname) const ;

  const QDomDocument& document() const;

  QString dump() const ;

  QStringList ls() const ;

  iterator begin() ;
  
  iterator end() ;

  unsigned int size() const ;

  // =============================================
  //   Various modifiers
  // =============================================

  virtual bool setDocument(QString doc) ;
  virtual bool setDocument(QByteArray doc) ;

 virtual  bool setDocument(QDomDocument doc) ;

  bool cd(const QString& path = QString()) ;
  bool cd(const QDomElement&) ;
  // get ot the root directory without having to know what it is
  bool cdToRoot() { return cd(QString("/%1").arg(document().documentElement().tagName()));}
  QDomElement mkdir(const QString& path) ;

  bool rmdir(const QString& path) ;

  bool mv(const QString& oldpath, const QString& newpath) ;

  bool cp(const QString& source, const QString& target) ;

  bool setAttribute(const QString& path,
                    const QString& attrname,
            const QString& attrvalue) ;

  bool setAttribute(const QString& attrname, const QString& attrvalue) ;
  void push() { savePoints.push(cur_path_node_); } // push current working directory
  void pop() { if(savePoints.count() > 0) cur_path_node_ = savePoints.pop();} // pop the CD
  void clearStack() { savePoints.clear(); }
  void setText(QString s); // set text on current element
  QString text(QString path) // get the text for a node - restore current after fetch
  {
   QString res("");
    push();
    if(cd(path)) res = currentElement().text();
    pop();
   return res;
  }
  QDomElement mkdirAndCd(QString s) // create and change
  {
    QDomElement e = mkdir(s);
    cd(s);
    return e;
  };

  QDomElement mkdirSetText(QString s, QString text) // create and change
  {
    QDomElement e = mkdir(s);
    cd(e);
    setText(text);
    return e;
  };

 bool loadFromFile(QString s)
 {
     QFile f(s);
     if(f.open(QIODevice::ReadOnly))
     {
        doc_.clear();
        markUpdated();
        return doc_.setContent(&f);
     };
     return false;
 }


// get and set a variant value
void XmlSet ( QString s, QVariant v)
{
     push();
     mkdir(s);
     cd(s);
    VariantToElement(v,currentElement());
    pop();
};

void  XmlGet ( QString s, QVariant &b)
 {
    push();
    if(cd(s))
    {
        b = (elementToVariant(currentElement()));
    }
    pop();
};

// get and set a variant value
void XmlSet ( QString s, QHostAddress a)
{
     push();
     mkdir(s);
     cd(s);
    VariantToElement(QVariant(a.toString()),currentElement());
    pop();
};

void  XmlGet ( QString s, QHostAddress &b)
 {
    push();
    if(cd(s))
    {
        QVariant v = (elementToVariant(currentElement()));
        b = QHostAddress(v.toString());
    }
    pop();
};



// return a variant
QVariant GetVar ( QString s)
 {
    QVariant b;
    XmlGet(s,b);
    return b;
};

//
// these all assume the pwd is at the root  of the config tree
// is each control has a sub-directory the same as the object name
//
#ifdef QT_GUI_LIB

void XmlGet(QLineEdit *item){ item->setText(GetVar(item->objectName()).toString());}
void XmlGet(QLabel *item){ item->setText(GetVar(item->objectName()).toString());}
void XmlSet(QLineEdit *item) {XmlSet(item->objectName(),QVariant(item->text()));}
void XmlSet(QLabel *item) {XmlSet(item->objectName(),QVariant(item->text()));}
void XmlGet(QDoubleSpinBox *item){ item->setValue(GetVar(item->objectName()).toDouble());}
void XmlSet(QDoubleSpinBox *item) {XmlSet(item->objectName(),QVariant(item->value()));}
void XmlGet(QSpinBox *item){ item->setValue(GetVar(item->objectName()).toInt());}
void XmlSet(QSpinBox *item) {XmlSet(item->objectName(),QVariant(item->value()));}
void XmlGet(QComboBox *item){ item->setCurrentIndex(GetVar(item->objectName()).toInt());}
void XmlSet(QComboBox *item) {XmlSet(item->objectName(),QVariant(item->currentIndex()));}
void XmlGetText(QComboBox *item)
{
    setComboText(item,GetVar(item->objectName()).toString());
}
void XmlSetText(QComboBox *item) {XmlSet(item->objectName(),QVariant(item->currentText()));}
//
// this covers most buttons
//
void XmlGet(QAbstractButton *item){ item->setChecked(GetVar(item->objectName()).toBool());}
void XmlSet(QAbstractButton *item) {XmlSet(item->objectName(),QVariant(item->isChecked()));}
//

void XmlGet(QDateTimeEdit *item){ item->setDateTime(GetVar(item->objectName()).toDateTime());}
void XmlSet(QDateTimeEdit *item) {XmlSet(item->objectName(),QVariant(item->dateTime()));}

// this gets and sets lists . if Get/Set Checked is true then the checked state of the listed items is handled
void XmlGet(QListWidget *item, bool fGetChecked = false)
{
    QStringList l = GetVar(item->objectName()).toStringList();
    if(fGetChecked)
    {
        // assumes the list has been populated
        setCheckList(item, l);
    }
    else
    {
        item->clear();
        item->addItems(l);
    }
}
void XmlSet(QListWidget *item, bool fSetChecked = false)
{
    QStringList l;
    if(fSetChecked)
    {
      l = getCheckList(item); // only save the checked item list
    }
    else
    {
        for(int i = 0; i < item->count(); i++) l << item->item(i)->text(); // save the text of all the items
    }
    XmlSet(item->objectName(),QVariant(l));
}
void XmlGet(QPlainTextEdit *item) { item->setPlainText(GetVar(item->objectName()).toString()); }
void XmlSet(QPlainTextEdit *item) {XmlSet(item->objectName(),QVariant(item->toPlainText()));}
#endif
//
void initialise(QString s = "Document")
{
   doc_.clear();
    clearStack();
    cur_path_node_ = doc_;
    doc_.appendChild (doc_.createElement(s)); // create the document element
    markUpdated();
}

 QVariant elementToVariant(QDomElement e);
 void VariantToElement(QVariant v, QDomElement e);

 QDateTime getUpdateTime() const { return updateTime;}
 void markUpdated() { updateTime = QDateTime::currentDateTime();}
private:
  QDomNode cd_to_node(const QString& path) ;
  QDomDocument doc_ ;
  QDomNode cur_path_node_ ;
  QDateTime updateTime; // when last updated

} ;

// helper macros - can only use in class member function

template <class T>
XMLTraversal & XmlSet (XMLTraversal &x, QString s, T b)
{
    QVariant v;
    v.setValue<T>(b);
     x.XmlSet(s,v);
     return x;
};
template <class T>
XMLTraversal &  XmlGet (XMLTraversal &x, QString s, T &b)
 {
    QVariant v;
    x.XmlGet(s,v);
    b = qVariantValue<T>(v);
    return x;
};


// sets the variable name as the element tagname and then sets the text for the element to the value
#define XMLSET(x,v)  { XmlSet(x,#v,v);}
// inverse of set
#define XMLGET(x,v) { XmlGet(x,#v,v);}

inline  XMLTraversal & XmlSet (XMLTraversal &x, QString s, QVariant v)
{
    x.XmlSet(s,v);
    return x;
};

inline XMLTraversal &  XmlGet (XMLTraversal &x, QString s, QVariant &b)
 {
    x.XmlGet(s,b);
    return x;
};

// sets the variable name as the elemetn tagname and then sets the text for the element to the value
#define XMLSETVAR(x,v)  { XmlSetVar(x,#v,v);}
// inverse of set
#define XMLGETVAR(x,v) { XmlGetVar(x,#v,v);}


// -----------------------------------------------------------------

inline const QDomDocument & XMLTraversal::document() const  {
  return doc_ ;
}

inline XMLTraversal::iterator XMLTraversal::begin() {
  return iterator(currentNode()) ;
}

inline XMLTraversal::iterator XMLTraversal::end() {
  return iterator() ;
}

inline unsigned int XMLTraversal::size() const {
  int i = 0 ;
  QDomNode node = cur_path_node_.firstChild() ;
  while(!node.isNull()) {
    if (node.isElement())
      i++ ;
    node = node.nextSibling() ;
  }
  return i ;
}

inline bool XMLTraversal::isValid() const {
  return (!doc_.isNull()) ;
}

inline QString XMLTraversal::attribute(const QString& name) const {
  if (!cur_path_node_.isElement())
    return QString::null ;
  return (const_cast<QDomNode&>(cur_path_node_)).
    toElement().attribute(name) ;
}

inline bool XMLTraversal::hasAttribute(const QString& attrname) const {
  if (!cur_path_node_.isElement())
    return false ;
  return (const_cast<QDomNode&>(cur_path_node_)).
    toElement().hasAttribute(attrname) ;
}

inline bool XMLTraversal::exists(const QString& d) const {
  XMLTraversal* This = const_cast<XMLTraversal*>(this) ;
  QDomNode cur = cur_path_node_ ;
  QDomNode node = This->cd_to_node(d) ;
  This->cur_path_node_ = cur ;
  return !node.isNull() ;
}

inline QString XMLTraversal::dump() const {
  return doc_.toString() ;
}



inline bool XMLTraversal::iterator::operator!=(const iterator& i) const {
  return !(operator==(i)) ;
}

inline QDomElement XMLTraversal::iterator::operator*() const {
  return const_cast<QDomNode&>(cur_).toElement() ;
}

inline QDomElement XMLTraversal::iterator::operator->() const {
  return const_cast<QDomNode&>(cur_).toElement() ;
}

inline bool XMLTraversal::iterator::operator==(const iterator& i) const {
  if (i.cur_.isNull() && cur_.isNull())
    return true ;

  if (i.elt_ == elt_ && i.cur_ == cur_)
    return true ;
  return false ;
}



#endif

---