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>
#include <zypp/sat/SolvableSet.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       = 1,    
        CAT_YAST        = 1<<1, 
        CAT_SECURITY    = 1<<2, 
        CAT_RECOMMENDED = 1<<3, 
        CAT_OPTIONAL    = 1<<4, 
        CAT_DOCUMENT    = 1<<5  
      };
      ZYPP_DECLARE_FLAGS(Categories, Category);
 
      enum InteractiveFlag {
        NoFlags = 0x0000,
        Reboot  = 0x0001,
        Message = 0x0002,
        License = 0x0004
      };
      ZYPP_DECLARE_FLAGS(InteractiveFlags, InteractiveFlag);
 
      enum SeverityFlag {
        SEV_OTHER       = 1,    
        SEV_NONE        = 1<<1, 
        SEV_LOW         = 1<<2, 
        SEV_MODERATE    = 1<<3, 
        SEV_IMPORTANT   = 1<<4, 
        SEV_CRITICAL    = 1<<5  
      };
      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;
      bool isCategory( Categories category_r ) const;
 
      template <class TContainer, typename = typename TContainer::value_type>
      bool isCategory( const TContainer & categories_r ) const
      {
        for ( const std::string & el : categories_r )
        { if ( isCategory( el ) ) return true; }
        return false;
      }
 
      static Category categoryEnum( const std::string & category_r );
 
      std::string severity() const;
 
      SeverityFlag severityFlag() const;
 
      bool isSeverity( const std::string & severity_r ) const;
      bool isSeverity( SeverityFlags severity_r ) const;
 
      template <class TContainer, typename = typename TContainer::value_type>
      bool isSeverity( const TContainer & severities_r ) const
      {
        for ( const std::string & el : severities_r )
        { if ( isSeverity( el ) ) return true; }
        return false;
      }
 
      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::Categories);
  ZYPP_DECLARE_OPERATORS_FOR_FLAGS(Patch::InteractiveFlags);
  ZYPP_DECLARE_OPERATORS_FOR_FLAGS(Patch::SeverityFlags);
 
  std::string asString( const Patch::Category & obj );
 
  std::string asString( const Patch::InteractiveFlag & obj );
 
  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