Delete get_terms() and find_obscured_terms().

Originally, I thought these would be useful in the analysis that's used
to generate the Xapian search.  However, I ended up not using them, and
they don't have a good definition with the prefix-search stuff that's
coming up, so I've just removed them for now.

1 files changed, 0 insertions, 284 deletions

diff --git a/src/generic/apt/matching/match.cc b/src/generic/apt/matching/match.cc
index 6510c163..bb1761a2 100644
--- a/src/generic/apt/matching/match.cc
+++ b/src/generic/apt/matching/match.cc
@@ -2444,290 +2444,6 @@ namespace aptitude
       }
     }
 
-    /** \brief Get all the terms used inside ?term in the given
-     *  pattern.
-     *
-     *  \param p   The pattern to analyze.
-     *
-     *  \param output  A set into which the terms will be
-     *                 placed;
-     */
-    void get_terms(const ref_ptr<pattern> &p,
-		   std::set<std::string> &output)
-    {
-      switch(p->get_type())
-	{
-	  // Structural patterns:
-	case pattern::all_versions:
-	  get_terms(p->get_all_versions_pattern(),
-		    output);
-	  break;
-
-	case pattern::and_tp:
-	  for(std::vector<ref_ptr<pattern> >::const_iterator it =
-		p->get_and_patterns().begin();
-	      it != p->get_and_patterns().end(); ++it)
-	    get_terms(*it, output);
-	  break;
-
-	case pattern::any_version:
-	  get_terms(p->get_any_version_pattern(),
-		    output);
-	  break;
-
-	case pattern::for_tp:
-	  get_terms(p->get_for_pattern(),
-		    output);
-	  break;
-
-	case pattern::narrow:
-	  get_terms(p->get_narrow_filter(),
-		    output);
-	  get_terms(p->get_narrow_pattern(),
-		    output);
-	  break;
-
-	case pattern::not_tp:
-	  get_terms(p->get_not_pattern(),
-		    output);
-	  break;
-
-	case pattern::or_tp:
-	  for(std::vector<ref_ptr<pattern> >::const_iterator it =
-		p->get_or_patterns().begin();
-	      it != p->get_or_patterns().end(); ++it)
-	    get_terms(*it, output);
-	  break;
-
-	case pattern::widen:
-	  get_terms(p->get_widen_pattern(),
-		    output);
-	  break;
-
-	  // Atomic patterns with sub-patterns:
-	case pattern::bind:
-	  get_terms(p->get_bind_pattern(),
-		    output);
-	  break;
-
-	case pattern::depends:
-	  get_terms(p->get_depends_pattern(),
-		    output);
-	  break;
-
-	case pattern::provides:
-	  get_terms(p->get_provides_pattern(),
-		    output);
-	  break;
-
-	case pattern::reverse_depends:
-	  get_terms(p->get_reverse_depends_pattern(),
-		    output);
-	  break;
-
-	case pattern::reverse_provides:
-	  get_terms(p->get_reverse_provides_pattern(),
-		    output);
-	  break;
-
-	  // Terms themselves:
-	case pattern::term:
-	  output.insert(p->get_term_term());
-	  break;
-
-	  // Atomic patterns with no sub-patterns:
-	case pattern::archive:
-	case pattern::action:
-	case pattern::automatic:
-	case pattern::broken:
-	case pattern::broken_type:
-	case pattern::candidate_version:
-	case pattern::config_files:
-	case pattern::current_version:
-	case pattern::description:
-	case pattern::essential:
-	case pattern::equal:
-	case pattern::false_tp:
-	case pattern::garbage:
-	case pattern::install_version:
-	case pattern::installed:
-	case pattern::maintainer:
-	case pattern::name:
-	case pattern::new_tp:
-	case pattern::obsolete:
-	case pattern::origin:
-	case pattern::priority:
-	case pattern::section:
-	case pattern::source_package:
-	case pattern::source_version:
-	case pattern::tag:
-	case pattern::task:
-	case pattern::true_tp:
-	case pattern::upgradable:
-	case pattern::user_tag:
-	case pattern::version:
-	case pattern::virtual_tp:
-	  // Nothing to do; they won't have sub-terms.
-	  break;
-
-	default:
-	  throw MatchingException(std::string("Internal error: unhandled pattern type in ") + __func__);
-	}
-    }
-
-    /** \brief Return all the "obscured" terms in the
-     *  given pattern.
-     *
-     *  Obscured terms are terms hidden inside constructs like ?bind
-     *  and ?depends that we can't generate a sensible Xapian query
-     *  for.
-     *
-     *  \param p   The pattern to analyze
-     *  \param output   The set into which the obscured terms
-     *                  will be placed.
-     *  \param top_level_obscured   Normally false; if true,
-     *                              terms at the top level
-     *                              will be treated as if
-     *                              they are obscured.
-     */
-    void find_obscured_terms(const ref_ptr<pattern> &p,
-			     std::set<std::string> &output,
-			     bool top_level_obscured)
-    {
-      switch(p->get_type())
-	{
-	  // Structural patterns:
-	case pattern::all_versions:
-	  find_obscured_terms(p->get_all_versions_pattern(),
-			      output,
-			      top_level_obscured);
-	  break;
-
-	case pattern::and_tp:
-	  for(std::vector<ref_ptr<pattern> >::const_iterator it =
-		p->get_and_patterns().begin();
-	      it != p->get_and_patterns().end(); ++it)
-	    find_obscured_terms(*it, output,
-				top_level_obscured);
-	  break;
-
-	case pattern::any_version:
-	  find_obscured_terms(p->get_any_version_pattern(),
-			      output,
-			      top_level_obscured);
-	  break;
-
-	case pattern::for_tp:
-	  find_obscured_terms(p->get_for_pattern(),
-			      output,
-			      top_level_obscured);
-	  break;
-
-	case pattern::narrow:
-	  find_obscured_terms(p->get_narrow_filter(),
-			      output,
-			      top_level_obscured);
-	  find_obscured_terms(p->get_narrow_pattern(),
-			      output,
-			      top_level_obscured);
-	  break;
-
-	case pattern::not_tp:
-	  find_obscured_terms(p->get_not_pattern(),
-			      output,
-			      top_level_obscured);
-	  break;
-
-	case pattern::or_tp:
-	  for(std::vector<ref_ptr<pattern> >::const_iterator it =
-		p->get_or_patterns().begin();
-	      it != p->get_or_patterns().end(); ++it)
-	    find_obscured_terms(*it, output,
-				top_level_obscured);
-	  break;
-
-	case pattern::widen:
-	  find_obscured_terms(p->get_widen_pattern(),
-			      output,
-			      top_level_obscured);
-	  break;
-
-	  // Atomic patterns with sub-patterns:
-	case pattern::bind:
-	  find_obscured_terms(p->get_bind_pattern(),
-			      output,
-			      true);
-	  break;
-
-	case pattern::depends:
-	  find_obscured_terms(p->get_depends_pattern(),
-			      output,
-			      true);
-	  break;
-
-	case pattern::provides:
-	  find_obscured_terms(p->get_provides_pattern(),
-			      output,
-			      true);
-	  break;
-
-	case pattern::reverse_depends:
-	  find_obscured_terms(p->get_reverse_depends_pattern(),
-			      output,
-			      true);
-	  break;
-
-	case pattern::reverse_provides:
-	  find_obscured_terms(p->get_reverse_provides_pattern(),
-			      output,
-			      true);
-	  break;
-
-	  // Terms themselves:
-	case pattern::term:
-	  if(top_level_obscured)
-	    output.insert(p->get_term_term());
-	  break;
-
-	  // Atomic patterns with no sub-patterns:
-	case pattern::archive:
-	case pattern::action:
-	case pattern::automatic:
-	case pattern::broken:
-	case pattern::broken_type:
-	case pattern::candidate_version:
-	case pattern::config_files:
-	case pattern::current_version:
-	case pattern::description:
-	case pattern::essential:
-	case pattern::equal:
-	case pattern::false_tp:
-	case pattern::garbage:
-	case pattern::install_version:
-	case pattern::installed:
-	case pattern::maintainer:
-	case pattern::name:
-	case pattern::new_tp:
-	case pattern::obsolete:
-	case pattern::origin:
-	case pattern::priority:
-	case pattern::section:
-	case pattern::source_package:
-	case pattern::source_version:
-	case pattern::tag:
-	case pattern::task:
-	case pattern::true_tp:
-	case pattern::upgradable:
-	case pattern::user_tag:
-	case pattern::version:
-	case pattern::virtual_tp:
-	  break;
-
-	default:
-	  throw MatchingException(std::string("Internal error: unhandled pattern type in ") + __func__);
-	}
-    }
-
     ref_ptr<structural_match>
     get_match(const ref_ptr<pattern> &p,
 	      const pkgCache::PkgIterator &pkg,