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