Patch.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_PATCH_H
#define ZYPP_PATCH_H

#include "zypp/base/Flags.h"
#include "zypp/sat/SolvAttr.h"
#include "zypp/ResObject.h"

namespace zypp
{ 


  DEFINE_PTR_TYPE(Patch);


  class Patch : public ResObject
  {
    public:
      typedef Patch                    Self;
      typedef ResTraits<Self>          TraitsType;
      typedef TraitsType::PtrType      Ptr;
      typedef TraitsType::constPtrType constPtr;

    public:
      typedef sat::SolvableSet Contents;

      enum Category {
        CAT_OTHER,
        CAT_YAST,
        CAT_SECURITY,
        CAT_RECOMMENDED,
        CAT_OPTIONAL,
        CAT_DOCUMENT
      };

      enum InteractiveFlag {
        NoFlags = 0x0000,
        Reboot  = 0x0001,
        Message = 0x0002,
        License = 0x0004
      };
      ZYPP_DECLARE_FLAGS(InteractiveFlags, InteractiveFlag);

      enum SeverityFlag {
        SEV_NONE        = 0,    
        SEV_OTHER       = 1,    
        SEV_LOW         = 1<<1, 
        SEV_MODERATE    = 1<<2, 
        SEV_IMPORTANT   = 1<<3, 
        SEV_CRITICAL    = 1<<4  
      };
      ZYPP_DECLARE_FLAGS(SeverityFlags, SeverityFlag);

    public:
      Date timestamp() const
      { return buildtime(); }

      std::string category() const;

      Category categoryEnum() const;

      bool isCategory( const std::string & category_r ) const;

      static Category categoryEnum( const std::string & category_r );

      std::string severity() const;

      SeverityFlag severityFlag() const;

      bool isSeverity( const std::string & severity_r ) const;

      static SeverityFlag severityFlag( const std::string & category_r );

      bool rebootSuggested() const;

      bool restartSuggested() const;

      bool reloginSuggested() const;

      std::string message( const Locale & lang_r = Locale() ) const;

      InteractiveFlags interactiveFlags() const;

      bool interactiveWhenIgnoring( InteractiveFlags flags_r = NoFlags ) const;

      bool interactive() const;

    public:
      Contents contents() const;

    public:

      class ReferenceIterator;
      ReferenceIterator referencesBegin() const;
      ReferenceIterator referencesEnd() const;

    protected:
      friend Ptr make<Self>( const sat::Solvable & solvable_r );
      Patch( const sat::Solvable & solvable_r );
      virtual ~Patch();
  };
  ZYPP_DECLARE_OPERATORS_FOR_FLAGS(Patch::InteractiveFlags);
  ZYPP_DECLARE_OPERATORS_FOR_FLAGS(Patch::SeverityFlags);

  std::string asString( const Patch::SeverityFlag & obj );

  class Patch::ReferenceIterator : public boost::iterator_adaptor<
      Patch::ReferenceIterator           // Derived
      , sat::LookupAttr::iterator        // Base
      , int                              // Value
      , boost::forward_traversal_tag     // CategoryOrTraversal
      , int                              // Reference
  >
  {
    public:
      ReferenceIterator() {}
      explicit ReferenceIterator( const sat::Solvable & val_r );

      std::string id() const;
      std::string href() const;
      std::string title() const;
      std::string type() const;

    private:
      friend class boost::iterator_core_access;
      int dereference() const { return 0; }
  };

  inline Patch::ReferenceIterator Patch::referencesBegin() const
  { return ReferenceIterator(satSolvable()); }

  inline Patch::ReferenceIterator Patch::referencesEnd() const
  { return ReferenceIterator(); }


} // namespace zypp
#endif // ZYPP_PATCH_H