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 <iostream>
  13 #include <fstream>
  14 #include <list>
  15 #include <map>
  16 #include <set>
  17 #include <string>
  18
  19 #include <apt-pkg/error.h>
  20 #include <apt-pkg/pkgcache.h>
  21                                                                         /*}}}*/
  22
  23 class pkgCacheFile;
  24
  25 namespace APT {
  26 class PackageSet;
  27 class VersionSet;
  28 class CacheSetHelper {                                                  /*{{{*/
  29 /** \class APT::CacheSetHelper
  30     Simple base class with a lot of virtual methods which can be overridden
  31     to alter the behavior or the output of the CacheSets.
  32
  33     This helper is passed around by the static methods in the CacheSets and
  34     used every time they hit an error condition or something could be
  35     printed out.
  36 */
  37 public:                                                                 /*{{{*/
  38         CacheSetHelper(bool const &ShowError = true,
  39                 GlobalError::MsgType ErrorType = GlobalError::ERROR) :
  40                         ShowError(ShowError), ErrorType(ErrorType) {};
  41         virtual ~CacheSetHelper() {};
  42
  43         virtual void showTaskSelection(PackageSet const &pkgset, std::string const &pattern) {};
  44         virtual void showRegExSelection(PackageSet const &pkgset, std::string const &pattern) {};
  45         virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
  46                                  std::string const &ver, bool const &verIsRel) {};
  47
  48         virtual pkgCache::PkgIterator canNotFindPkgName(pkgCacheFile &Cache, std::string const &str);
  49         virtual PackageSet canNotFindTask(pkgCacheFile &Cache, std::string pattern);
  50         virtual PackageSet canNotFindRegEx(pkgCacheFile &Cache, std::string pattern);
  51         virtual PackageSet canNotFindPackage(pkgCacheFile &Cache, std::string const &str);
  52         virtual VersionSet canNotFindAllVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
  53         virtual VersionSet canNotFindInstCandVer(pkgCacheFile &Cache,
  54                                 pkgCache::PkgIterator const &Pkg);
  55         virtual VersionSet canNotFindCandInstVer(pkgCacheFile &Cache,
  56                                 pkgCache::PkgIterator const &Pkg);
  57         virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache,
  58                                 pkgCache::PkgIterator const &Pkg);
  59         virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache,
  60                                 pkgCache::PkgIterator const &Pkg);
  61         virtual pkgCache::VerIterator canNotFindInstalledVer(pkgCacheFile &Cache,
  62                                 pkgCache::PkgIterator const &Pkg);
  63
  64         bool showErrors() const { return ShowError; };
  65         bool showErrors(bool const &newValue) { if (ShowError == newValue) return ShowError; else return ((ShowError = newValue) == false); };
  66         GlobalError::MsgType errorType() const { return ErrorType; };
  67         GlobalError::MsgType errorType(GlobalError::MsgType const &newValue)
  68         {
  69                 if (ErrorType == newValue) return ErrorType;
  70                 else {
  71                         GlobalError::MsgType const &oldValue = ErrorType;
  72                         ErrorType = newValue;
  73                         return oldValue;
  74                 }
  75         };
  76
  77                                                                         /*}}}*/
  78 protected:
  79         bool ShowError;
  80         GlobalError::MsgType ErrorType;
  81 };                                                                      /*}}}*/
  82 class PackageSet : public std::set<pkgCache::PkgIterator> {             /*{{{*/
  83 /** \class APT::PackageSet
  84
  85     Simple wrapper around a std::set to provide a similar interface to
  86     a set of packages as to the complete set of all packages in the
  87     pkgCache. */
  88 public:                                                                 /*{{{*/
  89         /** \brief smell like a pkgCache::PkgIterator */
  90         class const_iterator : public std::set<pkgCache::PkgIterator>::const_iterator {/*{{{*/
  91         public:
  92                 const_iterator(std::set<pkgCache::PkgIterator>::const_iterator x) :
  93                          std::set<pkgCache::PkgIterator>::const_iterator(x) {}
  94
  95                 operator pkgCache::PkgIterator(void) { return **this; }
  96
  97                 inline const char *Name() const {return (**this).Name(); }
  98                 inline std::string FullName(bool const &Pretty) const { return (**this).FullName(Pretty); }
  99                 inline std::string FullName() const { return (**this).FullName(); }
 100                 inline const char *Section() const {return (**this).Section(); }
 101                 inline bool Purge() const {return (**this).Purge(); }
 102                 inline const char *Arch() const {return (**this).Arch(); }
 103                 inline pkgCache::GrpIterator Group() const { return (**this).Group(); }
 104                 inline pkgCache::VerIterator VersionList() const { return (**this).VersionList(); }
 105                 inline pkgCache::VerIterator CurrentVer() const { return (**this).CurrentVer(); }
 106                 inline pkgCache::DepIterator RevDependsList() const { return (**this).RevDependsList(); }
 107                 inline pkgCache::PrvIterator ProvidesList() const { return (**this).ProvidesList(); }
 108                 inline pkgCache::PkgIterator::OkState State() const { return (**this).State(); }
 109                 inline const char *CandVersion() const { return (**this).CandVersion(); }
 110                 inline const char *CurVersion() const { return (**this).CurVersion(); }
 111                 inline pkgCache *Cache() const { return (**this).Cache(); };
 112                 inline unsigned long Index() const {return (**this).Index();};
 113                 // we have only valid iterators here
 114                 inline bool end() const { return false; };
 115
 116                 friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, (*i)); }
 117
 118                 inline pkgCache::Package const * operator->() const {
 119                         return &***this;
 120                 };
 121         };
 122         // 103. set::iterator is required to be modifiable, but this allows modification of keys
 123         typedef APT::PackageSet::const_iterator iterator;
 124                                                                         /*}}}*/
 125
 126         using std::set<pkgCache::PkgIterator>::insert;
 127         inline void insert(pkgCache::PkgIterator const &P) { if (P.end() == false) std::set<pkgCache::PkgIterator>::insert(P); };
 128         inline void insert(PackageSet const &pkgset) { insert(pkgset.begin(), pkgset.end()); };
 129
 130         /** \brief returns all packages in the cache who belong to the given task
 131
 132             A simple helper responsible for search for all members of a task
 133             in the cache. Optional it prints a a notice about the
 134             packages chosen cause of the given task.
 135             \param Cache the packages are in
 136             \param pattern name of the task
 137             \param helper responsible for error and message handling */
 138         static APT::PackageSet FromTask(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
 139         static APT::PackageSet FromTask(pkgCacheFile &Cache, std::string const &pattern) {
 140                 CacheSetHelper helper;
 141                 return FromTask(Cache, pattern, helper);
 142         }
 143
 144         /** \brief returns all packages in the cache whose name matchs a given pattern
 145
 146             A simple helper responsible for executing a regular expression on all
 147             package names in the cache. Optional it prints a a notice about the
 148             packages chosen cause of the given package.
 149             \param Cache the packages are in
 150             \param pattern regular expression for package names
 151             \param helper responsible for error and message handling */
 152         static APT::PackageSet FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
 153         static APT::PackageSet FromRegEx(pkgCacheFile &Cache, std::string const &pattern) {
 154                 CacheSetHelper helper;
 155                 return FromRegEx(Cache, pattern, helper);
 156         }
 157
 158         /** \brief returns all packages specified by a string
 159
 160             \param Cache the packages are in
 161             \param string String the package name(s) should be extracted from
 162             \param helper responsible for error and message handling */
 163         static APT::PackageSet FromString(pkgCacheFile &Cache, std::string const &string, CacheSetHelper &helper);
 164         static APT::PackageSet FromString(pkgCacheFile &Cache, std::string const &string) {
 165                 CacheSetHelper helper;
 166                 return FromString(Cache, string, helper);
 167         }
 168
 169         /** \brief returns a package specified by a string
 170
 171             \param Cache the package is in
 172             \param string String the package name should be extracted from
 173             \param helper responsible for error and message handling */
 174         static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &string, CacheSetHelper &helper);
 175         static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &string) {
 176                 CacheSetHelper helper;
 177                 return FromName(Cache, string, helper);
 178         }
 179
 180         /** \brief returns all packages specified on the commandline
 181
 182             Get all package names from the commandline and executes regex's if needed.
 183             No special package command is supported, just plain names.
 184             \param Cache the packages are in
 185             \param cmdline Command line the package names should be extracted from
 186             \param helper responsible for error and message handling */
 187         static APT::PackageSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper);
 188         static APT::PackageSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
 189                 CacheSetHelper helper;
 190                 return FromCommandLine(Cache, cmdline, helper);
 191         }
 192
 193         struct Modifier {
 194                 enum Position { NONE, PREFIX, POSTFIX };
 195                 unsigned short ID;
 196                 const char * const Alias;
 197                 Position Pos;
 198                 Modifier (unsigned short const &id, const char * const alias, Position const &pos) : ID(id), Alias(alias), Pos(pos) {};
 199         };
 200
 201         /** \brief group packages by a action modifiers
 202
 203             At some point it is needed to get from the same commandline
 204             different package sets grouped by a modifier. Take
 205                 apt-get install apt awesome-
 206             as an example.
 207             \param Cache the packages are in
 208             \param cmdline Command line the package names should be extracted from
 209             \param mods list of modifiers the method should accept
 210             \param fallback the default modifier group for a package
 211             \param helper responsible for error and message handling */
 212         static std::map<unsigned short, PackageSet> GroupedFromCommandLine(
 213                 pkgCacheFile &Cache, const char **cmdline,
 214                 std::list<PackageSet::Modifier> const &mods,
 215                 unsigned short const &fallback, CacheSetHelper &helper);
 216         static std::map<unsigned short, PackageSet> GroupedFromCommandLine(
 217                 pkgCacheFile &Cache, const char **cmdline,
 218                 std::list<PackageSet::Modifier> const &mods,
 219                 unsigned short const &fallback) {
 220                 CacheSetHelper helper;
 221                 return GroupedFromCommandLine(Cache, cmdline,
 222                                 mods, fallback, helper);
 223         }
 224
 225         enum Constructor { UNKNOWN, REGEX, TASK };
 226         Constructor getConstructor() const { return ConstructedBy; };
 227
 228         PackageSet() : ConstructedBy(UNKNOWN) {};
 229         PackageSet(Constructor const &by) : ConstructedBy(by) {};
 230                                                                         /*}}}*/
 231 private:                                                                /*{{{*/
 232         Constructor ConstructedBy;
 233                                                                         /*}}}*/
 234 };                                                                      /*}}}*/
 235 class VersionSet : public std::set<pkgCache::VerIterator> {             /*{{{*/
 236 /** \class APT::VersionSet
 237
 238     Simple wrapper around a std::set to provide a similar interface to
 239     a set of versions as to the complete set of all versions in the
 240     pkgCache. */
 241 public:                                                                 /*{{{*/
 242         /** \brief smell like a pkgCache::VerIterator */
 243         class const_iterator : public std::set<pkgCache::VerIterator>::const_iterator {/*{{{*/
 244         public:
 245                 const_iterator(std::set<pkgCache::VerIterator>::const_iterator x) :
 246                          std::set<pkgCache::VerIterator>::const_iterator(x) {}
 247
 248                 operator pkgCache::VerIterator(void) { return **this; }
 249
 250                 inline pkgCache *Cache() const { return (**this).Cache(); };
 251                 inline unsigned long Index() const {return (**this).Index();};
 252                 // we have only valid iterators here
 253                 inline bool end() const { return false; };
 254
 255                 inline pkgCache::Version const * operator->() const {
 256                         return &***this;
 257                 };
 258
 259                 inline int CompareVer(const pkgCache::VerIterator &B) const { return (**this).CompareVer(B); };
 260                 inline const char *VerStr() const { return (**this).VerStr(); };
 261                 inline const char *Section() const { return (**this).Section(); };
 262                 inline const char *Arch() const { return (**this).Arch(); };
 263                 inline pkgCache::PkgIterator ParentPkg() const { return (**this).ParentPkg(); };
 264                 inline pkgCache::DescIterator DescriptionList() const { return (**this).DescriptionList(); };
 265                 inline pkgCache::DescIterator TranslatedDescription() const { return (**this).TranslatedDescription(); };
 266                 inline pkgCache::DepIterator DependsList() const { return (**this).DependsList(); };
 267                 inline pkgCache::PrvIterator ProvidesList() const { return (**this).ProvidesList(); };
 268                 inline pkgCache::VerFileIterator FileList() const { return (**this).FileList(); };
 269                 inline bool Downloadable() const { return (**this).Downloadable(); };
 270                 inline const char *PriorityType() const { return (**this).PriorityType(); };
 271                 inline std::string RelStr() const { return (**this).RelStr(); };
 272                 inline bool Automatic() const { return (**this).Automatic(); };
 273                 inline pkgCache::VerFileIterator NewestFile() const { return (**this).NewestFile(); };
 274         };
 275                                                                         /*}}}*/
 276         // 103. set::iterator is required to be modifiable, but this allows modification of keys
 277         typedef APT::VersionSet::const_iterator iterator;
 278
 279         using std::set<pkgCache::VerIterator>::insert;
 280         inline void insert(pkgCache::VerIterator const &V) { if (V.end() == false) std::set<pkgCache::VerIterator>::insert(V); };
 281         inline void insert(VersionSet const &verset) { insert(verset.begin(), verset.end()); };
 282
 283         /** \brief specifies which version(s) will be returned if non is given */
 284         enum Version {
 285                 /** All versions */
 286                 ALL,
 287                 /** Candidate and installed version */
 288                 CANDANDINST,
 289                 /** Candidate version */
 290                 CANDIDATE,
 291                 /** Installed version */
 292                 INSTALLED,
 293                 /** Candidate or if non installed version */
 294                 CANDINST,
 295                 /** Installed or if non candidate version */
 296                 INSTCAND,
 297                 /** Newest version */
 298                 NEWEST
 299         };
 300
 301         /** \brief returns all versions specified on the commandline
 302
 303             Get all versions from the commandline, uses given default version if
 304             non specifically requested  and executes regex's if needed on names.
 305             \param Cache the packages and versions are in
 306             \param cmdline Command line the versions should be extracted from
 307             \param helper responsible for error and message handling */
 308         static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
 309                         APT::VersionSet::Version const &fallback, CacheSetHelper &helper);
 310         static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
 311                         APT::VersionSet::Version const &fallback) {
 312                 CacheSetHelper helper;
 313                 return FromCommandLine(Cache, cmdline, fallback, helper);
 314         }
 315         static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
 316                 return FromCommandLine(Cache, cmdline, CANDINST);
 317         }
 318
 319         static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg,
 320                         APT::VersionSet::Version const &fallback, CacheSetHelper &helper,
 321                         bool const &onlyFromName = false);
 322         static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg,
 323                         APT::VersionSet::Version const &fallback) {
 324                 CacheSetHelper helper;
 325                 return FromString(Cache, pkg, fallback, helper);
 326         }
 327         static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg) {
 328                 return FromString(Cache, pkg, CANDINST);
 329         }
 330
 331         /** \brief returns all versions specified for the package
 332
 333             \param Cache the package and versions are in
 334             \param P the package in question
 335             \param fallback the version(s) you want to get
 336             \param helper the helper used for display and error handling */
 337         static APT::VersionSet FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
 338                 VersionSet::Version const &fallback, CacheSetHelper &helper);
 339         static APT::VersionSet FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
 340                         APT::VersionSet::Version const &fallback) {
 341                 CacheSetHelper helper;
 342                 return FromPackage(Cache, P, fallback, helper);
 343         }
 344         static APT::VersionSet FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) {
 345                 return FromPackage(Cache, P, CANDINST);
 346         }
 347
 348         struct Modifier {
 349                 enum Position { NONE, PREFIX, POSTFIX };
 350                 unsigned short ID;
 351                 const char * const Alias;
 352                 Position Pos;
 353                 VersionSet::Version SelectVersion;
 354                 Modifier (unsigned short const &id, const char * const alias, Position const &pos,
 355                           VersionSet::Version const &select) : ID(id), Alias(alias), Pos(pos),
 356                          SelectVersion(select) {};
 357         };
 358
 359         static std::map<unsigned short, VersionSet> GroupedFromCommandLine(
 360                 pkgCacheFile &Cache, const char **cmdline,
 361                 std::list<VersionSet::Modifier> const &mods,
 362                 unsigned short const &fallback, CacheSetHelper &helper);
 363         static std::map<unsigned short, VersionSet> GroupedFromCommandLine(
 364                 pkgCacheFile &Cache, const char **cmdline,
 365                 std::list<VersionSet::Modifier> const &mods,
 366                 unsigned short const &fallback) {
 367                 CacheSetHelper helper;
 368                 return GroupedFromCommandLine(Cache, cmdline,
 369                                 mods, fallback, helper);
 370         }
 371                                                                         /*}}}*/
 372 protected:                                                              /*{{{*/
 373
 374         /** \brief returns the candidate version of the package
 375
 376             \param Cache to be used to query for information
 377             \param Pkg we want the candidate version from this package */
 378         static pkgCache::VerIterator getCandidateVer(pkgCacheFile &Cache,
 379                 pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
 380
 381         /** \brief returns the installed version of the package
 382
 383             \param Cache to be used to query for information
 384             \param Pkg we want the installed version from this package */
 385         static pkgCache::VerIterator getInstalledVer(pkgCacheFile &Cache,
 386                 pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
 387                                                                         /*}}}*/
 388 };                                                                      /*}}}*/
 389 }
 390 #endif