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

[Daniel Burrows]

Author: dburrows
Date: Sat Sep 24 16:11:21 2005
New Revision: 4232

Modified:
   branches/aptitude-0.3/aptitude/ChangeLog
   branches/aptitude-0.3/aptitude/src/generic/resolver_manager.cc
   branches/aptitude-0.3/aptitude/src/generic/resolver_manager.h
Log:
Eliminate a bunch of duplicated code.

Modified: branches/aptitude-0.3/aptitude/ChangeLog
==============================================================================
--- branches/aptitude-0.3/aptitude/ChangeLog	(original)
+++ branches/aptitude-0.3/aptitude/ChangeLog	Sat Sep 24 16:11:21 2005
@@ -1,5 +1,9 @@
 2005-09-24  Daniel Burrows  <dburrows at debian.org>
 
+	* src/generic/resolver_manager.cc, src/generic/resolver_manager.h:
+
+	  Collect all the resolver manipulations into a common routine.
+
 	* src/generic/problemresolver/problemresolver.h:
 
 	  Add a set of "approved breaks" that should provide a more

Modified: branches/aptitude-0.3/aptitude/src/generic/resolver_manager.cc
==============================================================================
--- branches/aptitude-0.3/aptitude/src/generic/resolver_manager.cc	(original)
+++ branches/aptitude-0.3/aptitude/src/generic/resolver_manager.cc	Sat Sep 24 16:11:21 2005
@@ -707,15 +707,15 @@
   return rbox.take();
 }
 
-void resolver_manager::reject_version(const aptitude_resolver_version &ver)
+template<typename T>
+void resolver_manager::resolver_manipulation(const T &t,
+					     void (generic_problem_resolver<aptitude_universe>::*action)(const T &, undo_group *))
 {
   threads::mutex::lock l(mutex);
   background_suspender bs(*this);
 
-  assert(resolver);
-
   undo_group *undo = new undo_group;
-  resolver->reject_version(ver, undo);
+  (resolver->*action)(t, undo);
   if(undo->empty())
     delete undo;
   else
@@ -726,27 +726,14 @@
   state_changed();
 }
 
-void resolver_manager::unreject_version(const aptitude_resolver_version &ver)
+void resolver_manager::reject_version(const aptitude_resolver_version &ver)
 {
-  threads::mutex::lock l(mutex);
-  background_suspender bs(*this);
-
-  assert(resolver);
-
-  undo_group *undo = new undo_group;
-  resolver->unreject_version(ver, undo);
-  if(undo->empty())
-    delete undo;
-  else
-    undos->add_item(undo);
-
-
-  out_of_solutions.take();
-  out_of_solutions.put(false);
+  resolver_manipulation(ver, &aptitude_resolver::reject_version);
+}
 
-  l.release();
-  bs.unsuspend();
-  state_changed();
+void resolver_manager::unreject_version(const aptitude_resolver_version &ver)
+{
+  resolver_manipulation(ver, &aptitude_resolver::unreject_version);
 }
 
 bool resolver_manager::is_rejected(const aptitude_resolver_version &ver)
@@ -759,43 +746,12 @@
 
 void resolver_manager::mandate_version(const aptitude_resolver_version &ver)
 {
-  threads::mutex::lock l(mutex);
-  background_suspender bs(*this);
-
-  assert(resolver);
-
-  undo_group *undo = new undo_group;
-  resolver->mandate_version(ver, undo);
-  if(undo->empty())
-    delete undo;
-  else
-    undos->add_item(undo);
-
-  l.release();
-  bs.unsuspend();
-  state_changed();
+  resolver_manipulation(ver, &aptitude_resolver::mandate_version);
 }
 
 void resolver_manager::unmandate_version(const aptitude_resolver_version &ver)
 {
-  threads::mutex::lock l(mutex);
-  background_suspender bs(*this);
-
-  assert(resolver);
-
-  undo_group *undo = new undo_group;
-  resolver->unmandate_version(ver, undo);
-  if(undo->empty())
-    delete undo;
-  else
-    undos->add_item(undo);
-
-  out_of_solutions.take();
-  out_of_solutions.put(false);
-
-  l.release();
-  bs.unsuspend();
-  state_changed();
+  resolver_manipulation(ver, &aptitude_resolver::unmandate_version);
 }
 
 bool resolver_manager::is_mandatory(const aptitude_resolver_version &ver)
@@ -808,43 +764,12 @@
 
 void resolver_manager::harden_dep(const aptitude_resolver_dep &dep)
 {
-  threads::mutex::lock l(mutex);
-  background_suspender bs(*this);
-
-  assert(resolver);
-
-  undo_group *undo = new undo_group;
-  resolver->harden(dep, undo);
-  if(undo->empty())
-    delete undo;
-  else
-    undos->add_item(undo);
-
-  l.release();
-  bs.unsuspend();
-  state_changed();
+  resolver_manipulation(dep, &aptitude_resolver::harden);
 }
 
 void resolver_manager::unharden_dep(const aptitude_resolver_dep &dep)
 {
-  threads::mutex::lock l(mutex);
-  background_suspender bs(*this);
-
-  assert(resolver);
-
-  undo_group *undo = new undo_group;
-  resolver->unharden(dep);
-  if(undo->empty())
-    delete undo;
-  else
-    undos->add_item(undo);
-
-  out_of_solutions.take();
-  out_of_solutions.put(false);
-
-  l.release();
-  bs.unsuspend();
-  state_changed();
+  resolver_manipulation(dep, &aptitude_resolver::unharden);
 }
 
 bool resolver_manager::is_hardened(const aptitude_resolver_dep &dep)

Modified: branches/aptitude-0.3/aptitude/src/generic/resolver_manager.h
==============================================================================
--- branches/aptitude-0.3/aptitude/src/generic/resolver_manager.h	(original)
+++ branches/aptitude-0.3/aptitude/src/generic/resolver_manager.h	Sat Sep 24 16:11:21 2005
@@ -43,7 +43,9 @@
 class aptitude_resolver_version;
 class aptitude_resolver_dep;
 template<typename PackageUniverse> class generic_solution;
+template<typename PackageUniverse> class generic_problem_resolver;
 class aptitude_resolver;
+class undo_group;
 class undo_list;
 
 /** Manages a resolver for a single cache object.  When broken
@@ -284,9 +286,18 @@
    */
   void unsuspend_background_thread();
 
-
   /** Create a resolver if necessary. */
   void maybe_create_resolver();
+
+  /** Collects common code for the resolver manipulations such as
+   *  reject_version, unreject_version, etc: locks this class,
+   *  suspends the resolver, runs the manipulation and adds any undo
+   *  that is generated to the undo list, and finally executes
+   *  state_changed().
+   */
+  template<typename T>
+  void resolver_manipulation(const T &t,
+			     void (generic_problem_resolver<aptitude_universe>::*action)(const T &, undo_group *));
 public:
   /** Create a new resolver manager for the given cache file. */
   resolver_manager(aptitudeDepCache *cache);
@@ -436,6 +447,7 @@
   /** \return \b true if the given dep is hardened. */
   bool is_hardened(const aptitude_resolver_dep &dep);
 
+
   /** Requires that resolver_exists is \b true.  Force the resolver to
    *  leave the given soft dependency broken.
    */
@@ -448,6 +460,7 @@
   bool is_forced_broken(const aptitude_resolver_dep &dep);
 
 
+
   /** \return \b true if undo items exist in this resolver manager. */
   bool has_undo_items();