PkgDep.h

Go to the documentation of this file.

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

   File:       PkgDep.h
   Purpose:    All functions for solving dependences
   Author:     Ludwig Nussel <lnussel@suse.de>
   Maintainer: Ludwig Nussel <lnussel@suse.de>

   copied and modified from phi
/-*/

#ifndef _PkgDep_h
#define _PkgDep_h

#include <iostream>
#include <list>
#include <deque>

#include <y2pm/PkgName.h>
#include <y2pm/PkgEdition.h>
#include <y2pm/PkgRevRel.h>
#include <y2pm/PkgSet.h>
#include <y2pm/Alternatives.h>

class PkgDep {

        // ------------------------------ types ------------------------------

  public:
        enum alternative_kind {
                SIMPLE, REQUIRES_MORE, CONFLICT
        };
        enum alternatives_mode {
                ASK_ALWAYS, ASK_IF_NO_DEFAULT, AUTO_IF_NO_DEFAULT, AUTO_ALWAYS
        };

        struct RelInfo {

                enum Kind {
                        REQUIREMENT = 0, CONFLICT, OBSOLETION
                };

                PkgName name;
                PkgRelation rel;

                Kind kind;

                PMSolvablePtr solvable;

                RelInfo( PMSolvablePtr s, PkgRelation r, Kind k = REQUIREMENT )
                        : name(s->name()), rel(r),
                        kind(k), solvable(s)
                        {}
                RelInfo( PkgName n, PkgRelation r, Kind k = REQUIREMENT, PMSolvablePtr s = NULL )
                        : name(n), rel(r), kind(k), solvable(s)
                        {}
                RelInfo( PkgRevRelation r, Kind k = REQUIREMENT )
                        : name(r.pkg()->name()), rel(r.relation()),
                        kind(k), solvable(r.pkg())
                        {}
        };

        struct Alternative {
                PMSolvablePtr solvable;
                alternative_kind kind;

                Alternative( PMSolvablePtr p, alternative_kind k )
                        : solvable(p), kind(k) {}
        };

        typedef Alternatives::AltDefaultList (*AlternativesCallback)( PkgName name );

        struct NeededEditionRange {
                PkgEdition greater;
                PkgEdition less;
                bool less_incl : 1;
                bool greater_incl : 1;

                NeededEditionRange()
                        : greater(PkgEdition::UNSPEC), less(PkgEdition::UNSPEC),
                          less_incl(false), greater_incl(false) {}
                bool allows_any() const {
                        return greater.is_unspecified() && less.is_unspecified();
                }
                bool impossible() const {
                        return( (less < greater) ||
                                        (less == greater && (!less_incl || !greater_incl)) );
                }
                void merge( const PkgRelation& rel );
        };

        typedef std::list<PkgName> NameList;
        typedef NameList::iterator NameList_iterator;
        typedef NameList::const_iterator NameList_const_iterator;

        typedef std::list<RelInfo> RelInfoList;
        typedef RelInfoList::iterator RelInfoList_iterator;
        typedef RelInfoList::const_iterator RelInfoList_const_iterator;

        typedef std::list<PMSolvablePtr> SolvableList;

  private:
        struct Notes;

  public:
        struct Result
        {
                PkgName name;
                PkgEdition edition;

                PMSolvablePtr solvable;

                RelInfoList referers;
                PkgEdition is_upgrade_from;
                PkgEdition is_downgrade_from;
                bool from_input_list : 1;
                bool upgrade_to_remove_conflict : 1;
                bool install_to_avoid_break : 1;

                RelInfoList was_inconsistent;

                Result(const PkgDep& pkgdep, PMSolvablePtr pkg);

                Result(const PkgDep& pkgdep, const PkgName& name);
                void add_notes( const Notes& notes );
        };

        struct ErrorResult : public Result {
                bool not_available;
                NeededEditionRange not_avail_range;
                RelInfoList unresolvable;
                std::list<Alternative> alternatives;

                RelInfoList conflicts_with;
                SolvableList remove_to_solve_conflict;

                SolvableList remove_referers;

                ErrorResult(const PkgDep& pkgdep, PMSolvablePtr pkg);
                ErrorResult(const PkgDep& pkgdep, const PkgName& name);
                ErrorResult(const Result& res);

