X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=zypp%2FPoolItem.cc;h=37f401a757646116694abd7cd6a385b26c463a7a;hb=89237084b93beda74ca7a2902bb5900cecf94891;hp=00f3db18d06655aedc5c66aa82708eeb14152fda;hpb=5d0092dacb627aae37f5225650ef132c84ac79ed;p=platform%2Fupstream%2Flibzypp.git

diff --git a/zypp/PoolItem.cc b/zypp/PoolItem.cc
index 00f3db1..37f401a 100644
--- a/zypp/PoolItem.cc
+++ b/zypp/PoolItem.cc
@@ -11,6 +11,7 @@
 */
 #include <iostream>
 #include "zypp/base/Logger.h"
+#include "zypp/base/DefaultIntegral.h"
 
 #include "zypp/PoolItem.h"
 #include "zypp/ResPool.h"
@@ -27,7 +28,12 @@ namespace zypp
   //
   //	CLASS NAME : PoolItem::Impl
   //
-  /** PoolItem implementation. */
+  /** PoolItem implementation.
+   * \c _buddy handling:
+   * \li \c ==0 no buddy
+   * \li \c >0 this uses \c _buddy status
+   * \li \c <0 this status used by \c -_buddy
+   */
   struct PoolItem::Impl
   {
     public:
@@ -40,7 +46,18 @@ namespace zypp
       {}
 
       ResStatus & status() const
-      { return _status; }
+      { return _buddy > 0 ? PoolItem(buddy()).status() : _status; }
+
+      sat::Solvable buddy() const
+      {
+        if ( !_buddy )
+          return sat::Solvable::noSolvable;
+        if ( _buddy < 0 )
+          return sat::Solvable( -_buddy );
+        return sat::Solvable( _buddy );
+      }
+
+      void setBuddy( const sat::Solvable & solv_r );
 
       ResObject::constPtr resolvable() const
       { return _resolvable; }
@@ -53,16 +70,40 @@ namespace zypp
       }
 
     public:
+      bool isUndetermined() const
+      {
+	  return status().isUndetermined();
+      }
+
+      bool isRelevant() const
+      {
+	  return !status().isNonRelevant();
+      }
 
       bool isSatisfied() const
       {
-#warning TBD determine isSatisfied
-        return true;
+	  return status().isSatisfied();
+      }
+
+      bool isBroken() const
+      {
+	  return status().isBroken();
+      }
+
+      bool isNeeded() const
+      {
+	return status().isToBeInstalled() || ( isBroken() && ! status().isLocked() );
+      }
+
+      bool isUnwanted() const
+      {
+	return isBroken() && status().isLocked();
       }
 
     private:
       mutable ResStatus     _status;
       ResObject::constPtr   _resolvable;
