libzypp: zypp/ng/sat/solvable.h Source File

libzypp 17.38.11

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
17#include <zypp-core/ng/meta/type_traits.h>
18#include <zypp-core/ng/base/ranges.h>
19#include <zypp-core/ByteCount.h>
20#include <zypp-core/Date.h>
21#include <zypp-core/CheckSum.h>
22
23#include <zypp/ng/sat/poolconstants.h>
24#include <zypp/ng/sat/poolmember.h>
25#include <zypp/ng/sat/solvattr.h>
26#include <zypp/ng/restraits.h>
27#include <zypp/ng/idstring.h>
28#include <zypp/ng/edition.h>
29#include <zypp/ng/arch.h>
30#include <zypp/ng/cpeid.h>
31#include <zypp/ng/dep.h>
32#include <zypp/ng/sat/capabilities.h>
33#include <zypp/ng/sat/capability.h>
34#include <zypp/ng/reskind.h>
35#include <zypp/ng/locale.h>
36
37
38
39namespace zyppng
40{
42 namespace sat
43 {
44 class Solvable;
45
46 namespace detail {
47 template<> Pool & poolFromType( Solvable & );
48 template<> const Pool & poolFromType( const Solvable & );
49 }
50
65 class Solvable : public PoolMember<Solvable>
66 {
67 public:
68 using IdType = detail::SolvableIdType;
69
70 static const IdString patternToken;
71 static const IdString productToken;
72
73 static const IdString retractedToken;
74 static const IdString ptfMasterToken;
75 static const IdString ptfPackageToken;
76
77 public:
79 Solvable()
80 : _id( detail::noSolvableId )
81 {}
82
83 Solvable(const Solvable &) = default;
84 Solvable(Solvable &&) noexcept = default;
85 Solvable &operator=(const Solvable &) = default;
86 Solvable &operator=(Solvable &&) noexcept = default;
87
89 explicit Solvable( IdType id_r )
90 : _id( id_r )
91 {}
92
93 public:
95 static const Solvable noSolvable;
96
98 explicit operator bool() const
99 { return get(); }
100
101 public:
106 IdString ident()const;
107
109 ResKind kind()const;
110
115 bool isKind( const ResKind & kind_r ) const;
117 template<class TRes>
118 bool isKind() const
119 { return isKind( resKind<TRes>() ); }
120
121 template<class TIterator>
122 bool isKind( TIterator begin, TIterator end ) const
123 { return ranges::any_of( begin, end, [this]( const ResKind & k ){ return isKind(k); } ); }
124
125 bool isKind( std::initializer_list<ResKind> range ) const
126 { return isKind( range.begin(), range.end() ); }
127
129 std::string name() const;
130
132 Edition edition() const;
133
135 Arch arch() const;
136
138 IdString vendor() const;
139
141 detail::RepoIdType repository() const;
142
146 bool isSystem() const;
147
149 zypp::Date buildtime() const;
150
152 zypp::Date installtime() const;
153
157 bool identical( const Solvable & rhs ) const;
158
160 bool sameNVRA( const Solvable & rhs ) const
161 { return( get() == rhs.get() || ( ident() == rhs.ident() && edition() == rhs.edition() && arch() == rhs.arch() ) ); }
162
163 public:
169 Capabilities dep_provides() const;
170 Capabilities dep_requires() const;
171 Capabilities dep_conflicts() const;
172 Capabilities dep_obsoletes() const;
173 Capabilities dep_recommends() const;
174 Capabilities dep_suggests() const;
175 Capabilities dep_enhances() const;
176 Capabilities dep_supplements() const;
177 Capabilities dep_prerequires() const;
178
180 Capabilities dep( Dep which_r ) const
181 {
182 switch( which_r.inSwitch() )
183 {
184 case Dep::PROVIDES_e: return dep_provides(); break;
185 case Dep::REQUIRES_e: return dep_requires(); break;
186 case Dep::CONFLICTS_e: return dep_conflicts(); break;
187 case Dep::OBSOLETES_e: return dep_obsoletes(); break;
188 case Dep::RECOMMENDS_e: return dep_recommends(); break;
189 case Dep::SUGGESTS_e: return dep_suggests(); break;
190 case Dep::ENHANCES_e: return dep_enhances(); break;
191 case Dep::SUPPLEMENTS_e: return dep_supplements(); break;
192 case Dep::PREREQUIRES_e: return dep_prerequires(); break;
193 }
194 return Capabilities();
195 }
196
197 Capabilities operator[]( Dep which_r ) const
198 { return dep( which_r ); }
199
200
202 CapabilitySet providesNamespace( const std::string & namespace_r ) const;
203
211 CapabilitySet valuesOfNamespace( const std::string & namespace_r ) const;
213
214 std::pair<bool, CapabilitySet> matchesSolvable ( const SolvAttr &attr, const Solvable &solv ) const;
215
216 public:
219
220 bool supportsLocales() const;
222 bool supportsLocale( const Locale & locale_r ) const;
224 bool supportsLocale( const LocaleSet & locales_r ) const;
226 LocaleSet getSupportedLocales() const;
229 void getSupportedLocales( LocaleSet & locales_r ) const
230 { locales_r = getSupportedLocales(); }
231
232
233 public:
235 CpeId cpeId() const;
236
238 unsigned mediaNr() const;
239
261 zypp::ByteCount installSize() const;
262
264 zypp::ByteCount downloadSize() const;
265
267 std::string distribution() const;
268
270 std::string summary( const Locale & lang_r = Locale() ) const;
271
273 std::string description( const Locale & lang_r = Locale() ) const;
274
276 std::string insnotify( const Locale & lang_r = Locale() ) const;
278 std::string delnotify( const Locale & lang_r = Locale() ) const;
279
281 std::string licenseToConfirm( const Locale & lang_r = Locale() ) const;
283 bool needToAcceptLicense() const;
284
285 public:
291
295 std::string lookupStrAttribute( const SolvAttr & attr ) const;
306 std::string lookupStrAttribute( const SolvAttr & attr, const Locale & lang_r ) const;
307
312 unsigned long long lookupNumAttribute( const SolvAttr & attr ) const;
314 unsigned long long lookupNumAttribute( const SolvAttr & attr, unsigned long long notfound_r ) const;
315
320 bool lookupBoolAttribute( const SolvAttr & attr ) const;
321
326 detail::IdType lookupIdAttribute( const SolvAttr & attr ) const;
327
332 zypp::CheckSum lookupCheckSumAttribute( const SolvAttr & attr ) const;
333
334 public:
336 Solvable nextInPool() const;
338 Solvable nextInRepo() const;
340 detail::CSolvable * get() const;
342 IdType id() const { return _id; }
343
344 private:
345 IdType _id;
346 };
347
348
350 inline bool operator==( const Solvable & lhs, const Solvable & rhs )
351 { return lhs.get() == rhs.get(); }
352
354 inline bool operator!=( const Solvable & lhs, const Solvable & rhs )
355 { return lhs.get() != rhs.get(); }
356
358 inline bool operator<( const Solvable & lhs, const Solvable & rhs )
359 { return lhs.get() < rhs.get(); }
360
362 template<class TRes>
363 inline bool isKind( const Solvable & solvable_r )
364 { return solvable_r.isKind( ResTraits<TRes>::kind ); }
365
367 inline bool identical( const Solvable & lhs, const Solvable & rhs )
368 { return lhs.identical( rhs ); }
369
371 inline bool sameNVRA( const Solvable & lhs, const Solvable & rhs )
372 { return lhs.sameNVRA( rhs ); }
373
374
376 inline int compareByN( const Solvable & lhs, const Solvable & rhs )
377 {
378 int res = 0;
379 if ( lhs != rhs )
380 {
381 if ( (res = lhs.kind().compare( rhs.kind() )) == 0 )
382 res = lhs.name().compare( rhs.name() );
383 }
384 return res;
385 }
386
388 inline int compareByNVR( const Solvable & lhs, const Solvable & rhs )
389 {
390 int res = compareByN( lhs, rhs );
391 if ( res == 0 )
392 res = lhs.edition().compare( rhs.edition() );
393 return res;
394 }
395
397 inline int compareByNVRA( const Solvable & lhs, const Solvable & rhs )
398 {
399 int res = compareByNVR( lhs, rhs );
400 if ( res == 0 )
401 res = lhs.arch().compare( rhs.arch() );
402 return res;
403 }
404
406 namespace detail
407 {
414 class SolvableIterator
415 {
416 public:
417 using iterator_category = std::forward_iterator_tag;
418 using value_type = Solvable; // non-cv-qualified per [iterator.traits]; constness lives on reference
419 using difference_type = std::ptrdiff_t;
420 using pointer = void; // proxy-by-value: no stable address exists for a temporary
421 using reference = const Solvable; // operator* returns by value – read-only proxy
422
423 SolvableIterator()
424 : _base( nullptr )
425 {}
426
427 explicit SolvableIterator( const Solvable & val_r )
428 : _base( nullptr )
429 { initialAssignVal( val_r ); }
430
431 explicit SolvableIterator( SolvableIdType id_r )
432 : _base( nullptr )
433 { initialAssignVal( Solvable(id_r) ); }
434
435 reference operator*() const
436 { return _val; }
437
438 SolvableIterator & operator++()
439 { increment(); return *this; }
440
441 SolvableIterator operator++(int)
442 { SolvableIterator tmp = *this; increment(); return tmp; }
443
444 bool operator==( const SolvableIterator & rhs ) const
445 { return _base == rhs._base; }
446
447 bool operator!=( const SolvableIterator & rhs ) const
448 { return !(*this == rhs); }
449
450 CSolvable * const & base() const
451 { return _base; }
452
453 private:
454 void increment()
455 { assignVal( _val.nextInPool() ); }
456
457 void initialAssignVal( const Solvable & val_r )
458 { assignVal( val_r ? val_r : val_r.nextInPool() ); }
459
460 void assignVal( const Solvable & val_r )
461 { _val = val_r; _base = _val.get(); }
462
463 CSolvable * _base;
464 Solvable _val;
465 };
466 } // namespace detail
467
468 namespace detail {
469
470 template <typename T>
471 using satSolvable_t = decltype(std::declval<T>().satSolvable());
472
473 template <typename T>
474 constexpr bool has_satSolvable_v = std::is_detected_v<satSolvable_t, T>;
475
476 template <typename T, typename = void >
477 struct convert_to_solvable{
478 // static_assert to force specialization/implementation
479 static_assert( always_false_v<T>, "Type must have .satSolvable() or a specialization of detail::convert_to_solvable" );
480 };
481
482 template <typename T>
483 struct convert_to_solvable<T, std::void_t<satSolvable_t<T>>> {
484 template <typename SType = T>
485 static Solvable asSolvable( SType && obj ) {
486 return std::forward<SType>(obj).satSolvable();
487 }
488 };
489 }
490
495 struct asSolvable
496 {
497 using result_type = Solvable;
498
499 Solvable operator()( const Solvable & solv_r ) const
500 { return solv_r; }
501
502 template <typename T>
503 Solvable operator()( T&& obj )const {
504 return detail::convert_to_solvable<T>::asSolvable( std::forward<T>(obj));
505 }
506 };
507
508 } // namespace sat
509} // namespace zypp
510
511 ZYPP_DEFINE_ID_HASHABLE( ::zyppng::sat::Solvable );
512
513#endif // ZYPP_SAT_SOLVABLE_H
ByteCount.h
Date.h
ZYPP_DEFINE_ID_HASHABLE
#define ZYPP_DEFINE_ID_HASHABLE(C)
Define hash function for id based classes.
Definition Hash.h:26
arch.h
bool
zypp::Arch
Architecture.
Definition Arch.h:37
zypp::Arch::compare
int compare(const Arch &rhs) const
Arch comparison.
Definition Arch.cc:785
zypp::ByteCount
Store and operate with byte count.
Definition ByteCount.h:32
zypp::CheckSum
Definition CheckSum.h:34
zypp::CpeId
Common Platform Enumearation (2.3) See http://cpe.mitre.org/ for more information on the Common Platf...
Definition CpeId.h:33
zypp::Date
Store and operate on date (time_t).
Definition Date.h:33
zypp::Edition
Edition represents [epoch:]version[-release].
Definition Edition.h:60
zypp::IdString
Access to the sat-pools string space.
Definition IdString.h:55
zypp::Locale
'Language[_Country]' codes.
Definition Locale.h:51
zypp::ResKind
Resolvable kinds.
Definition ResKind.h:33
zypp::sat::SolvAttr
Solvable attribute keys.
Definition SolvAttr.h:41
zyppng::IdStringType::compare
static int compare(const Derived &lhs, const Derived &rhs)
Definition IdStringType.h:142
zyppng::sat::Capabilities
Container of Capability (currently read only).
Definition capabilities.h:33
zyppng::sat::PoolMember
Definition poolmember.h:28
zyppng::sat::Solvable
A Solvable object within the sat Pool.
Definition solvable.h:66
zyppng::sat::Solvable::lookupStrAttribute
std::string lookupStrAttribute(const SolvAttr &attr) const
returns the string attribute value for attr or an empty string if it does not exists.
Definition solvable.cc:108
zyppng::sat::Solvable::dep
Capabilities dep(Dep which_r) const
Return Capabilities selected by Dep constant.
Definition solvable.h:180
zyppng::sat::Solvable::ptfPackageToken
static const IdString ptfPackageToken
Indicator provides ptf-package().
Definition solvable.h:75
zyppng::sat::Solvable::get
detail::CSolvable * get() const
Expert backdoor.
Definition solvable.cc:77
zyppng::sat::Solvable::_id
IdType _id
Definition solvable.h:345
zyppng::sat::Solvable::lookupBoolAttribute
bool lookupBoolAttribute(const SolvAttr &attr) const
returns the boolean attribute value for attr or false if it does not exists.
Definition solvable.cc:148
zyppng::sat::Solvable::dep_conflicts
Capabilities dep_conflicts() const
Definition solvable.cc:345
zyppng::sat::Solvable::summary
std::string summary(const Locale &lang_r=Locale()) const
Short (singleline) text describing the solvable (opt.
Definition solvable.cc:575
zyppng::sat::Solvable::identical
bool identical(const Solvable &rhs) const
Test whether two Solvables have the same content.
Definition solvable.cc:318
zyppng::sat::Solvable::Solvable
Solvable()
Default ctor creates noSolvable.
Definition solvable.h:79
zyppng::sat::Solvable::name
std::string name() const
The name (without any ResKind prefix).
Definition solvable.cc:239
zyppng::sat::Solvable::needToAcceptLicense
bool needToAcceptLicense() const
True except for well known exceptions (i.e show license but no need to accept it).
zyppng::sat::Solvable::operator[]
Capabilities operator[](Dep which_r) const
Definition solvable.h:197
zyppng::sat::Solvable::isKind
bool isKind(TIterator begin, TIterator end) const
Definition solvable.h:122
zyppng::sat::Solvable::valuesOfNamespace
CapabilitySet valuesOfNamespace(const std::string &namespace_r) const
Return 'value[ op edition]' for namespaced provides 'namespace(value)[ op edition]'.
Definition solvable.cc:400
zyppng::sat::Solvable::Solvable
Solvable(const Solvable &)=default
zyppng::sat::Solvable::productToken
static const IdString productToken
Indicator provides product().
Definition solvable.h:71
zyppng::sat::Solvable::isKind
bool isKind(std::initializer_list< ResKind > range) const
Definition solvable.h:125
zyppng::sat::Solvable::kind
ResKind kind() const
The Solvables ResKind.
Definition solvable.cc:185
zyppng::sat::Solvable::cpeId
CpeId cpeId() const
The solvables CpeId if available.
Definition solvable.cc:538
zyppng::sat::Solvable::installSize
zypp::ByteCount installSize() const
Installed (unpacked) size.
Definition solvable.cc:557
zyppng::sat::Solvable::isKind
bool isKind() const
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition solvable.h:118
zyppng::sat::Solvable::retractedToken
static const IdString retractedToken
Indicator provides retracted-patch-package().
Definition solvable.h:73
zyppng::sat::Solvable::dep_prerequires
Capabilities dep_prerequires() const
Definition solvable.cc:375
zyppng::sat::Solvable::nextInPool
Solvable nextInPool() const
Return next Solvable in Pool (or noSolvable).
Definition solvable.cc:88
zyppng::sat::Solvable::patternToken
static const IdString patternToken
Indicator provides pattern().
Definition solvable.h:70
zyppng::sat::Solvable::isSystem
bool isSystem() const
Return whether this Solvable belongs to the system repo.
Definition solvable.cc:279
zyppng::sat::Solvable::sameNVRA
bool sameNVRA(const Solvable &rhs) const
Test for same name-version-release.arch.
Definition solvable.h:160
zyppng::sat::Solvable::delnotify
std::string delnotify(const Locale &lang_r=Locale()) const
UI hint text when selecting the solvable for uninstall (opt.
Definition solvable.cc:593
zyppng::sat::Solvable::dep_enhances
Capabilities dep_enhances() const
Definition solvable.cc:365
zyppng::sat::Solvable::licenseToConfirm
std::string licenseToConfirm(const Locale &lang_r=Locale()) const
License or agreement to accept before installing the solvable (opt.
zyppng::sat::Solvable::edition
Edition edition() const
The edition (version-release).
Definition solvable.cc:247
zyppng::sat::Solvable::supportsLocale
bool supportsLocale(const Locale &locale_r) const
Whether this Solvable supports a specific Locale.
Definition solvable.cc:514
zyppng::sat::Solvable::description
std::string description(const Locale &lang_r=Locale()) const
Long (multiline) text describing the solvable (opt.
Definition solvable.cc:581
zyppng::sat::Solvable::getSupportedLocales
LocaleSet getSupportedLocales() const
Return the supported locales.
Definition solvable.cc:528
zyppng::sat::Solvable::dep_requires
Capabilities dep_requires() const
Definition solvable.cc:340
zyppng::sat::Solvable::dep_supplements
Capabilities dep_supplements() const
Definition solvable.cc:370
zyppng::sat::Solvable::lookupIdAttribute
detail::IdType lookupIdAttribute(const SolvAttr &attr) const
returns the id attribute value for attr or detail::noId if it does not exists.
Definition solvable.cc:154
zyppng::sat::Solvable::ident
IdString ident() const
The identifier.
Definition solvable.cc:179
zyppng::sat::Solvable::installtime
zypp::Date installtime() const
The items install time (false if not installed).
Definition solvable.cc:291
zyppng::sat::Solvable::dep_obsoletes
Capabilities dep_obsoletes() const
Definition solvable.cc:350
zyppng::sat::Solvable::lookupNumAttribute
unsigned long long lookupNumAttribute(const SolvAttr &attr) const
returns the numeric attribute value for attr or 0 if it does not exists.
Definition solvable.cc:136
zyppng::sat::Solvable::dep_suggests
Capabilities dep_suggests() const
Definition solvable.cc:360
zyppng::sat::Solvable::IdType
detail::SolvableIdType IdType
Definition solvable.h:68
zyppng::sat::Solvable::id
IdType id() const
Expert backdoor.
Definition solvable.h:342
zyppng::sat::Solvable::insnotify
std::string insnotify(const Locale &lang_r=Locale()) const
UI hint text when selecting the solvable for install (opt.
Definition solvable.cc:587
zyppng::sat::Solvable::lookupCheckSumAttribute
zypp::CheckSum lookupCheckSumAttribute(const SolvAttr &attr) const
returns the CheckSum attribute value for attr or an empty CheckSum if ir does not exist.
Definition solvable.cc:160
zyppng::sat::Solvable::dep_recommends
Capabilities dep_recommends() const
Definition solvable.cc:355
zyppng::sat::Solvable::dep_provides
Capabilities dep_provides() const
Definition solvable.cc:335
zyppng::sat::Solvable::providesNamespace
CapabilitySet providesNamespace(const std::string &namespace_r) const
Return the namespaced provides 'namespace([value])[ op edition]' of this Solvable.
Definition solvable.cc:384
zyppng::sat::Solvable::distribution
std::string distribution() const
The distribution string.
Definition solvable.cc:569
zyppng::sat::Solvable::noSolvable
static const Solvable noSolvable
Represents no Solvable.
Definition solvable.h:95
zyppng::sat::Solvable::arch
Arch arch() const
The architecture.
Definition solvable.cc:253
zyppng::sat::Solvable::downloadSize
zypp::ByteCount downloadSize() const
Download size.
Definition solvable.cc:563
zyppng::sat::Solvable::isKind
bool isKind(const ResKind &kind_r) const
Test whether a Solvable is of a certain ResKind.
Definition solvable.cc:212
zyppng::sat::Solvable::vendor
IdString vendor() const
The vendor.
Definition solvable.cc:267
zyppng::sat::Solvable::nextInRepo
Solvable nextInRepo() const
Return next Solvable in Repo (or noSolvable).
Definition solvable.cc:94
zyppng::sat::Solvable::repository
detail::RepoIdType repository() const
The repo id this Solvable belongs to.
Definition solvable.cc:273
zyppng::sat::Solvable::buildtime
zypp::Date buildtime() const
The items build time.
Definition solvable.cc:285
zyppng::sat::Solvable::Solvable
Solvable(Solvable &&) noexcept=default
zyppng::sat::Solvable::mediaNr
unsigned mediaNr() const
Media number the solvable is located on (0 if no media access required).
Definition solvable.cc:544
zyppng::sat::Solvable::matchesSolvable
std::pair< bool, CapabilitySet > matchesSolvable(const SolvAttr &attr, const Solvable &solv) const
Definition solvable.cc:421
zyppng::sat::Solvable::ptfMasterToken
static const IdString ptfMasterToken
Indicator provides ptf().
Definition solvable.h:74
zyppng::sat::Solvable::supportsLocales
bool supportsLocales() const
Whether this Solvable claims to support locales.
Definition solvable.cc:508
zyppng::sat::detail::SolvableIterator::increment
void increment()
Definition solvable.h:454
zyppng::sat::detail::SolvableIterator::base
CSolvable *const & base() const
Definition solvable.h:450
zyppng::sat::detail::SolvableIterator::SolvableIterator
SolvableIterator()
Definition solvable.h:423
zyppng::sat::detail::SolvableIterator::operator==
bool operator==(const SolvableIterator &rhs) const
Definition solvable.h:444
zyppng::sat::detail::SolvableIterator::reference
const Solvable reference
Definition solvable.h:421
zyppng::sat::detail::SolvableIterator::SolvableIterator
SolvableIterator(const Solvable &val_r)
Definition solvable.h:427
zyppng::sat::detail::SolvableIterator::_val
Solvable _val
Definition solvable.h:464
zyppng::sat::detail::SolvableIterator::initialAssignVal
void initialAssignVal(const Solvable &val_r)
Definition solvable.h:457
zyppng::sat::detail::SolvableIterator::operator++
SolvableIterator & operator++()
Definition solvable.h:438
zyppng::sat::detail::SolvableIterator::_base
CSolvable * _base
Definition solvable.h:463
zyppng::sat::detail::SolvableIterator::operator*
reference operator*() const
Definition solvable.h:435
zyppng::sat::detail::SolvableIterator::operator!=
bool operator!=(const SolvableIterator &rhs) const
Definition solvable.h:447
zyppng::sat::detail::SolvableIterator::SolvableIterator
SolvableIterator(SolvableIdType id_r)
Definition solvable.h:431
zyppng::sat::detail::SolvableIterator::assignVal
void assignVal(const Solvable &val_r)
Definition solvable.h:460
zyppng::sat::detail::SolvableIterator::difference_type
std::ptrdiff_t difference_type
Definition solvable.h:419
zyppng::sat::detail::SolvableIterator::iterator_category
std::forward_iterator_tag iterator_category
Definition solvable.h:417
zyppng::sat::detail::SolvableIterator::pointer
void pointer
Definition solvable.h:420
zyppng::sat::detail::SolvableIterator::value_type
Solvable value_type
Definition solvable.h:418
zyppng::sat::detail::SolvableIterator::operator++
SolvableIterator operator++(int)
Definition solvable.h:441
cpeid.h
dep.h
edition.h
locale.h
std
Definition ansi.h:855
std::is_detected_v
constexpr bool is_detected_v
Definition type_traits.h:57
zypp::sat::compareByN
int compareByN(const Solvable &lhs, const Solvable &rhs)
relates: Solvable Compare according to kind and name.
Definition Solvable.h:507
zypp::sat::identical
bool identical(const Solvable &lhs, const Solvable &rhs)
relates: Solvable Test for same content.
Definition Solvable.h:498
zypp::sat::operator!=
bool operator!=(const FileConflicts &lhs, const FileConflicts &rhs)
relates: FileConflicts
Definition FileConflicts.h:89
zypp::sat::isKind
bool isKind(const Solvable &solvable_r)
relates: Solvable Test whether a Solvable is of a certain Kind.
Definition Solvable.h:494
zypp::sat::operator<
bool operator<(const LocaleSupport &lhs, const LocaleSupport &rhs)
relates: LocaleSupport
Definition LocaleSupport.h:120
zypp::sat::operator==
bool operator==(const FileConflicts &lhs, const FileConflicts &rhs)
relates: FileConflicts
Definition FileConflicts.h:85
zypp::sat::sameNVRA
bool sameNVRA(const Solvable &lhs, const Solvable &rhs)
relates: Solvable Test for same name version release and arch.
Definition Solvable.h:502
zypp::sat::compareByNVRA
int compareByNVRA(const Solvable &lhs, const Solvable &rhs)
relates: Solvable Compare according to kind, name, edition and arch.
Definition Solvable.h:528
zypp::sat::compareByNVR
int compareByNVR(const Solvable &lhs, const Solvable &rhs)
relates: Solvable Compare according to kind, name and edition.
Definition Solvable.h:519
zypp::LocaleSet
std::unordered_set< Locale > LocaleSet
Definition Locale.h:29
zypp::always_false_v
constexpr bool always_false_v
Definition LogControl.cc:60
zypp::resKind
ResKind resKind()
Convenient access to well known ResKinds.
Definition ResTraits.h:129
zyppng::detail
Definition reporthelper.h:31
zyppng::sat::detail
CLASS NAME : detail::DIWrap.
Definition cap2str.cc:14
zyppng::sat::detail::CSolvable
zypp::sat::detail::CSolvable CSolvable
Definition poolconstants.h:39
zyppng::sat::detail::RepoIdType
zypp::sat::detail::RepoIdType RepoIdType
Definition poolconstants.h:45
zyppng::sat::detail::poolFromType
Pool & poolFromType(T &)
zyppng::sat::detail::SolvableIdType
zypp::sat::detail::SolvableIdType SolvableIdType
Definition poolconstants.h:44
zyppng::sat::detail::satSolvable_t
decltype(std::declval< T >().satSolvable()) satSolvable_t
Definition solvable.h:471
zyppng::sat::detail::IdType
zypp::sat::detail::IdType IdType
Definition poolconstants.h:43
zyppng::sat::detail::has_satSolvable_v
constexpr bool has_satSolvable_v
Definition solvable.h:474
zyppng::sat
This file contains private API, this might break at any time between releases.
Definition capabilities.h:22
zyppng::sat::CapabilitySet
std::unordered_set< Capability > CapabilitySet
Definition capability.h:35
zyppng
Definition MediaNetworkRequestExecutor.h:16
poolconstants.h
poolmember.h
ranges.h
Namespace routing for C++20 ranges and C++23 ranges::to<T>() backport.
reskind.h
restraits.h
capabilities.h
capability.h
solvattr.h
zypp::Dep
Enumeration class of dependency types.
Definition Dep.h:31
zypp::Dep::inSwitch
for_use_in_switch inSwitch() const
Enumarator provided for use in switch statement.
Definition Dep.h:90
zypp::ResTraits
ResTraits.
Definition ResTraits.h:80
zyppng::Dep::SUGGESTS_e
@ SUGGESTS_e
Definition Dep.h:64
zyppng::Dep::REQUIRES_e
@ REQUIRES_e
Definition Dep.h:60
zyppng::Dep::PREREQUIRES_e
@ PREREQUIRES_e
Definition Dep.h:59
zyppng::Dep::RECOMMENDS_e
@ RECOMMENDS_e
Definition Dep.h:63
zyppng::Dep::SUPPLEMENTS_e
@ SUPPLEMENTS_e
Definition Dep.h:66
zyppng::Dep::PROVIDES_e
@ PROVIDES_e
Definition Dep.h:58
zyppng::Dep::CONFLICTS_e
@ CONFLICTS_e
Definition Dep.h:61
zyppng::Dep::ENHANCES_e
@ ENHANCES_e
Definition Dep.h:65
zyppng::Dep::OBSOLETES_e
@ OBSOLETES_e
Definition Dep.h:62
zyppng::sat::asSolvable
To Solvable transform functor.
Definition solvable.h:496
zyppng::sat::asSolvable::operator()
Solvable operator()(T &&obj) const
Definition solvable.h:503
zyppng::sat::asSolvable::operator()
Solvable operator()(const Solvable &solv_r) const
Definition solvable.h:499
zyppng::sat::asSolvable::result_type
Solvable result_type
Definition solvable.h:497
zyppng::sat::detail::convert_to_solvable< T, std::void_t< satSolvable_t< T > > >::asSolvable
static Solvable asSolvable(SType &&obj)
Definition solvable.h:485
zyppng::sat::detail::convert_to_solvable
Definition solvable.h:477
type_traits.h
CheckSum.h
idstring.h