libzypp  17.19.0
PoolItem.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #include <iostream>
13 #include "zypp/base/Logger.h"
15 
16 #include "zypp/PoolItem.h"
17 #include "zypp/ResPool.h"
18 #include "zypp/Package.h"
19 #include "zypp/VendorAttr.h"
20 
21 using std::endl;
22 
24 namespace zypp
25 {
26 
28  //
29  // CLASS NAME : PoolItem::Impl
30  //
38  {
39  public:
40  Impl() {}
41 
43  const ResStatus & status_r )
44  : _status( status_r )
45  , _resolvable( res_r )
46  {}
47 
48  ResStatus & status() const
49  { return _buddy > 0 ? PoolItem(buddy()).status() : _status; }
50 
52  {
53  if ( !_buddy )
55  if ( _buddy < 0 )
56  return sat::Solvable( -_buddy );
57  return sat::Solvable( _buddy );
58  }
59 
60  void setBuddy( const sat::Solvable & solv_r );
61 
63  { return _resolvable; }
64 
66  {
69  return _status;
70  }
71 
72  public:
73  bool isUndetermined() const
74  {
75  return status().isUndetermined();
76  }
77 
78  bool isRelevant() const
79  {
80  return !status().isNonRelevant();
81  }
82 
83  bool isSatisfied() const
84  {
85  return status().isSatisfied();
86  }
87 
88  bool isBroken() const
89  {
90  return status().isBroken();
91  }
92 
93  bool isNeeded() const
94  {
95  return status().isToBeInstalled() || ( isBroken() && ! status().isLocked() );
96  }
97 
98  bool isUnwanted() const
99  {
100  return isBroken() && status().isLocked();
101  }
102 
103  std::string patchStatusAsString() const
104  {
105  if ( isUndetermined() ) return "undetermined";
106  if ( isRelevant() ) return "relevant";
107  if ( isSatisfied() ) return "satisfied";
108  if ( isBroken() ) return "broken";
109  if ( isNeeded() ) return "needed";
110  if ( isUnwanted() ) return "unwanted";
111  return "none";
112  }
113 
114  private:
118 
123  public:
124  void saveState() const
125  { _savedStatus = status(); }
126  void restoreState() const
127  { status() = _savedStatus; }
128  bool sameState() const
129  {
130  if ( status() == _savedStatus )
131  return true;
132  // some bits changed...
133  if ( status().getTransactValue() != _savedStatus.getTransactValue()
134  && ( ! status().isBySolver() // ignore solver state changes
135  // removing a user lock also goes to bySolver
137  return false;
139  return false;
140  return true;
141  }
142  private:
145 
146  public:
148  static shared_ptr<Impl> nullimpl()
149  {
150  static shared_ptr<Impl> _nullimpl( new Impl );
151  return _nullimpl;
152  }
153  };
155 
157  inline std::ostream & operator<<( std::ostream & str, const PoolItem::Impl & obj )
158  {
159  str << obj.status();
160  if (obj.resolvable())
161  str << *obj.resolvable();
162  else
163  str << "(NULL)";
164  return str;
165  }
166 
167  inline void PoolItem::Impl::setBuddy( const sat::Solvable & solv_r )
168  {
169  PoolItem myBuddy( solv_r );
170  if ( myBuddy )
171  {
172  if ( myBuddy._pimpl->_buddy )
173  {
174  ERR << *this << " would be buddy2 in " << myBuddy << endl;
175  return;
176  }
177  myBuddy._pimpl->_buddy = -resolvable()->satSolvable().id();
178  _buddy = myBuddy.satSolvable().id();
179  DBG << *this << " has buddy " << myBuddy << endl;
180  }
181  }
182 
184  // class PoolItem
186 
188  : _pimpl( Impl::nullimpl() )
189  {}
190 
191  PoolItem::PoolItem( const sat::Solvable & solvable_r )
192  : _pimpl( ResPool::instance().find( solvable_r )._pimpl )
193  {}
194 
195  PoolItem::PoolItem( const ResObject::constPtr & resolvable_r )
196  : _pimpl( ResPool::instance().find( resolvable_r )._pimpl )
197  {}
198 
199  PoolItem::PoolItem( Impl * implptr_r )
200  : _pimpl( implptr_r )
201  {}
202 
204  {
205  return PoolItem( new Impl( makeResObject( solvable_r ), solvable_r.isSystem() ) );
206  }
207 
209  {}
210 
212  { return ResPool::instance(); }
213 
214 
215  ResStatus & PoolItem::status() const { return _pimpl->status(); }
217  sat::Solvable PoolItem::buddy() const { return _pimpl->buddy(); }
218  void PoolItem::setBuddy( const sat::Solvable & solv_r ) { _pimpl->setBuddy( solv_r ); }
219  bool PoolItem::isUndetermined() const { return _pimpl->isUndetermined(); }
220  bool PoolItem::isRelevant() const { return _pimpl->isRelevant(); }
221  bool PoolItem::isSatisfied() const { return _pimpl->isSatisfied(); }
222  bool PoolItem::isBroken() const { return _pimpl->isBroken(); }
223  bool PoolItem::isNeeded() const { return _pimpl->isNeeded(); }
224  bool PoolItem::isUnwanted() const { return _pimpl->isUnwanted(); }
225  std::string PoolItem::patchStatusAsString() const { return _pimpl->patchStatusAsString(); }
226 
227  void PoolItem::saveState() const { _pimpl->saveState(); }
229  bool PoolItem::sameState() const { return _pimpl->sameState(); }
231 
232 
233  std::ostream & operator<<( std::ostream & str, const PoolItem & obj )
234  { return str << *obj._pimpl; }
235 
236 } // namespace zypp
bool isBroken() const
Definition: PoolItem.cc:88
A Solvable object within the sat Pool.
Definition: Solvable.h:53
PoolItem()
Default ctor for use in std::container.
Definition: PoolItem.cc:187
IdType id() const
Expert backdoor.
Definition: Solvable.h:399
DefaultIntegral< sat::detail::IdType, sat::detail::noId > _buddy
Definition: PoolItem.cc:117
bool sameState() const
Definition: PoolItem.cc:229
bool isToBeInstalled() const
Definition: ResStatus.h:244
void setBuddy(const sat::Solvable &solv_r)
Buddies are set by pool::PoolImpl.
Definition: PoolItem.cc:218
bool isNonRelevant() const
Definition: ResStatus.h:225
ResStatus & status() const
Returns the current status.
Definition: PoolItem.cc:215
String related utilities and Regular expression matching.
sat::Solvable buddy() const
Return the buddy we share our status object with.
Definition: PoolItem.cc:217
bool isBroken() const
Definition: ResStatus.h:222
TransactValue getTransactValue() const
Definition: ResStatus.h:270
std::ostream & operator<<(std::ostream &str, const PoolItem::Impl &obj)
Definition: PoolItem.cc:157
bool sameState() const
Definition: PoolItem.cc:128
void saveState() const
Definition: PoolItem.cc:124
bool resetTransact(TransactByValue causer_r)
Not the same as setTransact( false ).
Definition: ResStatus.h:476
~PoolItem()
Dtor.
Definition: PoolItem.cc:208
bool isSatisfied() const
Whether a relevant items requirements are met.
Definition: PoolItem.cc:221
TraitsType::constPtrType constPtr
Definition: ResObject.h:43
void setBuddy(const sat::Solvable &solv_r)
Definition: PoolItem.cc:167
bool isRelevant() const
Definition: PoolItem.cc:78
bool isNeeded() const
Definition: PoolItem.cc:93
ResObject::constPtr resolvable() const
Returns the ResObject::constPtr.
Definition: PoolItem.cc:230
#define ERR
Definition: Logger.h:81
static const Solvable noSolvable
Represents no Solvable.
Definition: Solvable.h:74
Impl(ResObject::constPtr res_r, const ResStatus &status_r)
Definition: PoolItem.cc:42
ResStatus _savedStatus
Definition: PoolItem.cc:143
bool isBroken() const
Whether a relevant items requirements are broken.
Definition: PoolItem.cc:222
bool isUndetermined() const
Definition: PoolItem.cc:73
ResStatus & statusReset() const
Reset status.
Definition: PoolItem.cc:216
std::ostream & operator<<(std::ostream &str, const Exception &obj)
Definition: Exception.cc:147
static shared_ptr< Impl > nullimpl()
Offer default Impl.
Definition: PoolItem.cc:148
bool isUndetermined() const
No validation is performed for packages.
Definition: PoolItem.cc:219
PoolItem implementation.
Definition: PoolItem.cc:37
void restoreState() const
Definition: PoolItem.cc:228
bool isSatisfied() const
Definition: ResStatus.h:219
static PoolItem makePoolItem(const sat::Solvable &solvable_r)
PoolItem generator for pool::PoolImpl.
Definition: PoolItem.cc:203
bool setLock(bool toLock_r, TransactByValue causer_r)
Apply a lock (prevent transaction).
Definition: ResStatus.h:379
void restoreState() const
Definition: PoolItem.cc:126
bool isSystem() const
Return whether this Solvable belongs to the system repo.
Definition: Solvable.cc:372
ResObject::constPtr _resolvable
Definition: PoolItem.cc:116
bool isRelevant() const
Returns true if the solvable is relevant which means e.g.
Definition: PoolItem.cc:220
ResStatus & statusReset() const
Definition: PoolItem.cc:65
ResStatus & status() const
Definition: PoolItem.cc:48
bool isLicenceConfirmed() const
Definition: ResStatus.h:175
ResPool pool() const
Return the ResPool the item belongs to.
Definition: PoolItem.cc:211
Global ResObject pool.
Definition: ResPool.h:60
bool isUndetermined() const
Definition: ResStatus.h:216
bool isUnwanted() const
Definition: PoolItem.cc:98
bool isSatisfied() const
Definition: PoolItem.cc:83
bool isLocked() const
Definition: ResStatus.h:255
ResObject::constPtr resolvable() const
Definition: PoolItem.cc:62
Status bitfield.
Definition: ResStatus.h:53
bool isNeeded() const
This includes unlocked broken patches, as well as those already selected to be installed (otherwise c...
Definition: PoolItem.cc:223
ResObject::Ptr makeResObject(const sat::Solvable &solvable_r)
Create ResObject from sat::Solvable.
Definition: ResObject.cc:44
Combining sat::Solvable and ResStatus.
Definition: PoolItem.h:50
sat::Solvable buddy() const
Definition: PoolItem.cc:51
std::string patchStatusAsString() const
Definition: PoolItem.cc:225
std::string patchStatusAsString() const
Definition: PoolItem.cc:103
bool isUnwanted() const
Broken (needed) but locked patches.
Definition: PoolItem.cc:224
RW_pointer< Impl > _pimpl
Pointer to implementation.
Definition: PoolItem.h:154
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
Solvable satSolvable() const
Return the corresponding sat::Solvable.
Definition: SolvableType.h:57
bool isBySolver() const
Definition: ResStatus.h:281
#define DBG
Definition: Logger.h:78
void saveState() const
Definition: PoolItem.cc:227
static ResPool instance()
Singleton ctor.
Definition: ResPool.cc:33