zypp/PoolItem.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/PoolItem.cc
  10  *
  11 */
  12 #include <iostream>
  13 #include "zypp/base/Logger.h"
  14
  15 #include "zypp/PoolItem.h"
  16 #include "zypp/ResPool.h"
  17 #include "zypp/Package.h"
  18 #include "zypp/VendorAttr.h"
  19
  20 using std::endl;
  21
  22 ///////////////////////////////////////////////////////////////////
  23 namespace zypp
  24 { /////////////////////////////////////////////////////////////////
  25
  26   ///////////////////////////////////////////////////////////////////
  27   //
  28   //    CLASS NAME : PoolItem::Impl
  29   //
  30   /** PoolItem implementation. */
  31   struct PoolItem::Impl
  32   {
  33     public:
  34       Impl() {}
  35
  36       Impl( ResObject::constPtr res_r,
  37             const ResStatus & status_r )
  38       : _status( status_r )
  39       , _resolvable( res_r )
  40       {}
  41
  42       ResStatus & status() const
  43       { return _status; }
  44
  45       ResObject::constPtr resolvable() const
  46       { return _resolvable; }
  47
  48       ResStatus & statusReset() const
  49       {
  50         _status.setLock( false, zypp::ResStatus::USER );
  51         _status.resetTransact( zypp::ResStatus::USER );
  52         return _status;
  53       }
  54
  55     public:
  56
  57       bool isSatisfied() const
  58       {
  59         return _resolvable->isSatisfied();
  60       }
  61
  62       bool isRelevant() const
  63       {
  64         return _resolvable->isRelevant();
  65       }
  66
  67     private:
  68       mutable ResStatus     _status;
  69       ResObject::constPtr   _resolvable;
  70
  71     /** \name Poor man's save/restore state.
  72        * \todo There may be better save/restore state strategies.
  73      */
  74     //@{
  75     public:
  76       void saveState() const
  77       { _savedStatus = _status; }
  78       void restoreState() const
  79       { _status = _savedStatus; }
  80       bool sameState() const
  81       {
  82         if (    _status.getTransactValue() != _savedStatus.getTransactValue()
  83                 && !_status.isBySolver() )
  84           return false;
  85         if ( _status.isLicenceConfirmed() != _savedStatus.isLicenceConfirmed() )
  86           return false;
  87         return true;
  88       }
  89     private:
  90       mutable ResStatus _savedStatus;
  91     //@}
  92
  93     public:
  94       /** Offer default Impl. */
  95       static shared_ptr<Impl> nullimpl()
  96       {
  97         static shared_ptr<Impl> _nullimpl( new Impl );
  98         return _nullimpl;
  99       }
 100   };
 101   ///////////////////////////////////////////////////////////////////
 102
 103   /** \relates PoolItem::Impl Stream output */
 104   inline std::ostream & operator<<( std::ostream & str, const PoolItem::Impl & obj )
 105   {
 106     str << obj.status();
 107     if (obj.resolvable())
 108         str << *obj.resolvable();
 109     else
 110         str << "(NULL)";
 111     return str;
 112   }
 113
 114   ///////////////////////////////////////////////////////////////////
 115   //
 116   //    CLASS NAME : PoolItem
 117   //
 118   ///////////////////////////////////////////////////////////////////
 119
 120   ///////////////////////////////////////////////////////////////////
 121   //
 122   //    METHOD NAME : PoolItem::PoolItem
 123   //    METHOD TYPE : Ctor
 124   //
 125   PoolItem::PoolItem()
 126   : _pimpl( Impl::nullimpl() )
 127   {}
 128
 129   ///////////////////////////////////////////////////////////////////
 130   //
 131   //    METHOD NAME : PoolItem::PoolItem
 132   //    METHOD TYPE : Ctor
 133   //
 134   PoolItem::PoolItem( const sat::Solvable & solvable_r )
 135   : _pimpl( ResPool::instance().find( solvable_r )._pimpl )
 136   {}
 137
 138   ///////////////////////////////////////////////////////////////////
 139   //
 140   //    METHOD NAME : PoolItem::PoolItem
 141   //    METHOD TYPE : Ctor
 142   //
 143   PoolItem::PoolItem( const ResObject::constPtr & resolvable_r )
 144   : _pimpl( ResPool::instance().find( resolvable_r )._pimpl )
 145   {}
 146
 147   ///////////////////////////////////////////////////////////////////
 148   //
 149   //    METHOD NAME : PoolItem::PoolItem
 150   //    METHOD TYPE : Ctor
 151   //
 152   PoolItem::PoolItem( Impl * implptr_r )
 153   : _pimpl( implptr_r )
 154   {}
 155
 156   ///////////////////////////////////////////////////////////////////
 157   //
 158   //    METHOD NAME : PoolItem::makePoolItem
 159   //    METHOD TYPE : PoolItem
 160   //
 161   PoolItem PoolItem::makePoolItem( const sat::Solvable & solvable_r )
 162   { return PoolItem( new Impl( makeResObject( solvable_r ), solvable_r.isSystem() ) ); }
 163
 164   ///////////////////////////////////////////////////////////////////
 165   //
 166   //    METHOD NAME : PoolItem::~PoolItem
 167   //    METHOD TYPE : Dtor
 168   //
 169   PoolItem::~PoolItem()
 170   {}
 171
 172   ///////////////////////////////////////////////////////////////////
 173   //
 174   //    METHOD NAME : PoolItem::pool
 175   //    METHOD TYPE : ResPool
 176   //
 177   ResPool PoolItem::pool() const
 178   { return ResPool::instance(); }
 179
 180   ///////////////////////////////////////////////////////////////////
 181   //
 182   //    Forward to Impl:
 183   //
 184   ///////////////////////////////////////////////////////////////////
 185
 186   ResStatus & PoolItem::status() const
 187   { return _pimpl->status(); }
 188
 189   ResStatus & PoolItem::statusReset() const
 190   { return _pimpl->statusReset(); }
 191
 192   bool PoolItem::isSatisfied() const
 193   { return _pimpl->isSatisfied(); }
 194
 195   ResObject::constPtr PoolItem::resolvable() const
 196   { return _pimpl->resolvable(); }
 197
 198   void PoolItem::saveState() const
 199   { _pimpl->saveState(); }
 200
 201   void PoolItem::restoreState() const
 202   { _pimpl->restoreState(); }
 203
 204   bool PoolItem::sameState() const
 205   { return _pimpl->sameState(); }
 206
 207   /******************************************************************
 208    **
 209    **   FUNCTION NAME : operator<<
 210    **   FUNCTION TYPE : std::ostream &
 211   */
 212   std::ostream & operator<<( std::ostream & str, const PoolItem & obj )
 213   {
 214     return str << *obj._pimpl;
 215   }
 216
 217   /////////////////////////////////////////////////////////////////
 218 } // namespace zypp
 219 ///////////////////////////////////////////////////////////////////