Commit | Line | Data |
---|---|---|
ffee1c2b DK |
1 | // -*- mode: cpp; mode: fold -*- |
2 | // Description /*{{{*/ | |
3 | /* ###################################################################### | |
4 | ||
5 | Simple wrapper around a std::set to provide a similar interface to | |
7959c5ed DK |
6 | a set of cache structures as to the complete set of all structures |
7 | in the pkgCache. Currently only Package is supported. | |
ffee1c2b DK |
8 | |
9 | ##################################################################### */ | |
10 | /*}}}*/ | |
11 | // Include Files /*{{{*/ | |
ea542140 DK |
12 | #include <config.h> |
13 | ||
78c32596 | 14 | #include <apt-pkg/aptconfiguration.h> |
472ff00e | 15 | #include <apt-pkg/cachefile.h> |
9ba5aa3b | 16 | #include <apt-pkg/cachefilter.h> |
8fde7239 | 17 | #include <apt-pkg/cacheset.h> |
ffee1c2b | 18 | #include <apt-pkg/error.h> |
ffee1c2b | 19 | #include <apt-pkg/strutl.h> |
856d3b06 | 20 | #include <apt-pkg/versionmatch.h> |
472ff00e DK |
21 | #include <apt-pkg/pkgrecords.h> |
22 | #include <apt-pkg/policy.h> | |
ffee1c2b | 23 | |
78c32596 DK |
24 | #include <vector> |
25 | ||
ffee1c2b | 26 | #include <regex.h> |
ea542140 DK |
27 | |
28 | #include <apti18n.h> | |
ffee1c2b DK |
29 | /*}}}*/ |
30 | namespace APT { | |
dc0f01f7 | 31 | // FromTask - Return all packages in the cache from a specific task /*{{{*/ |
15fc8636 | 32 | bool PackageContainerInterface::FromTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) { |
bd631595 | 33 | size_t const archfound = pattern.find_last_of(':'); |
dc0f01f7 DK |
34 | std::string arch = "native"; |
35 | if (archfound != std::string::npos) { | |
36 | arch = pattern.substr(archfound+1); | |
37 | pattern.erase(archfound); | |
38 | } | |
39 | ||
40 | if (pattern[pattern.length() -1] != '^') | |
15fc8636 | 41 | return false; |
dc0f01f7 DK |
42 | pattern.erase(pattern.length()-1); |
43 | ||
bd631595 | 44 | if (unlikely(Cache.GetPkgCache() == 0 || Cache.GetDepCache() == 0)) |
15fc8636 DK |
45 | return false; |
46 | ||
47 | bool const wasEmpty = pci->empty(); | |
48 | if (wasEmpty == true) | |
49 | pci->setConstructor(TASK); | |
bd631595 | 50 | |
dc0f01f7 DK |
51 | // get the records |
52 | pkgRecords Recs(Cache); | |
53 | ||
54 | // build regexp for the task | |
55 | regex_t Pattern; | |
56 | char S[300]; | |
57 | snprintf(S, sizeof(S), "^Task:.*[, ]%s([, ]|$)", pattern.c_str()); | |
58 | if(regcomp(&Pattern,S, REG_EXTENDED | REG_NOSUB | REG_NEWLINE) != 0) { | |
59 | _error->Error("Failed to compile task regexp"); | |
15fc8636 | 60 | return false; |
dc0f01f7 DK |
61 | } |
62 | ||
15fc8636 | 63 | bool found = false; |
dc0f01f7 DK |
64 | for (pkgCache::GrpIterator Grp = Cache->GrpBegin(); Grp.end() == false; ++Grp) { |
65 | pkgCache::PkgIterator Pkg = Grp.FindPkg(arch); | |
66 | if (Pkg.end() == true) | |
67 | continue; | |
68 | pkgCache::VerIterator ver = Cache[Pkg].CandidateVerIter(Cache); | |
69 | if(ver.end() == true) | |
70 | continue; | |
71 | ||
72 | pkgRecords::Parser &parser = Recs.Lookup(ver.FileList()); | |
73 | const char *start, *end; | |
74 | parser.GetRec(start,end); | |
75 | unsigned int const length = end - start; | |
62d8a765 DK |
76 | if (unlikely(length == 0)) |
77 | continue; | |
dc0f01f7 DK |
78 | char buf[length]; |
79 | strncpy(buf, start, length); | |
80 | buf[length-1] = '\0'; | |
70e706ad DK |
81 | if (regexec(&Pattern, buf, 0, 0, 0) != 0) |
82 | continue; | |
83 | ||
15fc8636 DK |
84 | pci->insert(Pkg); |
85 | helper.showTaskSelection(Pkg, pattern); | |
86 | found = true; | |
dc0f01f7 | 87 | } |
70e706ad | 88 | regfree(&Pattern); |
dc0f01f7 | 89 | |
15fc8636 DK |
90 | if (found == false) { |
91 | helper.canNotFindTask(pci, Cache, pattern); | |
92 | pci->setConstructor(UNKNOWN); | |
93 | return false; | |
94 | } | |
95 | ||
96 | if (wasEmpty == false && pci->getConstructor() != UNKNOWN) | |
97 | pci->setConstructor(UNKNOWN); | |
dc0f01f7 | 98 | |
15fc8636 | 99 | return true; |
dc0f01f7 DK |
100 | } |
101 | /*}}}*/ | |
ffee1c2b | 102 | // FromRegEx - Return all packages in the cache matching a pattern /*{{{*/ |
15fc8636 | 103 | bool PackageContainerInterface::FromRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) { |
6e235c66 | 104 | static const char * const isregex = ".?+*|[^$"; |
6e235c66 | 105 | if (pattern.find_first_of(isregex) == std::string::npos) |
15fc8636 DK |
106 | return false; |
107 | ||
108 | bool const wasEmpty = pci->empty(); | |
109 | if (wasEmpty == true) | |
110 | pci->setConstructor(REGEX); | |
ffee1c2b | 111 | |
6e235c66 | 112 | size_t archfound = pattern.find_last_of(':'); |
dc0f01f7 | 113 | std::string arch = "native"; |
6e235c66 DK |
114 | if (archfound != std::string::npos) { |
115 | arch = pattern.substr(archfound+1); | |
116 | if (arch.find_first_of(isregex) == std::string::npos) | |
117 | pattern.erase(archfound); | |
118 | else | |
119 | arch = "native"; | |
120 | } | |
121 | ||
bd631595 | 122 | if (unlikely(Cache.GetPkgCache() == 0)) |
15fc8636 | 123 | return false; |
bd631595 | 124 | |
9ba5aa3b DK |
125 | APT::CacheFilter::PackageNameMatchesRegEx regexfilter(pattern); |
126 | ||
15fc8636 | 127 | bool found = false; |
9ba5aa3b DK |
128 | for (pkgCache::GrpIterator Grp = Cache.GetPkgCache()->GrpBegin(); Grp.end() == false; ++Grp) { |
129 | if (regexfilter(Grp) == false) | |
ffee1c2b | 130 | continue; |
6e235c66 | 131 | pkgCache::PkgIterator Pkg = Grp.FindPkg(arch); |
78c32596 | 132 | if (Pkg.end() == true) { |
6e235c66 DK |
133 | if (archfound == std::string::npos) { |
134 | std::vector<std::string> archs = APT::Configuration::getArchitectures(); | |
135 | for (std::vector<std::string>::const_iterator a = archs.begin(); | |
136 | a != archs.end() && Pkg.end() != true; ++a) | |
137 | Pkg = Grp.FindPkg(*a); | |
78c32596 DK |
138 | } |
139 | if (Pkg.end() == true) | |
140 | continue; | |
141 | } | |
ffee1c2b | 142 | |
15fc8636 DK |
143 | pci->insert(Pkg); |
144 | helper.showRegExSelection(Pkg, pattern); | |
145 | found = true; | |
ffee1c2b | 146 | } |
ffee1c2b | 147 | |
15fc8636 DK |
148 | if (found == false) { |
149 | helper.canNotFindRegEx(pci, Cache, pattern); | |
150 | pci->setConstructor(UNKNOWN); | |
151 | return false; | |
152 | } | |
153 | ||
b9179170 MV |
154 | if (wasEmpty == false && pci->getConstructor() != UNKNOWN) |
155 | pci->setConstructor(UNKNOWN); | |
156 | ||
157 | return true; | |
158 | } | |
159 | /*}}}*/ | |
160 | // FromFnmatch - Returns the package defined by this fnmatch /*{{{*/ | |
161 | bool | |
162 | PackageContainerInterface::FromFnmatch(PackageContainerInterface * const pci, | |
163 | pkgCacheFile &Cache, | |
164 | std::string pattern, | |
165 | CacheSetHelper &helper) | |
166 | { | |
167 | static const char * const isfnmatch = ".?*[]!"; | |
168 | if (pattern.find_first_of(isfnmatch) == std::string::npos) | |
169 | return false; | |
170 | ||
171 | bool const wasEmpty = pci->empty(); | |
172 | if (wasEmpty == true) | |
173 | pci->setConstructor(FNMATCH); | |
174 | ||
175 | size_t archfound = pattern.find_last_of(':'); | |
176 | std::string arch = "native"; | |
177 | if (archfound != std::string::npos) { | |
178 | arch = pattern.substr(archfound+1); | |
179 | if (arch.find_first_of(isfnmatch) == std::string::npos) | |
180 | pattern.erase(archfound); | |
181 | else | |
182 | arch = "native"; | |
183 | } | |
184 | ||
185 | if (unlikely(Cache.GetPkgCache() == 0)) | |
186 | return false; | |
187 | ||
188 | APT::CacheFilter::PackageNameMatchesFnmatch filter(pattern); | |
189 | ||
190 | bool found = false; | |
191 | for (pkgCache::GrpIterator Grp = Cache.GetPkgCache()->GrpBegin(); Grp.end() == false; ++Grp) { | |
192 | if (filter(Grp) == false) | |
193 | continue; | |
194 | pkgCache::PkgIterator Pkg = Grp.FindPkg(arch); | |
195 | if (Pkg.end() == true) { | |
196 | if (archfound == std::string::npos) { | |
197 | std::vector<std::string> archs = APT::Configuration::getArchitectures(); | |
198 | for (std::vector<std::string>::const_iterator a = archs.begin(); | |
199 | a != archs.end() && Pkg.end() != true; ++a) | |
200 | Pkg = Grp.FindPkg(*a); | |
201 | } | |
202 | if (Pkg.end() == true) | |
203 | continue; | |
204 | } | |
205 | ||
206 | pci->insert(Pkg); | |
16724b66 MV |
207 | #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13) |
208 | helper.showFnmatchSelection(Pkg, pattern); | |
209 | #else | |
b9179170 | 210 | helper.showRegExSelection(Pkg, pattern); |
16724b66 | 211 | #endif |
b9179170 MV |
212 | found = true; |
213 | } | |
214 | ||
215 | if (found == false) { | |
16724b66 MV |
216 | #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13) |
217 | helper.canNotFindFnmatch(pci, Cache, pattern); | |
218 | #else | |
219 | helper.canNotFindRegEx(pci, Cache, pattern); | |
220 | #endif | |
b9179170 MV |
221 | pci->setConstructor(UNKNOWN); |
222 | return false; | |
223 | } | |
224 | ||
15fc8636 DK |
225 | if (wasEmpty == false && pci->getConstructor() != UNKNOWN) |
226 | pci->setConstructor(UNKNOWN); | |
70e706ad | 227 | |
15fc8636 | 228 | return true; |
78c32596 DK |
229 | } |
230 | /*}}}*/ | |
bd631595 | 231 | // FromName - Returns the package defined by this string /*{{{*/ |
15fc8636 | 232 | pkgCache::PkgIterator PackageContainerInterface::FromName(pkgCacheFile &Cache, |
bd631595 DK |
233 | std::string const &str, CacheSetHelper &helper) { |
234 | std::string pkg = str; | |
235 | size_t archfound = pkg.find_last_of(':'); | |
236 | std::string arch; | |
237 | if (archfound != std::string::npos) { | |
238 | arch = pkg.substr(archfound+1); | |
239 | pkg.erase(archfound); | |
240 | } | |
241 | ||
242 | if (Cache.GetPkgCache() == 0) | |
243 | return pkgCache::PkgIterator(Cache, 0); | |
244 | ||
245 | pkgCache::PkgIterator Pkg(Cache, 0); | |
246 | if (arch.empty() == true) { | |
247 | pkgCache::GrpIterator Grp = Cache.GetPkgCache()->FindGrp(pkg); | |
248 | if (Grp.end() == false) | |
249 | Pkg = Grp.FindPreferredPkg(); | |
250 | } else | |
251 | Pkg = Cache.GetPkgCache()->FindPkg(pkg, arch); | |
252 | ||
253 | if (Pkg.end() == true) | |
254 | return helper.canNotFindPkgName(Cache, str); | |
255 | return Pkg; | |
256 | } | |
257 | /*}}}*/ | |
2f0d4029 DK |
258 | // FromGroup - Returns the package defined by this string /*{{{*/ |
259 | bool PackageContainerInterface::FromGroup(PackageContainerInterface * const pci, pkgCacheFile &Cache, | |
260 | std::string pkg, CacheSetHelper &helper) { | |
261 | if (unlikely(Cache.GetPkgCache() == 0)) | |
262 | return false; | |
263 | ||
264 | size_t const archfound = pkg.find_last_of(':'); | |
265 | std::string arch; | |
266 | if (archfound != std::string::npos) { | |
267 | arch = pkg.substr(archfound+1); | |
268 | pkg.erase(archfound); | |
f1d86c0e DK |
269 | if (arch == "all" || arch == "native") |
270 | arch = _config->Find("APT::Architecture"); | |
2f0d4029 DK |
271 | } |
272 | ||
273 | pkgCache::GrpIterator Grp = Cache.GetPkgCache()->FindGrp(pkg); | |
274 | if (Grp.end() == false) { | |
275 | if (arch.empty() == true) { | |
276 | pkgCache::PkgIterator Pkg = Grp.FindPreferredPkg(); | |
277 | if (Pkg.end() == false) | |
278 | { | |
279 | pci->insert(Pkg); | |
280 | return true; | |
281 | } | |
282 | } else { | |
283 | bool found = false; | |
284 | // for 'linux-any' return the first package matching, for 'linux-*' return all matches | |
285 | bool const isGlobal = arch.find('*') != std::string::npos; | |
286 | APT::CacheFilter::PackageArchitectureMatchesSpecification pams(arch); | |
287 | for (pkgCache::PkgIterator Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg)) { | |
288 | if (pams(Pkg) == false) | |
289 | continue; | |
290 | pci->insert(Pkg); | |
291 | found = true; | |
292 | if (isGlobal == false) | |
293 | break; | |
294 | } | |
295 | if (found == true) | |
296 | return true; | |
297 | } | |
298 | } | |
299 | ||
300 | pkgCache::PkgIterator Pkg = helper.canNotFindPkgName(Cache, pkg); | |
301 | if (Pkg.end() == true) | |
302 | return false; | |
303 | ||
304 | pci->insert(Pkg); | |
305 | return true; | |
306 | } | |
307 | /*}}}*/ | |
856d3b06 | 308 | // FromString - Return all packages matching a specific string /*{{{*/ |
15fc8636 DK |
309 | bool PackageContainerInterface::FromString(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str, CacheSetHelper &helper) { |
310 | bool found = true; | |
48c39e32 DK |
311 | _error->PushToStack(); |
312 | ||
2f0d4029 DK |
313 | if (FromGroup(pci, Cache, str, helper) == false && |
314 | FromTask(pci, Cache, str, helper) == false && | |
15fc8636 DK |
315 | FromRegEx(pci, Cache, str, helper) == false) |
316 | { | |
317 | helper.canNotFindPackage(pci, Cache, str); | |
318 | found = false; | |
48c39e32 | 319 | } |
dc0f01f7 | 320 | |
15fc8636 | 321 | if (found == true) |
48c39e32 DK |
322 | _error->RevertToStack(); |
323 | else | |
324 | _error->MergeWithStack(); | |
15fc8636 | 325 | return found; |
856d3b06 DK |
326 | } |
327 | /*}}}*/ | |
15fc8636 DK |
328 | // FromCommandLine - Return all packages specified on commandline /*{{{*/ |
329 | bool PackageContainerInterface::FromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) { | |
330 | bool found = false; | |
331 | for (const char **I = cmdline; *I != 0; ++I) | |
332 | found |= PackageContainerInterface::FromString(pci, Cache, *I, helper); | |
333 | return found; | |
334 | } | |
335 | /*}}}*/ | |
336 | // FromModifierCommandLine - helper doing the work for PKG:GroupedFromCommandLine /*{{{*/ | |
337 | bool PackageContainerInterface::FromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci, | |
338 | pkgCacheFile &Cache, const char * cmdline, | |
339 | std::list<Modifier> const &mods, CacheSetHelper &helper) { | |
340 | std::string str = cmdline; | |
e6a12579 | 341 | unsigned short fallback = modID; |
15fc8636 DK |
342 | bool modifierPresent = false; |
343 | for (std::list<Modifier>::const_iterator mod = mods.begin(); | |
344 | mod != mods.end(); ++mod) { | |
345 | size_t const alength = strlen(mod->Alias); | |
346 | switch(mod->Pos) { | |
347 | case Modifier::POSTFIX: | |
348 | if (str.compare(str.length() - alength, alength, | |
349 | mod->Alias, 0, alength) != 0) | |
55c59998 | 350 | continue; |
15fc8636 DK |
351 | str.erase(str.length() - alength); |
352 | modID = mod->ID; | |
55c59998 | 353 | break; |
15fc8636 DK |
354 | case Modifier::PREFIX: |
355 | continue; | |
356 | case Modifier::NONE: | |
357 | continue; | |
55c59998 | 358 | } |
15fc8636 DK |
359 | modifierPresent = true; |
360 | break; | |
361 | } | |
362 | if (modifierPresent == true) { | |
363 | bool const errors = helper.showErrors(false); | |
364 | pkgCache::PkgIterator Pkg = FromName(Cache, cmdline, helper); | |
365 | helper.showErrors(errors); | |
366 | if (Pkg.end() == false) { | |
367 | pci->insert(Pkg); | |
e6a12579 | 368 | modID = fallback; |
15fc8636 DK |
369 | return true; |
370 | } | |
371 | } | |
372 | return FromString(pci, Cache, str, helper); | |
373 | } | |
374 | /*}}}*/ | |
375 | // FromModifierCommandLine - helper doing the work for VER:GroupedFromCommandLine /*{{{*/ | |
376 | bool VersionContainerInterface::FromModifierCommandLine(unsigned short &modID, | |
377 | VersionContainerInterface * const vci, | |
378 | pkgCacheFile &Cache, const char * cmdline, | |
379 | std::list<Modifier> const &mods, | |
380 | CacheSetHelper &helper) { | |
381 | Version select = NEWEST; | |
382 | std::string str = cmdline; | |
383 | bool modifierPresent = false; | |
384 | unsigned short fallback = modID; | |
385 | for (std::list<Modifier>::const_iterator mod = mods.begin(); | |
386 | mod != mods.end(); ++mod) { | |
387 | if (modID == fallback && mod->ID == fallback) | |
388 | select = mod->SelectVersion; | |
389 | size_t const alength = strlen(mod->Alias); | |
390 | switch(mod->Pos) { | |
391 | case Modifier::POSTFIX: | |
392 | if (str.compare(str.length() - alength, alength, | |
393 | mod->Alias, 0, alength) != 0) | |
bd631595 | 394 | continue; |
15fc8636 DK |
395 | str.erase(str.length() - alength); |
396 | modID = mod->ID; | |
397 | select = mod->SelectVersion; | |
398 | break; | |
399 | case Modifier::PREFIX: | |
400 | continue; | |
401 | case Modifier::NONE: | |
402 | continue; | |
bd631595 | 403 | } |
15fc8636 DK |
404 | modifierPresent = true; |
405 | break; | |
55c59998 | 406 | } |
15fc8636 DK |
407 | if (modifierPresent == true) { |
408 | bool const errors = helper.showErrors(false); | |
409 | bool const found = VersionContainerInterface::FromString(vci, Cache, cmdline, select, helper, true); | |
410 | helper.showErrors(errors); | |
e6a12579 DK |
411 | if (found == true) { |
412 | modID = fallback; | |
15fc8636 | 413 | return true; |
e6a12579 | 414 | } |
15fc8636 DK |
415 | } |
416 | return FromString(vci, Cache, str, select, helper); | |
55c59998 DK |
417 | } |
418 | /*}}}*/ | |
856d3b06 | 419 | // FromCommandLine - Return all versions specified on commandline /*{{{*/ |
15fc8636 DK |
420 | bool VersionContainerInterface::FromCommandLine(VersionContainerInterface * const vci, |
421 | pkgCacheFile &Cache, const char **cmdline, | |
422 | Version const &fallback, CacheSetHelper &helper) { | |
423 | bool found = false; | |
bd631595 | 424 | for (const char **I = cmdline; *I != 0; ++I) |
15fc8636 DK |
425 | found |= VersionContainerInterface::FromString(vci, Cache, *I, fallback, helper); |
426 | return found; | |
55c59998 DK |
427 | } |
428 | /*}}}*/ | |
429 | // FromString - Returns all versions spedcified by a string /*{{{*/ | |
15fc8636 DK |
430 | bool VersionContainerInterface::FromString(VersionContainerInterface * const vci, |
431 | pkgCacheFile &Cache, std::string pkg, | |
432 | Version const &fallback, CacheSetHelper &helper, | |
433 | bool const onlyFromName) { | |
55c59998 DK |
434 | std::string ver; |
435 | bool verIsRel = false; | |
436 | size_t const vertag = pkg.find_last_of("/="); | |
472ff00e | 437 | if (vertag != std::string::npos) { |
55c59998 DK |
438 | ver = pkg.substr(vertag+1); |
439 | verIsRel = (pkg[vertag] == '/'); | |
440 | pkg.erase(vertag); | |
441 | } | |
bd631595 DK |
442 | PackageSet pkgset; |
443 | if (onlyFromName == false) | |
15fc8636 | 444 | PackageContainerInterface::FromString(&pkgset, Cache, pkg, helper); |
bd631595 | 445 | else { |
15fc8636 | 446 | pkgset.insert(PackageContainerInterface::FromName(Cache, pkg, helper)); |
bd631595 DK |
447 | } |
448 | ||
c8db3fff DK |
449 | bool errors = true; |
450 | if (pkgset.getConstructor() != PackageSet::UNKNOWN) | |
451 | errors = helper.showErrors(false); | |
15fc8636 DK |
452 | |
453 | bool found = false; | |
55c59998 DK |
454 | for (PackageSet::const_iterator P = pkgset.begin(); |
455 | P != pkgset.end(); ++P) { | |
472ff00e | 456 | if (vertag == std::string::npos) { |
15fc8636 | 457 | found |= VersionContainerInterface::FromPackage(vci, Cache, P, fallback, helper); |
55c59998 | 458 | continue; |
856d3b06 | 459 | } |
55c59998 DK |
460 | pkgCache::VerIterator V; |
461 | if (ver == "installed") | |
70e706ad | 462 | V = getInstalledVer(Cache, P, helper); |
55c59998 | 463 | else if (ver == "candidate") |
70e706ad | 464 | V = getCandidateVer(Cache, P, helper); |
f1a58ff8 DK |
465 | else if (ver == "newest") { |
466 | if (P->VersionList != 0) | |
467 | V = P.VersionList(); | |
468 | else | |
469 | V = helper.canNotFindNewestVer(Cache, P); | |
470 | } else { | |
55c59998 DK |
471 | pkgVersionMatch Match(ver, (verIsRel == true ? pkgVersionMatch::Release : |
472 | pkgVersionMatch::Version)); | |
473 | V = Match.Find(P); | |
474 | if (V.end() == true) { | |
475 | if (verIsRel == true) | |
476 | _error->Error(_("Release '%s' for '%s' was not found"), | |
477 | ver.c_str(), P.FullName(true).c_str()); | |
478 | else | |
479 | _error->Error(_("Version '%s' for '%s' was not found"), | |
480 | ver.c_str(), P.FullName(true).c_str()); | |
84910ad5 DK |
481 | continue; |
482 | } | |
78c32596 | 483 | } |
55c59998 DK |
484 | if (V.end() == true) |
485 | continue; | |
70e706ad | 486 | helper.showSelectedVersion(P, V, ver, verIsRel); |
15fc8636 DK |
487 | vci->insert(V); |
488 | found = true; | |
78c32596 | 489 | } |
c8db3fff DK |
490 | if (pkgset.getConstructor() != PackageSet::UNKNOWN) |
491 | helper.showErrors(errors); | |
15fc8636 | 492 | return found; |
856d3b06 DK |
493 | } |
494 | /*}}}*/ | |
fb83c1d0 | 495 | // FromPackage - versions from package based on fallback /*{{{*/ |
15fc8636 DK |
496 | bool VersionContainerInterface::FromPackage(VersionContainerInterface * const vci, |
497 | pkgCacheFile &Cache, | |
498 | pkgCache::PkgIterator const &P, | |
499 | Version const &fallback, | |
500 | CacheSetHelper &helper) { | |
84910ad5 | 501 | pkgCache::VerIterator V; |
70e706ad | 502 | bool showErrors; |
15fc8636 | 503 | bool found = false; |
84910ad5 | 504 | switch(fallback) { |
15fc8636 | 505 | case ALL: |
84910ad5 DK |
506 | if (P->VersionList != 0) |
507 | for (V = P.VersionList(); V.end() != true; ++V) | |
15fc8636 | 508 | found |= vci->insert(V); |
84910ad5 | 509 | else |
15fc8636 | 510 | helper.canNotFindAllVer(vci, Cache, P); |
84910ad5 | 511 | break; |
15fc8636 DK |
512 | case CANDANDINST: |
513 | found |= vci->insert(getInstalledVer(Cache, P, helper)); | |
514 | found |= vci->insert(getCandidateVer(Cache, P, helper)); | |
84910ad5 | 515 | break; |
15fc8636 DK |
516 | case CANDIDATE: |
517 | found |= vci->insert(getCandidateVer(Cache, P, helper)); | |
84910ad5 | 518 | break; |
15fc8636 DK |
519 | case INSTALLED: |
520 | found |= vci->insert(getInstalledVer(Cache, P, helper)); | |
84910ad5 | 521 | break; |
15fc8636 | 522 | case CANDINST: |
70e706ad DK |
523 | showErrors = helper.showErrors(false); |
524 | V = getCandidateVer(Cache, P, helper); | |
84910ad5 | 525 | if (V.end() == true) |
70e706ad DK |
526 | V = getInstalledVer(Cache, P, helper); |
527 | helper.showErrors(showErrors); | |
84910ad5 | 528 | if (V.end() == false) |
15fc8636 | 529 | found |= vci->insert(V); |
84910ad5 | 530 | else |
15fc8636 | 531 | helper.canNotFindInstCandVer(vci, Cache, P); |
84910ad5 | 532 | break; |
15fc8636 | 533 | case INSTCAND: |
70e706ad DK |
534 | showErrors = helper.showErrors(false); |
535 | V = getInstalledVer(Cache, P, helper); | |
84910ad5 | 536 | if (V.end() == true) |
70e706ad DK |
537 | V = getCandidateVer(Cache, P, helper); |
538 | helper.showErrors(showErrors); | |
84910ad5 | 539 | if (V.end() == false) |
15fc8636 | 540 | found |= vci->insert(V); |
84910ad5 | 541 | else |
15fc8636 | 542 | helper.canNotFindInstCandVer(vci, Cache, P); |
84910ad5 | 543 | break; |
15fc8636 | 544 | case NEWEST: |
84910ad5 | 545 | if (P->VersionList != 0) |
15fc8636 | 546 | found |= vci->insert(P.VersionList()); |
84910ad5 | 547 | else |
15fc8636 | 548 | helper.canNotFindNewestVer(Cache, P); |
84910ad5 DK |
549 | break; |
550 | } | |
15fc8636 | 551 | return found; |
84910ad5 DK |
552 | } |
553 | /*}}}*/ | |
856d3b06 | 554 | // getCandidateVer - Returns the candidate version of the given package /*{{{*/ |
15fc8636 | 555 | pkgCache::VerIterator VersionContainerInterface::getCandidateVer(pkgCacheFile &Cache, |
70e706ad | 556 | pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper) { |
a8ef7efd | 557 | pkgCache::VerIterator Cand; |
15fc8636 | 558 | if (Cache.IsPolicyBuilt() == true || Cache.IsDepCacheBuilt() == false) { |
bd631595 DK |
559 | if (unlikely(Cache.GetPolicy() == 0)) |
560 | return pkgCache::VerIterator(Cache); | |
a8ef7efd | 561 | Cand = Cache.GetPolicy()->GetCandidateVer(Pkg); |
2fbfb111 DK |
562 | } else { |
563 | Cand = Cache[Pkg].CandidateVerIter(Cache); | |
a8ef7efd | 564 | } |
70e706ad DK |
565 | if (Cand.end() == true) |
566 | return helper.canNotFindCandidateVer(Cache, Pkg); | |
856d3b06 DK |
567 | return Cand; |
568 | } | |
569 | /*}}}*/ | |
570 | // getInstalledVer - Returns the installed version of the given package /*{{{*/ | |
15fc8636 | 571 | pkgCache::VerIterator VersionContainerInterface::getInstalledVer(pkgCacheFile &Cache, |
70e706ad DK |
572 | pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper) { |
573 | if (Pkg->CurrentVer == 0) | |
574 | return helper.canNotFindInstalledVer(Cache, Pkg); | |
856d3b06 | 575 | return Pkg.CurrentVer(); |
ffee1c2b DK |
576 | } |
577 | /*}}}*/ | |
15fc8636 | 578 | |
bd631595 DK |
579 | // canNotFindPkgName - handle the case no package has this name /*{{{*/ |
580 | pkgCache::PkgIterator CacheSetHelper::canNotFindPkgName(pkgCacheFile &Cache, | |
581 | std::string const &str) { | |
582 | if (ShowError == true) | |
cd7bbc47 | 583 | _error->Insert(ErrorType, _("Unable to locate package %s"), str.c_str()); |
bd631595 DK |
584 | return pkgCache::PkgIterator(Cache, 0); |
585 | } | |
586 | /*}}}*/ | |
70e706ad | 587 | // canNotFindTask - handle the case no package is found for a task /*{{{*/ |
15fc8636 | 588 | void CacheSetHelper::canNotFindTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern) { |
70e706ad | 589 | if (ShowError == true) |
cd7bbc47 | 590 | _error->Insert(ErrorType, _("Couldn't find task '%s'"), pattern.c_str()); |
70e706ad DK |
591 | } |
592 | /*}}}*/ | |
593 | // canNotFindRegEx - handle the case no package is found by a regex /*{{{*/ | |
15fc8636 | 594 | void CacheSetHelper::canNotFindRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern) { |
70e706ad | 595 | if (ShowError == true) |
cd7bbc47 | 596 | _error->Insert(ErrorType, _("Couldn't find any package by regex '%s'"), pattern.c_str()); |
70e706ad | 597 | } |
16724b66 MV |
598 | #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13) |
599 | // canNotFindFnmatch - handle the case no package is found by a fnmatch /*{{{*/ | |
600 | void CacheSetHelper::canNotFindFnmatch(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern) { | |
601 | if (ShowError == true) | |
602 | _error->Insert(ErrorType, _("Couldn't find any package by glob '%s'"), pattern.c_str()); | |
603 | } | |
604 | #endif /*}}}*/ | |
70e706ad | 605 | // canNotFindPackage - handle the case no package is found from a string/*{{{*/ |
15fc8636 | 606 | void CacheSetHelper::canNotFindPackage(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str) { |
70e706ad DK |
607 | } |
608 | /*}}}*/ | |
609 | // canNotFindAllVer /*{{{*/ | |
15fc8636 | 610 | void CacheSetHelper::canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, |
70e706ad DK |
611 | pkgCache::PkgIterator const &Pkg) { |
612 | if (ShowError == true) | |
edc0ef10 | 613 | _error->Insert(ErrorType, _("Can't select versions from package '%s' as it is purely virtual"), Pkg.FullName(true).c_str()); |
70e706ad DK |
614 | } |
615 | /*}}}*/ | |
616 | // canNotFindInstCandVer /*{{{*/ | |
15fc8636 | 617 | void CacheSetHelper::canNotFindInstCandVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, |
70e706ad DK |
618 | pkgCache::PkgIterator const &Pkg) { |
619 | if (ShowError == true) | |
cd7bbc47 | 620 | _error->Insert(ErrorType, _("Can't select installed nor candidate version from package '%s' as it has neither of them"), Pkg.FullName(true).c_str()); |
70e706ad DK |
621 | } |
622 | /*}}}*/ | |
cf28bcad | 623 | // canNotFindInstCandVer /*{{{*/ |
15fc8636 | 624 | void CacheSetHelper::canNotFindCandInstVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, |
cf28bcad DK |
625 | pkgCache::PkgIterator const &Pkg) { |
626 | if (ShowError == true) | |
cd7bbc47 | 627 | _error->Insert(ErrorType, _("Can't select installed nor candidate version from package '%s' as it has neither of them"), Pkg.FullName(true).c_str()); |
cf28bcad DK |
628 | } |
629 | /*}}}*/ | |
70e706ad DK |
630 | // canNotFindNewestVer /*{{{*/ |
631 | pkgCache::VerIterator CacheSetHelper::canNotFindNewestVer(pkgCacheFile &Cache, | |
632 | pkgCache::PkgIterator const &Pkg) { | |
633 | if (ShowError == true) | |
cd7bbc47 | 634 | _error->Insert(ErrorType, _("Can't select newest version from package '%s' as it is purely virtual"), Pkg.FullName(true).c_str()); |
c8db3fff | 635 | return pkgCache::VerIterator(Cache, 0); |
70e706ad DK |
636 | } |
637 | /*}}}*/ | |
638 | // canNotFindCandidateVer /*{{{*/ | |
639 | pkgCache::VerIterator CacheSetHelper::canNotFindCandidateVer(pkgCacheFile &Cache, | |
640 | pkgCache::PkgIterator const &Pkg) { | |
641 | if (ShowError == true) | |
cd7bbc47 | 642 | _error->Insert(ErrorType, _("Can't select candidate version from package %s as it has no candidate"), Pkg.FullName(true).c_str()); |
c8db3fff | 643 | return pkgCache::VerIterator(Cache, 0); |
70e706ad DK |
644 | } |
645 | /*}}}*/ | |
646 | // canNotFindInstalledVer /*{{{*/ | |
647 | pkgCache::VerIterator CacheSetHelper::canNotFindInstalledVer(pkgCacheFile &Cache, | |
648 | pkgCache::PkgIterator const &Pkg) { | |
649 | if (ShowError == true) | |
cd7bbc47 | 650 | _error->Insert(ErrorType, _("Can't select installed version from package %s as it is not installed"), Pkg.FullName(true).c_str()); |
c8db3fff | 651 | return pkgCache::VerIterator(Cache, 0); |
70e706ad DK |
652 | } |
653 | /*}}}*/ | |
15fc8636 DK |
654 | // showTaskSelection /*{{{*/ |
655 | void CacheSetHelper::showTaskSelection(pkgCache::PkgIterator const &pkg, | |
656 | std::string const &pattern) { | |
657 | } | |
658 | /*}}}*/ | |
659 | // showRegExSelection /*{{{*/ | |
660 | void CacheSetHelper::showRegExSelection(pkgCache::PkgIterator const &pkg, | |
661 | std::string const &pattern) { | |
662 | } | |
663 | /*}}}*/ | |
16724b66 MV |
664 | #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13) |
665 | // showFnmatchSelection /*{{{*/ | |
666 | void CacheSetHelper::showFnmatchSelection(pkgCache::PkgIterator const &pkg, | |
667 | std::string const &pattern) { | |
668 | } | |
669 | /*}}}*/ | |
670 | #endif | |
15fc8636 DK |
671 | // showSelectedVersion /*{{{*/ |
672 | void CacheSetHelper::showSelectedVersion(pkgCache::PkgIterator const &Pkg, | |
673 | pkgCache::VerIterator const Ver, | |
674 | std::string const &ver, | |
675 | bool const verIsRel) { | |
676 | } | |
677 | /*}}}*/ | |
ffee1c2b | 678 | } |