zypp/sat/Solvable.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/sat/Solvable.h
  10  *
  11 */
  12 #ifndef ZYPP_SAT_SOLVABLE_H
  13 #define ZYPP_SAT_SOLVABLE_H
  14
  15 #include <iosfwd>
  16
  17 #include "zypp/base/SafeBool.h"
  18
  19 #include "zypp/sat/detail/PoolMember.h"
  20 #include "zypp/sat/SolvAttr.h"
  21 #include "zypp/ResTraits.h"
  22 #include "zypp/IdString.h"
  23 #include "zypp/Edition.h"
  24 #include "zypp/Arch.h"
  25 #include "zypp/Dep.h"
  26 #include "zypp/Capabilities.h"
  27 #include "zypp/Capability.h"
  28 #include "zypp/Locale.h"
  29
  30 ///////////////////////////////////////////////////////////////////
  31 namespace zypp
  32 { /////////////////////////////////////////////////////////////////
  33
  34   class CheckSum;
  35   class OnMediaLocation;
  36
  37   ///////////////////////////////////////////////////////////////////
  38   namespace sat
  39   { /////////////////////////////////////////////////////////////////
  40
  41     ///////////////////////////////////////////////////////////////////
  42     //
  43     //  CLASS NAME : Solvable
  44     //
  45     /** A \ref Solvable object within the sat \ref Pool.
  46      *
  47      * \note Unfortunately libsatsolver combines the objects kind and
  48      * name in a single identifier \c "pattern:kde_multimedia",
  49      * \b except for packages and source packes. They are not prefixed
  50      * by any kind string. Instead the architecture is abused to store
  51      * \c "src" and \c "nosrc" values.
  52      *
  53      * \ref Solvable will hide this inconsistency by treating source
  54      * packages as an own kind of solvable and map their arch to
  55      * \ref Arch_noarch.
  56      */
  57     class Solvable : protected detail::PoolMember,
  58                      private base::SafeBool<Solvable>
  59     {
  60       public:
  61         typedef sat::detail::SolvableIdType IdType;
  62
  63       public:
  64         /** Default ctor creates \ref noSolvable.*/
  65         Solvable()
  66         : _id( detail::noSolvableId ) {}
  67
  68         /** \ref PoolImpl ctor. */
  69         explicit Solvable( IdType id_r )
  70         : _id( id_r ) {}
  71
  72       public:
  73         /** Represents no \ref Solvable. */
  74         static const Solvable noSolvable;
  75
  76 #ifndef SWIG // Swig treats it as syntax error
  77         /** Evaluate \ref Solvable in a boolean context (\c != \c noSolvable). */
  78         using base::SafeBool<Solvable>::operator bool_type;
  79 #endif
  80
  81         /** Return whether this \ref Solvable belongs to the system repo.
  82          * \note This includes the otherwise hidden systemSolvable.
  83         */
  84         bool isSystem() const;
  85
  86         /** The \ref Repository this \ref Solvable belongs to. */
  87         Repository repository() const;
  88
  89       public:
  90
  91         /** \name Attribute lookup.
  92          * \see \ref LookupAttr and  \ref ArrayAttr providing a general, more
  93          * query like interface for attribute retrieval.
  94         */
  95         //@{
  96         /**
  97          * returns the string attribute value for \ref attr
  98          * or an empty string if it does not exists.
  99          */
 100         std::string lookupStrAttribute( const SolvAttr & attr ) const;
 101         /** \overload Trying to look up a translated string attribute.
 102          *
 103          * Returns the translation for \c lang_r (\b no fallback locales).
 104          *
 105          * Passing an empty \ref Locale will return the string for the
 106          * current default locale (\see \ref ZConfig::defaultTextLocale),
 107          * \b considering all fallback locales.
 108          *
 109          * Returns an empty string if no translation is available.
 110         */
 111         std::string lookupStrAttribute( const SolvAttr & attr, const Locale & lang_r ) const;
 112
 113         /**
 114          * returns the numeric attribute value for \ref attr
 115          * or 0 if it does not exists.
 116          */
 117         unsigned lookupNumAttribute( const SolvAttr & attr ) const;
 118
 119         /**
 120          * returns the boolean attribute value for \ref attr
 121          * or \c false if it does not exists.
 122          */
 123         bool lookupBoolAttribute( const SolvAttr & attr ) const;
 124
 125        /**
 126          * returns the id attribute value for \ref attr
 127          * or \ref detail::noId if it does not exists.
 128          */
 129         detail::IdType lookupIdAttribute( const SolvAttr & attr ) const;
 130
 131        /**
 132          * returns the CheckSum attribute value for \ref attr
 133          * or an empty CheckSum if ir does not exist.
 134          */
 135         CheckSum lookupCheckSumAttribute( const SolvAttr & attr ) const;
 136
 137         /**
 138          * returns OnMediaLocation data: This is everything we need to
 139          * download e.g. an rpm (path, checksum, downloadsize, etc.).
 140          */
 141         OnMediaLocation lookupLocation() const;
 142
 143         //@}
 144       public:
 145         /** The identifier.
 146          * This is the solvables \ref name, \b except for packages and
 147          * source packes, prefixed by it's \ref kind.
 148          */
 149         IdString     ident()    const;
 150
 151         ResKind      kind()     const;
 152         /** Test whether a Solvable is of a certain \ref ResKind. */
 153         bool         isKind( const ResKind & kind_r ) const;
 154
 155         std::string  name()     const;
 156         Edition      edition()  const;
 157         Arch         arch()     const;
 158
 159         IdString     vendor()   const;
 160
 161         bool         installOnly() const;
 162
 163       public:
 164
 165         /** \name Access to the \ref Solvable dependencies.
 166          *
 167          * \note Prerequires are a subset of requires.
 168          */
 169         //@{
 170         Capabilities operator[]( Dep which_r ) const;
 171
 172         Capabilities provides()    const;
 173         Capabilities requires()    const;
 174         Capabilities conflicts()   const;
 175         Capabilities obsoletes()   const;
 176         Capabilities recommends()  const;
 177         Capabilities suggests()    const;
 178         Capabilities enhances()    const;
 179         Capabilities supplements() const;
 180         Capabilities prerequires() const;
 181         //@}
 182
 183       public:
 184         /** \name Locale support. */
 185         //@{
 186         /** Whether this \c Solvable claims to support locales. */
 187         bool supportsLocales() const;
 188         /** Whether this \c Solvable supports a specific \ref Locale. */
 189         bool supportsLocale( const Locale & locale_r ) const;
 190         /** Whether this \c Solvable supports at least one of the specified locales. */
 191         bool supportsLocale( const LocaleSet & locales_r ) const;
 192         /** Whether this \c Solvable supports at least one requested locale.
 193          * \see \ref Pool::setRequestedLocales
 194         */
 195         bool supportsRequestedLocales() const;
 196         /** Return the supported locales via locales_r. */
 197         void getSupportedLocales( LocaleSet & locales_r ) const;
 198         /** \overload */
 199         LocaleSet getSupportedLocales() const
 200         { LocaleSet ret; getSupportedLocales( ret ); return ret; }
 201         //@}
 202
 203       public:
 204         /** Return next Solvable in \ref Pool (or \ref noSolvable). */
 205         Solvable nextInPool() const;
 206         /** Return next Solvable in \ref Repo (or \ref noSolvable). */
 207         Solvable nextInRepo() const;
 208
 209         /** Helper that splits an identifier into kind and name or vice versa.
 210          * \see \ref ident
 211         */
 212         class SplitIdent
 213         {
 214           public:
 215             SplitIdent() {}
 216             SplitIdent( IdString ident_r );
 217             SplitIdent( ResKind kind_r, IdString name_r );
 218             SplitIdent( ResKind kind_r, const C_Str & name_r );
 219
 220             IdString ident() const { return _ident; }
 221             ResKind  kind()  const { return _kind; }
 222             IdString name()  const { return _name; }
 223           private:
 224             IdString  _ident;
 225             ResKind   _kind;
 226             IdString  _name;
 227         };
 228
 229       public:
 230         /** Expert backdoor. */
 231         ::_Solvable * get() const;
 232         /** Expert backdoor. */
 233         IdType id() const { return _id; }
 234       private:
 235 #ifndef SWIG // Swig treats it as syntax error
 236         friend base::SafeBool<Solvable>::operator bool_type() const;
 237 #endif
 238         bool boolTest() const { return get(); }
 239       private:
 240         IdType _id;
 241     };
 242     ///////////////////////////////////////////////////////////////////
 243
 244     /** \relates Solvable Stream output */
 245     std::ostream & operator<<( std::ostream & str, const Solvable & obj );
 246
 247     /** \relates Solvable More verbose stream output including dependencies */
 248     std::ostream & dumpOn( std::ostream & str, const Solvable & obj );
 249
 250     /** \relates Solvable */
 251     inline bool operator==( const Solvable & lhs, const Solvable & rhs )
 252     { return lhs.get() == rhs.get(); }
 253
 254     /** \relates Solvable */
 255     inline bool operator!=( const Solvable & lhs, const Solvable & rhs )
 256     { return lhs.get() != rhs.get(); }
 257
 258     /** \relates Solvable */
 259     inline bool operator<( const Solvable & lhs, const Solvable & rhs )
 260     { return lhs.get() < rhs.get(); }
 261
 262     ///////////////////////////////////////////////////////////////////
 263     namespace detail
 264     { /////////////////////////////////////////////////////////////////
 265       ///////////////////////////////////////////////////////////////////
 266       //
 267       //        CLASS NAME : SolvableIterator
 268       //
 269       /** */
 270       class SolvableIterator : public boost::iterator_adaptor<
 271           SolvableIterator                   // Derived
 272           , ::_Solvable*                     // Base
 273           , const Solvable                   // Value
 274           , boost::forward_traversal_tag     // CategoryOrTraversal
 275           , const Solvable                   // Reference
 276           >
 277       {
 278         public:
 279           SolvableIterator()
 280           : SolvableIterator::iterator_adaptor_( 0 )
 281           {}
 282
 283           explicit SolvableIterator( const Solvable & val_r )
 284           : SolvableIterator::iterator_adaptor_( 0 )
 285           { assignVal( val_r ); }
 286
 287           explicit SolvableIterator( SolvableIdType id_r )
 288           : SolvableIterator::iterator_adaptor_( 0 )
 289           { assignVal( Solvable( id_r ) ); }
 290
 291         private:
 292           friend class boost::iterator_core_access;
 293
 294           Solvable dereference() const
 295           { return _val; }
 296
 297           void increment()
 298           { assignVal( _val.nextInPool() ); }
 299
 300         private:
 301           void assignVal( const Solvable & val_r )
 302           { _val = val_r; base_reference() = _val.get(); }
 303
 304           Solvable _val;
 305       };
 306       ///////////////////////////////////////////////////////////////////
 307       /////////////////////////////////////////////////////////////////
 308     } // namespace detail
 309     ///////////////////////////////////////////////////////////////////
 310
 311    /////////////////////////////////////////////////////////////////
 312   } // namespace sat
 313   ///////////////////////////////////////////////////////////////////
 314
 315   /** \relates sat::Solvable Test whether a \ref sat::Solvable is of a certain Kind. */
 316   template<class _Res>
 317   inline bool isKind( const sat::Solvable & solvable_r )
 318   { return solvable_r.isKind( ResTraits<_Res>::kind ); }
 319
 320   /////////////////////////////////////////////////////////////////
 321 } // namespace zypp
 322 ///////////////////////////////////////////////////////////////////
 323
 324 ZYPP_DEFINE_ID_HASHABLE( ::zypp::sat::Solvable );
 325
 326 #endif // ZYPP_SAT_SOLVABLE_H