ParseDefConsume.h

Go to the documentation of this file.

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

#include "zypp/base/PtrTypes.h"
#include "zypp/base/Function.h"
#include "zypp/base/Tr1hash.h"
#include "zypp/base/String.h"
#include "zypp/base/DefaultIntegral.h"

#include "zypp/parser/xml/Node.h"

namespace zypp
{ 
  namespace xml
  { 

    class Node;

    //
    //  CLASS NAME : ParseDefConsume
    //
    struct ParseDefConsume
    {
      virtual ~ParseDefConsume();

      virtual void start( const Node & _node );
      virtual void text ( const Node & _node );
      virtual void cdata( const Node & _node );
      virtual void done ( const Node & _node );

      virtual void startSubnode( const Node & _node );
      virtual void doneSubnode ( const Node & _node );
    };

    //
    //  CLASS NAME : ParseDefConsumeRedirect
    //
    class ParseDefConsumeRedirect : public ParseDefConsume
    {
    public:
      ParseDefConsumeRedirect();
      ParseDefConsumeRedirect( const shared_ptr<ParseDefConsume> & target_r );
      ParseDefConsumeRedirect( ParseDefConsume * allocatedTarget_r );
      ParseDefConsumeRedirect( ParseDefConsume & target_r );

      virtual ~ParseDefConsumeRedirect();

    public:
      void setRedirect( const shared_ptr<ParseDefConsume> & target_r );
      void setRedirect( ParseDefConsume * allocatedTarget_r );
      void setRedirect( ParseDefConsume & target_r );
      void cancelRedirect();

      shared_ptr<ParseDefConsume> getRedirect() const;

    public:
      virtual void start( const Node & _node );
      virtual void text ( const Node & _node );
      virtual void cdata( const Node & _node );
      virtual void done ( const Node & _node );
      virtual void startSubnode( const Node & _node );
      virtual void doneSubnode ( const Node & _node );

    private:
      shared_ptr<ParseDefConsume> _target;
    };

    //
    //  CLASS NAME : ParseDefConsumeCallback
    //
    class ParseDefConsumeCallback : public ParseDefConsume
    {
    public:
      typedef function<void(const Node &)> Callback;

      ParseDefConsumeCallback();

      virtual ~ParseDefConsumeCallback();

    public:
      virtual void start( const Node & node_r );
      virtual void text( const Node & node_r );
      virtual void cdata( const Node & node_r );
      virtual void done( const Node & node_r );
      virtual void startSubnode( const Node & node_r );
      virtual void doneSubnode( const Node & node_r );

    public:
      Callback _start;
      Callback _text;
      Callback _cdata;
      Callback _done;
      Callback _startSubnode;
      Callback _doneSubnode;
    };


    namespace parse_def_assign
    { 
     template <class _Type> struct Assigner;

      typedef shared_ptr<Assigner<void> > AssignerRef;

      template <>
          struct Assigner<void>
      {
        virtual ~Assigner()
        {}
        virtual void assign( const char * text_r )
        {}
      };

      template <class _Type>
          struct Assigner : public Assigner<void>
      {
        Assigner(_Type & value_r )
          : _value( &value_r )
        {}

        virtual void assign( const char * text_r )
        { *_value = _Type( text_r ); }

        private:
          _Type * _value;
      };

      template <>
          inline void Assigner<short>::assign( const char * text_r )              { str::strtonum( text_r, *_value ); }
      template <>
          inline void Assigner<int>::assign( const char * text_r )                { str::strtonum( text_r, *_value ); }
      template <>
          inline void Assigner<long>::assign( const char * text_r )               { str::strtonum( text_r, *_value ); }
      template <>
          inline void Assigner<long long>::assign( const char * text_r )          { str::strtonum( text_r, *_value ); }
      template <>
          inline void Assigner<unsigned short>::assign( const char * text_r )     { str::strtonum( text_r, *_value ); }
      template <>
          inline void Assigner<unsigned>::assign( const char * text_r )           { str::strtonum( text_r, *_value ); }
      template <>
          inline void Assigner<unsigned long>::assign( const char * text_r )      { str::strtonum( text_r, *_value ); }
      template <>
          inline void Assigner<unsigned long long>::assign( const char * text_r ) { str::strtonum( text_r, *_value ); }

