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