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/Hash.h>
#include <zypp/base/String.h>
#include <utility>
#include <zypp-core/base/DefaultIntegral>
 
#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( shared_ptr<ParseDefConsume> target_r );
      ParseDefConsumeRedirect( ParseDefConsume * allocatedTarget_r );
      ParseDefConsumeRedirect( ParseDefConsume & target_r );
 
      ~ParseDefConsumeRedirect() override;
 
    public:
      void setRedirect( shared_ptr<ParseDefConsume> target_r );
      void setRedirect( ParseDefConsume * allocatedTarget_r );
      void setRedirect( ParseDefConsume & target_r );
      void cancelRedirect();
 
      shared_ptr<ParseDefConsume> getRedirect() const;
 
    public:
      void start( const Node & _node ) override;
      void text ( const Node & _node ) override;
      void cdata( const Node & _node ) override;
      void done ( const Node & _node ) override;
      void startSubnode( const Node & _node ) override;
      void doneSubnode ( const Node & _node ) override;
 
    private:
      shared_ptr<ParseDefConsume> _target;
    };


    //
    //  CLASS NAME : ParseDefConsumeCallback
    //
    class ParseDefConsumeCallback : public ParseDefConsume
    {
    public:
      using Callback = function<void (const Node &)>;
 
      ParseDefConsumeCallback();
 
      ~ParseDefConsumeCallback() override;
 
    public:
      void start( const Node & node_r ) override;
      void text( const Node & node_r ) override;
      void cdata( const Node & node_r ) override;
      void done( const Node & node_r ) override;
      void startSubnode( const Node & node_r ) override;
      void doneSubnode( const Node & node_r ) override;
 
    public:
      Callback _start;
      Callback _text;
      Callback _cdata;
      Callback _done;
      Callback _startSubnode;
      Callback _doneSubnode;
    };



    namespace parse_def_assign
    { 
      template <class Tp> struct Assigner;
 
      using AssignerRef = shared_ptr<Assigner<void>>;

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

      template <class Tp>
      struct Assigner : public Assigner<void>
      {
        Assigner( Tp & value_r )
          : _value( &value_r )
        {}
 
        void assign( const char * text_r ) override
        { *_value = Tp( text_r ); }
 
        private:
          Tp * _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 Tp>
          inline AssignerRef assigner( Tp & value_r )
      { return AssignerRef( new Assigner<Tp>( value_r ) ); }
 
      template <class Tp, Tp TInitial>
          inline AssignerRef assigner( DefaultIntegral<Tp,TInitial> & 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 = std::move(pre_r); }

        void postnotify( function<void ( const Node & )> post_r )
        { _post = std::move(post_r); }
 
        void start( const xml::Node & node_r ) override
        {
          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() );
        }
 
        void text( const xml::Node & node_r ) override
        {
          if ( ! _text.empty() )
            assign( _text, node_r.value().c_str() );
        }
 
        void done( const xml::Node & node_r ) override
        {
          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::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 Tp>
            Builder( Tp & value_r )
          : _ptr( new Consumer )
        { operator()( value_r ); }

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

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

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

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

        Builder & operator>>( function<void ( const Node & )> done_r )
        { _ptr->postnotify( std::move(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 Tp>
        inline parse_def_assign::Builder parseDefAssign( Tp & value_r )
    { return parse_def_assign::Builder( value_r ); }
 
    template <class Tp>
        inline parse_def_assign::Builder parseDefAssign( const std::string & attr_r, Tp & value_r )
    { return parse_def_assign::Builder( attr_r, value_r ); }

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