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;

      ResObject::Kind 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 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 _Res>
      typename ResTraits<_Res>::constPtrType installedAsKind() const
      { return asKind<_Res>( candidateObj() ); }

      template<class _Res>
      typename ResTraits<_Res>::constPtrType candidateAsKind() const
      { return asKind<_Res>( 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;


      bool installedEmpty() const;
      installed_size_type installedSize() const;
      installed_iterator installedBegin() const;
      installed_iterator installedEnd() const;
      //}


      bool picklistEmpty() const;
      picklist_size_type picklistSize() const;
      picklist_iterator picklistBegin() const;
      picklist_iterator picklistEnd() const;
      //}


    public:
      bool hasObject() const
      { return (! installedEmpty()) || candidateObj(); }

      bool hasInstalledObj() const
      { return ! installedEmpty(); }

      bool hasCandidateObj() const
      { return candidateObj(); }

      bool hasBothObjects() const
      { return (! installedEmpty()) && candidateObj(); }

      bool hasInstalledObjOnly() const
      { return (! installedEmpty()) && ! candidateObj(); }

      bool hasCandidateObjOnly() const
      { return ( installedEmpty() ) && candidateObj(); }

      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 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:
      class 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