      template <>
          inline void Assigner<bool>::assign( const char * text_r ) { str::strToBoolNodefault( text_r, *_value ); }

      template <class _Type>
          inline AssignerRef assigner( _Type & value_r )
      { return AssignerRef( new Assigner<_Type>( value_r ) ); }

      template <class _Tp, _Tp _Initial>
          inline AssignerRef assigner( DefaultIntegral<_Tp,_Initial> & value_r )
      { return AssignerRef( new Assigner<_Tp>( value_r.get() ) ); }


      struct Consumer : public ParseDefConsume
      {
        void add( const AssignerRef & assigner_r )
        { _text.push_back( assigner_r ); }

        void add( const std::string & attr_r, const AssignerRef & assigner_r )
        { _attr[attr_r].push_back( assigner_r ); }

        void prenotify( function<void ( const Node & )> pre_r )
        { _pre = pre_r; }

        void postnotify( function<void ( const Node & )> post_r )
        { _post = post_r; }

        virtual void start( const xml::Node & node_r )
        {
          if ( _pre )
            _pre( node_r );

          if ( ! _attr.empty() )
            for_( it, _attr.begin(), _attr.end() )
              assign( it->second, node_r.getAttribute( it->first.c_str() ).c_str() );
        }

        virtual void text( const xml::Node & node_r )
        {
          if ( ! _text.empty() )
            assign( _text, node_r.value().c_str() );
        }

        virtual void done( const xml::Node & node_r )
        {
          if ( _post )
            _post( node_r );
        }

        private:
          void assign( const std::vector<AssignerRef> & vec_r, const char * value_r )
          {
            if ( value_r )
              for_( it, vec_r.begin(), vec_r.end() )
                (*it)->assign( value_r );
          }

        private:
          std::tr1::unordered_map<std::string, std::vector<AssignerRef> > _attr;
          std::vector<AssignerRef>                                        _text;
          function<void ( const Node & )>                                 _pre;
          function<void ( const Node & )>                                 _post;
      };

      struct Builder
      {
        Builder()
          : _ptr( new Consumer )
        {}

        template <class _Type>
            Builder( _Type & value_r )
          : _ptr( new Consumer )
        { operator()( value_r ); }

        template <class _Type>
            Builder( const std::string & attr_r, _Type & value_r )
          : _ptr( new Consumer )
        {  operator()( attr_r, value_r ); }

        template <class _Type>
            Builder & operator()( _Type & value_r )
        { _ptr->add( assigner( value_r ) ); return *this; }

        template <class _Type>
            Builder & operator()( const std::string & attr_r, _Type & value_r )
        { _ptr->add( attr_r, assigner( value_r ) ); return *this; }

        Builder & operator<<( function<void ( const Node & )> done_r )
        { _ptr->prenotify( done_r ); return *this; }

        Builder & operator>>( function<void ( const Node & )> done_r )
        { _ptr->postnotify( done_r ); return *this; }

        operator shared_ptr<ParseDefConsume> () const
        { return _ptr; }

        private:
          shared_ptr<Consumer> _ptr;
      };
    } // namespace parse_def_assign

    inline parse_def_assign::Builder parseDefAssign()
    { return parse_def_assign::Builder(); }

    template <class _Type>
        inline parse_def_assign::Builder parseDefAssign( _Type & value_r )
    { return parse_def_assign::Builder( value_r ); }

    template <class _Type>
        inline parse_def_assign::Builder parseDefAssign( const std::string & attr_r, _Type & value_r )
    { return parse_def_assign::Builder( attr_r, value_r ); }

  } // namespace xml
} // namespace zypp
#endif // ZYPP_PARSER_XML_PARSEDEFCONSUME_H