X-Git-Url: https://git.saurik.com/apt.git/blobdiff_plain/15fc8636b3e48eab5f3bc6f2e8c61c0409246909..5eb9a474dca2f48a935c234357c3adc9b372423e:/apt-pkg/cacheset.h diff --git a/apt-pkg/cacheset.h b/apt-pkg/cacheset.h index 411b31513..6f0a0e358 100644 --- a/apt-pkg/cacheset.h +++ b/apt-pkg/cacheset.h @@ -14,11 +14,16 @@ #include #include #include +#include #include #include #include #include + +#ifndef APT_8_CLEANER_HEADERS +#include +#endif /*}}}*/ class pkgCacheFile; @@ -159,35 +164,56 @@ template class PackageContainer : public PackageContainerInterf Container _cont; public: /*{{{*/ /** \brief smell like a pkgCache::PkgIterator */ - class const_iterator : public PackageContainerInterface::const_iterator, - public std::iterator {/*{{{*/ + class const_iterator : public PackageContainerInterface::const_iterator,/*{{{*/ + public std::iterator { typename Container::const_iterator _iter; public: const_iterator(typename Container::const_iterator i) : _iter(i) {} pkgCache::PkgIterator getPkg(void) const { return *_iter; } inline pkgCache::PkgIterator operator*(void) const { return *_iter; }; operator typename Container::const_iterator(void) const { return _iter; } - inline void operator++(void) { ++_iter; }; + inline const_iterator& operator++() { ++_iter; return *this; } + inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; } inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; }; inline bool operator==(const_iterator const &i) const { return _iter == i._iter; }; friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); } }; - // we are not going to allow modify our pkgiterators (it doesn't make sense)… - typedef APT::PackageContainer::const_iterator iterator; + class iterator : public PackageContainerInterface::const_iterator, + public std::iterator { + typename Container::iterator _iter; + public: + iterator(typename Container::iterator i) : _iter(i) {} + pkgCache::PkgIterator getPkg(void) const { return *_iter; } + inline pkgCache::PkgIterator operator*(void) const { return *_iter; }; + operator typename Container::iterator(void) const { return _iter; } + operator typename PackageContainer::const_iterator() { return PackageContainer::const_iterator(_iter); } + inline iterator& operator++() { ++_iter; return *this; } + inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; } + inline bool operator!=(iterator const &i) const { return _iter != i._iter; }; + inline bool operator==(iterator const &i) const { return _iter == i._iter; }; + inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; }; + inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; }; + friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); } + }; /*}}}*/ bool insert(pkgCache::PkgIterator const &P) { if (P.end() == true) return false; _cont.insert(P); return true; }; template void insert(PackageContainer const &pkgcont) { _cont.insert((typename Cont::const_iterator)pkgcont.begin(), (typename Cont::const_iterator)pkgcont.end()); }; void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); }; + bool empty() const { return _cont.empty(); }; void clear() { return _cont.clear(); }; - void erase(iterator position) { _cont.erase((typename Container::const_iterator)position); }; + //FIXME: on ABI break, replace the first with the second without bool + void erase(iterator position) { _cont.erase((typename Container::iterator)position); }; + iterator& erase(iterator &position, bool) { return position = _cont.erase((typename Container::iterator)position); }; size_t erase(const pkgCache::PkgIterator x) { return _cont.erase(x); }; void erase(iterator first, iterator last) { _cont.erase(first, last); }; size_t size() const { return _cont.size(); }; const_iterator begin() const { return const_iterator(_cont.begin()); }; const_iterator end() const { return const_iterator(_cont.end()); }; + iterator begin() { return iterator(_cont.begin()); }; + iterator end() { return iterator(_cont.end()); }; const_iterator find(pkgCache::PkgIterator const &P) const { return const_iterator(_cont.find(P)); }; void setConstructor(Constructor const &by) { ConstructedBy = by; }; @@ -318,7 +344,25 @@ private: /*{{{*/ Constructor ConstructedBy; /*}}}*/ }; /*}}}*/ + +template<> template void PackageContainer >::insert(PackageContainer const &pkgcont) { + for (typename PackageContainer::const_iterator p = pkgcont.begin(); p != pkgcont.end(); ++p) + _cont.push_back(*p); +}; +// these two are 'inline' as otherwise the linker has problems with seeing these untemplated +// specializations again and again - but we need to see them, so that library users can use them +template<> inline bool PackageContainer >::insert(pkgCache::PkgIterator const &P) { + if (P.end() == true) + return false; + _cont.push_back(P); + return true; +}; +template<> inline void PackageContainer >::insert(const_iterator begin, const_iterator end) { + for (const_iterator p = begin; p != end; ++p) + _cont.push_back(*p); +}; typedef PackageContainer > PackageSet; +typedef PackageContainer > PackageList; class VersionContainerInterface { /*{{{*/ /** \class APT::VersionContainerInterface @@ -406,6 +450,13 @@ public: std::list const &mods, CacheSetHelper &helper); + + static bool FromDependency(VersionContainerInterface * const vci, + pkgCacheFile &Cache, + pkgCache::DepIterator const &D, + Version const &selector, + CacheSetHelper &helper); + protected: /*{{{*/ /** \brief returns the candidate version of the package @@ -425,7 +476,7 @@ protected: /*{{{*/ }; /*}}}*/ template class VersionContainer : public VersionContainerInterface {/*{{{*/ -/** \class APT::PackageContainer +/** \class APT::VersionContainer Simple wrapper around a container class like std::set to provide a similar interface to a set of versions as to the complete set of all versions in the @@ -441,13 +492,29 @@ public: /*{{{*/ pkgCache::VerIterator getVer(void) const { return *_iter; } inline pkgCache::VerIterator operator*(void) const { return *_iter; }; operator typename Container::const_iterator(void) const { return _iter; } - inline void operator++(void) { ++_iter; }; + inline const_iterator& operator++() { ++_iter; return *this; } + inline const_iterator operator++(int) { const_iterator tmp(*this); operator++(); return tmp; } inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; }; inline bool operator==(const_iterator const &i) const { return _iter == i._iter; }; friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); } }; - // we are not going to allow modify our veriterators (it doesn't make sense)… - typedef APT::VersionContainer::const_iterator iterator; + class iterator : public VersionContainerInterface::const_iterator, + public std::iterator { + typename Container::iterator _iter; + public: + iterator(typename Container::iterator i) : _iter(i) {} + pkgCache::VerIterator getVer(void) const { return *_iter; } + inline pkgCache::VerIterator operator*(void) const { return *_iter; }; + operator typename Container::iterator(void) const { return _iter; } + operator typename VersionContainer::const_iterator() { return VersionContainer::const_iterator(_iter); } + inline iterator& operator++() { ++_iter; return *this; } + inline iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; } + inline bool operator!=(iterator const &i) const { return _iter != i._iter; }; + inline bool operator==(iterator const &i) const { return _iter == i._iter; }; + inline iterator& operator=(iterator const &i) { _iter = i._iter; return *this; }; + inline iterator& operator=(typename Container::iterator const &i) { _iter = i; return *this; }; + friend std::ostream& operator<<(std::ostream& out, iterator i) { return operator<<(out, *i); } + }; /*}}}*/ bool insert(pkgCache::VerIterator const &V) { if (V.end() == true) return false; _cont.insert(V); return true; }; @@ -455,13 +522,17 @@ public: /*{{{*/ void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); }; bool empty() const { return _cont.empty(); }; void clear() { return _cont.clear(); }; - void erase(iterator position) { _cont.erase((typename Container::const_iterator)position); }; - size_t erase(const pkgCache::PkgIterator x) { return _cont.erase(x); }; + //FIXME: on ABI break, replace the first with the second without bool + void erase(iterator position) { _cont.erase((typename Container::iterator)position); }; + iterator& erase(iterator &position, bool) { return position = _cont.erase((typename Container::iterator)position); }; + size_t erase(const pkgCache::VerIterator x) { return _cont.erase(x); }; void erase(iterator first, iterator last) { _cont.erase(first, last); }; size_t size() const { return _cont.size(); }; const_iterator begin() const { return const_iterator(_cont.begin()); }; const_iterator end() const { return const_iterator(_cont.end()); }; + iterator begin() { return iterator(_cont.begin()); }; + iterator end() { return iterator(_cont.end()); }; const_iterator find(pkgCache::VerIterator const &V) const { return const_iterator(_cont.find(V)); }; /** \brief returns all versions specified on the commandline @@ -520,7 +591,7 @@ public: /*{{{*/ return FromPackage(Cache, P, fallback, helper); } static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) { - return FromPackage(Cache, P, CANDINST); + return FromPackage(Cache, P, CANDIDATE); } static std::map GroupedFromCommandLine( @@ -547,8 +618,41 @@ public: /*{{{*/ return GroupedFromCommandLine(Cache, cmdline, mods, fallback, helper); } + + static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D, + Version const &selector, CacheSetHelper &helper) { + VersionContainer vercon; + VersionContainerInterface::FromDependency(&vercon, Cache, D, selector, helper); + return vercon; + } + static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D, + Version const &selector) { + CacheSetHelper helper; + return FromPackage(Cache, D, selector, helper); + } + static VersionContainer FromDependency(pkgCacheFile &Cache, pkgCache::DepIterator const &D) { + return FromPackage(Cache, D, CANDIDATE); + } /*}}}*/ }; /*}}}*/ + +template<> template void VersionContainer >::insert(VersionContainer const &vercont) { + for (typename VersionContainer::const_iterator v = vercont.begin(); v != vercont.end(); ++v) + _cont.push_back(*v); +}; +// these two are 'inline' as otherwise the linker has problems with seeing these untemplated +// specializations again and again - but we need to see them, so that library users can use them +template<> inline bool VersionContainer >::insert(pkgCache::VerIterator const &V) { + if (V.end() == true) + return false; + _cont.push_back(V); + return true; +}; +template<> inline void VersionContainer >::insert(const_iterator begin, const_iterator end) { + for (const_iterator v = begin; v != end; ++v) + _cont.push_back(*v); +}; typedef VersionContainer > VersionSet; +typedef VersionContainer > VersionList; } #endif