PMSelectable.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

   File:       PMSelectable.h

   Author:     Michael Andres <ma@suse.de>
   Maintainer: Michael Andres <ma@suse.de>

/-*/
#ifndef PMSelectable_h
#define PMSelectable_h

#include <iosfwd>
#include <list>

#include <y2pm/PMSelectablePtr.h>

#include <y2pm/PMTypes.h>
#include <y2pm/SelState.h>
#include <y2pm/PkgName.h>
#include <y2pm/PkgArch.h>
#include <y2pm/PMObjectPtr.h>

class PMManager;
class SavedState;

//
//      CLASS NAME : PMSelectable
class PMSelectable : public CountedRep {
  REP_BODY(PMSelectable);

  public:

    typedef std::list<PMObjectPtr> PMObjectList;

    class SavedState {
      public:
        SavedState() {}
      private:
        friend class PMManager;

        PMSelectablePtr _item;
        SelState        _state;
        PMObjectPtr     _userCandidateObj;

        SavedState( const PMSelectablePtr & item_r );
        bool mayReplay() const;
        bool replay();
        bool diff() const;
    };

  private:

    friend class Y2PM;
    static bool setCandidateOrder( PM::CandidateOrder neworder_r );

    typedef bool (*ClistCompare)( const PMObjectPtr & lhs, const PMObjectPtr & rhs );

    static ClistCompare _clistCompare;

    static bool clistAVS( const PMObjectPtr & lhs, const PMObjectPtr & rhs );

    static bool clistASV( const PMObjectPtr & lhs, const PMObjectPtr & rhs );

  private:

    friend class PMManager;
    friend class SavedState;

    PMManager *      _manager;
    SelState         _state;

    void _mgr_attach( PMManager * mgr_r );
    void _mgr_detach();

    void _attach_obj( PMObjectPtr & obj_r );
    void _detach_obj( PMObjectPtr & obj_r );

    void setInstalledObj( PMObjectPtr obj_r );
    void delInstalledObj() { setInstalledObj( PMObjectPtr() ); }

    static bool clistIsBetter( const PMObjectPtr & lhs, const PMObjectPtr & rhs );
    void clistAdd( PMObjectPtr obj_r );
    void clistDel( PMObjectPtr obj_r );
    void clistSort();
    void clistClearAll();

    void clearAll();

    bool isEmpty() const;

    void check() const;

  private:

    PkgName _name;

    PMObjectPtr _installedObj;
    PMObjectPtr _candidateObj;
    PMObjectPtr _userCandidateObj;

    PMObjectList _candidateList;

    PMObjectList::iterator clistLookup( PMObjectPtr obj_r );

    void chooseCandidateObj();
    void clearCandidateObj();

  private:

    typedef void (PMManager::*SelectableNotify)( constPMSelectablePtr item_r, SelState old_r, SelState new_r );

    // If the Selectables state is manipulated through this,
    // a notify is triggered on state change.
    struct ObservedSelState {
      const PMSelectable * _item;
      SelState &           _cstate;
      PMManager *&         _mgr;
      SelectableNotify     _notifyFnc;

      ObservedSelState( SelState & cstate_r, const PMSelectable * item_r,
                        PMManager *& mgr_r, SelectableNotify notifyFnc_r )
        : _item( item_r )
        , _cstate( cstate_r )
        , _mgr( mgr_r )
        , _notifyFnc( notifyFnc_r )
          {}

      // signature of SelState:: state manipulating methods
      typedef bool (SelState::*Manip)( const bool doit );

      bool operator()( Manip manip, const bool doit ) {
        if ( _mgr && _notifyFnc ) {
          SelState old( _cstate );
          bool ret = (_cstate.*manip)( doit );
          if ( old != _cstate ) {
            (_mgr->*_notifyFnc)( _item, old, _cstate );
          }
          return ret;
        }
        // no Manager to notify
        return (_cstate.*manip)( doit );
      }
    };

    ObservedSelState _observedState; // !decl. AFTER _manager _name and _state

