20#include <zypp-core/base/DtorReset> 
   21#include <zypp-core/base/DefaultIntegral> 
   83          DBG << tag_r << node_r << endl;
 
 
 
  108          _callback.setRedirect( std::move(target_r) );
 
 
  120            it->second->_parent = NULL;
 
 
  141        SubNodes::const_iterator it = 
_subnodes.find( name_r );
 
 
  160      std::string 
exstr( 
const std::string & what_r, 
const Impl & impl_r )
 const 
  162        std::ostringstream 
str;
 
  163        str << impl_r << 
": " << what_r;
 
 
  166      std::string 
exstr( 
const std::string & what_r, 
const Impl & impl_r, 
const Reader & reader_r )
 const 
  168        std::ostringstream 
str;
 
  169        str << impl_r << 
": " << what_r << 
" |reading " << *reader_r;
 
 
 
  193      std::pair<SubNodes::iterator, bool> res
 
  194      = 
_subnodes.insert( std::make_pair( subnode_r->_name, subnode_r ) );
 
  200      if ( res.first->second->_parent )
 
  204      res.first->second->_parent = 
this;
 
 
  214      if ( reader_r->
nodeType() != XML_READER_TYPE_ELEMENT )
 
  216          if ( reader_r->
depth() == 0 )
 
  225            } 
while( reader_r->
nodeType() != XML_READER_TYPE_ELEMENT );
 
  255          for ( 
bool done = 
false; ! done ; )
 
  265                case XML_READER_TYPE_ELEMENT:
 
  273                        sub->take( reader_r );
 
  279                          WAR << 
"Skip unknown node " << *reader_r << 
" in "<< *
this << endl;
 
  285                case XML_READER_TYPE_END_ELEMENT:
 
  298                case XML_READER_TYPE_TEXT:
 
  303                case XML_READER_TYPE_CDATA:
 
  319          if ( ! it->second->_visited && it->second->isMandatory() )
 
  323          it->second->_visited = 0; 
 
 
  355      return str << 
"ParseDef(" << obj.
_name 
 
  401    { 
return _pimpl->isOptional(); }
 
 
  404    { 
return _pimpl->isMandatory(); }
 
 
  407    { 
return _pimpl->singleDef(); }
 
 
  410    { 
return _pimpl->multiDef(); }
 
 
  413    { 
return _pimpl->_visited; }
 
 
  429    { 
_pimpl->_callback.setRedirect( target_r ); }
 
 
  432    { 
_pimpl->_callback.setRedirect( allocatedTarget_r ); }
 
 
  435    { 
_pimpl->_callback.setRedirect( target_r ); }
 
 
  438    { 
_pimpl->_callback.cancelRedirect(); }
 
 
  441    { 
return _pimpl->_callback.getRedirect(); }
 
 
  445    { 
_pimpl->take( reader_r ); }
 
 
  456#define X(T) case ParseDef::T: return str << #T 
 
Integral type with defined initial value when default constructed.
Assign a vaiable a certain value when going out of scope.
bool isEqual(TInt rhs) const
Test for equal value within a Range.
xmlTextReader based interface to Reader's current node.
int depth() const
The depth of the node in the tree.
NodeType nodeType() const
Get the node type of the current node.
int isEmptyElement() const
Check if the current node is empty.
XmlString name() const
The qualified name of the node, equal to Prefix :LocalName.
void text(const Node &_node) override
void cdata(const Node &_node) override
void startSubnode(const Node &_node) override
ParseDefConsumeRedirect()
void doneSubnode(const Node &_node) override
void done(const Node &_node) override
void start(const Node &_node) override
bool skipNode(Reader &reader_r)
Skip the current node.
void take(Reader &reader_r)
Impl(std::string &&name_r, Mode mode_r, shared_ptr< ParseDefConsume > &&target_r=shared_ptr< ParseDefConsume >())
DefaultIntegral< int,-1 > _parseDepth
std::string exstr(const std::string &what_r, const Impl &impl_r) const
Impl(const Impl &)=default
std::map< std::string, ImplPtr > SubNodes
ImplPtr getNode(const std::string &name_r) const
ParseDefImplConsume _callback
void addNode(const ImplPtr &subnode_r)
shared_ptr< Impl > ImplPtr
DefaultIntegral< unsigned, 0 > _visited
Impl & operator=(const Impl &)=delete
friend std::ostream & operator<<(std::ostream &str, const ParseDef::Impl &obj)
Impl & operator=(Impl &&)=delete
std::string exstr(const std::string &what_r, const Impl &impl_r, const Reader &reader_r) const
void setConsumer(const shared_ptr< ParseDefConsume > &target_r)
Set data consumer.
const std::string & name() const
ParseDef(std::string name_r, Mode mode_r)
void cancelConsumer()
Unset data consumer.
RW_pointer< Impl > _pimpl
Pointer to implementation (shared!)
ParseDef & addNode(ParseDef &subnode_r)
Add subnode definition.
shared_ptr< ParseDefConsume > getConsumer() const
Get data consumer.
friend std::ostream & operator<<(std::ostream &str, const ParseDef &obj)
ParseDef operator[](const std::string &name_r)
Get subnode by name.
void take(Reader &reader_r)
Parse the node.
xmlTextReader based interface to iterate xml streams.
bool seekToEndNode(int depth_r, const std::string &name_r)
std::string asString() const
Explicit conversion to std::string.
const char * c_str() const
Explicit conversion to const char *.
String related utilities and Regular expression matching.
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
std::ostream & operator<<(std::ostream &str, const ReadState &obj)
Easy-to use interface to the ZYPP dependency resolver.
constPtrType getPtr() const
Exceptions when building a ParseDef tree.
Base class for ParseDef consumer.
void done(const Node &node_r) override
void doneSubnode(const Node &node_r) override
void startSubnode(const Node &node_r) override
void debuglog(const char *const tag_r, const Node &node_r)
void cdata(const Node &node_r) override
void start(const Node &node_r) override
void text(const Node &node_r) override
bit::Range< ModeBitsType, 0, 1 > TypeBits
bit::BitField< ModeBitsType > ModeBits
bit::Range< ModeBitsType, TypeBits::end, 1 > VisitBits
Parse exceptions related to the documents node structure.
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.