XMLNodeIterator.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef XMLNodeIterator_h
#define XMLNodeIterator_h

#include <zypp/parser/LibXMLHelper.h>
#include <iosfwd>
//#include <ostream>
//#include <sstream>
#include "zypp/parser/xml_parser_assert.h"
#include "zypp/Pathname.h"
#include "zypp/parser/ParserProgress.h"
#include <iterator>

extern "C" {
  typedef void * xmlTextReaderLocatorPtr;
  struct _xmlNode;
  typedef struct _xmlNode xmlNode;
  typedef xmlNode *xmlNodePtr;

  struct _xmlTextReader;
  typedef _xmlTextReader xmlTextReader;
  typedef xmlTextReader *xmlTextReaderPtr;

  struct _xmlError;
  typedef _xmlError xmlError;
  typedef xmlError *xmlErrorPtr;
}

namespace zypp {

  namespace parser {


    class XMLParserError {
    public:
      XMLParserError(const char *msg,
                     int severity,
                     xmlTextReaderLocatorPtr locator,
                     int docLine,
                     int docColumn) throw();

      ~XMLParserError() throw();

      std::string msg() const throw();

      int severity() const throw();

      xmlTextReaderLocatorPtr locator() const throw();

      int docLine() const throw();

      int docColumn() const throw();

      std::string position() const throw();

    private:

      std::string _msg;
      int _severity;
      xmlTextReaderLocatorPtr _locator;
      int _docLine;
      int _docColumn;
    };


    std::ostream& operator<<(std::ostream &out, const XMLParserError& error);



    class XMLNodeIteratorBase {
    public:
      XMLNodeIteratorBase(std::istream &input,
                          const std::string &baseUrl,
                          const char *validationPath, parser::ParserProgress::Ptr progress );

      XMLNodeIteratorBase( const Pathname xml_file_path,
          const std::string &baseUrl,
          const char *validationPath, parser::ParserProgress::Ptr progress);
      
      XMLNodeIteratorBase();

      virtual ~XMLNodeIteratorBase();

      bool atEnd() const;

      bool
      operator==(const XMLNodeIteratorBase &other) const;

      bool
      operator!=(const XMLNodeIteratorBase &otherNode) const
      {
        return ! operator==(otherNode);
      }

      const XMLParserError *
      errorStatus() const;

    protected:

      virtual bool
      isInterested(const xmlNodePtr nodePtr) = 0;

      virtual void
      _process(const xmlTextReaderPtr readerPtr) = 0;

      void fetchNext();

      static void
      errorHandler(void * arg,
                   const char * msg,
                   int severity,
                   xmlTextReaderLocatorPtr locator);


      virtual void setCurrent(const void *data) = 0;
      virtual void* getCurrent() const = 0;

    private:

      XMLNodeIteratorBase & operator=(const XMLNodeIteratorBase& otherNode);

      XMLNodeIteratorBase(const XMLNodeIteratorBase& otherNode);

      std::auto_ptr<XMLParserError> _error;

      std::istream* _input;
      
      FILE* _file;
      

      xmlTextReaderPtr _reader;

      std::string _baseUrl;
      
      parser::ParserProgress::Ptr _progress;
      
      long int _stream_size;
      long int _bytes_consumed;
    }; /* end class XMLNodeIteratorBase */



    /* --------------------------------------------------------------------------- */

    template <class ENTRYTYPE>
    class XMLNodeIterator : public XMLNodeIteratorBase,
                            public std::iterator<std::input_iterator_tag, ENTRYTYPE>  {
    public:
      XMLNodeIterator(std::istream &input,
                      const std::string &baseUrl,
                      const char *validationPath = 0,
                      parser::ParserProgress::Ptr progress = parser::ParserProgress::Ptr() )
        : XMLNodeIteratorBase(input, baseUrl, validationPath, progress), _current(0)
      {
        /* Derived classes must call fetchNext() in their constructors themselves,
           XMLNodeIterator has no access to their virtual functions during
           construction */
      }

      XMLNodeIterator( const Pathname xml_file_path, const std::string &baseUrl
                      , const char *validationPath, parser::ParserProgress::Ptr progress)
          : XMLNodeIteratorBase( xml_file_path, baseUrl, validationPath, progress), _current(0)
      {
      }
      
      XMLNodeIterator(ENTRYTYPE &entry)
        : XMLNodeIteratorBase()
      {
        setCurrent((void *)& entry);
      }

      XMLNodeIterator()
        : XMLNodeIteratorBase(), _current(0)
      { }

      virtual ~XMLNodeIterator()
      { }

      ENTRYTYPE &
        operator*() const
      {
        assert (! atEnd());
        return * (ENTRYTYPE *) getCurrent();
      }

      ENTRYTYPE *
        operator()() const
      {
        if (_error)
          return 0;
        else
          return getCurrent();
      }

      XMLNodeIterator<ENTRYTYPE> &  /* ++iter */
      operator++() {
        fetchNext();
        return *this;
      }

      XMLNodeIterator operator++(int)   /* iter++ */
      {
        assert (!atEnd());
        XMLNodeIterator<ENTRYTYPE> tmp(operator()());
        fetchNext();
        return tmp;
      }

      const ENTRYTYPE *
        operator->()
      {
        xml_assert(! atEnd());
        return getCurrent();
      }

    protected:

      virtual bool
        isInterested(const xmlNodePtr nodePtr) = 0;

      virtual ENTRYTYPE
      process(const xmlTextReaderPtr readerPtr) = 0;

      void
      _process(const xmlTextReaderPtr readerPtr)
      {
        _current.reset( new ENTRYTYPE(process(readerPtr)));
      }

    private:

      void setCurrent(const void *data)
      {
        if (data)
          _current.reset(new ENTRYTYPE(* (ENTRYTYPE *) data));
        else
          _current.reset(0);
      }

      void *getCurrent() const
      {
        return _current.get();
      }

      std::auto_ptr<ENTRYTYPE> _current;
    }; /* end class XMLNodeIterator */

  }
}

#endif

---