  public:

    //PMSelectable();

    PMSelectable( const PkgName & name_r, SelectableNotify notify_Fnc_r = 0 );

    virtual ~PMSelectable();

  public:

    const PkgName & name() const { return _name; }

    PMObjectPtr installedObj() const { return _installedObj; }

    PMObjectPtr candidateObj() const { return _candidateObj; }

    unsigned availableObjs() const { return _candidateList.size(); }

    PMObjectList::const_iterator av_begin() const { return _candidateList.begin(); }

    PMObjectList::const_iterator av_end() const { return _candidateList.end(); }

    PMObjectList::const_reverse_iterator av_rbegin() const { return _candidateList.rbegin(); }

    PMObjectList::const_reverse_iterator av_rend() const { return _candidateList.rend(); }

  public:

    PMObjectPtr theObject() const {
      if ( _candidateObj )
        return _candidateObj;
      if ( _installedObj )
        return _installedObj;
      PMObjectPtr ret = bestCandidate();
      if ( ret )
        return ret;
      if ( availableObjs() )
        return *av_begin();
      return PMObjectPtr();
    }

    PMObjectPtr autoCandidate() const;

    PMObjectPtr userCandidate() const {
      return _userCandidateObj;
    }

    PMObjectPtr bestCandidate() const {
      PMObjectPtr ret = userCandidate();
      if ( ret )
        return ret;
      return autoCandidate();
    }

    bool setUserCandidate( const PMObjectPtr & obj_r );

    bool clrUserCandidate() { return setUserCandidate( PMObjectPtr() ); }

  public:

    // Keep this order, it's used for sorting package lists!
    // Dangerous / noteworthy states are sorted first.
    //
    // sh@suse.de

    enum UI_Status {
      S_Protected,           // Keep this unmodified ( have installedObj && S_Protected )
      S_Taboo,               // Keep this unmodified ( have no installedObj && S_Taboo)
      // requested by user:
      S_Del,                 // delete  installedObj ( clears S_Protected if set )
      S_Update,              // install candidateObj ( have installedObj, clears S_Protected if set )
      S_Install,             // install candidateObj ( have no installedObj, clears S_Taboo if set )
      // not requested by user:
      S_AutoDel,             // delete  installedObj
      S_AutoUpdate,          // install candidateObj ( have installedObj )
      S_AutoInstall,         // install candidateObj ( have no installedObj )
      // no modification:
      S_KeepInstalled,       // no modification      ( have installedObj && !S_Protected, clears S_Protected if set )
      S_NoInst,              // no modification      ( have no installedObj && !S_Taboo, clears S_Taboo if set )
    };

    friend std::ostream & operator<<( std::ostream & str, UI_Status obj );

  private:

    bool intern_set_status( const UI_Status state_r, const bool doit );

  public:

    bool set_status( const UI_Status state_r );

    bool test_set_status( const UI_Status state_r ) { return intern_set_status( state_r, false ); }

    UI_Status status() const;

  public:

    bool providesSources() const;

    bool set_source_install( const bool install_r );

    bool source_install() const { return _state.is_srcins(); }

  public:

    enum Fate {
      TO_DELETE  = -1,
      UNMODIFIED = 0,
      TO_INSTALL = 1
    };

    static Fate fate( SelState state_r ) {
      if ( state_r.to_modify() ) {
        return( state_r.to_delete() ? TO_DELETE : TO_INSTALL );
      }
      return UNMODIFIED;
    }

    Fate fate() const { return fate( _state ); }

    void setNothingSelected() { _observedState( &SelState::user_unset, true ); }

    bool downgrade_condition() const;

    // public usable part of SelState

    bool has_object()    const { return _state.has_object(); }

    bool has_installed() const { return _state.has_installed(); }

    bool has_candidate() const { return _state.has_candidate(); }

    bool has_both_objects() const { return _state.has_both_objects(); }

    bool has_installed_only() const { return _state.has_installed_only(); }

