libzypp  17.3.0
PoolItem.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #ifndef ZYPP_POOLITEM_H
13 #define ZYPP_POOLITEM_H
14 
15 #include <iosfwd>
16 #include <functional>
17 
18 #include "zypp/base/PtrTypes.h"
19 #include "zypp/ResObject.h"
20 
21 #include "zypp/sat/SolvableType.h"
22 #include "zypp/ResStatus.h"
23 
25 namespace zypp
26 {
27  class ResPool;
28  namespace pool
29  {
30  class PoolImpl;
31  }
50  class PoolItem : public sat::SolvableType<PoolItem>
51  {
52  friend std::ostream & operator<<( std::ostream & str, const PoolItem & obj );
53  public:
55  PoolItem();
56 
58  explicit PoolItem( const sat::Solvable & solvable_r );
59 
61  template <class Derived>
62  explicit PoolItem( const SolvableType<Derived> & solvable_r )
63  : PoolItem( solvable_r.satSolvable() )
64  {}
65 
67  explicit PoolItem( const ResObject::constPtr & resolvable_r );
68 
70  ~PoolItem();
71 
72  public:
76  ResStatus & status() const;
77 
79  ResStatus & statusReset() const;
80 
81 
87  bool isUndetermined() const;
88 
92  bool isRelevant() const;
93 
95  bool isSatisfied() const;
96 
98  bool isBroken() const;
99 
103  bool isNeeded() const;
104 
106  bool isUnwanted() const;
108 
110  public:
112  ResPool pool() const;
113 
115  explicit operator sat::Solvable() const
116  { return resolvable() ? resolvable()->satSolvable() : sat::Solvable::noSolvable; }
117 
121  sat::Solvable buddy() const;
122 
123  public:
127  ResObject::constPtr resolvable() const;
128 
132  operator ResObject::constPtr() const
133  { return resolvable(); }
134 
137  { return resolvable(); }
138 
139  private:
140  friend class pool::PoolImpl;
142  static PoolItem makePoolItem( const sat::Solvable & solvable_r );
144  void setBuddy( const sat::Solvable & solv_r );
146  public:
147  class Impl;
148  private:
149  explicit PoolItem( Impl * implptr_r );
152 
153  private:
157  friend class PoolItemSaver;
158  void saveState() const;
159  void restoreState() const;
160  bool sameState() const;
162  };
164 
166  std::ostream & operator<<( std::ostream & str, const PoolItem & obj );
167 
168 
170  inline bool operator==( const PoolItem & lhs, const PoolItem & rhs )
171  { return lhs.resolvable() == rhs.resolvable(); }
172 
174  inline bool operator==( const PoolItem & lhs, const ResObject::constPtr & rhs )
175  { return lhs.resolvable() == rhs; }
176 
178  inline bool operator==( const ResObject::constPtr & lhs, const PoolItem & rhs )
179  { return lhs == rhs.resolvable(); }
180 
181 
183  inline bool operator!=( const PoolItem & lhs, const PoolItem & rhs )
184  { return ! (lhs==rhs); }
185 
187  inline bool operator!=( const PoolItem & lhs, const ResObject::constPtr & rhs )
188  { return ! (lhs==rhs); }
189 
191  inline bool operator!=( const ResObject::constPtr & lhs, const PoolItem & rhs )
192  { return ! (lhs==rhs); }
193 
198  struct asPoolItem
199  {
201 
202  PoolItem operator()( const sat::Solvable & solv_r ) const
203  { return PoolItem( solv_r ); }
204  };
205 
206 } // namespace zypp
208 #endif // ZYPP_POOLITEM_H
A Solvable object within the sat Pool.
Definition: Solvable.h:53
std::ostream & operator<<(std::ostream &str, const PoolStats &obj)
Definition: PoolStats.cc:31
PoolItem(const SolvableType< Derived > &solvable_r)
Ctor looking up the sat::Solvable in the ResPool.
Definition: PoolItem.h:62
bool operator==(const ResObject::constPtr &lhs, const PoolItem &rhs)
Definition: PoolItem.h:178
PoolItem operator()(const sat::Solvable &solv_r) const
Definition: PoolItem.h:202
PoolItem result_type
Definition: PoolItem.h:200
String related utilities and Regular expression matching.
TraitsType::constPtrType constPtr
Definition: ResObject.h:44
ResObject::constPtr operator->() const
Forward -> access to ResObject.
Definition: PoolItem.h:136
ResObject::constPtr resolvable() const
Returns the ResObject::constPtr.
Definition: PoolItem.cc:217
static const Solvable noSolvable
Represents no Solvable.
Definition: Solvable.h:71
PoolItem implementation.
Definition: PoolItem.cc:37
bool operator!=(const PoolItem &lhs, const ResObject::constPtr &rhs)
Definition: PoolItem.h:187
Global ResObject pool.
Definition: ResPool.h:60
bool operator==(const PoolItem &lhs, const PoolItem &rhs)
Definition: PoolItem.h:170
Status bitfield.
Definition: ResStatus.h:53
Combining sat::Solvable and ResStatus.
Definition: PoolItem.h:50
bool operator!=(const PoolItem &lhs, const PoolItem &rhs)
Definition: PoolItem.h:183
bool operator==(const PoolItem &lhs, const ResObject::constPtr &rhs)
Definition: PoolItem.h:174
Base class for creating Solvable based types.
Definition: SolvableType.h:54
bool operator!=(const ResObject::constPtr &lhs, const PoolItem &rhs)
Definition: PoolItem.h:191
RW_pointer< Impl > _pimpl
Pointer to implementation.
Definition: PoolItem.h:151
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
Solvable to PoolItem transform functor.
Definition: PoolItem.h:198