                void add_unresolvable( PMSolvablePtr s, const PkgRelation& rel );
                void add_conflict( const PkgRevRelation& rrel,
                                                   const PkgDep& dep,
                                                   PMSolvablePtr to_remove,
                                                   PMSolvablePtr assume_instd,
                                                   RelInfo::Kind kind = RelInfo::CONFLICT,
                                                   const PkgSet* candidates = NULL);
                void add_conflict( PMSolvablePtr s, const PkgRelation& rel,
                                                   const PkgDep& dep,
                                                   PMSolvablePtr to_remove,
                                                   PMSolvablePtr assume_instd,
                                                   RelInfo::Kind kind = RelInfo::CONFLICT,
                                                   const PkgSet* candidates = NULL);
                void add_alternative( PMSolvablePtr p, alternative_kind k );
                void add_notes( const Notes& notes );

                bool state_change_not_possible;

                bool _error;
        };

        friend class Result;
        friend class ErrorResult;
        typedef std::list<Result> ResultList;
        typedef std::list<ErrorResult> ErrorResultList;
        
  private:

        class P;
        P* _dp;
        friend class P;

        // disallow copy and assign for now
        PkgDep(const PkgDep&);
        PkgDep& operator=(const PkgDep&);

        typedef std::list<PkgRevRelation> RevRelList;
        typedef RevRelList::iterator RevRelList_iterator;
        typedef RevRelList::const_iterator RevRelList_const_iterator;

        enum search_result { NONE, ONE, MULTI };

        struct IRelInfo {
                PMSolvablePtr pkg;
                PkgRelation rel;

                IRelInfo( PMSolvablePtr p, PkgRelation r ) : pkg(p), rel(r) {}
        };

        typedef std::list<IRelInfo> IRelInfoList;
        typedef IRelInfoList::iterator IRelInfoList_iterator;
        typedef IRelInfoList::const_iterator IRelInfoList_const_iterator;

        struct Notes {
                bool from_input : 1;
                bool upgrade_to_solve_conflict : 1;
                bool install_to_avoid_break : 1;
                bool not_available : 1;

                // the inconsistent package was not available
                bool inconsistent_notavailable : 1;
                RelInfoList was_inconsistent;

                IRelInfoList referers;
                NeededEditionRange not_avail_range;

                Notes() : from_input(false), upgrade_to_solve_conflict(false),
                        install_to_avoid_break(false),
                        not_available(false)
                        {}
        };

        typedef std::map<PkgName,Notes> Notes_type;
        typedef Notes_type::iterator Notes_iterator;
        typedef Notes_type::const_iterator Notes_const_iterator;

        struct AltInfo {
                PMSolvablePtr pkg;
                PkgRelation req;
                RevRelList providers;
                ErrorResult result;
                
                AltInfo( PMSolvablePtr p, const PkgRelation& r, const RevRelList& l,
                                 const ErrorResult& rs )
                        : pkg(p), req(r), providers(l), result(rs) {}
        };

        typedef std::deque<AltInfo> AltInfoList;
        typedef AltInfoList::iterator AltInfo_iterator;
        typedef AltInfoList::const_iterator AltInfo_const_iterator;
        
        // ---------------------------- static vars ----------------------------
//      static const PkgSet *default_avail;

        // initialisation in utils.cc
        static alternatives_mode default_alternatives_mode;
        static unsigned default_max_remove;

        // --------------------------- instance vars ---------------------------
        PkgSet installed;
        const PkgSet& available;

        AlternativesCallback _alternatives_callback;

        // --------------------- used during an install run --------------------
        PkgSet vinstalled;
        PkgSet *candidates;
        Notes_type notes;
        std::deque<PMSolvablePtr > to_check;
        ErrorResultList* i_obsoleted; // obsolete packages
        ResultList *good;
        ErrorResultList *bad;

        bool _install_installed;

