Use an abstract helper for error handling and output

instead of doing this directly in the CacheSets.
With this method an application like apt-get can change
the behavior of the CacheSets to his liking.
It can for example easily keep track of how packages
were added to the set: by names or with regex's…

1 files changed, 71 insertions, 33 deletions

diff --git a/cmdline/cacheset.h b/cmdline/cacheset.h
index 64a72e758..9c9491020 100644
--- a/cmdline/cacheset.h
+++ b/cmdline/cacheset.h
@@ -20,6 +20,45 @@
 #include <apt-pkg/pkgcache.h>
 									/*}}}*/
 namespace APT {
+class PackageSet;
+class VersionSet;
+class CacheSetHelper {							/*{{{*/
+/** \class APT::CacheSetHelper
+    Simple base class with a lot of virtual methods which can be overridden
+    to alter the behavior or the output of the CacheSets.
+
+    This helper is passed around by the static methods in the CacheSets and
+    used every time they hit an error condition or something could be
+    printed out.
+*/
+public:									/*{{{*/
+	CacheSetHelper(bool const &ShowError = true) : ShowError(ShowError) {};
+	virtual ~CacheSetHelper() {};
+
+	virtual void showTaskSelection(PackageSet const &pkgset, string const &pattern) {};
+	virtual void showRegExSelection(PackageSet const &pkgset, string const &pattern) {};
+	virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
+				 string const &ver, bool const &verIsRel) {};
+
+	virtual PackageSet canNotFindTask(pkgCacheFile &Cache, std::string pattern);
+	virtual PackageSet canNotFindRegEx(pkgCacheFile &Cache, std::string pattern);
+	virtual PackageSet canNotFindPackage(pkgCacheFile &Cache, std::string const &str);
+	virtual VersionSet canNotFindAllVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
+	virtual VersionSet canNotFindInstCandVer(pkgCacheFile &Cache,
+				pkgCache::PkgIterator const &Pkg);
+	virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache,
+				pkgCache::PkgIterator const &Pkg);
+	virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache,
+				pkgCache::PkgIterator const &Pkg);
+	virtual pkgCache::VerIterator canNotFindInstalledVer(pkgCacheFile &Cache,
+				pkgCache::PkgIterator const &Pkg);
+
+	bool showErrors() const { return ShowError; };
+	bool showErrors(bool const &newValue) { if (ShowError == newValue) return ShowError; else return ((ShowError = newValue) == false); };
+									/*}}}*/
+protected:
+	bool ShowError;
+};									/*}}}*/
 class PackageSet : public std::set<pkgCache::PkgIterator> {		/*{{{*/
 /** \class APT::PackageSet
 
@@ -66,6 +105,7 @@ public:									/*{{{*/
 
 	using std::set<pkgCache::PkgIterator>::insert;
 	inline void insert(pkgCache::PkgIterator const &P) { if (P.end() == false) std::set<pkgCache::PkgIterator>::insert(P); };
+	inline void insert(PackageSet const &pkgset) { insert(pkgset.begin(), pkgset.end()); };
 
 	/** \brief returns all packages in the cache who belong to the given task
 
@@ -75,10 +115,10 @@ public:									/*{{{*/
 	    \param Cache the packages are in
 	    \param pattern name of the task
 	    \param out stream to print the notice to */
-	static APT::PackageSet FromTask(pkgCacheFile &Cache, std::string pattern, std::ostream &out);
+	static APT::PackageSet FromTask(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
 	static APT::PackageSet FromTask(pkgCacheFile &Cache, std::string const &pattern) {
-		std::ostream out (std::ofstream("/dev/null").rdbuf());
-		return APT::PackageSet::FromTask(Cache, pattern, out);
+		CacheSetHelper helper;
+		return APT::PackageSet::FromTask(Cache, pattern, helper);
 	}
 
 	/** \brief returns all packages in the cache whose name matchs a given pattern
@@ -89,10 +129,10 @@ public:									/*{{{*/
 	    \param Cache the packages are in
 	    \param pattern regular expression for package names
 	    \param out stream to print the notice to */
-	static APT::PackageSet FromRegEx(pkgCacheFile &Cache, std::string pattern, std::ostream &out);
+	static APT::PackageSet FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
 	static APT::PackageSet FromRegEx(pkgCacheFile &Cache, std::string const &pattern) {
-		std::ostream out (std::ofstream("/dev/null").rdbuf());
-		return APT::PackageSet::FromRegEx(Cache, pattern, out);
+		CacheSetHelper helper;
+		return APT::PackageSet::FromRegEx(Cache, pattern, helper);
 	}
 
 	/** \brief returns all packages specified by a string
@@ -100,10 +140,10 @@ public:									/*{{{*/
 	    \param Cache the packages are in
 	    \param string String the package name(s) should be extracted from
 	    \param out stream to print various notices to */
-	static APT::PackageSet FromString(pkgCacheFile &Cache, std::string const &string, std::ostream &out);
+	static APT::PackageSet FromString(pkgCacheFile &Cache, std::string const &string, CacheSetHelper &helper);
 	static APT::PackageSet FromString(pkgCacheFile &Cache, std::string const &string) {
-		std::ostream out (std::ofstream("/dev/null").rdbuf());
-		return APT::PackageSet::FromString(Cache, string, out);
+		CacheSetHelper helper;
+		return APT::PackageSet::FromString(Cache, string, helper);
 	}
 
 	/** \brief returns all packages specified on the commandline
@@ -113,10 +153,10 @@ public:									/*{{{*/
 	    \param Cache the packages are in
 	    \param cmdline Command line the package names should be extracted from
 	    \param out stream to print various notices to */
-	static APT::PackageSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline, std::ostream &out);
+	static APT::PackageSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper);
 	static APT::PackageSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
