src/xpathiterator.h

См. документацию.

//
// C++ Interface: xpathiterator
//
// Description: 
//
//
// Author: yessss <gennadiyesss@mail.ru>, (C) 2007
//
// Copyright: See COPYING file that comes with this distribution
//
//

#include <xpath.h>
#include <xpathresult.h>
#include <to_xml.h>
#include <iostream>
#include <streambuf>

#ifndef XPATHITERATOR_H
#define XPATHITERATOR_H

class abstract_xpath_iterator{
     protected:
     abstract_xpath_iterator * parent;
     public:
          class xpath_iterator_functor{
          public:
               std::ostream* out;
               xpath_iterator_functor() {
                    out = &std::cout;
               }
               virtual void apply(abstract_xpath_iterator&) = 0;
               virtual ~xpath_iterator_functor(){
               }
          };
          abstract_xpath_iterator(abstract_xpath_iterator* par): parent(par) {
          }
          virtual void ApplyByPath(XPath::const_iterator, XPath::const_iterator, xpath_iterator_functor& f) = 0;
          virtual void ApplyByXPath(const XPath& xp, xpath_iterator_functor& f) {
               ApplyByPath(xp.begin(), xp.end(), f);
               return;
          }
          virtual void getValueByPath(XPath::const_iterator, XPath::const_iterator, XPathResult&) = 0;
          virtual XPathResult getValueByXPath(const XPath& xp) {
               XPathResult res;
               getValueByPath(xp.begin(), xp.end(), res);
               return res;
          }
          virtual ~abstract_xpath_iterator() {
          }
          virtual bool checkPathCondition(XPath::const_iterator, XPath::const_iterator) = 0;
          virtual bool checkXPathCondition(XPath xp) {
               return checkPathCondition(xp.begin(), xp.end());
          }
          virtual void to_xml(std::ostream& = std::cout) = 0;
};

template<typename T>
class xpath_iterator;

template<typename T>
class pointer_collector: public abstract_xpath_iterator::xpath_iterator_functor{
public:
     XPathResult rs;
     virtual void apply(abstract_xpath_iterator& it) {
          rs.push_back(((xpath_iterator<T>*)&it)->value);
     }
};

#define FUNCTOR_DECLARE(name)                                                             \
class name: public abstract_xpath_iterator::xpath_iterator_functor {            \
     public:                                                                                        \
     virtual void apply(abstract_xpath_iterator& i);                                      \
};

#define FUNCTOR_BEGIN(name)                                                                    \
void name::apply(abstract_xpath_iterator& i) {

#define FUNCTOR_END()                                                                          \
}

FUNCTOR_DECLARE(printer)

template<typename T>
class xpath_iterator: public abstract_xpath_iterator {
     public:
          T* value;
          xpath_iterator(abstract_xpath_iterator* par, T* val): abstract_xpath_iterator(par), value(val) {
          }
          virtual void ApplyByPath(XPath::const_iterator xp, XPath::const_iterator xe, xpath_iterator_functor& f){
               if(xp == xe) {
                    f.apply(*this);
                    return;
               }
          }
          virtual void getValueByPath(XPath::const_iterator xp, XPath::const_iterator xe, XPathResult& res) {
               if(xp == xe && value != NULL) {
                    res.push_back((void*)value);
                    return;
               }
               if(xp->type == XP_ELEMENT && xp->text == ".."){
                    parent->getValueByPath(++xp, xe, res);
                    return;
               }
          }
          void setValue(T* val) {
               value = val;
          }
          virtual bool checkPathCondition(XPath::const_iterator, XPath::const_iterator) {
               return true;
          }
          virtual void to_xml(std::ostream& out = std::cout) {
               if(value)
				::to_xml(*value, NULL, out);
          }
};

#endif //XPATHITERATOR_H

---