libzypp  17.37.5
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 dep_provides() const;
225  Capabilities dep_requires() const;
226  Capabilities dep_conflicts() const;
227  Capabilities dep_obsoletes() const;
228  Capabilities dep_recommends() const;
229  Capabilities dep_suggests() const;
230  Capabilities dep_enhances() const;
231  Capabilities dep_supplements() const;
232  Capabilities dep_prerequires() const;
233 
234 #if __cplusplus < 202002L
235  Capabilities provides() const ZYPP_DEPRECATED; // use dep_ prefixed version instead
236  Capabilities requires() const ZYPP_DEPRECATED; // use dep_ prefixed version instead
237  Capabilities conflicts() const ZYPP_DEPRECATED; // use dep_ prefixed version instead
238  Capabilities obsoletes() const ZYPP_DEPRECATED; // use dep_ prefixed version instead
239  Capabilities recommends() const ZYPP_DEPRECATED; // use dep_ prefixed version instead
240  Capabilities suggests() const ZYPP_DEPRECATED; // use dep_ prefixed version instead
241  Capabilities enhances() const ZYPP_DEPRECATED; // use dep_ prefixed version instead
242  Capabilities supplements() const ZYPP_DEPRECATED; // use dep_ prefixed version instead
243  Capabilities prerequires() const ZYPP_DEPRECATED; // use dep_ prefixed version instead
244 #endif
245 
247  Capabilities dep( Dep which_r ) const
248  {
249  switch( which_r.inSwitch() )
250  {
251  case Dep::PROVIDES_e: return dep_provides(); break;
252  case Dep::REQUIRES_e: return dep_requires(); break;
253  case Dep::CONFLICTS_e: return dep_conflicts(); break;
254  case Dep::OBSOLETES_e: return dep_obsoletes(); break;
255  case Dep::RECOMMENDS_e: return dep_recommends(); break;
256  case Dep::SUGGESTS_e: return dep_suggests(); break;
257  case Dep::ENHANCES_e: return dep_enhances(); break;
258  case Dep::SUPPLEMENTS_e: return dep_supplements(); break;
259  case Dep::PREREQUIRES_e: return dep_prerequires(); break;
260  }
261  return Capabilities();
262  }
264  Capabilities operator[]( Dep which_r ) const
265  { return dep( which_r ); }
266 
267 
269  CapabilitySet providesNamespace( const std::string & namespace_r ) const;
270 
278  CapabilitySet valuesOfNamespace( const std::string & namespace_r ) const;
280 
281  std::pair<bool, CapabilitySet> matchesSolvable ( const SolvAttr &attr, const sat::Solvable &solv ) const;
282 
283  public:
287  bool supportsLocales() const;
289  bool supportsLocale( const Locale & locale_r ) const;
291  bool supportsLocale( const LocaleSet & locales_r ) const;
295  bool supportsRequestedLocales() const;
297  LocaleSet getSupportedLocales() const;
299  void getSupportedLocales( LocaleSet & locales_r ) const
300  { locales_r = getSupportedLocales(); }
302 
303  public:
305  CpeId cpeId() const;
306 
308  unsigned mediaNr() const;
309 
331  ByteCount installSize() const;
332 
334  ByteCount downloadSize() const;
335 
337  std::string distribution() const;
338 
340  std::string summary( const Locale & lang_r = Locale() ) const;
341 
343  std::string description( const Locale & lang_r = Locale() ) const;
344 
346  std::string insnotify( const Locale & lang_r = Locale() ) const;
348  std::string delnotify( const Locale & lang_r = Locale() ) const;
349 
351  std::string licenseToConfirm( const Locale & lang_r = Locale() ) const;
353  bool needToAcceptLicense() const;
354 
355  public:
362  {
363  public:
365  SplitIdent( IdString ident_r );
366  SplitIdent( const char * ident_r );
367  SplitIdent( const std::string & ident_r );
368  SplitIdent( ResKind kind_r, IdString name_r );
369  SplitIdent( ResKind kind_r, const C_Str & name_r );
370 
371  IdString ident() const { return _ident; }
372  ResKind kind() const { return _kind; }
373  IdString name() const { return _name; }
374 
375  private:
379  };
380 
381  public:
391  std::string lookupStrAttribute( const SolvAttr & attr ) const;
402  std::string lookupStrAttribute( const SolvAttr & attr, const Locale & lang_r ) const;
403 
408  unsigned long long lookupNumAttribute( const SolvAttr & attr ) const;
410  unsigned long long lookupNumAttribute( const SolvAttr & attr, unsigned long long notfound_r ) const;
411 
416  bool lookupBoolAttribute( const SolvAttr & attr ) const;
417 
422  detail::IdType lookupIdAttribute( const SolvAttr & attr ) const;
423 
428  CheckSum lookupCheckSumAttribute( const SolvAttr & attr ) const;
429 
434  OnMediaLocation lookupLocation() const;
436 
437  public:
439  Solvable nextInPool() const;
441  Solvable nextInRepo() const;
443  detail::CSolvable * get() const;
445  IdType id() const { return _id; }
446 
447  private:
449  };
451 
453  std::ostream & operator<<( std::ostream & str, const Solvable & obj ) ZYPP_API;
454 
456  std::ostream & dumpOn( std::ostream & str, const Solvable & obj ) ZYPP_API;
457 
459  std::ostream & dumpAsXmlOn( std::ostream & str, const Solvable & obj ) ZYPP_API;
460 
462  inline bool operator==( const Solvable & lhs, const Solvable & rhs )
463  { return lhs.get() == rhs.get(); }
464 
466  inline bool operator!=( const Solvable & lhs, const Solvable & rhs )
467  { return lhs.get() != rhs.get(); }
468 
470  inline bool operator<( const Solvable & lhs, const Solvable & rhs )
471  { return lhs.get() < rhs.get(); }
472 
474  template<class TRes>
475  inline bool isKind( const Solvable & solvable_r )
476  { return solvable_r.isKind( ResTraits<TRes>::kind ); }
477 
479  inline bool identical( const Solvable & lhs, const Solvable & rhs )
480  { return lhs.identical( rhs ); }
481 
483  inline bool sameNVRA( const Solvable & lhs, const Solvable & rhs )
484  { return lhs.sameNVRA( rhs ); }
485 
486 
488  inline int compareByN( const Solvable & lhs, const Solvable & rhs )
489  {
490  int res = 0;
491  if ( lhs != rhs )
492  {
493  if ( (res = lhs.kind().compare( rhs.kind() )) == 0 )
494  res = lhs.name().compare( rhs.name() );
495  }
496  return res;
497  }
498 
500  inline int compareByNVR( const Solvable & lhs, const Solvable & rhs )
501  {
502  int res = compareByN( lhs, rhs );
503  if ( res == 0 )
504  res = lhs.edition().compare( rhs.edition() );
505  return res;
506  }
507 
509  inline int compareByNVRA( const Solvable & lhs, const Solvable & rhs )
510  {
511  int res = compareByNVR( lhs, rhs );
512  if ( res == 0 )
513  res = lhs.arch().compare( rhs.arch() );
514  return res;
515  }
516 
518  namespace detail
519  {
526  class SolvableIterator : public boost::iterator_adaptor<
527  SolvableIterator // Derived
528  , CSolvable* // Base
529  , const Solvable // Value
530  , boost::forward_traversal_tag // CategoryOrTraversal
531  , const Solvable // Reference
532  >
533  {
534  public:
536  : SolvableIterator::iterator_adaptor_( nullptr )
537  {}
538 
539  explicit SolvableIterator( const Solvable & val_r )
540  : SolvableIterator::iterator_adaptor_( nullptr )
541  { initialAssignVal( val_r ); }
542 
544  : SolvableIterator::iterator_adaptor_( nullptr )
545  { initialAssignVal( Solvable(id_r) ); }
546 
547  private:
549 
551  { return _val; }
552 
553  void increment()
554  { assignVal( _val.nextInPool() ); }
555 
556  private:
557  void initialAssignVal( const Solvable & val_r )
558  { assignVal( val_r ? val_r : val_r.nextInPool() ); }
559 
560  void assignVal( const Solvable & val_r )
561  { _val = val_r; base_reference() = _val.get(); }
562 
564  };
565  } // namespace detail
567  } // namespace sat
569 
570  class PoolItem;
572  namespace sat
573  {
579  {
581 
582  Solvable operator()( const Solvable & solv_r ) const
583  { return solv_r; }
584 
585  Solvable operator()( const PoolItem & pi_r ) const;
586 
587  Solvable operator()( const ResObject_constPtr & res_r ) const;
588  };
589  } // namespace sat
591 } // namespace zypp
593 
595 
596 #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:445
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:539
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:475
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:462
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:27
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:526
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:259
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:509
bool identical(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:479
bool sameNVRA(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:483
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:91
bool identical(const SolvableType< Derived > &lhs, const Solvable &rhs)
Definition: SolvableType.h:232
int compareByNVR(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:500
Arch arch() const
The architecture.
Definition: Solvable.cc:344
void getSupportedLocales(LocaleSet &locales_r) const
Definition: Solvable.h:299
Capabilities operator[](Dep which_r) const
Definition: Solvable.h:264
void initialAssignVal(const Solvable &val_r)
Definition: Solvable.h:557
void assignVal(const Solvable &val_r)
Definition: Solvable.h:560
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:548
bool compareByNVR(const SolvableType< Derived > &lhs, const Solvable &rhs)
Definition: SolvableType.h:273
Solvable()
Default ctor creates noSolvable.
Definition: Solvable.h:64
SolvableIterator(SolvableIdType id_r)
Definition: Solvable.h:543
sat::detail::SolvableIdType IdType
Definition: Solvable.h:56
Helper that splits an identifier into kind and name or vice versa.
Definition: Solvable.h:361
Capabilities dep(Dep which_r) const
Return Capabilities selected by Dep constant.
Definition: Solvable.h:247
int compareByN(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:488
bool operator<(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:470
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:582
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:578
Easy-to use interface to the ZYPP dependency resolver.
Definition: Application.cc:19
#define ZYPP_DEPRECATED
The ZYPP_DEPRECATED macro can be used to trigger compile-time warnings with gcc >= 3...
Definition: Globals.h:112
IdString ident() const
The identifier.
Definition: Solvable.cc:270
bool operator!=(const Solvable &lhs, const Solvable &rhs)
Definition: Solvable.h:466