libzypp  17.35.15
Solvable.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #ifndef ZYPP_SAT_SOLVABLE_H
13 #define ZYPP_SAT_SOLVABLE_H
14 
15 #include <iosfwd>
16 
18 #include <zypp/sat/SolvAttr.h>
19 #include <zypp/ResTraits.h>
20 #include <zypp/IdString.h>
21 #include <zypp/Edition.h>
22 #include <zypp/Arch.h>
23 #include <zypp/Dep.h>
24 #include <zypp/Capabilities.h>
25 #include <zypp/Capability.h>
26 #include <zypp/Locale.h>
27 
29 namespace zypp
30 {
31  class ByteCount;
32  class CheckSum;
33  class CpeId;
34  class Date;
35  class OnMediaLocation;
37  namespace sat
38  {
54  {
55  public:
57 
58  static const IdString retractedToken;
59  static const IdString ptfMasterToken;
60  static const IdString ptfPackageToken;
61 
62  public:
65  : _id( detail::noSolvableId )
66  {}
67 
68  Solvable(const Solvable &) = default;
69  Solvable(Solvable &&) noexcept = default;
70  Solvable &operator=(const Solvable &) = default;
71  Solvable &operator=(Solvable &&) noexcept = default;
72 
74  explicit Solvable( IdType id_r )
75  : _id( id_r )
76  {}
77 
78  public:
80  static const Solvable noSolvable;
81 
83  explicit operator bool() const
84  { return get(); }
85 
86  public:
91  IdString ident()const;
92 
94  ResKind kind()const;
95 
100  bool isKind( const ResKind & kind_r ) const;
102  template<class TRes>
103  bool isKind() const
104  { return isKind( resKind<TRes>() ); }
106  template<class TIterator>
107  bool isKind( TIterator begin, TIterator end ) const
108  { for_( it, begin, end ) if ( isKind( *it ) ) return true; return false; }
109 
111  std::string name() const;
112 
114  Edition edition() const;
115 
117  Arch arch() const;
118 
120  IdString vendor() const;
121 
123  Repository repository() const;
125  RepoInfo repoInfo() const;
126 
130  bool isSystem() const;
131 
135  bool onSystemByUser() const;
136 
140  bool onSystemByAuto() const;
141 
143  bool identIsAutoInstalled() const
144  { return identIsAutoInstalled( ident() ); }
146  static bool identIsAutoInstalled( const IdString & ident_r );
147 
151  bool multiversionInstall() const;
152 
154  bool isNeedreboot() const;
155 
175  bool isBlacklisted() const;
176 
178  bool isRetracted() const;
179 
181  bool isPtf() const;
182 
184  bool isPtfMaster() const;
185 
187  bool isPtfPackage() const;
189 
191  Date buildtime() const;
192 
194  Date installtime() const;
195 
196  public:
204  std::string asString() const;
205 
207  std::string asUserString() const;
208 
212  bool identical( const Solvable & rhs ) const;
213 
215  bool sameNVRA( const Solvable & rhs ) const
216  { return( get() == rhs.get() || ( ident() == rhs.ident() && edition() == rhs.edition() && arch() == rhs.arch() ) ); }
217 
218  public:
224  Capabilities provides() const;
225  Capabilities requires() const;
226  Capabilities conflicts() const;
227  Capabilities obsoletes() const;
228  Capabilities recommends() const;
229  Capabilities suggests() const;
230  Capabilities enhances() const;
231  Capabilities supplements() const;
232  Capabilities prerequires() const;
233 
235  Capabilities dep( Dep which_r ) const
236  {
237  switch( which_r.inSwitch() )
238  {
239  case Dep::PROVIDES_e: return provides(); break;
240  case Dep::REQUIRES_e: return requires(); break;
241  case Dep::CONFLICTS_e: return conflicts(); break;
242  case Dep::OBSOLETES_e: return obsoletes(); break;
243  case Dep::RECOMMENDS_e: return recommends(); break;
244  case Dep::SUGGESTS_e: return suggests(); break;
245  case Dep::ENHANCES_e: return enhances(); break;
246  case Dep::SUPPLEMENTS_e: return supplements(); break;
247  case Dep::PREREQUIRES_e: return prerequires(); break;
248  }
249  return Capabilities();
250  }
252  Capabilities operator[]( Dep which_r ) const
253  { return dep( which_r ); }
254 
255 
257  CapabilitySet providesNamespace( const std::string & namespace_r ) const;
258 
266  CapabilitySet valuesOfNamespace( const std::string & namespace_r ) const;
268 
269  std::pair<bool, CapabilitySet> matchesSolvable ( const SolvAttr &attr, const sat::Solvable &solv ) const;
270 
271  public:
275  bool supportsLocales() const;
277  bool supportsLocale( const Locale & locale_r ) const;
279  bool supportsLocale( const LocaleSet & locales_r ) const;
283  bool supportsRequestedLocales() const;
285  LocaleSet getSupportedLocales() const;
287  void getSupportedLocales( LocaleSet & locales_r ) const
288  { locales_r = getSupportedLocales(); }
290 
291  public:
293  CpeId cpeId() const;
294 
296  unsigned mediaNr() const;
297 
319  ByteCount installSize() const;
320 
322  ByteCount downloadSize() const;
323 
325  std::string distribution() const;
326 
328  std::string summary( const Locale & lang_r = Locale() ) const;
329 
331  std::string description( const Locale & lang_r = Locale() ) const;
332 
334  std::string insnotify( const Locale & lang_r = Locale() ) const;
336  std::string delnotify( const Locale & lang_r = Locale() ) const;
337 
339  std::string licenseToConfirm( const Locale & lang_r = Locale() ) const;
341  bool needToAcceptLicense() const;
342 
343  public:
350  {
351  public:
353  SplitIdent( IdString ident_r );
354  SplitIdent( const char * ident_r );
355  SplitIdent( const std::string & ident_r );
356  SplitIdent( ResKind kind_r, IdString name_r );
357  SplitIdent( ResKind kind_r, const C_Str & name_r );
358 
359  IdString ident() const { return _ident; }
360  ResKind kind() const { return _kind; }
361  IdString name() const { return _name; }
362 
363  private:
367  };
368 
369  public:
379  std::string lookupStrAttribute( const SolvAttr & attr ) const;
390  std::string lookupStrAttribute( const SolvAttr & attr, const Locale & lang_r ) const;
391 
396  unsigned long long lookupNumAttribute( const SolvAttr & attr ) const;
398  unsigned long long lookupNumAttribute( const SolvAttr & attr, unsigned long long notfound_r ) const;
399 
404  bool lookupBoolAttribute( const SolvAttr & attr ) const;
405 
410  detail::IdType lookupIdAttribute( const SolvAttr & attr ) const;
411 
416  CheckSum lookupCheckSumAttribute( const SolvAttr & attr ) const;
417 
422  OnMediaLocation lookupLocation() const;
424 
425  public:
427  Solvable nextInPool() const;
429  Solvable nextInRepo() const;
431  detail::CSolvable * get() const;
433  IdType id() const { return _id; }
434 
435  private:
437  };
439 
441  std::ostream & operator<<( std::ostream & str, const Solvable & obj ) ZYPP_API;
442 
444  std::ostream & dumpOn( std::ostream & str, const Solvable & obj ) ZYPP_API;
445 
447  std::ostream & dumpAsXmlOn( std::ostream & str, const Solvable & obj ) ZYPP_API;
448 
450  inline bool operator==( const Solvable & lhs, const Solvable & rhs )
451  { return lhs.get() == rhs.get(); }
452 
454  inline bool operator!=( const Solvable & lhs, const Solvable & rhs )
455  { return lhs.get() != rhs.get(); }
456 
458  inline bool operator<( const Solvable & lhs, const Solvable & rhs )
459  { return lhs.get() < rhs.get(); }
460 
462  template<class TRes>
463  inline bool isKind( const Solvable & solvable_r )
464  { return solvable_r.isKind( ResTraits<TRes>::kind ); }
465 
467  inline bool identical( const Solvable & lhs, const Solvable & rhs )
468  { return lhs.identical( rhs ); }
469 
471  inline bool sameNVRA( const Solvable & lhs, const Solvable & rhs )
472  { return lhs.sameNVRA( rhs ); }
473 
474 
476  inline int compareByN( const Solvable & lhs, const Solvable & rhs )
477  {
478  int res = 0;
479  if ( lhs != rhs )
480  {
481  if ( (res = lhs.kind().compare( rhs.kind() )) == 0 )
482  res = lhs.name().compare( rhs.name() );
483  }
484  return res;
485  }
486 
488  inline int compareByNVR( const Solvable & lhs, const Solvable & rhs )
489  {
490  int res = compareByN( lhs, rhs );
491  if ( res == 0 )
492  res = lhs.edition().compare( rhs.edition() );
493  return res;
494  }
495 
497  inline int compareByNVRA( const Solvable & lhs, const Solvable & rhs )
498  {
499  int res = compareByNVR( lhs, rhs );
500  if ( res == 0 )
501  res = lhs.arch().compare( rhs.arch() );
502  return res;
503  }
504 
506  namespace detail
507  {
514  class SolvableIterator : public boost::iterator_adaptor<
515  SolvableIterator // Derived
516  , CSolvable* // Base
517  , const Solvable // Value
518  , boost::forward_traversal_tag // CategoryOrTraversal
519  , const Solvable // Reference
520  >
521  {
522  public:
524  : SolvableIterator::iterator_adaptor_( nullptr )
525  {}
526 
527  explicit SolvableIterator( const Solvable & val_r )
528  : SolvableIterator::iterator_adaptor_( nullptr )
529  { initialAssignVal( val_r ); }
530 
532  : SolvableIterator::iterator_adaptor_( nullptr )
533  { initialAssignVal( Solvable(id_r) ); }
534 
535  private:
537 
539  { return _val; }
540 
541  void increment()
542  { assignVal( _val.nextInPool() ); }
543 
544  private:
545  void initialAssignVal( const Solvable & val_r )
546  { assignVal( val_r ? val_r : val_r.nextInPool() ); }
547 
548  void assignVal( const Solvable & val_r )
549  { _val = val_r; base_reference() = _val.get(); }
550 
552  };
553  } // namespace detail
555  } // namespace sat
557 
558  class PoolItem;
560  namespace sat
561  {
567  {
569 
570  Solvable operator()( const Solvable & solv_r ) const
571  { return solv_r; }
572 
573  Solvable operator()( const PoolItem & pi_r ) const;
574 
575  Solvable operator()( const ResObject_constPtr & res_r ) const;
576  };
577  } // namespace sat
579 } // namespace zypp
581 
583 
584 #endif // ZYPP_SAT_SOLVABLE_H
static const SolvableIdType noSolvableId(0)
Id to denote Solvable::noSolvable.
std::string asString(const Patch::Category &obj)
Definition: Patch.cc:122
bool sameNVRA(const Solvable &rhs) const
Test for same name-version-release.arch.
Definition: Solvable.h:215
bool isKind(const ResKind &val_r)
Convenient test for ResKinds.
Definition: ResTraits.h:140
std::string name() const
The name (without any ResKind prefix).
Definition: Solvable.cc:330
static const IdString ptfMasterToken
Indicator provides ptf()
Definition: Solvable.h:59
A Solvable object within the sat Pool.
Definition: Solvable.h:53
IdType id() const
Expert backdoor.
Definition: Solvable.h:433
ResKind kind() const
The Solvables ResKind.
Definition: Solvable.cc:276
Container of Capability (currently read only).
Definition: Capabilities.h:35
Describes a resource file located on a medium.
SolvableIterator(const Solvable &val_r)
Definition: Solvable.h:527
Enumeration class of dependency types.
Definition: Dep.h:29
bool isKind(TIterator begin, TIterator end) const
Definition: Solvable.h:107
bool isKind(const Solvable &solvable_r)
Definition: Solvable.h:463
Architecture.
Definition: Arch.h:36
Store and operate with byte count.
Definition: ByteCount.h:31
std::unordered_set< Locale > LocaleSet
Definition: Locale.h:29
sat::SolvAttr attr
Definition: PoolQuery.cc:312
std::ostream & operator<<(std::ostream &str, const FileConflicts &obj)
bool operator==(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:450
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:28
ZYPP_DEFINE_ID_HASHABLE(::zypp::sat::Solvable)
String related utilities and Regular expression matching.
bool isKind(const ResKind &kind_r) const
Test whether a Solvable is of a certain ResKind.
Definition: Solvable.cc:303
int IdType
Generic Id type.
Definition: PoolMember.h:104
What is known about a repository.
Definition: RepoInfo.h:71
Access to the sat-pools string space.
Definition: IdString.h:43
Common Platform Enumearation (2.3) See http://cpe.mitre.org/ for more information on the Common Platf...
Definition: CpeId.h:32
Edition represents [epoch:]version[-release]
Definition: Edition.h:60
ResTraits.
Definition: ResTraits.h:79
Iterate over valid Solvables in the pool.
Definition: Solvable.h:514
int compare(const Arch &rhs) const
Arch comparison.
Definition: Arch.cc:560
bool identical(const Solvable &rhs) const
Test whether two Solvables have the same content.
Definition: Solvable.cc:468
bool compareByN(const SolvableType< Derived > &lhs, const Solvable &rhs)
Definition: SolvableType.h:246
std::string asUserString(VendorSupportOption opt)
converts the support option to a name intended to be printed to the user.
static const Solvable noSolvable
Represents no Solvable.
Definition: Solvable.h:80
int compareByNVRA(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:497
bool identical(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:467
bool sameNVRA(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:471
static int compare(const Derived &lhs, const Derived &rhs)
Definition: IdStringType.h:134
static const IdString ptfPackageToken
Indicator provides ptf-package()
Definition: Solvable.h:60
::s_Solvable CSolvable
Wrapped libsolv C data type exposed as backdoor.
Definition: PoolMember.h:64
bool isKind() const
Definition: Solvable.h:103
Store and operate on date (time_t).
Definition: Date.h:32
bool identIsAutoInstalled() const
Whether an installed solvable with the same ident is flagged as AutoInstalled.
Definition: Solvable.h:143
Solvable attribute keys.
Definition: SolvAttr.h:40
Backlink to the associated PoolImpl.
Definition: PoolMember.h:88
for_use_in_switch inSwitch() const
Enumarator provided for use in switch statement.
Definition: Dep.h:89
Edition edition() const
The edition (version-release).
Definition: Solvable.cc:338
const Arch Arch_armv7hnl Arch_armv7nhl ZYPP_API
Definition: ResTraits.h:93
Convenience char* constructible from std::string and char*, it maps (char*)0 to an empty string...
Definition: String.h:90
bool identical(const SolvableType< Derived > &lhs, const Solvable &rhs)
Definition: SolvableType.h:219
int compareByNVR(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:488
Arch arch() const
The architecture.
Definition: Solvable.cc:344
void getSupportedLocales(LocaleSet &locales_r) const
Definition: Solvable.h:287
Capabilities operator[](Dep which_r) const
Definition: Solvable.h:252
void initialAssignVal(const Solvable &val_r)
Definition: Solvable.h:545
void assignVal(const Solvable &val_r)
Definition: Solvable.h:548
std::ostream & dumpOn(std::ostream &str, const LocaleSupport &obj)
Solvable nextInPool() const
Return next Solvable in Pool (or noSolvable).
Definition: Solvable.cc:114
&#39;Language[_Country]&#39; codes.
Definition: Locale.h:50
std::unordered_set< Capability > CapabilitySet
Definition: Capability.h:35
detail::CSolvable * get() const
Expert backdoor.
Definition: Solvable.cc:107
friend class boost::iterator_core_access
Definition: Solvable.h:536
bool compareByNVR(const SolvableType< Derived > &lhs, const Solvable &rhs)
Definition: SolvableType.h:260
Solvable()
Default ctor creates noSolvable.
Definition: Solvable.h:64
SolvableIterator(SolvableIdType id_r)
Definition: Solvable.h:531
sat::detail::SolvableIdType IdType
Definition: Solvable.h:56
Helper that splits an identifier into kind and name or vice versa.
Definition: Solvable.h:349
Capabilities dep(Dep which_r) const
Return Capabilities selected by Dep constant.
Definition: Solvable.h:235
int compareByN(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:476
bool operator<(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:458
unsigned int SolvableIdType
Id type to connect Solvable and sat-solvable.
Definition: PoolMember.h:125
Solvable operator()(const Solvable &solv_r) const
Definition: Solvable.h:570
Combining sat::Solvable and ResStatus.
Definition: PoolItem.h:50
static const IdString retractedToken
Indicator provides retracted-patch-package()
Definition: Solvable.h:58
std::ostream & dumpAsXmlOn(std::ostream &str, const FileConflicts &obj)
Resolvable kinds.
Definition: ResKind.h:32
To Solvable transform functor.
Definition: Solvable.h:566
Easy-to use interface to the ZYPP dependency resolver.
Definition: Application.cc:19
IdString ident() const
The identifier.
Definition: Solvable.cc:270
bool operator!=(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:454