apt-pkg/cacheset.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 /** \file cacheset.h
   4    Wrappers around std::set to have set::iterators which behave
   5    similar to the Iterators of the cache structures.
   6
   7    Provides also a few helper methods which work with these sets */
   8                                                                         /*}}}*/
   9 #ifndef APT_CACHESET_H
  10 #define APT_CACHESET_H
  11 // Include Files                                                        /*{{{*/
  12 #include <fstream>
  13 #include <map>
  14 #include <set>
  15 #include <list>
  16 #include <vector>
  17 #include <string>
  18 #include <iterator>
  19 #include <algorithm>
  20
  21 #include <stddef.h>
  22
  23 #include <apt-pkg/error.h>
  24 #include <apt-pkg/pkgcache.h>
  25 #include <apt-pkg/cacheiterators.h>
  26
  27 #ifndef APT_8_CLEANER_HEADERS
  28 #include <apt-pkg/cachefile.h>
  29 #endif
  30 #ifndef APT_10_CLEANER_HEADERS
  31 #include <iostream>
  32 #endif
  33                                                                         /*}}}*/
  34
  35 class pkgCacheFile;
  36
  37 namespace APT {
  38 class PackageContainerInterface;
  39 class VersionContainerInterface;
  40
  41 class CacheSetHelper {                                                  /*{{{*/
  42 /** \class APT::CacheSetHelper
  43     Simple base class with a lot of virtual methods which can be overridden
  44     to alter the behavior or the output of the CacheSets.
  45
  46     This helper is passed around by the static methods in the CacheSets and
  47     used every time they hit an error condition or something could be
  48     printed out.
  49 */
  50 public:                                                                 /*{{{*/
  51         CacheSetHelper(bool const ShowError = true,
  52                 GlobalError::MsgType ErrorType = GlobalError::ERROR) :
  53                         ShowError(ShowError), ErrorType(ErrorType) {}
  54         virtual ~CacheSetHelper() {}
  55
  56         enum PkgSelector { UNKNOWN, REGEX, TASK, FNMATCH, PACKAGENAME, STRING };
  57
  58         virtual bool PackageFrom(enum PkgSelector const select, PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern);
  59
  60         virtual bool PackageFromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline);
  61
  62         struct PkgModifier {
  63                 enum Position { NONE, PREFIX, POSTFIX };
  64                 unsigned short ID;
  65                 const char * const Alias;
  66                 Position Pos;
  67                 PkgModifier (unsigned short const &id, const char * const alias, Position const &pos) : ID(id), Alias(alias), Pos(pos) {}
  68         };
  69         virtual bool PackageFromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci,
  70                                             pkgCacheFile &Cache, const char * cmdline,
  71                                             std::list<PkgModifier> const &mods);
  72
  73         // use PackageFrom(PACKAGENAME, …) instead
  74         APT_DEPRECATED pkgCache::PkgIterator PackageFromName(pkgCacheFile &Cache, std::string const &pattern);
  75
  76         /** \brief be notified about the package being selected via pattern
  77          *
  78          * Main use is probably to show a message to the user what happened
  79          *
  80          * \param pkg is the package which was selected
  81          * \param select is the selection method which choose the package
  82          * \param pattern is the string used by the selection method to pick the package
  83          */
  84         virtual void showPackageSelection(pkgCache::PkgIterator const &pkg, PkgSelector const select, std::string const &pattern);
  85         // use the method above instead, react only on the type you need and let the base handle the rest if need be
  86         // this allows use to add new selection methods without breaking the ABI constantly with new virtual methods
  87         APT_DEPRECATED virtual void showTaskSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
  88         APT_DEPRECATED virtual void showRegExSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
  89         APT_DEPRECATED virtual void showFnmatchSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
  90
  91         /** \brief be notified if a package can't be found via pattern
  92          *
  93          * Can be used to show a message as well as to try something else to make it match
  94          *
  95          * \param select is the method tried for selection
  96          * \param pci is the container the package should be inserted in
  97          * \param Cache is the package universe available
  98          * \param pattern is the string not matching anything
  99          */
 100         virtual void canNotFindPackage(enum PkgSelector const select, PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern);
 101         // same as above for showPackageSelection
 102         APT_DEPRECATED virtual void canNotFindTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
 103         APT_DEPRECATED virtual void canNotFindRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
 104         APT_DEPRECATED virtual void canNotFindFnmatch(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
 105         APT_DEPRECATED virtual void canNotFindPackage(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str);
 106
 107         /** \brief specifies which version(s) we want to refer to */
 108         enum VerSelector {
 109                 /** by release string */
 110                 RELEASE,
 111                 /** by version number string */
 112                 VERSIONNUMBER,
 113                 /** All versions */
 114                 ALL,
 115                 /** Candidate and installed version */
 116                 CANDANDINST,
 117                 /** Candidate version */
 118                 CANDIDATE,
 119                 /** Installed version */
 120                 INSTALLED,
 121                 /** Candidate or if non installed version */
 122                 CANDINST,
 123                 /** Installed or if non candidate version */
 124                 INSTCAND,
 125                 /** Newest version */
 126                 NEWEST
 127         };
 128
 129         /** \brief be notified about the version being selected via pattern
 130          *
 131          * Main use is probably to show a message to the user what happened
 132          * Note that at the moment this method is only called for RELEASE
 133          * and VERSION selections, not for the others.
 134          *
 135          * \param Pkg is the package which was selected for
 136          * \param Ver is the version selected
 137          * \param select is the selection method which choose the version
 138          * \param pattern is the string used by the selection method to pick the version
 139          */
 140         virtual void showVersionSelection(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver,
 141               enum VerSelector const select, std::string const &pattern);
 142         // renamed to have a similar interface to showPackageSelection
 143         APT_DEPRECATED virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
 144                                  std::string const &ver, bool const verIsRel);
 145
 146         /** \brief be notified if a version can't be found for a package
 147          *
 148          * Main use is probably to show a message to the user what happened
 149          *
 150          * \param select is the method tried for selection
 151          * \param vci is the container the version should be inserted in
 152          * \param Cache is the package universe available
 153          * \param Pkg is the package we wanted a version from
 154          */
 155         virtual void canNotFindVersion(enum VerSelector const select, VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
 156         // same as above for showPackageSelection
 157         APT_DEPRECATED virtual void canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
 158         APT_DEPRECATED virtual void canNotFindInstCandVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,
 159                                 pkgCache::PkgIterator const &Pkg);
 160         APT_DEPRECATED virtual void canNotFindCandInstVer(VersionContainerInterface * const vci,
 161                                 pkgCacheFile &Cache,
 162                                 pkgCache::PkgIterator const &Pkg);
 163
 164         // the difference between canNotFind and canNotGet is that the later is more low-level
 165         // and called from other places: In this case looking into the code is the only real answer…
 166         virtual pkgCache::VerIterator canNotGetVersion(enum VerSelector const select, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
 167         // same as above for showPackageSelection
 168         APT_DEPRECATED virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache,
 169                                 pkgCache::PkgIterator const &Pkg);
 170         APT_DEPRECATED virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache,
 171                                 pkgCache::PkgIterator const &Pkg);
 172         APT_DEPRECATED virtual pkgCache::VerIterator canNotFindInstalledVer(pkgCacheFile &Cache,
 173                                 pkgCache::PkgIterator const &Pkg);
 174
 175         virtual pkgCache::PkgIterator canNotFindPkgName(pkgCacheFile &Cache, std::string const &str);
 176
 177         bool showErrors() const { return ShowError; }
 178         bool showErrors(bool const newValue) { if (ShowError == newValue) return ShowError; else return ((ShowError = newValue) == false); }
 179         GlobalError::MsgType errorType() const { return ErrorType; }
 180         GlobalError::MsgType errorType(GlobalError::MsgType const &newValue)
 181         {
 182                 if (ErrorType == newValue) return ErrorType;
 183                 else {
 184                         GlobalError::MsgType const &oldValue = ErrorType;
 185                         ErrorType = newValue;
 186                         return oldValue;
 187                 }
 188         }
 189
 190                                                                         /*}}}*/
 191 protected:
 192         bool ShowError;
 193         GlobalError::MsgType ErrorType;
 194
 195         pkgCache::VerIterator canNotGetInstCandVer(pkgCacheFile &Cache,
 196                 pkgCache::PkgIterator const &Pkg);
 197         pkgCache::VerIterator canNotGetCandInstVer(pkgCacheFile &Cache,
 198                 pkgCache::PkgIterator const &Pkg);
 199
 200         bool PackageFromTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
 201         bool PackageFromRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
 202         bool PackageFromFnmatch(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
 203         bool PackageFromPackageName(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
 204         bool PackageFromString(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern);
 205 };                                                                      /*}}}*/
 206
 207 class PackageContainerInterface {                                       /*{{{*/
 208 /** \class PackageContainerInterface
 209
 210  * Interface ensuring that all operations can be executed on the yet to
 211  * define concrete PackageContainer - access to all methods is possible,
 212  * but in general the wrappers provided by the PackageContainer template
 213  * are nicer to use.
 214
 215  * This class mostly protects use from the need to write all implementation
 216  * of the methods working on containers in the template */
 217 public:
 218         class const_iterator {                                          /*{{{*/
 219         public:
 220                 virtual pkgCache::PkgIterator getPkg() const = 0;
 221                 operator pkgCache::PkgIterator(void) const { return getPkg(); }
 222
 223                 inline const char *Name() const {return getPkg().Name(); }
 224                 inline std::string FullName(bool const Pretty) const { return getPkg().FullName(Pretty); }
 225                 inline std::string FullName() const { return getPkg().FullName(); }
 226                 APT_DEPRECATED inline const char *Section() const {
 227 #if __GNUC__ >= 4
 228         #pragma GCC diagnostic push
 229         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 230 #endif
 231            return getPkg().Section();
 232 #if __GNUC__ >= 4
 233         #pragma GCC diagnostic pop
 234 #endif
 235                 }
 236                 inline bool Purge() const {return getPkg().Purge(); }
 237                 inline const char *Arch() const {return getPkg().Arch(); }
 238                 inline pkgCache::GrpIterator Group() const { return getPkg().Group(); }
 239                 inline pkgCache::VerIterator VersionList() const { return getPkg().VersionList(); }
 240                 inline pkgCache::VerIterator CurrentVer() const { return getPkg().CurrentVer(); }
 241                 inline pkgCache::DepIterator RevDependsList() const { return getPkg().RevDependsList(); }
 242                 inline pkgCache::PrvIterator ProvidesList() const { return getPkg().ProvidesList(); }
 243                 inline pkgCache::PkgIterator::OkState State() const { return getPkg().State(); }
 244                 inline const char *CandVersion() const { return getPkg().CandVersion(); }
 245                 inline const char *CurVersion() const { return getPkg().CurVersion(); }
 246                 inline pkgCache *Cache() const { return getPkg().Cache(); }
 247                 inline unsigned long Index() const {return getPkg().Index();}
 248                 // we have only valid iterators here
 249                 inline bool end() const { return false; }
 250
 251                 inline pkgCache::Package const * operator->() const {return &*getPkg();}
 252         };
 253                                                                         /*}}}*/
 254
 255         virtual bool insert(pkgCache::PkgIterator const &P) = 0;
 256         virtual bool empty() const = 0;
 257         virtual void clear() = 0;
 258
 259         // FIXME: This is a bloody hack removed soon. Use CacheSetHelper::PkgSelector !
 260         enum APT_DEPRECATED Constructor { UNKNOWN = CacheSetHelper::UNKNOWN,
 261                 REGEX = CacheSetHelper::REGEX,
 262                 TASK = CacheSetHelper::TASK,
 263                 FNMATCH = CacheSetHelper::FNMATCH };
 264 #if __GNUC__ >= 4
 265         #pragma GCC diagnostic push
 266         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 267 #endif
 268         void setConstructor(Constructor const by) { ConstructedBy = (CacheSetHelper::PkgSelector)by; }
 269 #if __GNUC__ >= 4
 270         #pragma GCC diagnostic pop
 271 #endif
 272
 273         void setConstructor(CacheSetHelper::PkgSelector const by) { ConstructedBy = by; }
 274         CacheSetHelper::PkgSelector getConstructor() const { return ConstructedBy; }
 275         PackageContainerInterface() : ConstructedBy(CacheSetHelper::UNKNOWN) {}
 276         PackageContainerInterface(CacheSetHelper::PkgSelector const by) : ConstructedBy(by) {}
 277
 278         APT_DEPRECATED static bool FromTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
 279            return helper.PackageFrom(CacheSetHelper::TASK, pci, Cache, pattern); }
 280         APT_DEPRECATED static bool FromRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
 281            return helper.PackageFrom(CacheSetHelper::REGEX, pci, Cache, pattern); }
 282         APT_DEPRECATED static bool FromFnmatch(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
 283            return helper.PackageFrom(CacheSetHelper::FNMATCH, pci, Cache, pattern); }
 284         APT_DEPRECATED static bool FromGroup(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
 285            return helper.PackageFrom(CacheSetHelper::PACKAGENAME, pci, Cache, pattern); }
 286         APT_DEPRECATED static bool FromString(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
 287            return helper.PackageFrom(CacheSetHelper::STRING, pci, Cache, pattern); }
 288         APT_DEPRECATED static bool FromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
 289            return helper.PackageFromCommandLine(pci, Cache, cmdline); }
 290
 291         APT_DEPRECATED typedef CacheSetHelper::PkgModifier Modifier;
 292
 293 #if __GNUC__ >= 4
 294         #pragma GCC diagnostic push
 295         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 296 #endif
 297         APT_DEPRECATED static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
 298            return helper.PackageFromName(Cache, pattern); }
 299         APT_DEPRECATED static bool FromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci,
 300               pkgCacheFile &Cache, const char * cmdline,
 301               std::list<Modifier> const &mods, CacheSetHelper &helper) {
 302            return helper.PackageFromModifierCommandLine(modID, pci, Cache, cmdline, mods); }
 303 #if __GNUC__ >= 4
 304         #pragma GCC diagnostic pop
 305 #endif
 306
 307 private:
 308         CacheSetHelper::PkgSelector ConstructedBy;
 309 };
 310                                                                         /*}}}*/
 311 template<class Container> class PackageContainer : public PackageContainerInterface {/*{{{*/
 312 /** \class APT::PackageContainer
 313
 314     Simple wrapper around a container class like std::set to provide a similar
 315     interface to a set of packages as to the complete set of all packages in the
 316     pkgCache. */
 317         Container _cont;
 318 public:                                                                 /*{{{*/
 319         /** \brief smell like a pkgCache::PkgIterator */
 320         class const_iterator : public PackageContainerInterface::const_iterator,/*{{{*/
 321                                public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {
 322                 typename Container::const_iterator _iter;
 323         public:
 324                 const_iterator(typename Container::const_iterator i) : _iter(i) {}
 325                 pkgCache::PkgIterator getPkg(void) const { return *_iter; }
 326                 inline pkgCache::PkgIterator operator*(void) const { return *_iter; }
 327                 operator typename Container::const_iterator(void) const { return _iter; }
 328                 inline const_iterator& operator++() { ++_iter; return *this; }
 329                 inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; }
 330                 inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; }
 331                 inline bool operator==(const_iterator const &i) const { return _iter == i._iter; }
 332                 friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
 333         };
 334         class iterator : public PackageContainerInterface::const_iterator,
 335                          public std::iterator<std::forward_iterator_tag, typename Container::iterator> {
 336                 typename Container::iterator _iter;
 337         public:
 338                 iterator(typename Container::iterator i) : _iter(i) {}
 339                 pkgCache::PkgIterator getPkg(void) const { return *_iter; }
 340                 inline pkgCache::PkgIterator operator*(void) const { return *_iter; }
 341                 operator typename Container::iterator(void) const { return _iter; }
 342                 operator typename PackageContainer<Container>::const_iterator() { return typename PackageContainer<Container>::const_iterator(_iter); }
 343                 inline iterator& operator++() { ++_iter; return *this; }
 344                 inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
 345                 inline bool operator!=(iterator const &i) const { return _iter != i._iter; }
 346                 inline bool operator==(iterator const &i) const { return _iter == i._iter; }
 347                 inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; }
 348                 inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; }
 349                 friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
 350         };
 351                                                                         /*}}}*/
 352
 353         bool insert(pkgCache::PkgIterator const &P) { if (P.end() == true) return false; _cont.insert(P); return true; }
 354         template<class Cont> void insert(PackageContainer<Cont> const &pkgcont) { _cont.insert((typename Cont::const_iterator)pkgcont.begin(), (typename Cont::const_iterator)pkgcont.end()); }
 355         void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); }
 356
 357         bool empty() const { return _cont.empty(); }
 358         void clear() { return _cont.clear(); }
 359         //FIXME: on ABI break, replace the first with the second without bool
 360         void erase(iterator position) { _cont.erase((typename Container::iterator)position); }
 361         iterator& erase(iterator &position, bool) { return position = _cont.erase((typename Container::iterator)position); }
 362         size_t erase(const pkgCache::PkgIterator x) { return _cont.erase(x); }
 363         void erase(iterator first, iterator last) { _cont.erase(first, last); }
 364         size_t size() const { return _cont.size(); }
 365
 366         const_iterator begin() const { return const_iterator(_cont.begin()); }
 367         const_iterator end() const { return const_iterator(_cont.end()); }
 368         iterator begin() { return iterator(_cont.begin()); }
 369         iterator end() { return iterator(_cont.end()); }
 370         const_iterator find(pkgCache::PkgIterator const &P) const { return const_iterator(_cont.find(P)); }
 371
 372         PackageContainer() : PackageContainerInterface() {}
 373         PackageContainer(CacheSetHelper::PkgSelector const &by) : PackageContainerInterface(by) {}
 374 #if __GNUC__ >= 4
 375         #pragma GCC diagnostic push
 376         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 377 #endif
 378         APT_DEPRECATED PackageContainer(Constructor const &by) : PackageContainerInterface((CacheSetHelper::PkgSelector)by) {}
 379 #if __GNUC__ >= 4
 380         #pragma GCC diagnostic pop
 381 #endif
 382
 383         /** \brief sort all included versions with given comparer
 384
 385             Some containers are sorted by default, some are not and can't be,
 386             but a few like std::vector can be sorted if need be, so this can be
 387             specialized in later on. The default is that this will fail though.
 388             Specifically, already sorted containers like std::set will return
 389             false as well as there is no easy way to check that the given comparer
 390             would sort in the same way the set is currently sorted
 391
 392             \return \b true if the set was sorted, \b false if not. */
 393         template<class Compare> bool sort(Compare /*Comp*/) { return false; }
 394
 395         /** \brief returns all packages in the cache who belong to the given task
 396
 397             A simple helper responsible for search for all members of a task
 398             in the cache. Optional it prints a a notice about the
 399             packages chosen cause of the given task.
 400             \param Cache the packages are in
 401             \param pattern name of the task
 402             \param helper responsible for error and message handling */
 403         static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
 404                 PackageContainer cont(CacheSetHelper::TASK);
 405                 helper.PackageFrom(CacheSetHelper::TASK, &cont, Cache, pattern);
 406                 return cont;
 407         }
 408         static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern) {
 409                 CacheSetHelper helper;
 410                 return FromTask(Cache, pattern, helper);
 411         }
 412
 413         /** \brief returns all packages in the cache whose name matchs a given pattern
 414
 415             A simple helper responsible for executing a regular expression on all
 416             package names in the cache. Optional it prints a a notice about the
 417             packages chosen cause of the given package.
 418             \param Cache the packages are in
 419             \param pattern regular expression for package names
 420             \param helper responsible for error and message handling */
 421         static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
 422                 PackageContainer cont(CacheSetHelper::REGEX);
 423                 helper.PackageFrom(CacheSetHelper::REGEX, &cont, Cache, pattern);
 424                 return cont;
 425         }
 426
 427         static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string const &pattern) {
 428                 CacheSetHelper helper;
 429                 return FromRegEx(Cache, pattern, helper);
 430         }
 431
 432         static PackageContainer FromFnmatch(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
 433                 PackageContainer cont(CacheSetHelper::FNMATCH);
 434                 helper.PackageFrom(CacheSetHelper::FNMATCH, &cont, Cache, pattern);
 435                 return cont;
 436         }
 437         static PackageContainer FromFnMatch(pkgCacheFile &Cache, std::string const &pattern) {
 438                 CacheSetHelper helper;
 439                 return FromFnmatch(Cache, pattern, helper);
 440         }
 441
 442 #if __GNUC__ >= 4
 443         #pragma GCC diagnostic push
 444         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 445 #endif
 446         /** \brief returns a package specified by a string
 447
 448             \param Cache the package is in
 449             \param pattern String the package name should be extracted from
 450             \param helper responsible for error and message handling */
 451         APT_DEPRECATED static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
 452                 return helper.PackageFromName(Cache, pattern);
 453         }
 454         APT_DEPRECATED static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern) {
 455                 CacheSetHelper helper;
 456                 return FromName(Cache, pattern, helper);
 457         }
 458 #if __GNUC__ >= 4
 459         #pragma GCC diagnostic pop
 460 #endif
 461
 462         /** \brief returns all packages specified by a string
 463
 464             \param Cache the packages are in
 465             \param pattern String the package name(s) should be extracted from
 466             \param helper responsible for error and message handling */
 467         static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
 468                 PackageContainer cont;
 469                 helper.PackageFrom(CacheSetHelper::PACKAGENAME, &cont, Cache, pattern);
 470                 return cont;
 471         }
 472         static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern) {
 473                 CacheSetHelper helper;
 474                 return FromString(Cache, pattern, helper);
 475         }
 476
 477         /** \brief returns all packages specified on the commandline
 478
 479             Get all package names from the commandline and executes regex's if needed.
 480             No special package command is supported, just plain names.
 481             \param Cache the packages are in
 482             \param cmdline Command line the package names should be extracted from
 483             \param helper responsible for error and message handling */
 484         static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
 485                 PackageContainer cont;
 486                 helper.PackageFromCommandLine(&cont, Cache, cmdline);
 487                 return cont;
 488         }
 489         static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
 490                 CacheSetHelper helper;
 491                 return FromCommandLine(Cache, cmdline, helper);
 492         }
 493
 494         /** \brief group packages by a action modifiers
 495
 496             At some point it is needed to get from the same commandline
 497             different package sets grouped by a modifier. Take
 498                 apt-get install apt awesome-
 499             as an example.
 500             \param Cache the packages are in
 501             \param cmdline Command line the package names should be extracted from
 502             \param mods list of modifiers the method should accept
 503             \param fallback the default modifier group for a package
 504             \param helper responsible for error and message handling */
 505         static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
 506                                                                                  pkgCacheFile &Cache,
 507                                                                                  const char **cmdline,
 508                                                                                  std::list<CacheSetHelper::PkgModifier> const &mods,
 509                                                                                  unsigned short const &fallback,
 510                                                                                  CacheSetHelper &helper) {
 511                 std::map<unsigned short, PackageContainer> pkgsets;
 512                 for (const char **I = cmdline; *I != 0; ++I) {
 513                         unsigned short modID = fallback;
 514                         PackageContainer pkgset;
 515                         helper.PackageFromModifierCommandLine(modID, &pkgset, Cache, *I, mods);
 516                         pkgsets[modID].insert(pkgset);
 517                 }
 518                 return pkgsets;
 519         }
 520         static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
 521                                                                                  pkgCacheFile &Cache,
 522                                                                                  const char **cmdline,
 523                                                                                  std::list<CacheSetHelper::PkgModifier> const &mods,
 524                                                                                  unsigned short const &fallback) {
 525                 CacheSetHelper helper;
 526                 return GroupedFromCommandLine(Cache, cmdline,
 527                                 mods, fallback, helper);
 528         }
 529                                                                         /*}}}*/
 530 };                                                                      /*}}}*/
 531 // specialisations for push_back containers: std::list & std::vector    /*{{{*/
 532 template<> template<class Cont> void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(PackageContainer<Cont> const &pkgcont) {
 533         for (typename PackageContainer<Cont>::const_iterator p = pkgcont.begin(); p != pkgcont.end(); ++p)
 534                 _cont.push_back(*p);
 535 }
 536 template<> template<class Cont> void PackageContainer<std::vector<pkgCache::PkgIterator> >::insert(PackageContainer<Cont> const &pkgcont) {
 537         for (typename PackageContainer<Cont>::const_iterator p = pkgcont.begin(); p != pkgcont.end(); ++p)
 538                 _cont.push_back(*p);
 539 }
 540 // these two are 'inline' as otherwise the linker has problems with seeing these untemplated
 541 // specializations again and again - but we need to see them, so that library users can use them
 542 template<> inline bool PackageContainer<std::list<pkgCache::PkgIterator> >::insert(pkgCache::PkgIterator const &P) {
 543         if (P.end() == true)
 544                 return false;
 545         _cont.push_back(P);
 546         return true;
 547 }
 548 template<> inline bool PackageContainer<std::vector<pkgCache::PkgIterator> >::insert(pkgCache::PkgIterator const &P) {
 549         if (P.end() == true)
 550                 return false;
 551         _cont.push_back(P);
 552         return true;
 553 }
 554 template<> inline void PackageContainer<std::list<pkgCache::PkgIterator> >::insert(const_iterator begin, const_iterator end) {
 555         for (const_iterator p = begin; p != end; ++p)
 556                 _cont.push_back(*p);
 557 }
 558 template<> inline void PackageContainer<std::vector<pkgCache::PkgIterator> >::insert(const_iterator begin, const_iterator end) {
 559         for (const_iterator p = begin; p != end; ++p)
 560                 _cont.push_back(*p);
 561 }
 562                                                                         /*}}}*/
 563
 564 template<> template<class Compare> inline bool PackageContainer<std::vector<pkgCache::PkgIterator> >::sort(Compare Comp) {
 565         std::sort(_cont.begin(), _cont.end(), Comp);
 566         return true;
 567 }
 568
 569 // class PackageUniverse - pkgCache as PackageContainerInterface        /*{{{*/
 570 /** \class PackageUniverse
 571
 572     Wraps around our usual pkgCache, so that it can be stuffed into methods
 573     expecting a PackageContainer.
 574
 575     The wrapping is read-only in practice modeled by making erase and co
 576     private methods. */
 577 class PackageUniverse : public PackageContainerInterface {
 578         pkgCache * const _cont;
 579 public:
 580         typedef pkgCache::PkgIterator iterator;
 581         typedef pkgCache::PkgIterator const_iterator;
 582
 583         bool empty() const { return false; }
 584         size_t size() const { return _cont->Head().PackageCount; }
 585
 586         const_iterator begin() const { return _cont->PkgBegin(); }
 587         const_iterator end() const { return  _cont->PkgEnd(); }
 588         iterator begin() { return _cont->PkgBegin(); }
 589         iterator end() { return _cont->PkgEnd(); }
 590
 591         PackageUniverse(pkgCache * const Owner) : _cont(Owner) { }
 592
 593 private:
 594         bool insert(pkgCache::PkgIterator const &) { return true; }
 595         template<class Cont> void insert(PackageContainer<Cont> const &) { }
 596         void insert(const_iterator, const_iterator) { }
 597
 598         void clear() { }
 599         iterator& erase(iterator &iter) { return iter; }
 600         size_t erase(const pkgCache::PkgIterator) { return 0; }
 601         void erase(iterator, iterator) { }
 602 };
 603                                                                         /*}}}*/
 604 typedef PackageContainer<std::set<pkgCache::PkgIterator> > PackageSet;
 605 typedef PackageContainer<std::list<pkgCache::PkgIterator> > PackageList;
 606 typedef PackageContainer<std::vector<pkgCache::PkgIterator> > PackageVector;
 607
 608 class VersionContainerInterface {                                       /*{{{*/
 609 /** \class APT::VersionContainerInterface
 610
 611     Same as APT::PackageContainerInterface, just for Versions */
 612 public:
 613         /** \brief smell like a pkgCache::VerIterator */
 614         class const_iterator {                                          /*{{{*/
 615         public:
 616                 virtual pkgCache::VerIterator getVer() const = 0;
 617                 operator pkgCache::VerIterator(void) { return getVer(); }
 618
 619                 inline pkgCache *Cache() const { return getVer().Cache(); }
 620                 inline unsigned long Index() const {return getVer().Index();}
 621                 inline int CompareVer(const pkgCache::VerIterator &B) const { return getVer().CompareVer(B); }
 622                 inline const char *VerStr() const { return getVer().VerStr(); }
 623                 inline const char *Section() const { return getVer().Section(); }
 624                 inline const char *Arch() const { return getVer().Arch(); }
 625                 inline pkgCache::PkgIterator ParentPkg() const { return getVer().ParentPkg(); }
 626                 inline pkgCache::DescIterator DescriptionList() const { return getVer().DescriptionList(); }
 627                 inline pkgCache::DescIterator TranslatedDescription() const { return getVer().TranslatedDescription(); }
 628                 inline pkgCache::DepIterator DependsList() const { return getVer().DependsList(); }
 629                 inline pkgCache::PrvIterator ProvidesList() const { return getVer().ProvidesList(); }
 630                 inline pkgCache::VerFileIterator FileList() const { return getVer().FileList(); }
 631                 inline bool Downloadable() const { return getVer().Downloadable(); }
 632                 inline const char *PriorityType() const { return getVer().PriorityType(); }
 633                 inline std::string RelStr() const { return getVer().RelStr(); }
 634                 inline bool Automatic() const { return getVer().Automatic(); }
 635                 inline pkgCache::VerFileIterator NewestFile() const { return getVer().NewestFile(); }
 636                 // we have only valid iterators here
 637                 inline bool end() const { return false; }
 638
 639                 inline pkgCache::Version const * operator->() const { return &*getVer(); }
 640         };
 641                                                                         /*}}}*/
 642
 643         virtual bool insert(pkgCache::VerIterator const &V) = 0;
 644         virtual bool empty() const = 0;
 645         virtual void clear() = 0;
 646
 647         /** \brief specifies which version(s) will be returned if non is given */
 648         enum APT_DEPRECATED Version {
 649                 ALL = CacheSetHelper::ALL,
 650                 CANDANDINST = CacheSetHelper::CANDANDINST,
 651                 CANDIDATE = CacheSetHelper::CANDIDATE,
 652                 INSTALLED = CacheSetHelper::INSTALLED,
 653                 CANDINST = CacheSetHelper::CANDINST,
 654                 INSTCAND = CacheSetHelper::INSTCAND,
 655                 NEWEST = CacheSetHelper::NEWEST
 656         };
 657
 658         struct Modifier {
 659                 unsigned short const ID;
 660                 const char * const Alias;
 661                 enum Position { NONE, PREFIX, POSTFIX } const Pos;
 662                 enum CacheSetHelper::VerSelector const SelectVersion;
 663                 Modifier (unsigned short const &id, const char * const alias, Position const &pos,
 664                           enum CacheSetHelper::VerSelector const select) : ID(id), Alias(alias), Pos(pos),
 665                          SelectVersion(select) {}
 666 #if __GNUC__ >= 4
 667         #pragma GCC diagnostic push
 668         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 669 #endif
 670                 APT_DEPRECATED Modifier(unsigned short const &id, const char * const alias, Position const &pos,
 671                           Version const &select) : ID(id), Alias(alias), Pos(pos),
 672                          SelectVersion((CacheSetHelper::VerSelector)select) {}
 673 #if __GNUC__ >= 4
 674         #pragma GCC diagnostic pop
 675 #endif
 676         };
 677
 678         static bool FromCommandLine(VersionContainerInterface * const vci, pkgCacheFile &Cache,
 679                                     const char **cmdline, CacheSetHelper::VerSelector const fallback,
 680                                     CacheSetHelper &helper);
 681 #if __GNUC__ >= 4
 682         #pragma GCC diagnostic push
 683         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 684 #endif
 685         APT_DEPRECATED static bool FromCommandLine(VersionContainerInterface * const vci, pkgCacheFile &Cache,
 686                                     const char **cmdline, Version const &fallback,
 687                                     CacheSetHelper &helper) {
 688            return FromCommandLine(vci, Cache, cmdline, (CacheSetHelper::VerSelector)fallback, helper);
 689         }
 690 #if __GNUC__ >= 4
 691         #pragma GCC diagnostic pop
 692 #endif
 693
 694         static bool FromString(VersionContainerInterface * const vci, pkgCacheFile &Cache,
 695                                std::string pkg, CacheSetHelper::VerSelector const fallback, CacheSetHelper &helper,
 696                                bool const onlyFromName = false);
 697 #if __GNUC__ >= 4
 698         #pragma GCC diagnostic push
 699         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 700 #endif
 701         APT_DEPRECATED static bool FromString(VersionContainerInterface * const vci, pkgCacheFile &Cache,
 702                                std::string pkg, Version const &fallback, CacheSetHelper &helper,
 703                                bool const onlyFromName = false) {
 704            return FromString(vci, Cache, pkg, (CacheSetHelper::VerSelector)fallback, helper, onlyFromName);
 705         }
 706 #if __GNUC__ >= 4
 707         #pragma GCC diagnostic pop
 708 #endif
 709
 710         static bool FromPackage(VersionContainerInterface * const vci, pkgCacheFile &Cache,
 711                                 pkgCache::PkgIterator const &P, CacheSetHelper::VerSelector const fallback,
 712                                 CacheSetHelper &helper);
 713 #if __GNUC__ >= 4
 714         #pragma GCC diagnostic push
 715         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 716 #endif
 717         APT_DEPRECATED static bool FromPackage(VersionContainerInterface * const vci, pkgCacheFile &Cache,
 718                                 pkgCache::PkgIterator const &P, Version const &fallback,
 719                                 CacheSetHelper &helper) {
 720            return FromPackage(vci, Cache, P, (CacheSetHelper::VerSelector)fallback, helper);
 721         }
 722 #if __GNUC__ >= 4
 723         #pragma GCC diagnostic pop
 724 #endif
 725
 726         static bool FromModifierCommandLine(unsigned short &modID,
 727                                             VersionContainerInterface * const vci,
 728                                             pkgCacheFile &Cache, const char * cmdline,
 729                                             std::list<Modifier> const &mods,
 730                                             CacheSetHelper &helper);
 731
 732
 733         static bool FromDependency(VersionContainerInterface * const vci,
 734                                    pkgCacheFile &Cache,
 735                                    pkgCache::DepIterator const &D,
 736                                    CacheSetHelper::VerSelector const selector,
 737                                    CacheSetHelper &helper);
 738 #if __GNUC__ >= 4
 739         #pragma GCC diagnostic push
 740         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 741 #endif
 742         APT_DEPRECATED static bool FromDependency(VersionContainerInterface * const vci,
 743                                    pkgCacheFile &Cache,
 744                                    pkgCache::DepIterator const &D,
 745                                    Version const &selector,
 746                                    CacheSetHelper &helper) {
 747            return FromDependency(vci, Cache, D, (CacheSetHelper::VerSelector)selector, helper);
 748         }
 749 #if __GNUC__ >= 4
 750         #pragma GCC diagnostic pop
 751 #endif
 752
 753 protected:                                                              /*{{{*/
 754
 755         /** \brief returns the candidate version of the package
 756
 757             \param Cache to be used to query for information
 758             \param Pkg we want the candidate version from this package
 759             \param helper used in this container instance */
 760         static pkgCache::VerIterator getCandidateVer(pkgCacheFile &Cache,
 761                 pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
 762
 763         /** \brief returns the installed version of the package
 764
 765             \param Cache to be used to query for information
 766             \param Pkg we want the installed version from this package
 767             \param helper used in this container instance */
 768         static pkgCache::VerIterator getInstalledVer(pkgCacheFile &Cache,
 769                 pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
 770                                                                         /*}}}*/
 771 };
 772                                                                         /*}}}*/
 773 template<class Container> class VersionContainer : public VersionContainerInterface {/*{{{*/
 774 /** \class APT::VersionContainer
 775
 776     Simple wrapper around a container class like std::set to provide a similar
 777     interface to a set of versions as to the complete set of all versions in the
 778     pkgCache. */
 779         Container _cont;
 780 public:                                                                 /*{{{*/
 781         /** \brief smell like a pkgCache::VerIterator */
 782         class const_iterator : public VersionContainerInterface::const_iterator,
 783                                public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {/*{{{*/
 784                 typename Container::const_iterator _iter;
 785         public:
 786                 const_iterator(typename Container::const_iterator i) : _iter(i) {}
 787                 pkgCache::VerIterator getVer(void) const { return *_iter; }
 788                 inline pkgCache::VerIterator operator*(void) const { return *_iter; }
 789                 operator typename Container::const_iterator(void) const { return _iter; }
 790                 inline const_iterator& operator++() { ++_iter; return *this; }
 791                 inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; }
 792                 inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; }
 793                 inline bool operator==(const_iterator const &i) const { return _iter == i._iter; }
 794                 friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
 795         };
 796         class iterator : public VersionContainerInterface::const_iterator,
 797                          public std::iterator<std::forward_iterator_tag, typename Container::iterator> {
 798                 typename Container::iterator _iter;
 799         public:
 800                 iterator(typename Container::iterator i) : _iter(i) {}
 801                 pkgCache::VerIterator getVer(void) const { return *_iter; }
 802                 inline pkgCache::VerIterator operator*(void) const { return *_iter; }
 803                 operator typename Container::iterator(void) const { return _iter; }
 804                 operator typename VersionContainer<Container>::const_iterator() { return typename VersionContainer<Container>::const_iterator(_iter); }
 805                 inline iterator& operator++() { ++_iter; return *this; }
 806                 inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
 807                 inline bool operator!=(iterator const &i) const { return _iter != i._iter; }
 808                 inline bool operator==(iterator const &i) const { return _iter == i._iter; }
 809                 inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; }
 810                 inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; }
 811                 friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); }
 812         };
 813                                                                         /*}}}*/
 814
 815         bool insert(pkgCache::VerIterator const &V) { if (V.end() == true) return false; _cont.insert(V); return true; }
 816         template<class Cont> void insert(VersionContainer<Cont> const &vercont) { _cont.insert((typename Cont::const_iterator)vercont.begin(), (typename Cont::const_iterator)vercont.end()); }
 817         void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); }
 818         bool empty() const { return _cont.empty(); }
 819         void clear() { return _cont.clear(); }
 820         //FIXME: on ABI break, replace the first with the second without bool
 821         void erase(iterator position) { _cont.erase((typename Container::iterator)position); }
 822         iterator& erase(iterator &position, bool) { return position = _cont.erase((typename Container::iterator)position); }
 823         size_t erase(const pkgCache::VerIterator x) { return _cont.erase(x); }
 824         void erase(iterator first, iterator last) { _cont.erase(first, last); }
 825         size_t size() const { return _cont.size(); }
 826
 827         const_iterator begin() const { return const_iterator(_cont.begin()); }
 828         const_iterator end() const { return const_iterator(_cont.end()); }
 829         iterator begin() { return iterator(_cont.begin()); }
 830         iterator end() { return iterator(_cont.end()); }
 831         const_iterator find(pkgCache::VerIterator const &V) const { return const_iterator(_cont.find(V)); }
 832
 833         /** \brief sort all included versions with given comparer
 834
 835             Some containers are sorted by default, some are not and can't be,
 836             but a few like std::vector can be sorted if need be, so this can be
 837             specialized in later on. The default is that this will fail though.
 838             Specifically, already sorted containers like std::set will return
 839             false as well as there is no easy way to check that the given comparer
 840             would sort in the same way the set is currently sorted
 841
 842             \return \b true if the set was sorted, \b false if not. */
 843         template<class Compare> bool sort(Compare /*Comp*/) { return false; }
 844
 845         /** \brief returns all versions specified on the commandline
 846
 847             Get all versions from the commandline, uses given default version if
 848             non specifically requested  and executes regex's if needed on names.
 849             \param Cache the packages and versions are in
 850             \param cmdline Command line the versions should be extracted from
 851             \param fallback version specification
 852             \param helper responsible for error and message handling */
 853         static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
 854                         CacheSetHelper::VerSelector const fallback, CacheSetHelper &helper) {
 855                 VersionContainer vercon;
 856                 VersionContainerInterface::FromCommandLine(&vercon, Cache, cmdline, fallback, helper);
 857                 return vercon;
 858         }
 859         static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
 860                         CacheSetHelper::VerSelector const fallback) {
 861                 CacheSetHelper helper;
 862                 return FromCommandLine(Cache, cmdline, fallback, helper);
 863         }
 864         static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
 865                 return FromCommandLine(Cache, cmdline, CacheSetHelper::CANDINST);
 866         }
 867         static VersionContainer FromString(pkgCacheFile &Cache, std::string const &pkg,
 868                         CacheSetHelper::VerSelector const fallback, CacheSetHelper &helper,
 869                                            bool const /*onlyFromName = false*/) {
 870                 VersionContainer vercon;
 871                 VersionContainerInterface::FromString(&vercon, Cache, pkg, fallback, helper);
 872                 return vercon;
 873         }
 874         static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg,
 875                         CacheSetHelper::VerSelector const fallback) {
 876                 CacheSetHelper helper;
 877                 return FromString(Cache, pkg, fallback, helper);
 878         }
 879         static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg) {
 880                 return FromString(Cache, pkg, CacheSetHelper::CANDINST);
 881         }
 882 #if __GNUC__ >= 4
 883         #pragma GCC diagnostic push
 884         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 885 #endif
 886         static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
 887                         Version const &fallback, CacheSetHelper &helper) {
 888                 VersionContainer vercon;
 889                 VersionContainerInterface::FromCommandLine(&vercon, Cache, cmdline, (CacheSetHelper::VerSelector)fallback, helper);
 890                 return vercon;
 891         }
 892         static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
 893                         Version const &fallback) {
 894                 CacheSetHelper helper;
 895                 return FromCommandLine(Cache, cmdline, (CacheSetHelper::VerSelector)fallback, helper);
 896         }
 897         static VersionContainer FromString(pkgCacheFile &Cache, std::string const &pkg,
 898                         Version const &fallback, CacheSetHelper &helper,
 899                                            bool const /*onlyFromName = false*/) {
 900                 VersionContainer vercon;
 901                 VersionContainerInterface::FromString(&vercon, Cache, pkg, (CacheSetHelper::VerSelector)fallback, helper);
 902                 return vercon;
 903         }
 904         static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg,
 905                         Version const &fallback) {
 906                 CacheSetHelper helper;
 907                 return FromString(Cache, pkg, (CacheSetHelper::VerSelector)fallback, helper);
 908         }
 909 #if __GNUC__ >= 4
 910         #pragma GCC diagnostic pop
 911 #endif
 912
 913         /** \brief returns all versions specified for the package
 914
 915             \param Cache the package and versions are in
 916             \param P the package in question
 917             \param fallback the version(s) you want to get
 918             \param helper the helper used for display and error handling */
 919         static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
 920                 CacheSetHelper::VerSelector const fallback, CacheSetHelper &helper) {
 921                 VersionContainer vercon;
 922                 VersionContainerInterface::FromPackage(&vercon, Cache, P, fallback, helper);
 923                 return vercon;
 924         }
 925         static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
 926                                             CacheSetHelper::VerSelector const fallback) {
 927                 CacheSetHelper helper;
 928                 return FromPackage(Cache, P, fallback, helper);
 929         }
 930 #if __GNUC__ >= 4
 931         #pragma GCC diagnostic push
 932         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 933 #endif
 934         static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
 935                 Version const &fallback, CacheSetHelper &helper) {
 936                 VersionContainer vercon;
 937                 VersionContainerInterface::FromPackage(&vercon, Cache, P, (CacheSetHelper::VerSelector)fallback, helper);
 938                 return vercon;
 939         }
 940         static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
 941                                             Version const &fallback) {
 942                 CacheSetHelper helper;
 943                 return FromPackage(Cache, P, (CacheSetHelper::VerSelector)fallback, helper);
 944         }
 945 #if __GNUC__ >= 4
 946         #pragma GCC diagnostic pop
 947 #endif
 948         static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) {
 949                 return FromPackage(Cache, P, CacheSetHelper::CANDIDATE);
 950         }
 951
 952         static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
 953                                                                                  pkgCacheFile &Cache,
 954                                                                                  const char **cmdline,
 955                                                                                  std::list<Modifier> const &mods,
 956                                                                                  unsigned short const fallback,
 957                                                                                  CacheSetHelper &helper) {
 958                 std::map<unsigned short, VersionContainer> versets;
 959                 for (const char **I = cmdline; *I != 0; ++I) {
 960                         unsigned short modID = fallback;
 961                         VersionContainer verset;
 962                         VersionContainerInterface::FromModifierCommandLine(modID, &verset, Cache, *I, mods, helper);
 963                         versets[modID].insert(verset);
 964                 }
 965                 return versets;
 966
 967         }
 968         static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
 969                 pkgCacheFile &Cache, const char **cmdline,
 970                 std::list<Modifier> const &mods,
 971                 unsigned short const fallback) {
 972                 CacheSetHelper helper;
 973                 return GroupedFromCommandLine(Cache, cmdline,
 974                                 mods, fallback, helper);
 975         }
 976
 977         static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
 978                                                CacheSetHelper::VerSelector const selector, CacheSetHelper &helper) {
 979                 VersionContainer vercon;
 980                 VersionContainerInterface::FromDependency(&vercon, Cache, D, selector, helper);
 981                 return vercon;
 982         }
 983         static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
 984                                                CacheSetHelper::VerSelector const selector) {
 985                 CacheSetHelper helper;
 986                 return FromPackage(Cache, D, selector, helper);
 987         }
 988 #if __GNUC__ >= 4
 989         #pragma GCC diagnostic push
 990         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 991 #endif
 992         static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
 993                                                Version const &selector, CacheSetHelper &helper) {
 994                 VersionContainer vercon;
 995                 VersionContainerInterface::FromDependency(&vercon, Cache, D, (CacheSetHelper::VerSelector)selector, helper);
 996                 return vercon;
 997         }
 998         static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D,
 999                                                Version const &selector) {
1000                 CacheSetHelper helper;
1001                 return FromPackage(Cache, D, (CacheSetHelper::VerSelector)selector, helper);
1002         }
1003 #if __GNUC__ >= 4
1004         #pragma GCC diagnostic pop
1005 #endif
1006         static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D) {
1007                 return FromPackage(Cache, D, CacheSetHelper::CANDIDATE);
1008         }
1009                                                                         /*}}}*/
1010 };                                                                      /*}}}*/
1011 // specialisations for push_back containers: std::list & std::vector    /*{{{*/
1012 template<> template<class Cont> void VersionContainer<std::list<pkgCache::VerIterator> >::insert(VersionContainer<Cont> const &vercont) {
1013         for (typename VersionContainer<Cont>::const_iterator v = vercont.begin(); v != vercont.end(); ++v)
1014                 _cont.push_back(*v);
1015 }
1016 template<> template<class Cont> void VersionContainer<std::vector<pkgCache::VerIterator> >::insert(VersionContainer<Cont> const &vercont) {
1017         for (typename VersionContainer<Cont>::const_iterator v = vercont.begin(); v != vercont.end(); ++v)
1018                 _cont.push_back(*v);
1019 }
1020 // these two are 'inline' as otherwise the linker has problems with seeing these untemplated
1021 // specializations again and again - but we need to see them, so that library users can use them
1022 template<> inline bool VersionContainer<std::list<pkgCache::VerIterator> >::insert(pkgCache::VerIterator const &V) {
1023         if (V.end() == true)
1024                 return false;
1025         _cont.push_back(V);
1026         return true;
1027 }
1028 template<> inline bool VersionContainer<std::vector<pkgCache::VerIterator> >::insert(pkgCache::VerIterator const &V) {
1029         if (V.end() == true)
1030                 return false;
1031         _cont.push_back(V);
1032         return true;
1033 }
1034 template<> inline void VersionContainer<std::list<pkgCache::VerIterator> >::insert(const_iterator begin, const_iterator end) {
1035         for (const_iterator v = begin; v != end; ++v)
1036                 _cont.push_back(*v);
1037 }
1038 template<> inline void VersionContainer<std::vector<pkgCache::VerIterator> >::insert(const_iterator begin, const_iterator end) {
1039         for (const_iterator v = begin; v != end; ++v)
1040                 _cont.push_back(*v);
1041 }
1042                                                                         /*}}}*/
1043
1044 template<> template<class Compare> inline bool VersionContainer<std::vector<pkgCache::VerIterator> >::sort(Compare Comp) {
1045         std::sort(_cont.begin(), _cont.end(), Comp);
1046         return true;
1047 }
1048
1049 typedef VersionContainer<std::set<pkgCache::VerIterator> > VersionSet;
1050 typedef VersionContainer<std::list<pkgCache::VerIterator> > VersionList;
1051 typedef VersionContainer<std::vector<pkgCache::VerIterator> > VersionVector;
1052 }
1053 #endif