libzypp 17.37.10

Selectable.cc
Go to the documentation of this file.
1/*---------------------------------------------------------------------\
2| ____ _ __ __ ___ |
3| |__ / \ / / . \ . \ |
4| / / \ V /| _/ _/ |
5| / /__ | | | | | | |
6| /_____||_| |_| |_| |
7| |
8\---------------------------------------------------------------------*/
12#include <iostream>
13#include <utility>
14//#include <zypp/base/Logger.h>
15
16#include <zypp/ui/Selectable.h>
17#include <zypp/ui/SelectableImpl.h>
18#include <zypp/ResPool.h>
19
21 namespace zypp
22{
24 namespace ui
25 {
26
27 IMPL_PTR_TYPE(Selectable);
28
29 Selectable::Ptr Selectable::get( const pool::ByIdent & ident_r )
30 { return ResPool::instance().proxy().lookup( ident_r ); }
31
33 //
34 // METHOD NAME : Selectable::Selectable
35 // METHOD TYPE : Ctor
36 //
37 Selectable::Selectable( Impl_Ptr pimpl_r )
38 : _pimpl( std::move(pimpl_r) )
39 {}
40
42 //
43 // METHOD NAME : Selectable::~Selectable
44 // METHOD TYPE : Dtor
45 //
46 Selectable::~Selectable()
47 {}
48
50 //
51 // Forward to implementation.
52 // Restrict PoolItems to ResObject::constPtr!
53 //
55
56 IdString Selectable::ident() const
57 { return _pimpl->ident(); }
58
59 ResKind Selectable::kind() const
60 { return _pimpl->kind(); }
61
62 const std::string & Selectable::name() const
63 { return _pimpl->name(); }
64
65 Status Selectable::status() const
66 { return _pimpl->status(); }
67
68 bool Selectable::setStatus( Status state_r, ResStatus::TransactByValue causer_r )
69 { return _pimpl->setStatus( state_r, causer_r ); }
70
71 PoolItem Selectable::installedObj() const
72 { return _pimpl->installedObj(); }
73
74 PoolItem Selectable::candidateObj() const
75 { return _pimpl->candidateObj(); }
76
77 PoolItem Selectable::candidateObjFrom( Repository repo_r ) const
78 { return _pimpl->candidateObjFrom( repo_r ); }
79
80 PoolItem Selectable::updateCandidateObj() const
81 { return _pimpl->updateCandidateObj(); }
82
83 PoolItem Selectable::highestAvailableVersionObj() const
84 { return _pimpl->highestAvailableVersionObj(); }
85
86 bool Selectable::identIsAutoInstalled() const
87 { return _pimpl->identIsAutoInstalled(); }
88
89 bool Selectable::identicalAvailable( const PoolItem & rhs ) const
90 { return _pimpl->identicalAvailable( rhs ); }
91
92 bool Selectable::identicalInstalled( const PoolItem & rhs ) const
93 { return _pimpl->identicalInstalled( rhs ); }
94
95 PoolItem Selectable::identicalAvailableObj( const PoolItem & rhs ) const
96 { return _pimpl->identicalAvailableObj( rhs ); }
97
98 PoolItem Selectable::identicalInstalledObj( const PoolItem & rhs ) const
99 { return _pimpl->identicalInstalledObj( rhs ); }
100
101 PoolItem Selectable::setCandidate( const PoolItem & newCandidate_r, ResStatus::TransactByValue causer_r )
102 { return _pimpl->setCandidate( newCandidate_r, causer_r ); }
103
104 PoolItem Selectable::setCandidate( const ResObject::constPtr& newCandidate_r, ResStatus::TransactByValue causer_r )
105 { return _pimpl->setCandidate( PoolItem( newCandidate_r ), causer_r ); }
106
107 bool Selectable::setOnSystem( const PoolItem & newCandidate_r, ResStatus::TransactByValue causer_r )
108 {
109 if ( identicalInstalled( newCandidate_r ) )
110 return setFate( UNMODIFIED, causer_r );
111 return setCandidate( newCandidate_r, causer_r ) && setFate( TO_INSTALL, causer_r );
112 }
113
114 PoolItem Selectable::theObj() const
115 { return _pimpl->theObj(); }
116
117 std::vector<std::string> Selectable::supersededBy() const
118 { return _pimpl->supersededBy(); }
119
121
122 bool Selectable::availableEmpty() const
123 { return _pimpl->availableEmpty(); }
124
125 Selectable::available_size_type Selectable::availableSize() const
126 { return _pimpl->availableSize(); }
127
128 Selectable::available_iterator Selectable::availableBegin() const
129 { return _pimpl->availableBegin(); }
130
131 Selectable::available_iterator Selectable::availableEnd() const
132 { return _pimpl->availableEnd(); }
133
135
136 bool Selectable::installedEmpty() const
137 { return _pimpl->installedEmpty(); }
138
139 Selectable::installed_size_type Selectable::installedSize() const
140 { return _pimpl->installedSize(); }
141
142 Selectable::installed_iterator Selectable::installedBegin() const
143 { return _pimpl->installedBegin(); }
144
145 Selectable::installed_iterator Selectable::installedEnd() const
146 { return _pimpl->installedEnd(); }
147
149
150 bool Selectable::picklistEmpty() const
151 { return _pimpl->picklistEmpty(); }
152
153 Selectable::picklist_size_type Selectable::picklistSize() const
154 { return _pimpl->picklistSize(); }
155
156 Selectable::picklist_iterator Selectable::picklistBegin() const
157 { return _pimpl->picklistBegin(); }
158
159 Selectable::picklist_iterator Selectable::picklistEnd() const
160 { return _pimpl->picklistEnd(); }
161
162 Selectable::picklist_size_type Selectable::picklistPos( const PoolItem & pi_r ) const
163 { return picklistPos( pi_r.satSolvable() ); }
164
165 Selectable::picklist_size_type Selectable::picklistPos( const sat::Solvable & solv_r ) const
166 {
167 picklist_size_type idx = picklist_size_type(0);
168 for ( const auto & pi : picklist() )
169 {
170 if ( pi == solv_r )
171 return idx;
172 ++idx;
173 }
174 return picklistNoPos;
175 }
176
178
179 bool Selectable::hasBlacklisted() const
180 { return _pimpl->hasBlacklisted(); }
181
182 bool Selectable::hasBlacklistedInstalled() const
183 { return _pimpl->hasBlacklistedInstalled(); }
184
185 bool Selectable::hasRetracted() const
186 { return _pimpl->hasRetracted(); }
187
188 bool Selectable::hasRetractedInstalled() const
189 { return _pimpl->hasRetractedInstalled(); }
190
191 bool Selectable::hasPtf() const
192 { return _pimpl->hasPtf(); }
193
194 bool Selectable::hasPtfInstalled() const
195 { return _pimpl->hasPtfInstalled(); }
196
197
198 bool Selectable::isUnmaintained() const
199 { return _pimpl->isUnmaintained(); }
200
201 bool Selectable::multiversionInstall() const
202 { return _pimpl->multiversionInstall(); }
203
204 bool Selectable::pickInstall( const PoolItem & pi_r, ResStatus::TransactByValue causer_r, bool yesno_r )
205 { return _pimpl->pickInstall( pi_r, causer_r, yesno_r ); }
206
207 bool Selectable::pickDelete( const PoolItem & pi_r, ResStatus::TransactByValue causer_r, bool yesno_r )
208 { return _pimpl->pickDelete( pi_r, causer_r, yesno_r ); }
209
210 Status Selectable::pickStatus( const PoolItem & pi_r ) const
211 { return _pimpl->pickStatus( pi_r ); }
212
213 bool Selectable::setPickStatus( const PoolItem & pi_r, Status state_r, ResStatus::TransactByValue causer_r )
214 { return _pimpl->setPickStatus( pi_r, state_r, causer_r ); }
215
217
218 bool Selectable::isUndetermined() const
219 { return _pimpl->isUndetermined(); }
220
221 bool Selectable::isRelevant() const
222 { return _pimpl->isRelevant(); }
223
224 bool Selectable::isSatisfied() const
225 { return _pimpl->isSatisfied(); }
226
227 bool Selectable::isBroken() const
228 { return _pimpl->isBroken(); }
229
230 bool Selectable::isNeeded() const
231 {
232 return fate() == TO_INSTALL || ( ! locked() && isBroken() );
233 }
234
235 bool Selectable::isUnwanted() const
236 {
237 return locked() && isBroken() ;
238 }
239
240 ResStatus::TransactByValue Selectable::modifiedBy() const
241 { return _pimpl->modifiedBy(); }
242
243 bool Selectable::hasLicenceConfirmed() const
244 { return _pimpl->hasLicenceConfirmed(); }
245
246 void Selectable::setLicenceConfirmed( bool val_r )
247 { _pimpl->setLicenceConfirmed( val_r ); }
248
249 bool Selectable::hasLocks() const
250 { return _pimpl->hasLocks(); }
251
252 Selectable::Fate Selectable::fate() const
253 {
254 switch ( status() ) {
255 case S_Update:
256 case S_Install:
257 case S_AutoUpdate:
258 case S_AutoInstall:
259 return TO_INSTALL;
260 break;
261
262 case S_Del:
263 case S_AutoDel:
264 return TO_DELETE;
265 break;
266
267 case S_Protected:
268 case S_Taboo:
269 case S_KeepInstalled:
270 case S_NoInst:
271 break;
272 }
273 return UNMODIFIED;
274 };
275
276 bool Selectable::setFate( Fate fate_r, ResStatus::TransactByValue causer_r )
277 {
278 switch ( fate_r )
279 {
280 case TO_INSTALL:
281 return setStatus( hasInstalledObj() ? S_Update : S_Install, causer_r );
282 break;
283
284 case TO_DELETE:
285 return setStatus( S_Del, causer_r );
286 break;
287
288 case UNMODIFIED:
289 switch ( status() ) {
290 case S_Protected:
291 case S_Taboo:
292 return true;
293 break;
294 default:
295 return setStatus( hasInstalledObj() ? S_KeepInstalled : S_NoInst, causer_r );
296 break;
297 }
298 break;
299 }
300 return false;
301 }
302
303 bool Selectable::setInstalled( ResStatus::TransactByValue causer_r )
304 {
305 return( hasInstalledObj() || setStatus( S_Install, causer_r ) );
306 }
307
308 bool Selectable::setUpToDate( ResStatus::TransactByValue causer_r )
309 {
310 if ( ! hasInstalledObj() )
311 return setStatus( S_Install, causer_r );
312
313 PoolItem cand( candidateObj() );
314 if ( ! cand )
315 return true;
316
317 return( installedObj()->edition() >= cand->edition()
318 || setStatus( S_Update, causer_r ) );
319 }
320
321 bool Selectable::setDeleted( ResStatus::TransactByValue causer_r )
322 {
323 return( ! hasInstalledObj() || setStatus( S_Del, causer_r ) );
324 }
325
326 /******************************************************************
327 **
328 ** FUNCTION NAME : operator<<
329 ** FUNCTION TYPE : std::ostream &
330 */
331 std::ostream & operator<<( std::ostream & str, const Selectable & obj )
332 { return str << *(obj._pimpl); }
333
334 std::ostream & dumpOn( std::ostream & str, const Selectable & obj )
335 { return dumpOn( str, *(obj._pimpl) ); }
336
338 } // namespace ui
341} // namespace zypp
ResPool.h
SelectableImpl.h
Selectable.h
zypp::IdString
Access to the sat-pools string space.
Definition IdString.h:44
zypp::PoolItem
Combining sat::Solvable and ResStatus.
Definition PoolItem.h:51
zypp::Repository
Definition Repository.h:40
zypp::ResKind
Resolvable kinds.
Definition ResKind.h:33
zypp::ResObject::constPtr
TraitsType::constPtrType constPtr
Definition ResObject.h:43
zypp::ResPoolProxy::lookup
ui::Selectable::Ptr lookup(const pool::ByIdent &ident_r) const
Definition ResPoolProxy.cc:276
zypp::ResPool::instance
static ResPool instance()
Singleton ctor.
Definition ResPool.cc:38
zypp::ResPool::proxy
ResPoolProxy proxy() const
preliminary
Definition ResPool.cc:59
zypp::ResStatus::TransactByValue
TransactByValue
Definition ResStatus.h:108
zypp::pool::ByIdent
Main filter selecting PoolItems by name and kind.
Definition ByIdent.h:29
zypp::sat::Solvable
A Solvable object within the sat Pool.
Definition Solvable.h:54
zypp::ui::Selectable
Collects PoolItems of same kind and name.
Definition Selectable.h:53
zypp::ui::Selectable::hasRetractedInstalled
bool hasRetractedInstalled() const
True if this Selectable contains an installed retracted item.
Definition Selectable.cc:188
zypp::ui::Selectable::available_size_type
SelectableTraits::available_size_type available_size_type
Definition Selectable.h:63
zypp::ui::Selectable::setStatus
bool setStatus(Status state_r, ResStatus::TransactByValue causer_r=ResStatus::USER)
Try to set a new Status.
Definition Selectable.cc:68
zypp::ui::Selectable::availableEnd
available_iterator availableEnd() const
Definition Selectable.cc:131
zypp::ui::Selectable::hasPtfInstalled
bool hasPtfInstalled() const
True if this Selectable contains an installed ptf item.
Definition Selectable.cc:194
zypp::ui::Selectable::installed_size_type
SelectableTraits::installed_size_type installed_size_type
Definition Selectable.h:66
zypp::ui::Selectable::installed_iterator
SelectableTraits::installed_iterator installed_iterator
Definition Selectable.h:65
zypp::ui::Selectable::supersededBy
std::vector< std::string > supersededBy() const
The name(s) of the successor package if vendorSupport is VendorSupportSuperseded.
Definition Selectable.cc:117
zypp::ui::Selectable::installedSize
installed_size_type installedSize() const
Definition Selectable.cc:139
zypp::ui::Selectable::picklistBegin
picklist_iterator picklistBegin() const
Definition Selectable.cc:156
zypp::ui::Selectable::multiversionInstall
bool multiversionInstall() const
Whether at least one of the available packages has multiversionInstall set.
Definition Selectable.cc:201
zypp::ui::Selectable::picklist
Iterable< picklist_iterator > picklist() const
Definition Selectable.h:289
zypp::ui::Selectable::pickStatus
Status pickStatus(const PoolItem &pi_r) const
Compute the ui::Status for an individual PoolItem.
Definition Selectable.cc:210
zypp::ui::Selectable::isUnmaintained
bool isUnmaintained() const
True if this package has no replacement from the available repositories.
Definition Selectable.cc:198
zypp::ui::Selectable::picklistSize
picklist_size_type picklistSize() const
Definition Selectable.cc:153
zypp::ui::Selectable::setDeleted
bool setDeleted(ResStatus::TransactByValue causer_r=ResStatus::USER)
Take care the item gets deleted if it is installed.
Definition Selectable.cc:321
zypp::ui::Selectable::isSatisfied
bool isSatisfied() const
Whether a relevant patchs requirements are met.
Definition Selectable.cc:224
zypp::ui::Selectable::get
static Ptr get(const pool::ByIdent &ident_r)
Get the Selctable.
Definition Selectable.cc:29
zypp::ui::Selectable::installedBegin
installed_iterator installedBegin() const
Definition Selectable.cc:142
zypp::ui::Selectable::locked
bool locked() const
True if locked (subclass of unmodified).
Definition Selectable.h:476
zypp::ui::Selectable::availableSize
available_size_type availableSize() const
Definition Selectable.cc:125
zypp::ui::Selectable::picklistNoPos
static constexpr const picklist_size_type picklistNoPos
Returned by picklistPos if the Item does not belong to the picklist.
Definition Selectable.h:293
zypp::ui::Selectable::setLicenceConfirmed
void setLicenceConfirmed(bool val_r=true)
Set LicenceConfirmed bit.
Definition Selectable.cc:246
zypp::ui::Selectable::modifiedBy
ResStatus::TransactByValue modifiedBy() const
Return who caused the modification.
Definition Selectable.cc:240
zypp::ui::Selectable::installedObj
PoolItem installedObj() const
The last Installed object.
Definition Selectable.cc:71
zypp::ui::Selectable::highestAvailableVersionObj
PoolItem highestAvailableVersionObj() const
Simply the highest available version, ignoring priorities and policies.
Definition Selectable.cc:83
zypp::ui::Selectable::picklist_size_type
SelectableTraits::picklist_size_type picklist_size_type
Definition Selectable.h:69
zypp::ui::Selectable::hasLocks
bool hasLocks() const
True if it includes locked items (don't mix this with the locked status).
Definition Selectable.cc:249
zypp::ui::Selectable::hasRetracted
bool hasRetracted() const
True if this Selectable contains available retracted items.
Definition Selectable.cc:185
zypp::ui::Selectable::hasBlacklistedInstalled
bool hasBlacklistedInstalled() const
True if this Selectable contains an installed blacklisted item (retracted,ptf,...).
Definition Selectable.cc:182
zypp::ui::Selectable::picklistEnd
picklist_iterator picklistEnd() const
Definition Selectable.cc:159
zypp::ui::Selectable::setInstalled
bool setInstalled(ResStatus::TransactByValue causer_r=ResStatus::USER)
Take care the item gets installed if it is not.
Definition Selectable.cc:303
zypp::ui::Selectable::hasBlacklisted
bool hasBlacklisted() const
True if this Selectable contains available blacklisted items (retracted,ptf,...).
Definition Selectable.cc:179
zypp::ui::Selectable::Selectable
Selectable(Impl_Ptr pimpl_r)
Default ctor.
Definition Selectable.cc:37
zypp::ui::Selectable::_pimpl
RW_pointer< Impl > _pimpl
Pointer to implementation.
Definition Selectable.h:570
zypp::ui::Selectable::ident
IdString ident() const
The identifier.
Definition Selectable.cc:56
zypp::ui::Selectable::installedEnd
installed_iterator installedEnd() const
Definition Selectable.cc:145
zypp::ui::Selectable::updateCandidateObj
PoolItem updateCandidateObj() const
The best candidate for update, if there is one.
Definition Selectable.cc:80
zypp::ui::Selectable::candidateObjFrom
PoolItem candidateObjFrom(Repository repo_r) const
The best candidate provided by a specific Repository, if there is one.
Definition Selectable.cc:77
zypp::ui::Selectable::setUpToDate
bool setUpToDate(ResStatus::TransactByValue causer_r=ResStatus::USER)
Take care the item gets installed if it is not, or is older.
Definition Selectable.cc:308
zypp::ui::Selectable::name
const std::string & name() const
The ResObjects name.
Definition Selectable.cc:62
zypp::ui::Selectable::fate
Fate fate() const
Definition Selectable.cc:252
zypp::ui::Selectable::hasPtf
bool hasPtf() const
True if this Selectable contains available ptf items.
Definition Selectable.cc:191
zypp::ui::Selectable::Impl_Ptr
shared_ptr< Impl > Impl_Ptr
Definition Selectable.h:562
zypp::ui::Selectable::~Selectable
~Selectable() override
Dtor.
Definition Selectable.cc:46
zypp::ui::Selectable::theObj
PoolItem theObj() const
An object you could use as pars pro toto.
Definition Selectable.cc:114
zypp::ui::Selectable::availableEmpty
bool availableEmpty() const
Definition Selectable.cc:122
zypp::ui::Selectable::identIsAutoInstalled
bool identIsAutoInstalled() const
Whether this ident is flagged as AutoInstalled.
Definition Selectable.cc:86
zypp::ui::Selectable::availableBegin
available_iterator availableBegin() const
Definition Selectable.cc:128
zypp::ui::Selectable::Fate
Fate
Definition Selectable.h:458
zypp::ui::Selectable::UNMODIFIED
@ UNMODIFIED
Definition Selectable.h:460
zypp::ui::Selectable::TO_INSTALL
@ TO_INSTALL
Definition Selectable.h:461
zypp::ui::Selectable::TO_DELETE
@ TO_DELETE
Definition Selectable.h:459
zypp::ui::Selectable::pickInstall
bool pickInstall(const PoolItem &pi_r, ResStatus::TransactByValue causer_r=ResStatus::USER, bool yesno_r=true)
Select a specific available item for installation.
Definition Selectable.cc:204
zypp::ui::Selectable::setOnSystem
bool setOnSystem(const PoolItem &newCandidate_r, ResStatus::TransactByValue causer_r=ResStatus::USER)
Arrange the specified candidate (out of available objects) to be on system after commit.
Definition Selectable.cc:107
zypp::ui::Selectable::setCandidate
PoolItem setCandidate(const PoolItem &newCandidate_r, ResStatus::TransactByValue causer_r=ResStatus::USER)
Set a candidate (out of available objects).
Definition Selectable.cc:101
zypp::ui::Selectable::isRelevant
bool isRelevant() const
Returns true if the patch is relevant which means that at least one package of the patch is installed...
Definition Selectable.cc:221
zypp::ui::Selectable::isUnwanted
bool isUnwanted() const
Broken (needed) but locked patches.
Definition Selectable.cc:235
zypp::ui::Selectable::candidateObj
PoolItem candidateObj() const
The 'best' or 'most interesting' among all available objects.
Definition Selectable.cc:74
zypp::ui::Selectable::identicalAvailable
bool identicalAvailable(const PoolItem &rhs) const
True if rhs is installed and one with the same content is available.
Definition Selectable.cc:89
zypp::ui::Selectable::isBroken
bool isBroken() const
Whether a relevant patchs requirements are broken.
Definition Selectable.cc:227
zypp::ui::Selectable::hasInstalledObj
bool hasInstalledObj() const
True if installed object is present.
Definition Selectable.h:316
zypp::ui::Selectable::picklist_iterator
SelectableTraits::picklist_iterator picklist_iterator
Definition Selectable.h:68
zypp::ui::Selectable::setPickStatus
bool setPickStatus(const PoolItem &pi_r, Status state_r, ResStatus::TransactByValue causer_r=ResStatus::USER)
Assign a new status to a specific item.
Definition Selectable.cc:213
zypp::ui::Selectable::status
Status status() const
Return the current Status.
Definition Selectable.cc:65
zypp::ui::Selectable::hasLicenceConfirmed
bool hasLicenceConfirmed() const
Return value of LicenceConfirmed bit.
Definition Selectable.cc:243
zypp::ui::Selectable::identicalInstalled
bool identicalInstalled(const PoolItem &rhs) const
True if rhs has the same content as an installed one.
Definition Selectable.cc:92
zypp::ui::Selectable::identicalAvailableObj
PoolItem identicalAvailableObj(const PoolItem &rhs) const
Return an available Object with the same content as rhs.
Definition Selectable.cc:95
zypp::ui::Selectable::Ptr
intrusive_ptr< Selectable > Ptr
Definition Selectable.h:58
zypp::ui::Selectable::isUndetermined
bool isUndetermined() const
Returns true for packages, because packages are not classified by the solver.
Definition Selectable.cc:218
zypp::ui::Selectable::kind
ResKind kind() const
The ResObjects kind.
Definition Selectable.cc:59
zypp::ui::Selectable::setFate
bool setFate(Fate fate_r, ResStatus::TransactByValue causer_r=ResStatus::USER)
Definition Selectable.cc:276
zypp::ui::Selectable::pickDelete
bool pickDelete(const PoolItem &pi_r, ResStatus::TransactByValue causer_r=ResStatus::USER, bool yesno_r=true)
Select a specific installed item for deletion.
Definition Selectable.cc:207
zypp::ui::Selectable::available_iterator
SelectableTraits::available_iterator available_iterator
Iterates over ResObject::constPtr.
Definition Selectable.h:62
zypp::ui::Selectable::isNeeded
bool isNeeded() const
This includes unlocked broken patches, as well as those already selected to be installed.
Definition Selectable.cc:230
zypp::ui::Selectable::picklistEmpty
bool picklistEmpty() const
Definition Selectable.cc:150
zypp::ui::Selectable::identicalInstalledObj
PoolItem identicalInstalledObj(const PoolItem &rhs) const
\Return an installed Object with the same content as rhs.
Definition Selectable.cc:98
zypp::ui::Selectable::installedEmpty
bool installedEmpty() const
Definition Selectable.cc:136
zypp::ui::Selectable::picklistPos
picklist_size_type picklistPos(const PoolItem &pi_r) const
Return the position of pi_r in the piclist or picklistNoPos.
Definition Selectable.cc:162
std
Definition Arch.h:364
str
String related utilities and Regular expression matching.
zypp::ui
Definition SolvIterMixin.cc:57
zypp::ui::Status
Status
UI status Status values calculated by Selectable.
Definition Status.h:36
zypp::ui::S_AutoUpdate
@ S_AutoUpdate
Definition Status.h:45
zypp::ui::S_Taboo
@ S_Taboo
Definition Status.h:38
zypp::ui::S_AutoInstall
@ S_AutoInstall
Definition Status.h:46
zypp::ui::S_Install
@ S_Install
Definition Status.h:42
zypp::ui::S_AutoDel
@ S_AutoDel
Definition Status.h:44
zypp::ui::S_NoInst
@ S_NoInst
Definition Status.h:49
zypp::ui::S_Protected
@ S_Protected
Definition Status.h:37
zypp::ui::S_KeepInstalled
@ S_KeepInstalled
Definition Status.h:48
zypp::ui::S_Del
@ S_Del
Definition Status.h:40
zypp::ui::S_Update
@ S_Update
Definition Status.h:41
zypp::ui::operator<<
std::ostream & operator<<(std::ostream &str, const Selectable &obj)
Definition Selectable.cc:331
zypp::ui::dumpOn
std::ostream & dumpOn(std::ostream &str, const Selectable &obj)
Definition Selectable.cc:334
zypp
Easy-to use interface to the ZYPP dependency resolver.
Definition Application.cc:20
zypp::sat::SolvableType::satSolvable
Solvable satSolvable() const
Return the corresponding sat::Solvable.
Definition SolvableType.h:57
IMPL_PTR_TYPE
#define IMPL_PTR_TYPE(NAME)
Definition ReferenceCounted.h:137