[Aptitude-svn-commit] r3909 - in branches/aptitude-0.3/aptitude: .
src/generic src/generic/problemresolver
Daniel Burrows
dburrows at costa.debian.org
Wed Aug 17 23:52:11 UTC 2005
Author: dburrows
Date: Wed Aug 17 23:52:06 2005
New Revision: 3909
Modified:
branches/aptitude-0.3/aptitude/ChangeLog
branches/aptitude-0.3/aptitude/src/generic/aptcache.cc
branches/aptitude-0.3/aptitude/src/generic/aptcache.h
branches/aptitude-0.3/aptitude/src/generic/problemresolver/problemresolver.h
Log:
Allow the user to 'harden' soft dependencies. (untested)
Modified: branches/aptitude-0.3/aptitude/ChangeLog
==============================================================================
--- branches/aptitude-0.3/aptitude/ChangeLog (original)
+++ branches/aptitude-0.3/aptitude/ChangeLog Wed Aug 17 23:52:06 2005
@@ -1,5 +1,11 @@
2005-08-17 Daniel Burrows <dburrows at debian.org>
+ * src/generic/problemresolver/problemresolver.h, src/generic/aptcache.cc, src/generic/aptcache.h:
+
+ Add support for "hardening" soft dependencies; basically this
+ functions like a rejection of the decision to leave the
+ dependency unresolved.
+
* src/solution_screen.cc:
Use an aptitude_universe::dep, not a pkgCache::DepIterator, to
Modified: branches/aptitude-0.3/aptitude/src/generic/aptcache.cc
==============================================================================
--- branches/aptitude-0.3/aptitude/src/generic/aptcache.cc (original)
+++ branches/aptitude-0.3/aptitude/src/generic/aptcache.cc Wed Aug 17 23:52:06 2005
@@ -1488,6 +1488,50 @@
return resolver->is_mandatory(ver);
}
+void aptitudeDepCache::resolver_harden_dep(const aptitude_resolver_dep &dep)
+{
+ assert(resolver);
+
+ resolver->harden(dep);
+}
+
+void aptitudeDepCache::resolver_unharden_dep(const aptitude_resolver_dep &dep)
+{
+ assert(resolver);
+
+ resolver->unharden(dep);
+}
+
+bool aptitudeDepCache::resolver_is_hardened(const aptitude_resolver_dep &dep)
+{
+ assert(resolver);
+
+ return resolver->is_hardened(dep);
+}
+
+void aptitudeDepCache::resolver_force_break_dep(const aptitude_resolver_dep &dep)
+{
+ assert(resolver);
+
+ resolver->force_break(dep);
+}
+
+void aptitudeDepCache::resolver_unforce_break_dep(const aptitude_resolver_dep &dep)
+{
+ assert(resolver);
+
+ resolver->unforce_break(dep);
+}
+
+bool aptitudeDepCache::resolver_is_forced_broken(const aptitude_resolver_dep &dep)
+{
+ assert(resolver);
+
+ return resolver->is_forced_broken(dep);
+}
+
+
+
void aptitudeDepCache::apply_current_solution(undo_group *undo)
{
aptitude_resolver::solution sol=get_current_solution();
Modified: branches/aptitude-0.3/aptitude/src/generic/aptcache.h
==============================================================================
--- branches/aptitude-0.3/aptitude/src/generic/aptcache.h (original)
+++ branches/aptitude-0.3/aptitude/src/generic/aptcache.h Wed Aug 17 23:52:06 2005
@@ -42,6 +42,7 @@
class undo_group;
class pkgProblemResolver;
class aptitude_universe;
+class aptitude_resolver_dep;
class aptitude_resolver_version;
class aptitude_resolver;
template<class PkgUniverse> class generic_solution;
@@ -468,6 +469,33 @@
/** \return \b true if the given version is mandatory. */
bool resolver_is_mandatory(const aptitude_resolver_version &ver);
+
+
+ /** Requires that resolver_exists is \b true. Force the resolver to
+ * treat the given soft dependency as a hard dependency; as above,
+ * you can always cancel this instruction later.
+ */
+ void resolver_harden_dep(const aptitude_resolver_dep &dep);
+
+ /** Cancels a resolver_harden_dep call. */
+ void resolver_unharden_dep(const aptitude_resolver_dep &dep);
+
+ /** \return \b true if the given dep is hardened. */
+ bool resolver_is_hardened(const aptitude_resolver_dep &dep);
+
+ /** Requires that resolver_exists is \b true. Force the resolver to
+ * leave the given soft dependency broken.
+ */
+ void resolver_force_break_dep(const aptitude_resolver_dep &dep);
+
+ /** Cancels a resolver_force_break_dep call. */
+ void resolver_unforce_break_dep(const aptitude_resolver_dep &dep);
+
+ /** \return \b true if the given dep is forced-broken. */
+ bool resolver_is_forced_broken(const aptitude_resolver_dep &dep);
+
+
+
/** Advance to the next solution.
*
* \return the next solution. This reference is not guaranteed to
Modified: branches/aptitude-0.3/aptitude/src/generic/problemresolver/problemresolver.h
==============================================================================
--- branches/aptitude-0.3/aptitude/src/generic/problemresolver/problemresolver.h (original)
+++ branches/aptitude-0.3/aptitude/src/generic/problemresolver/problemresolver.h Wed Aug 17 23:52:06 2005
@@ -295,6 +295,11 @@
*/
std::set<version> user_rejected;
+ /** Stores dependencies that have been "hardened" by the user (that
+ * aren't allowed to default).
+ */
+ std::set<dep> user_hardened;
+
/** Stores generated solutions: */
std::vector<solution> generated_solutions;
@@ -1015,30 +1020,58 @@
/** Calculate whether the solution is rejected based on
* user_rejected by testing whether the intersection of the
- * solution and the rejected set is nonempty.
+ * solution domain and the rejected set is nonempty.
*/
- bool is_rejected(const solution &s)
+ bool is_rejected(const solution &s) const
{
- typename std::set<version>::const_iterator uf_iter
+ typename std::set<version>::const_iterator ur_iter
= user_rejected.begin();
- typename std::map<package, action>::const_iterator s_iter
+ typename std::map<package, action>::const_iterator sa_iter
= s.get_actions().begin();
- while(uf_iter != user_rejected.end() &&
- s_iter != s.get_actions().end())
+ while(ur_iter != user_rejected.end() &&
+ sa_iter != s.get_actions().end())
+ {
+ if(*ur_iter == sa_iter->second.ver)
+ return true;
+ else if(*ur_iter < sa_iter->second.ver)
+ ++ur_iter;
+ else
+ ++sa_iter;
+ }
+
+ return false;
+ }
+
+ bool breaks_hardened(const solution &s) const
+ {
+ typename std::set<dep>::const_iterator uh_iter
+ = user_hardened.begin();
+
+ typename std::set<dep>::const_iterator su_iter
+ = s.get_unresolved_soft_deps().end();
+
+ while(uh_iter != user_hardened.end() &&
+ su_iter != s.get_unresolved_soft_deps().end())
{
- if(*uf_iter == s_iter->second.ver)
+ if(*uh_iter == *su_iter)
return true;
- else if(*uf_iter < s_iter->second.ver)
- ++uf_iter;
+ else if(*uh_iter < *su_iter)
+ ++uh_iter;
else
- ++s_iter;
+ ++su_iter;
}
return false;
}
+ /** \return \b true if the given solution should be deferred. */
+ bool should_defer(const solution &s) const
+ {
+ return is_rejected(s) || breaks_hardened(s);
+ }
+
/** Place any solutions that were deferred and are no longer
* rejected back on the open queue.
*/
@@ -1055,7 +1088,7 @@
{
++j;
- if(!is_rejected(*i))
+ if(!should_defer(*i))
{
open.push(*i);
deferred.erase(i);
@@ -1172,7 +1205,7 @@
return false;
}
- else if(is_rejected(s))
+ else if(should_defer(s))
{
if(debug)
{
@@ -1701,6 +1734,67 @@
return true;
}
+ /** Query whether the given dependency is hardened. */
+ bool is_hardened(const dep &d) const
+ {
+ return user_hardened.find(d) != user_hardened.end();
+ }
+
+ /** Harden the given dependency. */
+ void harden(const dep &d)
+ {
+ assert(d.is_soft());
+
+ user_hardened.insert(d);
+ }
+
+ /** Un-harden (soften?) the given dependency. */
+ void unharden(const dep &d)
+ {
+ user_hardened.erase(d);
+ }
+
+ /** Query whether the given dependency is forced to be broken. */
+ bool is_forced_broken(const dep &d) const
+ {
+ if(user_hardened.find(d) != user_hardened.end())
+ return false;
+
+ for(typename dep::solver_iterator si = d.solvers_begin();
+ !si.end(); ++si)
+ if(!is_rejected(*si))
+ return false;
+
+ return true;
+ }
+
+ /** Force the given soft dependency to be broken.
+ *
+ * \param d a soft dependency.
+ */
+ void force_break(const dep &d)
+ {
+ assert(d.is_soft());
+
+ unharden(d);
+
+ for(typename dep::solver_iterator si = d.solvers_begin();
+ !si.end(); ++si)
+ reject(*si);
+ }
+
+ /** The given soft dependency must be forced-broken; allow it to be
+ * resolved in any way.
+ */
+ void unforce_break(const dep &d)
+ {
+ assert(is_forced_broken(d));
+
+ for(typename dep::solver_iterator si = d.solvers_begin();
+ !si.end(); ++si)
+ unreject(*si);
+ }
+
/** Try to find the "next" solution: remove partial solutions from
* the open queue and place them in the closed queue until one of
* the following occurs:
More information about the Aptitude-svn-commit
mailing list