Selectable.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_UI_SELECTABLE_H
#define ZYPP_UI_SELECTABLE_H
 
#include <iosfwd>
#include <utility>
 
#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 ZYPP_API 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:
      using Ptr = intrusive_ptr<Selectable>;
      using constPtr = intrusive_ptr<const Selectable>;

      using available_iterator = SelectableTraits::available_iterator;
      using available_size_type = SelectableTraits::available_size_type;
 
      using installed_iterator = SelectableTraits::installed_iterator;
      using installed_size_type = SelectableTraits::installed_size_type;
 
      using picklist_iterator = SelectableTraits::picklist_iterator;
      using picklist_size_type = SelectableTraits::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( std::move(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;

       * \see \ref identicalInstalled.
       */
      bool identicalInstalledCandidate() const
      { return identicalInstalled( candidateObj() ); }

       * \see \ref identicalInstalled.
       */
      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( const 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;

      std::vector<std::string> supersededBy() 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 );

      /** Deselect a specific available item from installation.
      */
      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 );

      /** Deselect a specific installed item from deletion.
       */
      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; }

       * \see \ref hasLocks
       */
      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;
      using Impl_Ptr = shared_ptr<Impl>;
      Selectable( Impl_Ptr pimpl_r );
    private:
      ~Selectable() override;
    private:
      RW_pointer<Impl> _pimpl;
    };


    std::ostream & operator<<( std::ostream & str, const Selectable & obj ) ZYPP_API;

    std::ostream & dumpOn( std::ostream & str, const Selectable & obj ) ZYPP_API;

    struct ZYPP_API asSelectable
    {
      using result_type = Selectable_Ptr;
 
      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