*/
#include <iostream>
#include "zypp/base/Logger.h"
+#include "zypp/base/DefaultIntegral.h"
#include "zypp/PoolItem.h"
#include "zypp/ResPool.h"
//
// 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:
{}
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; }
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.
//@{
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;
}
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::isUndetermined() const
- { return _pimpl->isUndetermined(); }
- bool PoolItem::isRelevant() const
- { return _pimpl->isRelevant(); }
+ 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(); }
- bool PoolItem::isSatisfied() const
- { return _pimpl->isSatisfied(); }
+ 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(); }
- bool PoolItem::isBroken() const
- { return _pimpl->isBroken(); }
- 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(); }
-
- /******************************************************************
- **
- ** 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
///////////////////////////////////////////////////////////////////