+      DefaultIntegral<sat::detail::IdType,sat::detail::noId> _buddy;
 
     /** \name Poor man's save/restore state.
        * \todo There may be better save/restore state strategies.
@@ -70,15 +111,20 @@ namespace zypp
     //@{
     public:
       void saveState() const
-      { _savedStatus = _status; }
+      { _savedStatus = status(); }
       void restoreState() const
-      { _status = _savedStatus; }
+      { status() = _savedStatus; }
       bool sameState() const
       {
-        if (    _status.getTransactValue() != _savedStatus.getTransactValue()
-                && !_status.isBySolver() )
+        if ( status() == _savedStatus )
+          return true;
+        // some bits changed...
+        if ( status().getTransactValue() != _savedStatus.getTransactValue()
+             && ( ! status().isBySolver() // ignore solver state changes
+                  // removing a user lock also goes to bySolver
+                  || _savedStatus.getTransactValue() == ResStatus::LOCKED ) )
           return false;
-        if ( _status.isLicenceConfirmed() != _savedStatus.isLicenceConfirmed() )
+        if ( status().isLicenceConfirmed() != _savedStatus.isLicenceConfirmed() )
           return false;
         return true;
       }
@@ -107,109 +153,73 @@ namespace zypp
     return str;
   }
 
+  inline void PoolItem::Impl::setBuddy( const sat::Solvable & solv_r )
+  {
+    PoolItem myBuddy( solv_r );
+    if ( myBuddy )
+    {
+      if ( myBuddy._pimpl->_buddy )
+      {
+	ERR <<  *this << " would be buddy2 in " << myBuddy << endl;
+	return;
+      }
+      myBuddy._pimpl->_buddy = -resolvable()->satSolvable().id();
+      _buddy = myBuddy.satSolvable().id();
+      DBG << *this << " has buddy " << myBuddy << endl;
+    }
+  }
+
   ///////////////////////////////////////////////////////////////////
-  //
-  //	CLASS NAME : PoolItem
-  //
+  //	class PoolItem
   ///////////////////////////////////////////////////////////////////
 
-  ///////////////////////////////////////////////////////////////////
-  //
-  //	METHOD NAME : PoolItem::PoolItem
-  //	METHOD TYPE : Ctor
-  //
   PoolItem::PoolItem()
   : _pimpl( Impl::nullimpl() )
   {}
 
-  ///////////////////////////////////////////////////////////////////
-  //
-  //	METHOD NAME : PoolItem::PoolItem
-  //	METHOD TYPE : Ctor
-  //
   PoolItem::PoolItem( const sat::Solvable & solvable_r )
   : _pimpl( ResPool::instance().find( solvable_r )._pimpl )
   {}
 
-  ///////////////////////////////////////////////////////////////////
-  //
-  //	METHOD NAME : PoolItem::PoolItem
-  //	METHOD TYPE : Ctor
-  //
   PoolItem::PoolItem( const ResObject::constPtr & resolvable_r )
   : _pimpl( ResPool::instance().find( resolvable_r )._pimpl )
   {}
 
-  ///////////////////////////////////////////////////////////////////
-  //
-  //	METHOD NAME : PoolItem::PoolItem
-  //	METHOD TYPE : Ctor
-  //
   PoolItem::PoolItem( Impl * implptr_r )
   : _pimpl( implptr_r )
   {}
 
-  ///////////////////////////////////////////////////////////////////
-  //
-  //	METHOD NAME : PoolItem::makePoolItem
-  //	METHOD TYPE : PoolItem
-  //
   PoolItem PoolItem::makePoolItem( const sat::Solvable & solvable_r )
-  { return PoolItem( new Impl( makeResObject( solvable_r ), solvable_r.isSystem() ) ); }
+  {
+    return PoolItem( new Impl( makeResObject( solvable_r ), solvable_r.isSystem() ) );
+  }
 
-  ///////////////////////////////////////////////////////////////////
-  //
-  //	METHOD NAME : PoolItem::~PoolItem
-  //	METHOD TYPE : Dtor
-  //
   PoolItem::~PoolItem()
   {}
 
-  ///////////////////////////////////////////////////////////////////
-  //
-  //	METHOD NAME : PoolItem::pool
-  //	METHOD TYPE : ResPool
-  //
   ResPool PoolItem::pool() const
   { return ResPool::instance(); }
 
-  ///////////////////////////////////////////////////////////////////
-  //
-  //	Forward to Impl:
-  //
-  ///////////////////////////////////////////////////////////////////
-
-  ResStatus & PoolItem::status() const
-  { return _pimpl->status(); }
-
-  ResStatus & PoolItem::statusReset() const
-  { return _pimpl->statusReset(); }
-
-  bool PoolItem::isSatisfied() const
-  { return _pimpl->isSatisfied(); }
 
-  ResObject::constPtr PoolItem::resolvable() const
-  { return _pimpl->resolvable(); }
+  ResStatus & PoolItem::status() const			{ return _pimpl->status(); }
+  ResStatus & PoolItem::statusReset() const		{ return _pimpl->statusReset(); }
+  sat::Solvable PoolItem::buddy() const			{ return _pimpl->buddy(); }
+  void PoolItem::setBuddy( const sat::Solvable & solv_r )	{ _pimpl->setBuddy( solv_r ); }
+  bool PoolItem::isUndetermined() const			{ return _pimpl->isUndetermined(); }
+  bool PoolItem::isRelevant() const			{ return _pimpl->isRelevant(); }
+  bool PoolItem::isSatisfied() const			{ return _pimpl->isSatisfied(); }
+  bool PoolItem::isBroken() const			{ return _pimpl->isBroken(); }
+  bool PoolItem::isNeeded() const			{ return _pimpl->isNeeded(); }
+  bool PoolItem::isUnwanted() const			{ return _pimpl->isUnwanted(); }
 
-  void PoolItem::saveState() const
-  { _pimpl->saveState(); }
+  void PoolItem::saveState() const			{ _pimpl->saveState(); }
+  void PoolItem::restoreState() const			{ _pimpl->restoreState(); }
+  bool PoolItem::sameState() const			{ return _pimpl->sameState(); }
+  ResObject::constPtr PoolItem::resolvable() const	{ return _pimpl->resolvable(); }
 
-  void PoolItem::restoreState() const
-  { _pimpl->restoreState(); }
 
-  bool PoolItem::sameState() const
-  { return _pimpl->sameState(); }
-
-  /******************************************************************
-   **
-   **	FUNCTION NAME : operator<<
-   **	FUNCTION TYPE : std::ostream &
-  */
   std::ostream & operator<<( std::ostream & str, const PoolItem & obj )
-  {
-    return str << *obj._pimpl;
-  }
+  { return str << *obj._pimpl; }
 
-  /////////////////////////////////////////////////////////////////
 } // namespace zypp
 ///////////////////////////////////////////////////////////////////