[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