        // -------------------------- private methods --------------------------
        // install.cc
        void add_package( PMSolvablePtr cand );
        search_result search_for_provider( const PkgRelation& req,
                                                                           PMSolvablePtr referer,
                                                                           ErrorResult *res );
        bool check_for_broken_reqs( PMSolvablePtr oldpkg, PMSolvablePtr newpkg,
                                                                ErrorResult &res );
        bool req_ok_after_upgrade( const PkgRelation& rel, PMSolvablePtr oldpkg,
                                                           PMSolvablePtr newpkg );
        // remove.cc
        void virtual_remove_package( PMSolvablePtr pkg, SolvableList& to_remove,
                                                                 PMSolvablePtr assume_instd = NULL, const PkgSet* candidates = NULL) const;
        // utils.cc
        bool also_provided_by_installed( const PkgRelation& rel );
        PMSolvablePtr upgrade_solves_conflict( PMSolvablePtr pkg,
                                                                                        const PkgRelation& confl );
        PMSolvablePtr try_upgrade_conflictor( PMSolvablePtr pkg,
                                                                                   const PkgRelation& provides );
        PMSolvablePtr try_upgrade_conflicted( PMSolvablePtr pkg,
                                                                                   const PkgRelation& confl );
        PMSolvablePtr try_upgrade_requirerer( PMSolvablePtr pkg,
                                                                                   PMSolvablePtr oldpkg,
                                                                                   PMSolvablePtr newpkg );
        PMSolvablePtr available_upgrade( PMSolvablePtr pkg );
        void do_upgrade_for_conflict( PMSolvablePtr upgrade );
        bool has_conflict_with( const PkgRelation& confl, PMSolvablePtr pkg );
        void add_referer( const PkgName& name, PMSolvablePtr referer,
                                          const PkgRelation& rel );
        void add_referer( PMSolvablePtr pkg, PMSolvablePtr referer,
                                          const PkgRelation& rel ) {
                add_referer( pkg->name(), referer, rel );
        }
        void add_not_available( PMSolvablePtr referer, const PkgRelation& rel );

        // return empty list
        static Alternatives::AltDefaultList default_alternatives_callback( PkgName name )
        {
                return Alternatives::AltDefaultList();
        }

public:
        PkgDep( PkgSet& instd, const PkgSet& avail,
                        AlternativesCallback alternatives_callback = default_alternatives_callback,
                        alternatives_mode m = default_alternatives_mode );
        ~PkgDep();
                
//      PkgDep(  const PkgSet& instd, alternatives_mode m=default_alternatives_mode)
//              : alt_mode(m), installed(instd), available(*default_avail), _pool(pool) {}
/*      PkgDep( alternatives_mode m = default_alternatives_mode )
                : alt_mode(m), installed(PkgSet(DTagListI0())),
                  available(*default_avail) {}
*/
        bool install( PkgSet& candidates,
                          ResultList& good,
                          ErrorResultList& bad,
                          ErrorResultList& out_obsoleted,
                          bool commit_to_installed = true,
                          bool check_inconsistent = false);
        void remove( SolvableList& pkgs );
        bool consistent( ErrorResultList& failures );
        /*
        bool upgrade(   PkgSet&candidates, ResultList& out_good,
                        ErrorResultList& out_bad, SolvableList& to_remove,
                        bool all = false, bool none = false,
                        unsigned max_remove = default_max_remove );
        */

        bool solvesystemnoauto(
                PkgSet &candidates,
                ResultList& out_good,
                ErrorResultList& out_bad,
                ErrorResultList& out_obsoleted);


        const PkgSet& current_installed() { return installed; }
        
        const PkgSet& current_available() { return available; }

        // set defaults
/*
        static void set_default_available( const PkgSet& av ) {
                default_avail = &av;
        }
*/
        void set_alternatives_mode(alternatives_mode mode);
        
        void set_alternatives_callback(Alternatives::AltDefaultList (*alternatives_callback)( PkgName name ))
        {
                _alternatives_callback = alternatives_callback;
        }

        void install_installed(bool yes)
            { _install_installed = yes; }

        static void set_default_alternatives_mode( alternatives_mode m ) {
                default_alternatives_mode = m;
        }

        static void set_default_max_remove( unsigned mr ) {
                default_max_remove = mr;
        }

    public: // static members

        static void remove_package( PkgSet *set, PMSolvablePtr pkg,
                                                 SolvableList& to_remove, const PkgSet* candidates = NULL);

        static unsigned count_providers_for( const PkgSet* set, const PkgRelation& req );
};

// output.cc
std::ostream& operator<<( std::ostream& os, const PkgDep::Result& res );
std::ostream& operator<<( std::ostream& os, const PkgDep::ErrorResult& res );
std::ostream& operator<<( std::ostream& os, const PkgDep::RelInfoList& rl );
std::ostream& operator<<( std::ostream& os, const std::list<PkgDep::Alternative>& al );
std::ostream& operator<<( std::ostream& os, const PkgDep::NameList& nl );
std::ostream& operator<<( std::ostream& os, const PkgDep::NeededEditionRange& range );

#endif  /* _PkgDep_h */

// Local Variables:
// tab-width: 4
// End:

---