]>
Commit | Line | Data |
---|---|---|
1 | // Include Files /*{{{*/ | |
2 | #include <config.h> | |
3 | ||
4 | #include <apt-pkg/cachefile.h> | |
5 | #include <apt-pkg/cachefilter.h> | |
6 | #include <apt-pkg/cacheset.h> | |
7 | #include <apt-pkg/cmndline.h> | |
8 | #include <apt-pkg/pkgrecords.h> | |
9 | #include <apt-pkg/progress.h> | |
10 | #include <apt-pkg/strutl.h> | |
11 | #include <apt-pkg/configuration.h> | |
12 | #include <apt-pkg/macros.h> | |
13 | #include <apt-pkg/pkgcache.h> | |
14 | #include <apt-pkg/cacheiterators.h> | |
15 | ||
16 | #include <apt-private/private-cacheset.h> | |
17 | #include <apt-private/private-list.h> | |
18 | #include <apt-private/private-output.h> | |
19 | ||
20 | #include <iostream> | |
21 | #include <sstream> | |
22 | #include <map> | |
23 | #include <string> | |
24 | #include <utility> | |
25 | #include <vector> | |
26 | ||
27 | #include <apti18n.h> | |
28 | /*}}}*/ | |
29 | ||
30 | struct PackageSortAlphabetic /*{{{*/ | |
31 | { | |
32 | bool operator () (const pkgCache::PkgIterator &p_lhs, | |
33 | const pkgCache::PkgIterator &p_rhs) | |
34 | { | |
35 | const std::string &l_name = p_lhs.FullName(true); | |
36 | const std::string &r_name = p_rhs.FullName(true); | |
37 | return (l_name < r_name); | |
38 | } | |
39 | }; | |
40 | /*}}}*/ | |
41 | class PackageNameMatcher : public Matcher /*{{{*/ | |
42 | { | |
43 | #ifdef PACKAGE_MATCHER_ABI_COMPAT | |
44 | #define PackageMatcher PackageNameMatchesFnmatch | |
45 | #endif | |
46 | public: | |
47 | PackageNameMatcher(const char **patterns) | |
48 | { | |
49 | for(int i=0; patterns[i] != NULL; ++i) | |
50 | { | |
51 | std::string pattern = patterns[i]; | |
52 | #ifdef PACKAGE_MATCHER_ABI_COMPAT | |
53 | APT::CacheFilter::PackageNameMatchesFnmatch *cachefilter = NULL; | |
54 | cachefilter = new APT::CacheFilter::PackageNameMatchesFnmatch(pattern); | |
55 | #else | |
56 | APT::CacheFilter::PackageMatcher *cachefilter = NULL; | |
57 | if(_config->FindB("APT::Cmd::Use-Regexp", false) == true) | |
58 | cachefilter = new APT::CacheFilter::PackageNameMatchesRegEx(pattern); | |
59 | else | |
60 | cachefilter = new APT::CacheFilter::PackageNameMatchesFnmatch(pattern); | |
61 | #endif | |
62 | filters.push_back(cachefilter); | |
63 | } | |
64 | } | |
65 | virtual ~PackageNameMatcher() | |
66 | { | |
67 | for(J=filters.begin(); J != filters.end(); ++J) | |
68 | delete *J; | |
69 | } | |
70 | virtual bool operator () (const pkgCache::PkgIterator &P) | |
71 | { | |
72 | for(J=filters.begin(); J != filters.end(); ++J) | |
73 | { | |
74 | APT::CacheFilter::PackageMatcher *cachefilter = *J; | |
75 | if((*cachefilter)(P)) | |
76 | return true; | |
77 | } | |
78 | return false; | |
79 | } | |
80 | ||
81 | private: | |
82 | std::vector<APT::CacheFilter::PackageMatcher*> filters; | |
83 | std::vector<APT::CacheFilter::PackageMatcher*>::const_iterator J; | |
84 | #undef PackageMatcher | |
85 | }; | |
86 | /*}}}*/ | |
87 | static void ListAllVersions(pkgCacheFile &CacheFile, pkgRecords &records,/*{{{*/ | |
88 | pkgCache::PkgIterator P, | |
89 | std::ostream &outs, | |
90 | bool include_summary=true) | |
91 | { | |
92 | for (pkgCache::VerIterator Ver = P.VersionList(); | |
93 | Ver.end() == false; ++Ver) | |
94 | { | |
95 | ListSingleVersion(CacheFile, records, Ver, outs, include_summary); | |
96 | outs << "\n"; | |
97 | } | |
98 | } | |
99 | /*}}}*/ | |
100 | // list - list package based on criteria /*{{{*/ | |
101 | // --------------------------------------------------------------------- | |
102 | bool DoList(CommandLine &Cmd) | |
103 | { | |
104 | pkgCacheFile CacheFile; | |
105 | pkgCache *Cache = CacheFile.GetPkgCache(); | |
106 | if (unlikely(Cache == NULL)) | |
107 | return false; | |
108 | pkgRecords records(CacheFile); | |
109 | ||
110 | const char **patterns; | |
111 | const char *all_pattern[] = { "*", NULL}; | |
112 | ||
113 | if (strv_length(Cmd.FileList + 1) == 0) | |
114 | { | |
115 | patterns = all_pattern; | |
116 | } else { | |
117 | patterns = Cmd.FileList + 1; | |
118 | } | |
119 | ||
120 | std::map<std::string, std::string> output_map; | |
121 | std::map<std::string, std::string>::const_iterator K; | |
122 | ||
123 | bool includeSummary = _config->FindB("APT::Cmd::List-Include-Summary"); | |
124 | ||
125 | PackageNameMatcher matcher(patterns); | |
126 | LocalitySortedVersionSet bag; | |
127 | OpTextProgress progress(*_config); | |
128 | progress.OverallProgress(0, | |
129 | Cache->Head().PackageCount, | |
130 | Cache->Head().PackageCount, | |
131 | _("Listing")); | |
132 | GetLocalitySortedVersionSet(CacheFile, bag, matcher, progress); | |
133 | for (LocalitySortedVersionSet::iterator V = bag.begin(); V != bag.end(); ++V) | |
134 | { | |
135 | std::stringstream outs; | |
136 | if(_config->FindB("APT::Cmd::All-Versions", false) == true) | |
137 | { | |
138 | ListAllVersions(CacheFile, records, V.ParentPkg(), outs, includeSummary); | |
139 | output_map.insert(std::make_pair<std::string, std::string>( | |
140 | V.ParentPkg().Name(), outs.str())); | |
141 | } else { | |
142 | ListSingleVersion(CacheFile, records, V, outs, includeSummary); | |
143 | output_map.insert(std::make_pair<std::string, std::string>( | |
144 | V.ParentPkg().Name(), outs.str())); | |
145 | } | |
146 | } | |
147 | ||
148 | // FIXME: SORT! and make sorting flexible (alphabetic, by pkg status) | |
149 | // output the sorted map | |
150 | for (K = output_map.begin(); K != output_map.end(); ++K) | |
151 | std::cout << (*K).second << std::endl; | |
152 | ||
153 | ||
154 | return true; | |
155 | } | |
156 |