From a0c19a217ca2ed38ae0ecb4b8d2d4f8c4e53289f Mon Sep 17 00:00:00 2001 From: David Kalnischkies Date: Sun, 12 Jul 2015 13:41:12 +0200 Subject: implement a more generic ShowList method apt-get is displaying various lists of package names, which until now it was building as a string before passing it to ShowList, which inserted linebreaks at fitting points and showed a title if needed, but it never really understood what it was working with. With the help of C++11 the new generic knows not only what it works with, but generates the list on the fly rather than asking for it and potentially discarding parts of the input (= the non-default verbose display). It also doubles as a test for how usable the CacheSets are with C++11. (Not all callers are adapted yet.) Git-Dch: Ignore --- apt-pkg/cacheset.h | 99 +++++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 79 insertions(+), 20 deletions(-) (limited to 'apt-pkg/cacheset.h') diff --git a/apt-pkg/cacheset.h b/apt-pkg/cacheset.h index 03f3605a1..0b9b9441c 100644 --- a/apt-pkg/cacheset.h +++ b/apt-pkg/cacheset.h @@ -17,6 +17,7 @@ #include #endif #include +#include #include #include #include @@ -210,16 +211,15 @@ private: void * const d; }; /*}}}*/ // Iterator templates for our Containers /*{{{*/ -template class Container_iterator_base : +template class Container_iterator_base : public std::iterator::iterator_category, container_iterator>, public Interface::iterator_base { protected: container_iterator _iter; - inline virtual typename Container::value_type getType(void) const APT_OVERRIDE { return *_iter; } public: explicit Container_iterator_base(container_iterator i) : _iter(i) {} - inline typename Container::value_type operator*(void) const { return *_iter; } + inline container_value operator*(void) const { return this->getType(); } operator container_iterator(void) const { return _iter; } inline iterator_type& operator++() { ++_iter; return static_cast(*this); } inline iterator_type operator++(int) { iterator_type tmp(*this); operator++(); return tmp; } @@ -241,48 +241,56 @@ public: friend Master; }; template class Container_const_iterator : - public Container_iterator_base, typename Container::const_iterator> + public Container_iterator_base, typename Container::const_iterator, typename Container::value_type> { typedef Container_const_iterator iterator_type; typedef typename Container::const_iterator container_iterator; public: explicit Container_const_iterator(container_iterator i) : - Container_iterator_base(i) {} + Container_iterator_base(i) {} + + inline virtual typename Container::value_type getType(void) const APT_OVERRIDE { return *this->_iter; } }; template class Container_iterator : - public Container_iterator_base, typename Container::iterator> + public Container_iterator_base, typename Container::iterator, typename Container::value_type> { typedef Container_iterator iterator_type; typedef typename Container::iterator container_iterator; public: explicit Container_iterator(container_iterator i) : - Container_iterator_base(i) {} + Container_iterator_base(i) {} operator typename Master::const_iterator() { return typename Master::const_iterator(this->_iter); } inline iterator_type& operator=(iterator_type const &i) { this->_iter = i._iter; return static_cast(*this); } inline iterator_type& operator=(container_iterator const &i) { this->_iter = i; return static_cast(*this); } + + inline virtual typename Container::value_type getType(void) const APT_OVERRIDE { return *this->_iter; } }; template class Container_const_reverse_iterator : - public Container_iterator_base, typename Container::const_reverse_iterator> + public Container_iterator_base, typename Container::const_reverse_iterator, typename Container::value_type> { typedef Container_const_reverse_iterator iterator_type; typedef typename Container::const_reverse_iterator container_iterator; public: explicit Container_const_reverse_iterator(container_iterator i) : - Container_iterator_base(i) {} + Container_iterator_base(i) {} + + inline virtual typename Container::value_type getType(void) const APT_OVERRIDE { return *this->_iter; } }; template class Container_reverse_iterator : - public Container_iterator_base, typename Container::reverse_iterator> + public Container_iterator_base, typename Container::reverse_iterator, typename Container::value_type> { typedef Container_reverse_iterator iterator_type; typedef typename Container::reverse_iterator container_iterator; public: explicit Container_reverse_iterator(container_iterator i) : - Container_iterator_base(i) {} + Container_iterator_base(i) {} operator typename Master::const_iterator() { return typename Master::const_iterator(this->_iter); } inline iterator_type& operator=(iterator_type const &i) { this->_iter = i._iter; return static_cast(*this); } inline iterator_type& operator=(container_iterator const &i) { this->_iter = i; return static_cast(*this); } + + inline virtual typename Container::value_type getType(void) const APT_OVERRIDE { return *this->_iter; } }; /*}}}*/ class PackageContainerInterface { /*{{{*/ @@ -583,6 +591,10 @@ template<> template void PackageContainer template void PackageContainer >::insert(PackageContainer const &pkgcont) { + for (typename PackageContainer::const_iterator p = pkgcont.begin(); p != pkgcont.end(); ++p) + _cont.push_back(*p); +} template<> template void PackageContainer >::insert(PackageContainer const &pkgcont) { for (typename PackageContainer::const_iterator p = pkgcont.begin(); p != pkgcont.end(); ++p) _cont.push_back(*p); @@ -603,6 +615,12 @@ template<> inline bool PackageContainer return true; } #endif +template<> inline bool PackageContainer >::insert(pkgCache::PkgIterator const &P) { + if (P.end() == true) + return false; + _cont.push_back(P); + return true; +} template<> inline bool PackageContainer >::insert(pkgCache::PkgIterator const &P) { if (P.end() == true) return false; @@ -619,6 +637,10 @@ template<> inline void PackageContainer _cont.push_front(*p); } #endif +template<> inline void PackageContainer >::insert(const_iterator begin, const_iterator end) { + for (const_iterator p = begin; p != end; ++p) + _cont.push_back(*p); +} template<> inline void PackageContainer >::insert(const_iterator begin, const_iterator end) { for (const_iterator p = begin; p != end; ++p) _cont.push_back(*p); @@ -647,6 +669,10 @@ template<> template inline bool PackageContainer template inline bool PackageContainer >::sort(Compare Comp) { + std::sort(_cont.begin(), _cont.end(), Comp); + return true; +} /*}}}*/ // class PackageUniverse - pkgCache as PackageContainerInterface /*{{{*/ @@ -657,22 +683,35 @@ template<> template inline bool PackageContainer + { + protected: + inline virtual pkgCache::PkgIterator getType(void) const APT_OVERRIDE + { + return _iter; + } + public: + explicit const_iterator(pkgCache::PkgIterator i): + Container_iterator_base(i) {} + + }; + typedef const_iterator iterator; APT_PUBLIC bool empty() const APT_OVERRIDE { return false; } APT_PUBLIC size_t size() const APT_OVERRIDE { return _cont->Head().PackageCount; } - APT_PUBLIC const_iterator begin() const { return _cont->PkgBegin(); } - APT_PUBLIC const_iterator end() const { return _cont->PkgEnd(); } - APT_PUBLIC const_iterator cbegin() const { return _cont->PkgBegin(); } - APT_PUBLIC const_iterator cend() const { return _cont->PkgEnd(); } - APT_PUBLIC iterator begin() { return _cont->PkgBegin(); } - APT_PUBLIC iterator end() { return _cont->PkgEnd(); } + APT_PUBLIC const_iterator begin() const { return const_iterator(_cont->PkgBegin()); } + APT_PUBLIC const_iterator end() const { return const_iterator(_cont->PkgEnd()); } + APT_PUBLIC const_iterator cbegin() const { return const_iterator(_cont->PkgBegin()); } + APT_PUBLIC const_iterator cend() const { return const_iterator(_cont->PkgEnd()); } + APT_PUBLIC iterator begin() { return iterator(_cont->PkgBegin()); } + APT_PUBLIC iterator end() { return iterator(_cont->PkgEnd()); } + + APT_PUBLIC pkgCache * data() const { return _cont; } explicit APT_PUBLIC PackageUniverse(pkgCache * const Owner); APT_PUBLIC virtual ~PackageUniverse(); @@ -693,6 +732,7 @@ typedef PackageContainer > PackageUnor typedef PackageContainer > PackageForwardList; #endif typedef PackageContainer > PackageList; +typedef PackageContainer > PackageDeque; typedef PackageContainer > PackageVector; class VersionContainerInterface { /*{{{*/ @@ -1059,6 +1099,10 @@ template<> template void VersionContainer template void VersionContainer >::insert(VersionContainer const &vercont) { + for (typename VersionContainer::const_iterator v = vercont.begin(); v != vercont.end(); ++v) + _cont.push_back(*v); +} template<> template void VersionContainer >::insert(VersionContainer const &vercont) { for (typename VersionContainer::const_iterator v = vercont.begin(); v != vercont.end(); ++v) _cont.push_back(*v); @@ -1079,6 +1123,12 @@ template<> inline bool VersionContainer return true; } #endif +template<> inline bool VersionContainer >::insert(pkgCache::VerIterator const &V) { + if (V.end() == true) + return false; + _cont.push_back(V); + return true; +} template<> inline bool VersionContainer >::insert(pkgCache::VerIterator const &V) { if (V.end() == true) return false; @@ -1095,6 +1145,10 @@ template<> inline void VersionContainer _cont.push_front(*v); } #endif +template<> inline void VersionContainer >::insert(const_iterator begin, const_iterator end) { + for (const_iterator v = begin; v != end; ++v) + _cont.push_back(*v); +} template<> inline void VersionContainer >::insert(const_iterator begin, const_iterator end) { for (const_iterator v = begin; v != end; ++v) _cont.push_back(*v); @@ -1123,6 +1177,10 @@ template<> template inline bool VersionContainer template inline bool VersionContainer >::sort(Compare Comp) { + std::sort(_cont.begin(), _cont.end(), Comp); + return true; +} /*}}}*/ typedef VersionContainer > VersionSet; @@ -1131,6 +1189,7 @@ typedef VersionContainer > VersionUnor typedef VersionContainer > VersionForwardList; #endif typedef VersionContainer > VersionList; +typedef VersionContainer > VersionDeque; typedef VersionContainer > VersionVector; } #endif -- cgit v1.2.3