    bool has_candidate_only() const { return _state.has_candidate_only(); }

  public:

    bool to_modify()     const { return _state.to_modify(); }

    bool to_delete()     const { return _state.to_delete(); }

    bool to_install()    const { return _state.to_install(); }

  public:

    bool by_user()       const { return _state.by_user(); }

    bool by_appl()       const { return _state.by_appl(); }

    bool by_auto()       const { return _state.by_auto(); }

  public:

    bool is_taboo()      const { return _state.is_taboo(); }

  public:

    bool user_unset() { return _observedState( &SelState::user_unset, true ); }

    bool user_set_delete() { return _observedState( &SelState::user_set_delete, true ); }

    bool user_set_install() { return _observedState( &SelState::user_set_install, true ); }

    bool user_set_taboo() { return _observedState( &SelState::user_set_taboo, true ); }

    bool user_clr_taboo() { return _observedState( &SelState::user_clr_taboo, true ); }

  public:

    bool appl_unset() { return _observedState( &SelState::appl_unset, true ); }

    bool appl_set_delete() { return _observedState( &SelState::appl_set_delete, true ); }

    bool appl_force_install() { return _observedState( &SelState::appl_set_install, true ); }

    bool appl_set_install() { return !downgrade_condition() && appl_force_install(); }

  public:

    bool auto_unset() { return _observedState( &SelState::auto_unset, true ); }

    bool auto_set_delete() { return _observedState( &SelState::auto_set_delete, true ); }

    bool auto_force_install() { return _observedState( &SelState::auto_set_install, true ); }

    bool auto_set_install() { return !downgrade_condition() && auto_force_install(); }

  private:

    bool do_set_onSystem( bool (PMSelectable::*fnc_unset)(), bool (PMSelectable::*fnc_install)() ) {
      if ( has_installed() ) {
        if ( ! to_delete() )
          return true; // already onSystem
        return (this->*fnc_unset)();
      } else {
        if ( to_install() )
          return true; // already onSystem
        return (this->*fnc_install)();
      }
    }

    bool do_set_offSystem( bool (PMSelectable::*fnc_unset)(), bool (PMSelectable::*fnc_delete)() ) {
      if ( has_installed() ) {
        if ( to_delete() )
          return true; // already offSystem
        return (this->*fnc_delete)();
      } else {
        if ( ! to_install() )
          return true; // already offSystem
        return (this->*fnc_unset)();
      }
    }

  public:

    bool is_onSystem() const {
      if ( has_installed() )
        return( ! to_delete() );
      else
        return( to_install() );
    }

    bool is_offSystem() const { return( ! is_onSystem() ); }

    bool user_set_onSystem() { return do_set_onSystem( &PMSelectable::user_unset, &PMSelectable::user_set_install ); }

    bool user_set_offSystem() { return do_set_offSystem( &PMSelectable::user_unset, &PMSelectable::user_set_delete ); }

    bool appl_set_onSystem() { return do_set_onSystem( &PMSelectable::appl_unset, &PMSelectable::appl_set_install ); }

    bool appl_set_offSystem() { return do_set_offSystem( &PMSelectable::appl_unset, &PMSelectable::appl_set_delete ); }

    bool auto_set_onSystem() { return do_set_onSystem( &PMSelectable::auto_unset, &PMSelectable::auto_set_install ); }

    bool auto_set_offSystem() { return do_set_offSystem( &PMSelectable::auto_unset, &PMSelectable::auto_set_delete ); }

  public:

    virtual std::ostream & dumpOn( std::ostream & str ) const;

    std::ostream & dumpStateOn( std::ostream & str ) const;

  public:

    typedef bool (PMSelectable::*Test_method)() const;

    typedef bool (*Test_fnc)( const constPMSelectablePtr & sel_r );

    static bool test( const constPMSelectablePtr & sel_r, Test_method fnc_r ) {
      if ( sel_r && fnc_r )
        return (sel_r.operator->()->*fnc_r)();
      return false;
    }
};


#endif // PMSelectable_h

---