PMSelectionManager.h

Go to the documentation of this file.

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

  File:       PMSelectionManager.h

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

/-*/
#ifndef PMSelectionManager_h
#define PMSelectionManager_h

#include <iosfwd>
#include <list>
#include <map>

#include <y2pm/PMTypes.h>
#include <y2pm/PMManager.h>
#include <y2pm/PMSelection.h>
#include <y2pm/PMSelectable.h>
#include <y2pm/PMPackageManager.h>

//
//      CLASS NAME : PMSelectionManager
class PMSelectionManager : public PMManager {

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

  PMSelectionManager & operator=( const PMSelectionManager & );
  PMSelectionManager            ( const PMSelectionManager & );

  private:
    virtual void postPSI();
    virtual void postPAC();
    virtual void postPRC();

  private:

    friend class Y2PM;
    PMSelectionManager();
    virtual ~PMSelectionManager();

    typedef std::map<PMSelectablePtr,PMSelectable::Fate> ActiveMap;

    ActiveMap _last_active;

    void setLast( const PMSelectablePtr & sel_r, PMSelectable::Fate val_r );

    PMSelectable::Fate lastState( const PMSelectablePtr & sel_r ) const;

    PMSelectable::Fate getState( const PMSelectablePtr & sel_r ) const;

  private:

    ActiveMap saved_last_active;

  public:

    virtual void SaveState() {
      saved_last_active = _last_active;
      PMManager::SaveState();
    }

    virtual bool RestoreState() {
      if ( !PMManager::RestoreState() ) {
        saved_last_active.clear();
        return false;
      }
      _last_active = saved_last_active;
      return true;
    }

    virtual void ClearSaveState() {
      saved_last_active.clear();
      PMManager::ClearSaveState();
    }


  private:

    virtual PMObjectPtr assertObjectType( const PMObjectPtr & object_r ) const;

  private:

    // Remember selection packages fate.
    struct PkgFates {
      void add( PMSelectableVec & lhs, const PMSelectableVec & rhs ) {
        lhs.insert( rhs.begin(), rhs.end() );
      }
      public:
        // selections to install:
        PMSelectableVec pkgToDelete;   // hard request: get rid of it (delpack)
        PMSelectableVec pkgToInstall;  // hard request: (re)install it
        // unmodified but installed selections: protect inspacks from deletion (except by a delpack)
        PMSelectableVec pkgOnSystem;   // soft request: Keep it OnSystem.
        // selections to delete:
        PMSelectableVec pkgOffSystem;  // soft request: if no one minds, bring it OffSystem
        // EVERYTHING ELSE:
        PMSelectableVec pkgUnmodified; // is set to unmodified

        void addToDelete  ( const PMSelectableVec & rhs ) { add( pkgToDelete, rhs ); }
        void addToInstall ( const PMSelectableVec & rhs ) { add( pkgToInstall, rhs ); }
        void addOnSystem  ( const PMSelectableVec & rhs ) { add( pkgOnSystem, rhs ); }
        void addOffSystem ( const PMSelectableVec & rhs ) { add( pkgOffSystem, rhs ); }
        void addUnmodified( const PMSelectableVec & rhs ) { add( pkgUnmodified, rhs ); }
      public:
        PMSelectableVec pkgProcessed;

        void setNothingProcessed() { pkgProcessed.clear(); }

        void setProcessed( PMSelectableVec rhs ) {
          add( pkgProcessed, rhs );
          rhs.clear();
        }
        void processedToDelete()   { setProcessed( pkgToDelete ); }
        void processedToInstall()  { setProcessed( pkgToInstall ); }
        void processedOnSystem()   { setProcessed( pkgOnSystem ); }
        void processedOffSystem()  { setProcessed( pkgOffSystem ); }
        void processedUnmodified() { setProcessed( pkgUnmodified ); }

        bool didProcess( PMSelectablePtr pkg_r ) const {
          return( pkgProcessed.find( pkg_r ) != pkgProcessed.end() );
        }
    };

    PMError syncToPkgMgr( PkgFates & fates_r );

  public:

    PMError activate( PMPackageManager & package_mgr );

    PMError activate();

    PMError requestedLocalesChanged( const PM::LocaleSet & addLocales_r,
                                     const PM::LocaleSet & delLocales_r );

    PMError installOnTarget();

};


#endif // PMSelectionManager_h

---