libzypp  13.10.6
ParseDefConsume.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #ifndef ZYPP_PARSER_XML_PARSEDEFCONSUME_H
13 #define ZYPP_PARSER_XML_PARSEDEFCONSUME_H
14 
15 #include "zypp/base/PtrTypes.h"
16 #include "zypp/base/Function.h"
17 #include "zypp/base/Tr1hash.h"
18 #include "zypp/base/String.h"
20 
21 #include "zypp/parser/xml/Node.h"
22 
24 namespace zypp
25 {
26  namespace xml
28  {
29 
30  class Node;
31 
33  //
34  // CLASS NAME : ParseDefConsume
35  //
39  {
40  virtual ~ParseDefConsume();
41 
42  virtual void start( const Node & _node );
43  virtual void text ( const Node & _node );
44  virtual void cdata( const Node & _node );
45  virtual void done ( const Node & _node );
46 
47  virtual void startSubnode( const Node & _node );
48  virtual void doneSubnode ( const Node & _node );
49  };
51 
53  //
54  // CLASS NAME : ParseDefConsumeRedirect
55  //
61  {
62  public:
64  ParseDefConsumeRedirect( const shared_ptr<ParseDefConsume> & target_r );
65  ParseDefConsumeRedirect( ParseDefConsume * allocatedTarget_r );
67 
68  virtual ~ParseDefConsumeRedirect();
69 
70  public:
71  void setRedirect( const shared_ptr<ParseDefConsume> & target_r );
72  void setRedirect( ParseDefConsume * allocatedTarget_r );
73  void setRedirect( ParseDefConsume & target_r );
74  void cancelRedirect();
75 
76  shared_ptr<ParseDefConsume> getRedirect() const;
77 
78  public:
79  virtual void start( const Node & _node );
80  virtual void text ( const Node & _node );
81  virtual void cdata( const Node & _node );
82  virtual void done ( const Node & _node );
83  virtual void startSubnode( const Node & _node );
84  virtual void doneSubnode ( const Node & _node );
85 
86  private:
87  shared_ptr<ParseDefConsume> _target;
88  };
90 
92  //
93  // CLASS NAME : ParseDefConsumeCallback
94  //
98  {
99  public:
100  typedef function<void(const Node &)> Callback;
101 
103 
104  virtual ~ParseDefConsumeCallback();
105 
106  public:
107  virtual void start( const Node & node_r );
108  virtual void text( const Node & node_r );
109  virtual void cdata( const Node & node_r );
110  virtual void done( const Node & node_r );
111  virtual void startSubnode( const Node & node_r );
112  virtual void doneSubnode( const Node & node_r );
113 
114  public:
121  };
123 
125 
126  namespace parse_def_assign
127  {
128  template <class _Type> struct Assigner;
129 
130  typedef shared_ptr<Assigner<void> > AssignerRef;
131 
133  template <>
134  struct Assigner<void>
135  {
136  virtual ~Assigner()
137  {}
138  virtual void assign( const char * text_r )
139  {}
140  };
141 
145  template <class _Type>
146  struct Assigner : public Assigner<void>
147  {
148  Assigner(_Type & value_r )
149  : _value( &value_r )
150  {}
151 
152  virtual void assign( const char * text_r )
153  { *_value = _Type( text_r ); }
154 
155  private:
156  _Type * _value;
157  };
158 
163  template <>
164  inline void Assigner<short>::assign( const char * text_r ) { str::strtonum( text_r, *_value ); }
165  template <>
166  inline void Assigner<int>::assign( const char * text_r ) { str::strtonum( text_r, *_value ); }
167  template <>
168  inline void Assigner<long>::assign( const char * text_r ) { str::strtonum( text_r, *_value ); }
169  template <>
170  inline void Assigner<long long>::assign( const char * text_r ) { str::strtonum( text_r, *_value ); }
171  template <>
172  inline void Assigner<unsigned short>::assign( const char * text_r ) { str::strtonum( text_r, *_value ); }
173  template <>
174  inline void Assigner<unsigned>::assign( const char * text_r ) { str::strtonum( text_r, *_value ); }
175  template <>
176  inline void Assigner<unsigned long>::assign( const char * text_r ) { str::strtonum( text_r, *_value ); }
177  template <>
178  inline void Assigner<unsigned long long>::assign( const char * text_r ) { str::strtonum( text_r, *_value ); }
179 
180  template <>
181  inline void Assigner<bool>::assign( const char * text_r ) { str::strToBoolNodefault( text_r, *_value ); }
183 
186  template <class _Type>
187  inline AssignerRef assigner( _Type & value_r )
188  { return AssignerRef( new Assigner<_Type>( value_r ) ); }
189 
190  template <class _Tp, _Tp _Initial>
191  inline AssignerRef assigner( DefaultIntegral<_Tp,_Initial> & value_r )
192  { return AssignerRef( new Assigner<_Tp>( value_r.get() ) ); }
194 
195 
213  struct Consumer : public ParseDefConsume
214  {
216  void add( const AssignerRef & assigner_r )
217  { _text.push_back( assigner_r ); }
218 
220  void add( const std::string & attr_r, const AssignerRef & assigner_r )
221  { _attr[attr_r].push_back( assigner_r ); }
222 
224  void prenotify( function<void ( const Node & )> pre_r )
225  { _pre = pre_r; }
226 
228  void postnotify( function<void ( const Node & )> post_r )
229  { _post = post_r; }
230 
231  virtual void start( const xml::Node & node_r )
232  {
233  if ( _pre )
234  _pre( node_r );
235 
236  if ( ! _attr.empty() )
237  for_( it, _attr.begin(), _attr.end() )
238  assign( it->second, node_r.getAttribute( it->first.c_str() ).c_str() );
239  }
240 
241  virtual void text( const xml::Node & node_r )
242  {
243  if ( ! _text.empty() )
244  assign( _text, node_r.value().c_str() );
245  }
246 
247  virtual void done( const xml::Node & node_r )
248  {
249  if ( _post )
250  _post( node_r );
251  }
252 
253  private:
254  void assign( const std::vector<AssignerRef> & vec_r, const char * value_r )
255  {
256  if ( value_r )
257  for_( it, vec_r.begin(), vec_r.end() )
258  (*it)->assign( value_r );
259  }
260 
261  private:
262  std::tr1::unordered_map<std::string, std::vector<AssignerRef> > _attr;
263  std::vector<AssignerRef> _text;
264  function<void ( const Node & )> _pre;
265  function<void ( const Node & )> _post;
266  };
267 
281  struct Builder
282  {
285  : _ptr( new Consumer )
286  {}
287 
289  template <class _Type>
290  Builder( _Type & value_r )
291  : _ptr( new Consumer )
292  { operator()( value_r ); }
293 
295  template <class _Type>
296  Builder( const std::string & attr_r, _Type & value_r )
297  : _ptr( new Consumer )
298  { operator()( attr_r, value_r ); }
299 
301  template <class _Type>
302  Builder & operator()( _Type & value_r )
303  { _ptr->add( assigner( value_r ) ); return *this; }
304 
306  template <class _Type>
307  Builder & operator()( const std::string & attr_r, _Type & value_r )
308  { _ptr->add( attr_r, assigner( value_r ) ); return *this; }
309 
311  Builder & operator<<( function<void ( const Node & )> done_r )
312  { _ptr->prenotify( done_r ); return *this; }
313 
315  Builder & operator>>( function<void ( const Node & )> done_r )
316  { _ptr->postnotify( done_r ); return *this; }
317 
319  operator shared_ptr<ParseDefConsume> () const
320  { return _ptr; }
321 
322  private:
323  shared_ptr<Consumer> _ptr;
324  };
326  } // namespace parse_def_assign
328 
356  inline parse_def_assign::Builder parseDefAssign()
357  { return parse_def_assign::Builder(); }
358 
359  template <class _Type>
360  inline parse_def_assign::Builder parseDefAssign( _Type & value_r )
361  { return parse_def_assign::Builder( value_r ); }
362 
363  template <class _Type>
364  inline parse_def_assign::Builder parseDefAssign( const std::string & attr_r, _Type & value_r )
365  { return parse_def_assign::Builder( attr_r, value_r ); }
367 
369  } // namespace xml
372 } // namespace zypp
374 #endif // ZYPP_PARSER_XML_PARSEDEFCONSUME_H
function< void(const Node &)> _post
virtual void start(const Node &node_r)
void add(const std::string &attr_r, const AssignerRef &assigner_r)
Extend Consumer.
bool strToBoolNodefault(const C_Str &str, bool &return_r)
Parse str into a bool if it&#39;s a legal true or false string.
Definition: String.h:352
virtual void done(const Node &_node)
virtual void text(const Node &node_r)
Builder & operator()(_Type &value_r)
Extend Consumer.
virtual void doneSubnode(const Node &_node)
virtual void startSubnode(const Node &_node)
virtual void text(const Node &_node)
shared_ptr< ParseDefConsume > _target
shared_ptr< Assigner< void > > AssignerRef
virtual void text(const xml::Node &node_r)
virtual void doneSubnode(const Node &_node)
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:27
Edition * _value
Definition: SysContent.cc:311
ParseDef consumer that invokes callbacks.
Helper class to build a Consumer.
void postnotify(function< void(const Node &)> post_r)
Set post notification callback.
virtual void cdata(const Node &_node)
std::tr1::unordered_map< std::string, std::vector< AssignerRef > > _attr
virtual void cdata(const Node &_node)
XmlString value() const
Provides the text value of the node if present.
Definition: Node.h:140
xmlTextReader based interface to Reader&#39;s current node.
Definition: Node.h:35
virtual void assign(const char *text_r)
virtual void cdata(const Node &node_r)
virtual void assign(const char *text_r)
virtual void text(const Node &_node)
virtual void done(const Node &node_r)
void assign(const std::vector< AssignerRef > &vec_r, const char *value_r)
function< void(const Node &)> Callback
virtual void start(const xml::Node &node_r)
Builder(const std::string &attr_r, _Type &value_r)
Contruct Consumer.
Builder(_Type &value_r)
Contruct Consumer.
Base class for ParseDef consumer.
_It strtonum(const C_Str &str)
Parsing numbers from string.
Definition: String.h:304
ParseDef consumer assigning Node text and attribues values to variables.
const char * c_str() const
Explicit conversion to const char *.
Definition: XmlString.h:73
std::vector< AssignerRef > _text
void prenotify(function< void(const Node &)> pre_r)
Set pre notification callback.
virtual void doneSubnode(const Node &node_r)
shared_ptr< ParseDefConsume > getRedirect() const
XmlString getAttribute(const char *name_r) const
Provides a copy of the attribute value with the specified qualified name.
Definition: Node.h:71
function< void(const Node &)> _pre
ParseDef consumer redirecting all events to another consumer.
virtual void done(const xml::Node &node_r)
Builder & operator()(const std::string &attr_r, _Type &value_r)
Extend Consumer.
virtual void start(const Node &_node)
virtual void startSubnode(const Node &node_r)
virtual void done(const Node &_node)
virtual void startSubnode(const Node &_node)
virtual void start(const Node &_node)
void add(const AssignerRef &assigner_r)
Extend Consumer.
Builder & operator>>(function< void(const Node &)> done_r)
Set post notification callback.
void setRedirect(const shared_ptr< ParseDefConsume > &target_r)
Assigner assigns text to types constructible from char*.