-		std::ostream out (std::ofstream("/dev/null").rdbuf());
-		return APT::PackageSet::FromCommandLine(Cache, cmdline, out);
+		CacheSetHelper helper;
+		return APT::PackageSet::FromCommandLine(Cache, cmdline, helper);
 	}
 
 	struct Modifier {
@@ -130,14 +170,14 @@ public:									/*{{{*/
 	static std::map<unsigned short, PackageSet> GroupedFromCommandLine(
 		pkgCacheFile &Cache, const char **cmdline,
 		std::list<PackageSet::Modifier> const &mods,
-		unsigned short const &fallback, std::ostream &out);
+		unsigned short const &fallback, CacheSetHelper &helper);
 	static std::map<unsigned short, PackageSet> GroupedFromCommandLine(
 		pkgCacheFile &Cache, const char **cmdline,
 		std::list<PackageSet::Modifier> const &mods,
 		unsigned short const &fallback) {
-		std::ostream out (std::ofstream("/dev/null").rdbuf());
+		CacheSetHelper helper;
 		return APT::PackageSet::GroupedFromCommandLine(Cache, cmdline,
-				mods, fallback, out);
+				mods, fallback, helper);
 	}
 									/*}}}*/
 };									/*}}}*/
@@ -189,6 +229,7 @@ public:									/*{{{*/
 
 	using std::set<pkgCache::VerIterator>::insert;
 	inline void insert(pkgCache::VerIterator const &V) { if (V.end() == false) std::set<pkgCache::VerIterator>::insert(V); };
+	inline void insert(VersionSet const &verset) { insert(verset.begin(), verset.end()); };
 
 	/** \brief specifies which version(s) will be returned if non is given */
 	enum Version {
@@ -216,22 +257,22 @@ public:									/*{{{*/
 	    \param cmdline Command line the versions should be extracted from
 	    \param out stream to print various notices to */
 	static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
-			APT::VersionSet::Version const &fallback, std::ostream &out);
+			APT::VersionSet::Version const &fallback, CacheSetHelper &helper);
 	static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
 			APT::VersionSet::Version const &fallback) {
-		std::ostream out (std::ofstream("/dev/null").rdbuf());
-		return APT::VersionSet::FromCommandLine(Cache, cmdline, fallback, out);
+		CacheSetHelper helper;
+		return APT::VersionSet::FromCommandLine(Cache, cmdline, fallback, helper);
 	}
 	static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
 		return APT::VersionSet::FromCommandLine(Cache, cmdline, CANDINST);
 	}
 
 	static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg,
-			APT::VersionSet::Version const &fallback, std::ostream &out);
+			APT::VersionSet::Version const &fallback, CacheSetHelper &helper);
 	static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg,
 			APT::VersionSet::Version const &fallback) {
-		std::ostream out (std::ofstream("/dev/null").rdbuf());
-		return APT::VersionSet::FromString(Cache, pkg, fallback, out);
+		CacheSetHelper helper;
+		return APT::VersionSet::FromString(Cache, pkg, fallback, helper);
 	}
 	static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg) {
 		return APT::VersionSet::FromString(Cache, pkg, CANDINST);
@@ -251,14 +292,14 @@ public:									/*{{{*/
 	static std::map<unsigned short, VersionSet> GroupedFromCommandLine(
 		pkgCacheFile &Cache, const char **cmdline,
 		std::list<VersionSet::Modifier> const &mods,
-		unsigned short const &fallback, std::ostream &out);
+		unsigned short const &fallback, CacheSetHelper &helper);
 	static std::map<unsigned short, VersionSet> GroupedFromCommandLine(
 		pkgCacheFile &Cache, const char **cmdline,
 		std::list<VersionSet::Modifier> const &mods,
 		unsigned short const &fallback) {
-		std::ostream out (std::ofstream("/dev/null").rdbuf());
+		CacheSetHelper helper;
 		return APT::VersionSet::GroupedFromCommandLine(Cache, cmdline,
-				mods, fallback, out);
+				mods, fallback, helper);
 	}
 									/*}}}*/
 protected:								/*{{{*/
@@ -266,23 +307,20 @@ protected:								/*{{{*/
 	/** \brief returns the candidate version of the package
 
 	    \param Cache to be used to query for information
-	    \param Pkg we want the candidate version from this package
-	    \param AllowError add an error to the stack if not */
+	    \param Pkg we want the candidate version from this package */
 	static pkgCache::VerIterator getCandidateVer(pkgCacheFile &Cache,
-		pkgCache::PkgIterator const &Pkg, bool const &AllowError = false);
+		pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
 
 	/** \brief returns the installed version of the package
 
 	    \param Cache to be used to query for information
-	    \param Pkg we want the installed version from this package
-	    \param AllowError add an error to the stack if not */
+	    \param Pkg we want the installed version from this package */
 	static pkgCache::VerIterator getInstalledVer(pkgCacheFile &Cache,
-		pkgCache::PkgIterator const &Pkg, bool const &AllowError = false);
-
+		pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
 
-	static bool AddSelectedVersion(pkgCacheFile &Cache, VersionSet &verset,
+	static void AddSelectedVersion(pkgCacheFile &Cache, VersionSet &verset,
 		pkgCache::PkgIterator const &P, VersionSet::Version const &fallback,
-		bool const &AllowError = false);
+		CacheSetHelper &helper);
 
 									/*}}}*/
 };									/*}}}*/