*/
#include <iostream>
#include "zypp/base/Logger.h"
+#include "zypp/base/DefaultIntegral.h"
#include "zypp/PoolItem.h"
+#include "zypp/ResPool.h"
#include "zypp/Package.h"
#include "zypp/VendorAttr.h"
-#include "zypp/sat/Solvable.h"
-
using std::endl;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//
- // CLASS NAME : PoolItem_Ref::Impl
+ // CLASS NAME : PoolItem::Impl
//
- /** PoolItem_Ref implementation. */
- struct PoolItem_Ref::Impl
+ /** 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
{
- Impl()
- {}
+ public:
+ Impl() {}
- Impl( ResObject::constPtr res_r,
- const ResStatus & status_r = ResStatus() )
- : _status( status_r )
- , _resolvable( res_r )
- {
- autoprotect();
- }
+ Impl( ResObject::constPtr res_r,
+ const ResStatus & status_r )
+ : _status( status_r )
+ , _resolvable( res_r )
+ {}
- ResStatus & status() const
- { return _status; }
+ ResStatus & status() const
+ { return _buddy > 0 ? PoolItem(buddy()).status() : _status; }
- ResStatus & statusReset() const
- {
- if ( ! autoprotect() )
- {
- _status.setLock( false, zypp::ResStatus::USER );
- _status.resetTransact( zypp::ResStatus::USER );
- }
- return _status;
- }
+ sat::Solvable buddy() const
+ {
+ if ( !_buddy )
+ return sat::Solvable::noSolvable;
+ if ( _buddy < 0 )
+ return sat::Solvable( -_buddy );
+ return sat::Solvable( _buddy );
+ }
- ResObject::constPtr resolvable() const
- { return _resolvable; }
+ void setBuddy( sat::Solvable solv_r );
- bool autoprotect() const;
+ ResObject::constPtr resolvable() const
+ { return _resolvable; }
- const sat::Solvable & satSolvable() const
- { return _satSolvable; }
+ ResStatus & statusReset() const
+ {
+ _status.setLock( false, zypp::ResStatus::USER );
+ _status.resetTransact( zypp::ResStatus::USER );
+ return _status;
+ }
- void rememberSatSolvable( const sat::Solvable & slv_r ) const
- { _satSolvable = slv_r; }
+ public:
+ bool isUndetermined() const
+ {
+ return status().isUndetermined();
+ }
+
+ bool isRelevant() const
+ {
+ return !status().isNonRelevant();
+ }
- private:
- mutable ResStatus _status;
- ResObject::constPtr _resolvable;
- mutable sat::Solvable _satSolvable;
+ bool isSatisfied() const
+ {
+ 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.
- */
+ * \todo There may be better save/restore state strategies.
+ */
//@{
- public:
- void saveState() const
- { _savedStatus = _status; }
- void restoreState() const
- { _status = _savedStatus; }
- bool sameState() const
- {
- if ( _status.getTransactValue() != _savedStatus.getTransactValue()
- && !_status.isBySolver() )
- return false;
- if ( _status.isLicenceConfirmed() != _savedStatus.isLicenceConfirmed() )
- return false;
- return true;
- }
- private:
- mutable ResStatus _savedStatus;
+ public:
+ void saveState() const
+ { _savedStatus = status(); }
+ void restoreState() const
+ { status() = _savedStatus; }
+ bool sameState() const
+ {
+ 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() )
+ return false;
+ return true;
+ }
+ private:
+ mutable ResStatus _savedStatus;
//@}
- public:
- /** Offer default Impl. */
- static shared_ptr<Impl> nullimpl()
- {
- static shared_ptr<Impl> _nullimpl( new Impl );
- return _nullimpl;
- }
+ public:
+ /** Offer default Impl. */
+ static shared_ptr<Impl> nullimpl()
+ {
+ static shared_ptr<Impl> _nullimpl( new Impl );
+ return _nullimpl;
+ }
};
///////////////////////////////////////////////////////////////////
- /** \relates PoolItem_Ref::Impl Stream output */
- inline std::ostream & operator<<( std::ostream & str, const PoolItem_Ref::Impl & obj )
+ /** \relates PoolItem::Impl Stream output */
+ inline std::ostream & operator<<( std::ostream & str, const PoolItem::Impl & obj )
{
str << obj.status();
if (obj.resolvable())
return str;
}
- inline bool PoolItem_Ref::Impl::autoprotect() const
+ inline void PoolItem::Impl::setBuddy( sat::Solvable solv_r )
{
- if ( _status.isInstalled()
- && isKind<Package>( _resolvable )
- && VendorAttr::instance().autoProtect( _resolvable->vendor() ) )
- {
- _status.setLock( true, zypp::ResStatus::USER );
- MIL << "Protect vendor '" << _resolvable->vendor() << "' " << *this << endl;
- return true;
- }
- return false;
+ PoolItem myBuddy( solv_r );
+ if ( myBuddy )
+ {
+ myBuddy._pimpl->_buddy = -resolvable()->satSolvable().id();
+ _buddy = myBuddy.satSolvable().id();
+ DBG << *this << " has buddy " << myBuddy << endl;
+ }
}
///////////////////////////////////////////////////////////////////
//
- // CLASS NAME : PoolItem_Ref
+ // CLASS NAME : PoolItem
//
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//
- // METHOD NAME : PoolItem_Ref::PoolItem_Ref
+ // METHOD NAME : PoolItem::PoolItem
// METHOD TYPE : Ctor
//
- PoolItem_Ref::PoolItem_Ref()
+ PoolItem::PoolItem()
: _pimpl( Impl::nullimpl() )
{}
///////////////////////////////////////////////////////////////////
//
- // METHOD NAME : PoolItem_Ref::PoolItem_Ref
+ // METHOD NAME : PoolItem::PoolItem
// METHOD TYPE : Ctor
//
- PoolItem_Ref::PoolItem_Ref( ResObject::constPtr res_r )
- : _pimpl( new Impl( res_r ) )
+ PoolItem::PoolItem( const sat::Solvable & solvable_r )
+ : _pimpl( ResPool::instance().find( solvable_r )._pimpl )
{}
///////////////////////////////////////////////////////////////////
//
- // METHOD NAME : PoolItem_Ref::PoolItem_Ref
+ // METHOD NAME : PoolItem::PoolItem
// METHOD TYPE : Ctor
//
- PoolItem_Ref::PoolItem_Ref( ResObject::constPtr res_r, const ResStatus & status_r )
- : _pimpl( new Impl( res_r, status_r ) )
+ PoolItem::PoolItem( const ResObject::constPtr & resolvable_r )
+ : _pimpl( ResPool::instance().find( resolvable_r )._pimpl )
{}
///////////////////////////////////////////////////////////////////
//
- // METHOD NAME : PoolItem_Ref::~PoolItem_Ref
+ // 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() ) );
+ }
+
+ ///////////////////////////////////////////////////////////////////
+ //
+ // METHOD NAME : PoolItem::~PoolItem
// METHOD TYPE : Dtor
//
- PoolItem_Ref::~PoolItem_Ref()
+ PoolItem::~PoolItem()
{}
///////////////////////////////////////////////////////////////////
//
+ // METHOD NAME : PoolItem::pool
+ // METHOD TYPE : ResPool
+ //
+ ResPool PoolItem::pool() const
+ { return ResPool::instance(); }
+
+ ///////////////////////////////////////////////////////////////////
+ //
// Forward to Impl:
//
///////////////////////////////////////////////////////////////////
- ResStatus & PoolItem_Ref::status() const
+ ResStatus & PoolItem::status() const
{ return _pimpl->status(); }
- ResStatus & PoolItem_Ref::statusReset() const
+ ResStatus & PoolItem::statusReset() const
{ return _pimpl->statusReset(); }
- ResObject::constPtr PoolItem_Ref::resolvable() const
- { return _pimpl->resolvable(); }
+ sat::Solvable PoolItem::buddy() const
+ { return _pimpl->buddy(); }
+
+ void PoolItem::setBuddy( sat::Solvable solv_r )
+ { _pimpl->setBuddy( solv_r ); }
- void PoolItem_Ref::saveState() const
+ 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_Ref::restoreState() const
+ void PoolItem::restoreState() const
{ _pimpl->restoreState(); }
- bool PoolItem_Ref::sameState() const
+ bool PoolItem::sameState() const
{ return _pimpl->sameState(); }
- const sat::Solvable & PoolItem_Ref::satSolvable() const
- { return _pimpl->satSolvable(); }
-
- void PoolItem_Ref::rememberSatSolvable( const sat::Solvable & slv_r ) const
- { _pimpl->rememberSatSolvable( slv_r ); }
+ ResObject::constPtr PoolItem::resolvable() const
+ { return _pimpl->resolvable(); }
/******************************************************************
**
** FUNCTION NAME : operator<<
** FUNCTION TYPE : std::ostream &
*/
- std::ostream & operator<<( std::ostream & str, const PoolItem_Ref & obj )
+ std::ostream & operator<<( std::ostream & str, const PoolItem & obj )
{
return str << *obj._pimpl;
}
projects / platform / upstream / libzypp.git / blobdiff