Selectable.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_UI_SELECTABLE_H
#define ZYPP_UI_SELECTABLE_H
 
#include <iosfwd>
 
#include <zypp/base/ReferenceCounted.h>
#include <zypp/base/NonCopyable.h>
#include <zypp/base/PtrTypes.h>
#include <zypp/base/Iterator.h>
 
#include <zypp/ui/SelectableTraits.h>
#include <zypp/ui/Status.h>
 
namespace zypp
{ 
 
  namespace ui
  { 
 
    DEFINE_PTR_TYPE(Selectable);
 
    //
    //  CLASS NAME : Selectable
    //
    class Selectable : public base::ReferenceCounted, private base::NonCopyable
    {
      friend std::ostream & operator<<( std::ostream & str, const Selectable & obj );
      friend std::ostream & dumpOn( std::ostream & str, const Selectable & obj );
 
    public:
      typedef intrusive_ptr<Selectable>        Ptr;
      typedef intrusive_ptr<const Selectable>  constPtr;
 
      typedef SelectableTraits::available_iterator      available_iterator;
      typedef SelectableTraits::available_size_type     available_size_type;
 
      typedef SelectableTraits::installed_iterator      installed_iterator;
      typedef SelectableTraits::installed_size_type     installed_size_type;
 
      typedef SelectableTraits::picklist_iterator       picklist_iterator;
      typedef SelectableTraits::picklist_size_type      picklist_size_type;
 
    public:
      static Ptr get( const pool::ByIdent & ident_r );
 
      static Ptr get( IdString ident_r )
      { return get( pool::ByIdent( ident_r ) ); }
 
      static Ptr get( ResKind kind_r, const std::string & name_r )
      { return get( pool::ByIdent( kind_r, name_r ) ); }
 
      static Ptr get( const std::string & name_r )
      { return get( pool::ByIdent( ResKind::package, name_r ) ); }
 
      static Ptr get( const sat::Solvable & solv_r )
      { return get( pool::ByIdent( solv_r ) ); }
 
      static Ptr get( const ResObject::constPtr & resolvable_r )
      { return resolvable_r ? get( resolvable_r->satSolvable() ) : Ptr(); }
 
      static Ptr get( const PoolItem & pi_r )
      { return get( pi_r.satSolvable() ); }
 
    public:
      IdString ident() const;
 
      ResKind kind() const;
 
      const std::string & name() const;
 
      PoolItem installedObj() const;
 
      PoolItem candidateObj() const;
 
      PoolItem candidateObjFrom( Repository repo_r ) const;
 
      PoolItem updateCandidateObj() const;
 
      PoolItem highestAvailableVersionObj() const;
 
      bool identIsAutoInstalled() const;
 
      bool identicalAvailable( const PoolItem & rhs ) const;
 
      bool identicalInstalled( const PoolItem & rhs ) const;
 
      bool identicalInstalledCandidate() const
      { return identicalInstalled( candidateObj() ); }
 
      bool identicalInstalledUpdateCandidate() const
      { return identicalInstalled( updateCandidateObj() ); }
 
      PoolItem identicalAvailableObj( const PoolItem & rhs ) const;
 
      PoolItem identicalInstalledObj( const PoolItem & rhs ) const;
 
      template<class TRes>
      typename ResTraits<TRes>::constPtrType installedAsKind() const
      { return asKind<TRes>( candidateObj() ); }
 
      template<class TRes>
      typename ResTraits<TRes>::constPtrType candidateAsKind() const
      { return asKind<TRes>( candidateObj() ); }
 
      PoolItem setCandidate( const PoolItem & newCandidate_r, ResStatus::TransactByValue causer_r = ResStatus::USER );
      PoolItem setCandidate( ResObject::constPtr newCandidate_r, ResStatus::TransactByValue causer_r = ResStatus::USER );
 
      bool setOnSystem( const PoolItem & newCandidate_r, ResStatus::TransactByValue causer_r = ResStatus::USER );
 
      PoolItem theObj() const;
 
 
      bool availableEmpty() const;
      available_size_type availableSize() const;
      available_iterator availableBegin() const;
      available_iterator availableEnd() const;
      inline Iterable<available_iterator>  available() const
      { return makeIterable( availableBegin(), availableEnd() ); }
 
 
      bool installedEmpty() const;
      installed_size_type installedSize() const;
      installed_iterator installedBegin() const;
      installed_iterator installedEnd() const;
      inline Iterable<installed_iterator> installed() const
      { return makeIterable( installedBegin(), installedEnd() ); }
 
 
      bool picklistEmpty() const;
      picklist_size_type picklistSize() const;
      picklist_iterator picklistBegin() const;
      picklist_iterator picklistEnd() const;
      inline Iterable<picklist_iterator> picklist() const
      { return makeIterable( picklistBegin(), picklistEnd() ); }
 
      static constexpr const picklist_size_type picklistNoPos = picklist_size_type(-1);
 
      picklist_size_type picklistPos( const PoolItem & pi_r ) const;
 
