zypp/Resolvable.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file zypp/Resolvable.h
  10  *
  11 */
  12 #ifndef ZYPP_RESOLVABLE_H
  13 #define ZYPP_RESOLVABLE_H
  14
  15 #include <iosfwd>
  16 #include <string>
  17
  18 #include "zypp/base/Deprecated.h"
  19
  20 #include "zypp/base/ReferenceCounted.h"
  21 #include "zypp/base/NonCopyable.h"
  22 #include "zypp/base/PtrTypes.h"
  23
  24 #include "zypp/sat/Solvable.h"
  25
  26 #include "zypp/Dependencies.h"
  27
  28 ///////////////////////////////////////////////////////////////////
  29 namespace zypp
  30 { /////////////////////////////////////////////////////////////////
  31
  32   struct NVRAD;
  33
  34   ///////////////////////////////////////////////////////////////////
  35   //
  36   //    CLASS NAME : Resolvable
  37   //
  38   /** Interface base for resolvable objects (identification and dependencies).
  39    * \todo Merge with ResObject
  40   */
  41   class Resolvable : protected sat::Solvable,
  42                      public base::ReferenceCounted, private base::NonCopyable
  43   {
  44     friend std::ostream & operator<<( std::ostream & str, const Resolvable & obj );
  45
  46   public:
  47     typedef Resolvable               Self;
  48     typedef ResTraits<Self>          TraitsType;
  49     typedef TraitsType::KindType     Kind;
  50     typedef TraitsType::PtrType      Ptr;
  51     typedef TraitsType::constPtrType constPtr;
  52
  53   public:
  54     /** Whether this represents a valid- or no-solvable. */
  55     using sat::Solvable::operator bool_type;
  56     /** Whether this represents an installed solvable. */
  57     using sat::Solvable::isSystem;
  58
  59     using sat::Solvable::ident;
  60
  61     using sat::Solvable::kind;
  62     using sat::Solvable::name;
  63     using sat::Solvable::edition;
  64     using sat::Solvable::arch;
  65
  66     /** \name Dependencies. */
  67     //@{
  68     /** Select by Dep. */
  69     Capabilities dep( Dep which_r ) const
  70     { return operator[]( which_r ); }
  71     using sat::Solvable::operator[];
  72     using sat::Solvable::provides;
  73     using sat::Solvable::requires;
  74     using sat::Solvable::conflicts;
  75     using sat::Solvable::obsoletes;
  76     using sat::Solvable::recommends;
  77     using sat::Solvable::suggests;
  78     using sat::Solvable::freshens;
  79     using sat::Solvable::enhances;
  80     using sat::Solvable::supplements;
  81     using sat::Solvable::prerequires;
  82     //@}
  83
  84   public:
  85     /** Returns true if the solvable is satisfied */
  86     using sat::Solvable::isSatisfied;
  87
  88     /** Returns true if the solvable is satisfied */
  89     using sat::Solvable::isBroken;
  90
  91     /** Returns true if the solvable is relevant which means e.G. for patches
  92      *  that at least one package of the patch is installed.
  93      */
  94     using sat::Solvable::isRelevant;
  95
  96   public:
  97     const sat::Solvable & satSolvable() const { return *this; }
  98
  99   protected:
 100     /** Ctor */
 101     Resolvable( const sat::Solvable & solvable_r );
 102     /** Dtor */
 103     virtual ~Resolvable();
 104     /** Helper for stream output */
 105     virtual std::ostream & dumpOn( std::ostream & str ) const;
 106  };
 107  ///////////////////////////////////////////////////////////////////
 108
 109  /** \relates Resolvable Stream output */
 110  inline std::ostream & operator<<( std::ostream & str, const Resolvable & obj )
 111  { return obj.dumpOn( str ); }
 112
 113  /** \relates Resolvable More verbose stream output including dependencies */
 114  inline std::ostream & dumpOn( std::ostream & str, const Resolvable & obj )
 115  { return dumpOn( str, obj.satSolvable() ); }
 116
 117   /** Test whether a Resolvable::Ptr is of a certain Kind.
 118    * \return \c Ture iff \a p is not \c NULL and points to a Resolvable
 119    * of the specified Kind.
 120    * \relates Resolvable
 121    * \code
 122    * isKind<Package>(resPtr);
 123    * \endcode
 124   */
 125   template<class _Res>
 126     inline bool isKind( const Resolvable::constPtr & p )
 127     { return p && p->kind() == ResTraits<_Res>::kind; }
 128
 129   // Specialization for Resolvable: Always true.
 130   template<>
 131     inline bool isKind<Resolvable>( const Resolvable::constPtr & p )
 132     { return p; }
 133
 134   // Specialization for ResObject: Always true.
 135   template<>
 136     inline bool isKind<ResObject>( const Resolvable::constPtr & p )
 137     { return p; }
 138
 139
 140   /** Convert Resolvable::Ptr into Ptr of a certain Kind.
 141    * \return \c NULL iff \a p is \c NULL or points to a Resolvable
 142    * not of the specified Kind.
 143    * \relates Resolvable
 144    * \code
 145    * asKind<Package>(resPtr);
 146    * \endcode
 147   */
 148   template<class _Res>
 149     inline typename ResTraits<_Res>::PtrType asKind( const Resolvable::Ptr & p )
 150     { return dynamic_pointer_cast<_Res>(p); }
 151
 152   template<class _Res>
 153     inline typename ResTraits<_Res>::constPtrType asKind( const Resolvable::constPtr & p )
 154     { return dynamic_pointer_cast<const _Res>(p); }
 155
 156   ///////////////////////////////////////////////////////////////////
 157
 158   /** \relates Resolvable Compare Resolvable::constPtr according to
 159    *  \a kind and \a name.
 160   */
 161   inline int compareByN( const Resolvable::constPtr & lhs,
 162                          const Resolvable::constPtr & rhs )
 163   {
 164     if ( lhs == rhs )
 165       return 0;
 166     if ( ! (lhs && rhs) )
 167       return lhs ? 1 : -1;
 168     int res = 0;
 169     if ( (res = lhs->kind().compare( rhs->kind() )) )
 170       return res;
 171     return lhs->name().compare( rhs->name() );
 172   }
 173
 174   /** \relates Resolvable Compare Resolvable::constPtr according to
 175    *  \a kind, \a name and \a edition(compare!).
 176   */
 177   inline int compareByNVR( const Resolvable::constPtr & lhs,
 178                            const Resolvable::constPtr & rhs )
 179   {
 180     if ( lhs == rhs )
 181       return 0;
 182     if ( ! (lhs && rhs) )
 183       return lhs ? 1 : -1;
 184     int res = 0;
 185     if ( (res = lhs->kind().compare( rhs->kind() )) )
 186       return res;
 187     if ( (res = lhs->name().compare( rhs->name() )) )
 188       return res;
 189     return lhs->edition().compare( rhs->edition() );
 190   }
 191
 192   /** \relates Resolvable Compare Resolvable::constPtr according to
 193    *  \a kind, \a name, \a edition(compare!) and \a arch.
 194   */
 195   inline int compareByNVRA( const Resolvable::constPtr & lhs,
 196                             const Resolvable::constPtr & rhs )
 197   {
 198     if ( lhs == rhs )
 199       return 0;
 200     if ( ! (lhs && rhs) )
 201       return lhs ? 1 : -1;
 202     int res = 0;
 203     if ( (res = lhs->kind().compare( rhs->kind() )) )
 204       return res;
 205     if ( (res = lhs->name().compare( rhs->name() )) )
 206       return res;
 207     if ( (res = lhs->edition().compare( rhs->edition() )) )
 208       return res;
 209     return lhs->arch().compare( rhs->arch() );
 210   }
 211
 212   /////////////////////////////////////////////////////////////////
 213 } // namespace zypp
 214 ///////////////////////////////////////////////////////////////////
 215 #endif // ZYPP_RESOLVABLE_H