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 ZYPP_API Patch : public ResObject
  {
    public:
      using Self = Patch;
      using TraitsType = ResTraits<Self>;
      using Ptr = TraitsType::PtrType;
      using constPtr = TraitsType::constPtrType;
 
    public:
      using Contents = sat::SolvableSet;
 
      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 );
      ~Patch() override;
  };
  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 ) ZYPP_API;

  std::string asString( const Patch::InteractiveFlag & obj ) ZYPP_API;

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

  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