      picklist_size_type picklistPos( const sat::Solvable & solv_r ) const;
 
 
    public:
      bool hasObject() const
      { return (! installedEmpty()) || candidateObj(); }
 
      bool hasInstalledObj() const
      { return ! installedEmpty(); }
 
      bool hasCandidateObj() const
      { return bool(candidateObj()); }
 
      bool hasBothObjects() const
      { return (! installedEmpty()) && candidateObj(); }
 
      bool hasInstalledObjOnly() const
      { return (! installedEmpty()) && ! candidateObj(); }
 
      bool hasCandidateObjOnly() const
      { return ( installedEmpty() ) && candidateObj(); }
 
 
      bool hasBlacklisted() const;
 
      bool hasBlacklistedInstalled() const;
 
      bool hasRetracted() const;
 
      bool hasRetractedInstalled() const;
 
      bool hasPtf() const;
 
      bool hasPtfInstalled() const;
 
      bool isUnmaintained() const;
 
      bool multiversionInstall() const;
 
      bool pickInstall( const PoolItem & pi_r, ResStatus::TransactByValue causer_r = ResStatus::USER, bool yesno_r = true );
 
      bool pickNoInstall( const PoolItem & pi_r, ResStatus::TransactByValue causer_r = ResStatus::USER )
      { return pickInstall( pi_r, causer_r, false ); }
 
      bool pickDelete( const PoolItem & pi_r, ResStatus::TransactByValue causer_r = ResStatus::USER, bool yesno_r = true );
 
      bool pickNoDelete( const PoolItem & pi_r, ResStatus::TransactByValue causer_r = ResStatus::USER )
      { return pickDelete( pi_r, causer_r, false ); }
 
      Status pickStatus( const PoolItem & pi_r ) const;
 
      bool setPickStatus( const PoolItem & pi_r, Status state_r, ResStatus::TransactByValue causer_r = ResStatus::USER );
 
      bool isUndetermined() const;
 
      bool isRelevant() const;
 
      bool isSatisfied() const;
 
      bool isBroken() const;
 
      bool isNeeded() const;
 
       bool isUnwanted() const;
 
     public:
      enum Fate {
        TO_DELETE  = -1,
        UNMODIFIED = 0,
        TO_INSTALL = 1
      };
      Fate fate() const;
 
      bool unmodified() const
      { return fate() == UNMODIFIED; }
 
      bool locked() const
      { Status st( status() ); return( st == S_Protected || st == S_Taboo ); }
 
      bool hasLocks() const;
 
      bool toModify() const
      { return fate() != UNMODIFIED; }
 
      bool toDelete() const
      { return fate() == TO_DELETE; }
 
      bool toInstall() const
      { return fate() == TO_INSTALL; }
 
      bool onSystem() const
      { return( ( hasInstalledObj() && !toDelete() )
              ||( hasCandidateObj() && toInstall() ) ); }
 
      bool offSystem() const
      { return ! onSystem(); }
 
      bool setFate( Fate fate_r, ResStatus::TransactByValue causer_r = ResStatus::USER );
 
      bool setToInstall( ResStatus::TransactByValue causer_r = ResStatus::USER )
      { return setFate( TO_INSTALL, causer_r ); }
 
      bool setInstalled( ResStatus::TransactByValue causer_r = ResStatus::USER );
 
      bool setUpToDate( ResStatus::TransactByValue causer_r = ResStatus::USER );
 
      bool setToDelete( ResStatus::TransactByValue causer_r = ResStatus::USER )
      { return setFate( TO_DELETE, causer_r ); }
 
      bool setDeleted( ResStatus::TransactByValue causer_r = ResStatus::USER );
 
      bool unset( ResStatus::TransactByValue causer_r = ResStatus::USER )
      { return setFate( UNMODIFIED, causer_r ); }
 
    public:
      Status status() const;
 
      bool setStatus( Status state_r, ResStatus::TransactByValue causer_r = ResStatus::USER );
 
      ResStatus::TransactByValue modifiedBy() const;
 
      bool hasLicenceConfirmed() const;
 
      void setLicenceConfirmed( bool val_r = true );
 
    public:
      struct Impl;
      typedef shared_ptr<Impl> Impl_Ptr;
      Selectable( Impl_Ptr pimpl_r );
    private:
      ~Selectable();
    private:
      RW_pointer<Impl> _pimpl;
    };
 
    std::ostream & operator<<( std::ostream & str, const Selectable & obj );
 
    std::ostream & dumpOn( std::ostream & str, const Selectable & obj );
 
    struct asSelectable
    {
      typedef Selectable_Ptr result_type;
 
      Selectable_Ptr operator()( const sat::Solvable & solv_r ) const;
 
      Selectable_Ptr operator()( const PoolItem & pi_r ) const
      { return operator()( pi_r.satSolvable() ); }
    };
 
  } // namespace ui
} // namespace zypp
#endif // ZYPP_UI_SELECTABLE_H