12#ifndef ZYPP_PARSER_XML_PARSEDEFCONSUME_H 
   13#define ZYPP_PARSER_XML_PARSEDEFCONSUME_H 
   20#include <zypp-core/base/DefaultIntegral> 
   44      virtual void text ( 
const Node & _node );
 
   46      virtual void done ( 
const Node & _node );
 
 
   80      void start( 
const Node & _node ) 
override;
 
   81      void text ( 
const Node & _node ) 
override;
 
   82      void cdata( 
const Node & _node ) 
override;
 
   83      void done ( 
const Node & _node ) 
override;
 
 
  108      void start( 
const Node & node_r ) 
override;
 
  109      void text( 
const Node & node_r ) 
override;
 
  110      void cdata( 
const Node & node_r ) 
override;
 
  111      void done( 
const Node & node_r ) 
override;
 
 
  129      template <
class Tp> 
struct Assigner;
 
  139        virtual void assign( 
const char * text_r )
 
 
 
  153        void assign( 
const char * text_r )
 override 
  154        { *
_value = Tp( text_r ); }
 
 
 
  190      template <
class Tp, Tp TInitial>
 
  191          inline AssignerRef assigner( DefaultIntegral<Tp,TInitial> & value_r )
 
  217        { 
_text.push_back( assigner_r ); }
 
 
  221        { 
_attr[attr_r].push_back( assigner_r ); }
 
 
  225        { 
_pre = std::move(pre_r); }
 
 
  229        { 
_post = std::move(post_r); }
 
 
  236          if ( ! 
_attr.empty() )
 
 
  243          if ( ! 
_text.empty() )
 
 
  254          void assign( 
const std::vector<AssignerRef> & vec_r, 
const char * value_r )
 
  257              for_( it, vec_r.begin(), vec_r.end() )
 
  258                (*it)->assign( value_r );
 
 
  262          std::unordered_map<std::string, std::vector<AssignerRef> > 
_attr;
 
 
  296            Builder( 
const std::string & attr_r, Tp & value_r )
 
 
  303        { 
_ptr->add( assigner( value_r ) ); 
return *
this; }
 
 
  308        { 
_ptr->add( attr_r, assigner( value_r ) ); 
return *
this; }
 
 
  312        { 
_ptr->prenotify( std::move(done_r) ); 
return *
this; }
 
 
  316        { 
_ptr->postnotify( std::move(done_r) ); 
return *
this; }
 
 
 
 
  360        inline parse_def_assign::Builder parseDefAssign( Tp & value_r )
 
  361    { 
return parse_def_assign::Builder( value_r ); }
 
  364        inline parse_def_assign::Builder parseDefAssign( 
const std::string & attr_r, Tp & value_r )
 
  365    { 
return parse_def_assign::Builder( attr_r, value_r ); }
 
xmlTextReader based interface to Reader's current node.
XmlString value() const
Provides the text value of the node if present.
XmlString getAttribute(const char *name_r) const
Provides a copy of the attribute value with the specified qualified name.
void startSubnode(const Node &node_r) override
void cdata(const Node &node_r) override
void start(const Node &node_r) override
void done(const Node &node_r) override
function< void(const Node &)> Callback
void text(const Node &node_r) override
ParseDefConsumeCallback()
void doneSubnode(const Node &node_r) override
~ParseDefConsumeCallback() override
void text(const Node &_node) override
void cdata(const Node &_node) override
void startSubnode(const Node &_node) override
shared_ptr< ParseDefConsume > getRedirect() const
ParseDefConsumeRedirect()
shared_ptr< ParseDefConsume > _target
void doneSubnode(const Node &_node) override
void setRedirect(shared_ptr< ParseDefConsume > target_r)
void done(const Node &_node) override
~ParseDefConsumeRedirect() override
void start(const Node &_node) override
const char * c_str() const
Explicit conversion to const char *.
TInt strtonum(const C_Str &str)
Parsing numbers from string.
bool strToBoolNodefault(const C_Str &str, bool &return_r)
Parse str into a bool if it's a legal true or false string.
parseDefAssign exposed details
shared_ptr< Assigner< void > > AssignerRef
Easy-to use interface to the ZYPP dependency resolver.
Base class for ParseDef consumer.
virtual void start(const Node &_node)
virtual void text(const Node &_node)
virtual void cdata(const Node &_node)
virtual ~ParseDefConsume()
virtual void doneSubnode(const Node &_node)
virtual void done(const Node &_node)
virtual void startSubnode(const Node &_node)
virtual void assign(const char *text_r)
Assigner assigns text to types constructible from char*.
void assign(const char *text_r) override
Helper class to build a Consumer.
Builder & operator<<(function< void(const Node &)> done_r)
Set pre notification callback.
Builder()
Contruct Consumer.
Builder & operator()(const std::string &attr_r, Tp &value_r)
Extend Consumer.
Builder & operator>>(function< void(const Node &)> done_r)
Set post notification callback.
Builder(const std::string &attr_r, Tp &value_r)
Contruct Consumer.
Builder & operator()(Tp &value_r)
Extend Consumer.
shared_ptr< Consumer > _ptr
Builder(Tp &value_r)
Contruct Consumer.
ParseDef consumer assigning Node text and attribues values to variables.
void add(const AssignerRef &assigner_r)
Extend Consumer.
std::unordered_map< std::string, std::vector< AssignerRef > > _attr
function< void(const Node &)> _pre
void text(const xml::Node &node_r) override
std::vector< AssignerRef > _text
void add(const std::string &attr_r, const AssignerRef &assigner_r)
Extend Consumer.
void postnotify(function< void(const Node &)> post_r)
Set post notification callback.
void prenotify(function< void(const Node &)> pre_r)
Set pre notification callback.
void start(const xml::Node &node_r) override
function< void(const Node &)> _post
void done(const xml::Node &node_r) override
void assign(const std::vector< AssignerRef > &vec_r, const char *value_r)
#define for_(IT, BEG, END)
Convenient for-loops using iterator.