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;
    class ParseDefConsume;

    //
    //  CLASS NAME : ParseDef
    //
    class ParseDef
    {
      typedef ParseDefTraits Traits;

    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( const std::string & name_r, Mode mode_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 & 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 );

    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

---