[Aptitude-svn-commit] r4231 - in branches/aptitude-0.3/aptitude: . src/generic/problemresolver

[Daniel Burrows]

Author: dburrows
Date: Sat Sep 24 15:57:21 2005
New Revision: 4231

Modified:
   branches/aptitude-0.3/aptitude/ChangeLog
   branches/aptitude-0.3/aptitude/src/generic/problemresolver/problemresolver.h
Log:
Add a set of 'approved breaks' as an eventual replacement for 'forced breaks'.

Modified: branches/aptitude-0.3/aptitude/ChangeLog
==============================================================================
--- branches/aptitude-0.3/aptitude/ChangeLog	(original)
+++ branches/aptitude-0.3/aptitude/ChangeLog	Sat Sep 24 15:57:21 2005
@@ -2,6 +2,15 @@
 
 	* src/generic/problemresolver/problemresolver.h:
 
+	  Add a set of "approved breaks" that should provide a more
+	  sensible way of handling soft dependencies: instead of forbidden
+	  the dependency to be solved outright, it just says that we
+	  should place it in the 'unresolved' set whenever it comes up as
+	  an option.  In other words, it defers any solution in which an
+	  action is labelled with that dependency.
+
+	* src/generic/problemresolver/problemresolver.h:
+
 	  Fix the resolver indentation (finally).
 
 2005-09-24 Rubén Porras <nahoo at inicia.es>

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	Sat Sep 24 15:57:21 2005
@@ -414,6 +414,11 @@
    */
   std::set<dep> user_hardened;
 
+  /** Stores dependencies that the user has said should be broken if
+   *  they come up.
+   */
+  std::set<dep> user_approved_broken;
+
   /** Stores generated solutions: */
   std::vector<solution> generated_solutions;
 
@@ -1322,6 +1327,18 @@
     return false;
   }
 
+  bool solves_approved_broken(const solution &s) const
+  {
+    const imm::map<package, action> &actions = s.get_actions();
+
+    for(typename imm::map<package, action>::const_iterator
+	  ai = actions.begin(); ai != actions.end(); ++ai)
+      if(user_approved_broken.find(ai->second.d) != user_approved_broken.end())
+	return true;
+
+    return false;
+  }
+
   /** \return \b true if the given solution passed up an opportunity
    *          to include an 'mandated' version.
    */
@@ -1362,7 +1379,8 @@
    */
   bool impinges_user_constraint(const dep &d) const
   {
-    if(user_hardened.find(d) != user_hardened.end())
+    if(user_hardened.find(d) != user_hardened.end() ||
+       user_approved_broken.find(d) != user_approved_broken.end())
       return true;
 
     for(typename dep::solver_iterator si = d.solvers_begin();
@@ -1387,7 +1405,7 @@
   bool should_defer(const solution &s) const
   {
     return contains_rejected(s) || breaks_hardened(s) ||
-      avoids_mandated(s);
+      avoids_mandated(s) || solves_approved_broken(s);
   }
 
   /** Place any solutions that were deferred and are no longer
@@ -2172,6 +2190,44 @@
       }
   }
 
+  /** \return \b true if the given dependency is in the
+   *  approved-broken state.
+   */
+  bool is_approved_broken(const dep &d) const
+  {
+    return user_approved_broken.find(d) != user_approved_broken.end();
+  }
+
+  /** Approve the breaking of the given dependency. */
+  void approve_break(const dep &d, undo_group *undo = NULL) const
+  {
+    std::pair<typename std::set<dep>::const_iterator, bool>
+      insert_result = user_approved_broken.insert(d);
+
+    if(insert_result.second)
+      {
+	if(undo != NULL)
+	  undo->add_item(new undo_resolver_manipulation<PackageUniverse, dep>(this, d, &generic_problem_resolver<PackageUniverse>::unapprove_break));
+
+	unharden(d, undo);
+      }
+  }
+
+  /** Cancel the required breaking of the given dependency. */
+  void unapprove_break(const dep &d, undo_group *undo = NULL) const
+  {
+    typename std::set<dep>::size_type erased_count
+      = user_approved_broken.erase(d);
+
+    if(erased_count > 0)
+      {
+	if(undo != NULL)
+	  undo->add_item(new undo_resolver_manipulation<PackageUniverse, dep>(this, d, &generic_problem_resolver<PackageUniverse>::approve_break));
+
+	deferred_dirty = true;
+      }
+  }
+
   /** Query whether the given dependency is forced to be broken. */
   bool is_forced_broken(const dep &d) const
   {