ParseDef.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_PARSER_XML_PARSEDEF_H
#define ZYPP_PARSER_XML_PARSEDEF_H
 
#include <iosfwd>
 
#include <zypp/base/PtrTypes.h>
#include <zypp/parser/xml/ParseDefTraits.h>

namespace zypp
{ 
  namespace xml
  { 
 
    class Reader;
    struct ParseDefConsume;

    //
    //  CLASS NAME : ParseDef
    //
    class ParseDef
    {
      using Traits = ParseDefTraits;
 
    public:
      enum Mode
        {
          OPTIONAL           = Traits::BIT_OPTIONAL  | Traits::BIT_ONCE,
          MANDTAORY          = Traits::BIT_MANDTAORY | Traits::BIT_ONCE,
          MULTIPLE_OPTIONAL  = Traits::BIT_OPTIONAL  | Traits::BIT_MULTIPLE,
          MULTIPLE_MANDTAORY = Traits::BIT_MANDTAORY | Traits::BIT_MULTIPLE
        };
 
    public:
      ParseDef( std::string name_r, Mode mode_r );
      ParseDef( std::string name_r, Mode mode_r, shared_ptr<ParseDefConsume> target_r );
 
      virtual ~ParseDef();
 
    public:
      const std::string & name() const;
      Mode mode() const;
      bool isOptional() const;
      bool isMandatory() const;
      bool singleDef() const;
      bool multiDef() const;
      unsigned visited() const;
 
    public:
      ParseDef & addNode( ParseDef & subnode_r );
 
      ParseDef & addNode( const std::string & name_r, Mode mode_r )
      { ParseDef tmp( name_r, mode_r ); return addNode( tmp ); }
 
      ParseDef & addNode( const std::string & name_r, Mode mode_r, const shared_ptr<ParseDefConsume> & target_r )
      { ParseDef tmp( name_r, mode_r, target_r ); return addNode( tmp ); }

      ParseDef & operator()( ParseDef & subnode_r )
      { return addNode( subnode_r ); }
 
      ParseDef & operator()( const std::string & name_r, Mode mode_r )
      { return addNode( name_r, mode_r ); }
 
      ParseDef & operator()( const std::string & name_r, Mode mode_r, const shared_ptr<ParseDefConsume> & target_r )
      { return addNode( name_r, mode_r, target_r ); }

      ParseDef operator[]( const std::string & name_r );
 
    public:
      void setConsumer( const shared_ptr<ParseDefConsume> & target_r );
      void setConsumer( ParseDefConsume * allocatedTarget_r );
      void setConsumer( ParseDefConsume & target_r );
      void cancelConsumer();

      shared_ptr<ParseDefConsume> getConsumer() const;

      void take( Reader & reader_r );
 
    private:
      class Impl;
      RW_pointer<Impl> _pimpl;
 
      ParseDef( const shared_ptr<Impl> & pimpl_r );
      friend std::ostream & operator<<( std::ostream & str, const ParseDef & obj );
      friend std::ostream & operator<<( std::ostream & str, const ParseDef::Impl & obj );
 
    public:
      static bool _debug;
    };


    std::ostream & operator<<( std::ostream & str, ParseDef::Mode obj );

    std::ostream & operator<<( std::ostream & str, const ParseDef & obj );

  } // namespace xml
} // namespace zypp
#endif // ZYPP_PARSER_XML_PARSEDEF_H