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       bool validate() const
  68       {
  69         return _resolvable->validate();
  70       }
  71
  72     private:
  73       mutable ResStatus     _status;
  74       ResObject::constPtr   _resolvable;
  75
  76     /** \name Poor man's save/restore state.
  77        * \todo There may be better save/restore state strategies.
  78      */
  79     //@{
  80     public:
  81       void saveState() const
  82       { _savedStatus = _status; }
  83       void restoreState() const
  84       { _status = _savedStatus; }
  85       bool sameState() const
  86       {
  87         if (    _status.getTransactValue() != _savedStatus.getTransactValue()
  88                 && !_status.isBySolver() )
  89           return false;
  90         if ( _status.isLicenceConfirmed() != _savedStatus.isLicenceConfirmed() )
  91           return false;
  92         return true;
  93       }
  94     private:
  95       mutable ResStatus _savedStatus;
  96     //@}
  97
  98     public:
  99       /** Offer default Impl. */
 100       static shared_ptr<Impl> nullimpl()
 101       {
 102         static shared_ptr<Impl> _nullimpl( new Impl );
 103         return _nullimpl;
 104       }
 105   };
 106   ///////////////////////////////////////////////////////////////////
 107
 108   /** \relates PoolItem::Impl Stream output */
 109   inline std::ostream & operator<<( std::ostream & str, const PoolItem::Impl & obj )
 110   {
 111     str << obj.status();
 112     if (obj.resolvable())
 113         str << *obj.resolvable();
 114     else
 115         str << "(NULL)";
 116     return str;
 117   }
 118
 119   ///////////////////////////////////////////////////////////////////
 120   //
 121   //    CLASS NAME : PoolItem
 122   //
 123   ///////////////////////////////////////////////////////////////////
 124
 125   ///////////////////////////////////////////////////////////////////
 126   //
 127   //    METHOD NAME : PoolItem::PoolItem
 128   //    METHOD TYPE : Ctor
 129   //
 130   PoolItem::PoolItem()
 131   : _pimpl( Impl::nullimpl() )
 132   {}
 133
 134   ///////////////////////////////////////////////////////////////////
 135   //
 136   //    METHOD NAME : PoolItem::PoolItem
 137   //    METHOD TYPE : Ctor
 138   //
 139   PoolItem::PoolItem( const sat::Solvable & solvable_r )
 140   : _pimpl( ResPool::instance().find( solvable_r )._pimpl )
 141   {}
 142
 143   ///////////////////////////////////////////////////////////////////
 144   //
 145   //    METHOD NAME : PoolItem::PoolItem
 146   //    METHOD TYPE : Ctor
 147   //
 148   PoolItem::PoolItem( const ResObject::constPtr & resolvable_r )
 149   : _pimpl( ResPool::instance().find( resolvable_r )._pimpl )
 150   {}
 151
 152   ///////////////////////////////////////////////////////////////////
 153   //
 154   //    METHOD NAME : PoolItem::PoolItem
 155   //    METHOD TYPE : Ctor
 156   //
 157   PoolItem::PoolItem( Impl * implptr_r )
 158   : _pimpl( implptr_r )
 159   {}
 160
 161   ///////////////////////////////////////////////////////////////////
 162   //
 163   //    METHOD NAME : PoolItem::makePoolItem
 164   //    METHOD TYPE : PoolItem
 165   //
 166   PoolItem PoolItem::makePoolItem( const sat::Solvable & solvable_r )
 167   { return PoolItem( new Impl( makeResObject( solvable_r ), solvable_r.isSystem() ) ); }
 168
 169   ///////////////////////////////////////////////////////////////////
 170   //
 171   //    METHOD NAME : PoolItem::~PoolItem
 172   //    METHOD TYPE : Dtor
 173   //
 174   PoolItem::~PoolItem()
 175   {}
 176
 177   ///////////////////////////////////////////////////////////////////
 178   //
 179   //    METHOD NAME : PoolItem::pool
 180   //    METHOD TYPE : ResPool
 181   //
 182   ResPool PoolItem::pool() const
 183   { return ResPool::instance(); }
 184
 185   ///////////////////////////////////////////////////////////////////
 186   //
 187   //    Forward to Impl:
 188   //
 189   ///////////////////////////////////////////////////////////////////
 190
 191   ResStatus & PoolItem::status() const
 192   { return _pimpl->status(); }
 193
 194   ResStatus & PoolItem::statusReset() const
 195   { return _pimpl->statusReset(); }
 196
 197   bool PoolItem::isSatisfied() const
 198   { return _pimpl->isSatisfied(); }
 199
 200   ResObject::constPtr PoolItem::resolvable() const
 201   { return _pimpl->resolvable(); }
 202
 203   void PoolItem::saveState() const
 204   { _pimpl->saveState(); }
 205
 206   void PoolItem::restoreState() const
 207   { _pimpl->restoreState(); }
 208
 209   bool PoolItem::sameState() const
 210   { return _pimpl->sameState(); }
 211
 212   /******************************************************************
 213    **
 214    **   FUNCTION NAME : operator<<
 215    **   FUNCTION TYPE : std::ostream &
 216   */
 217   std::ostream & operator<<( std::ostream & str, const PoolItem & obj )
 218   {
 219     return str << *obj._pimpl;
 220   }
 221
 222   /////////////////////////////////////////////////////////////////
 223 } // namespace zypp
 224 ///////////////////////////////////////////////////////////////////