inline operator Str const *() const {return S == OwnerPointer() ? 0 : S;};
inline Str &operator *() {return *S;};
inline Str const &operator *() const {return *S;};
- inline pkgCache *Cache() {return Owner;};
+ inline pkgCache *Cache() const {return Owner;};
// Mixed stuff
inline void operator =(const Itr &B) {S = B.S; Owner = B.Owner;};
srcrecords.cc cachefile.cc versionmatch.cc policy.cc \
pkgsystem.cc indexfile.cc pkgcachegen.cc acquire-item.cc \
indexrecords.cc vendor.cc vendorlist.cc cdrom.cc indexcopy.cc \
- aptconfiguration.cc
+ aptconfiguration.cc packageset.cc
HEADERS+= algorithms.h depcache.h pkgcachegen.h cacheiterators.h \
orderlist.h sourcelist.h packagemanager.h tagfile.h \
init.h pkgcache.h version.h progress.h pkgrecords.h \
--- /dev/null
+// -*- mode: cpp; mode: fold -*-
+// Description /*{{{*/
+/* ######################################################################
+
+ Simple wrapper around a std::set to provide a similar interface to
+ a set of packages as to the complete set of all packages in the
+ pkgCache.
+
+ ##################################################################### */
+ /*}}}*/
+// Include Files /*{{{*/
+#include <apt-pkg/error.h>
+#include <apt-pkg/packageset.h>
+#include <apt-pkg/strutl.h>
+
+#include <apti18n.h>
+
+#include <regex.h>
+ /*}}}*/
+namespace APT {
+// FromRegEx - Return all packages in the cache matching a pattern /*{{{*/
+PackageSet PackageSet::FromRegEx(pkgCache &Cache, const char * const pattern, std::ostream &out) {
+ PackageSet pkgset;
+
+ const char * I;
+ for (I = pattern; *I != 0; I++)
+ if (*I == '.' || *I == '?' || *I == '+' || *I == '*' ||
+ *I == '|' || *I == '[' || *I == '^' || *I == '$')
+ break;
+ if (*I == 0)
+ return pkgset;
+
+ regex_t Pattern;
+ int Res;
+ if ((Res = regcomp(&Pattern, pattern , REG_EXTENDED | REG_ICASE | REG_NOSUB)) != 0) {
+ char Error[300];
+ regerror(Res, &Pattern, Error, sizeof(Error));
+ _error->Error(_("Regex compilation error - %s"), Error);
+ return pkgset;
+ }
+
+ for (pkgCache::GrpIterator Grp = Cache.GrpBegin(); Grp.end() == false; ++Grp)
+ {
+ if (regexec(&Pattern, Grp.Name(), 0, 0, 0) != 0)
+ continue;
+ pkgCache::PkgIterator Pkg = Grp.FindPkg("native");
+ if (unlikely(Pkg.end() == true))
+ // FIXME: Fallback to different architectures here?
+ continue;
+
+ ioprintf(out, _("Note, selecting %s for regex '%s'\n"),
+ Pkg.Name(), pattern);
+
+ pkgset.insert(Pkg);
+ }
+
+ regfree(&Pattern);
+
+ return pkgset;
+}
+ /*}}}*/
+}
#ifndef APT_PACKAGESET_H
#define APT_PACKAGESET_H
// Include Files /*{{{*/
+#include <iostream>
+#include <fstream>
+#include <set>
#include <string>
+
#include <apt-pkg/pkgcache.h>
/*}}}*/
namespace APT {
const_iterator(std::set<pkgCache::PkgIterator>::const_iterator x) :
std::set<pkgCache::PkgIterator>::const_iterator(x) {}
+ operator pkgCache::PkgIterator(void) { return **this; }
+
inline const char *Name() const {return (*this)->Name(); }
inline std::string FullName(bool const &Pretty) const { return (*this)->FullName(Pretty); }
inline std::string FullName() const { return (*this)->FullName(); }
inline pkgCache::PkgIterator::OkState State() const { return (*this)->State(); }
inline const char *CandVersion() const { return (*this)->CandVersion(); }
inline const char *CurVersion() const { return (*this)->CurVersion(); }
- inline pkgCache *Cache() {return (*this)->Cache();};
+ inline pkgCache *Cache() const { return (*this)->Cache(); };
+ inline unsigned long Index() const {return (*this)->Index();};
friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, (*i)); }
};
// 103. set::iterator is required to be modifiable, but this allows modification of keys
typedef typename APT::PackageSet::const_iterator iterator;
+
+ /** \brief returns all packages in the cache whose name matchs a given pattern
+
+ A simple helper responsible for executing a regular expression on all
+ package names in the cache. Optional it prints a a notice about the
+ packages chosen cause of the given package.
+ \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(pkgCache &Cache, const char *pattern, std::ostream &out);
+ static APT::PackageSet FromRegEx(pkgCache &Cache, const char *pattern) {
+ std::ostream out (std::ofstream("/dev/null").rdbuf());
+ return APT::PackageSet::FromRegEx(Cache, pattern, out);
+ }
+
/*}}}*/
};
/*}}}*/
#include <apt-pkg/sptr.h>
#include <apt-pkg/md5.h>
#include <apt-pkg/versionmatch.h>
-
+#include <apt-pkg/packageset.h>
+
#include <config.h>
#include <apti18n.h>
Packages++;
if (Pkg.end() == true)
{
- // Check if the name is a regex
- const char *I;
- for (I = S; *I != 0; I++)
- if (*I == '?' || *I == '*' || *I == '|' ||
- *I == '[' || *I == '^' || *I == '$')
- break;
- if (*I == 0)
+ APT::PackageSet pkgset = APT::PackageSet::FromRegEx(Cache, S, c1out);
+ if (pkgset.empty() == true)
return _error->Error(_("Couldn't find package %s"),S);
// Regexs must always be confirmed
ExpectedInst += 1000;
-
- // Compile the regex pattern
- regex_t Pattern;
- int Res;
- if ((Res = regcomp(&Pattern,S,REG_EXTENDED | REG_ICASE |
- REG_NOSUB)) != 0)
- {
- char Error[300];
- regerror(Res,&Pattern,Error,sizeof(Error));
- return _error->Error(_("Regex compilation error - %s"),Error);
- }
-
- // Run over the matches
+
bool Hit = false;
- for (pkgCache::GrpIterator Grp = Cache->GrpBegin(); Grp.end() == false; ++Grp)
+ for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
{
- if (regexec(&Pattern,Grp.Name(),0,0,0) != 0)
- continue;
- Pkg = Grp.FindPkg("native");
- if (unlikely(Pkg.end() == true))
- continue;
-
- ioprintf(c1out,_("Note, selecting %s for regex '%s'\n"),
- Pkg.Name(),S);
-
if (VerTag != 0)
if (TryToChangeVer(Pkg,Cache,VerTag,VerIsRel) == false)
return false;
-
+
Hit |= TryToInstall(Pkg,Cache,Fix,Remove,BrokenFix,
ExpectedInst,false);
}
- regfree(&Pattern);
-
+
if (Hit == false)
return _error->Error(_("Couldn't find package %s"),S);
}
- add a virtual destructor to FTWScanner class (for cppcheck)
* apt-pkg/packageset.h:
- add a simple wrapper around std::set for packages with it
+ - move regex magic from apt-get to new FromRegEx method
-- David Kalnischkies <kalnischkies@gmail.com> Sat, 29 May 2010 19:09:05 +0200
HCoop / ntk / apt.git / commitdiff