git.saurik.com Git - apt-legacy.git/blob

1 // -*- mode: cpp; mode: fold -*-

2 // Description /*{{{*/

3 // $Id: pkgcache.cc,v 1.37 2003/02/10 01:40:58 doogie Exp $

4 /* ######################################################################

6 Package Cache - Accessor code for the cache

8 Please see doc/apt-pkg/cache.sgml for a more detailed description of

9 this format. Also be sure to keep that file up-to-date!!

11 This is the general utility functions for cache managment. They provide

12 a complete set of accessor functions for the cache. The cacheiterators

13 header contains the STL-like iterators that can be used to easially

14 navigate the cache as well as seemlessly dereference the mmap'd

15 indexes. Use these always.

17 The main class provides for ways to get package indexes and some

18 general lookup functions to start the iterators.

20 ##################################################################### */

21 /*}}}*/

22 // Include Files /*{{{*/

23 #include <apt-pkg/pkgcache.h>

24 #include <apt-pkg/policy.h>

25 #include <apt-pkg/indexfile.h>

26 #include <apt-pkg/version.h>

27 #include <apt-pkg/error.h>

28 #include <apt-pkg/strutl.h>

29 #include <apt-pkg/configuration.h>

31 #include <apti18n.h>

33 #include <string>

34 #include <sys/stat.h>

35 #include <unistd.h>

37 #include <ctype.h>

38 /*}}}*/

40 using std::string;

43 // Cache::Header::Header - Constructor /*{{{*/

44 // ---------------------------------------------------------------------

45 /* Simply initialize the header */

 pkgCache::Header::Header()

47 {

48 Signature = 0x98FE76DC;

50 /* Whenever the structures change the major version should be bumped,

51 whenever the generator changes the minor version should be bumped. */

52 MajorVersion = 7;

53 MinorVersion = 0;

54 Dirty = false;

    HeaderSz = sizeof(pkgCache::Header);

    PackageSz = sizeof(pkgCache::Package);

    PackageFileSz = sizeof(pkgCache::PackageFile);

    VersionSz = sizeof(pkgCache::Version);

    DescriptionSz = sizeof(pkgCache::Description);

    DependencySz = sizeof(pkgCache::Dependency);

    ProvidesSz = sizeof(pkgCache::Provides);

    VerFileSz = sizeof(pkgCache::VerFile);

    DescFileSz = sizeof(pkgCache::DescFile);

66 PackageCount = 0;

67 VersionCount = 0;

68 DescriptionCount = 0;

69 DependsCount = 0;

70 PackageFileCount = 0;

71 VerFileCount = 0;

72 DescFileCount = 0;

73 ProvidesCount = 0;

74 MaxVerFileSize = 0;

75 MaxDescFileSize = 0;

77 FileList = 0;

78 StringList = 0;

79 VerSysName = 0;

80 Architecture = 0;

    memset(HashTable,0,sizeof(HashTable));

    memset(Pools,0,sizeof(Pools));

83 }

84 /*}}}*/

85 // Cache::Header::CheckSizes - Check if the two headers have same *sz /*{{{*/

86 // ---------------------------------------------------------------------

87 /* */

 bool pkgCache::Header::CheckSizes(Header &Against) const

89 {

    if (HeaderSz == Against.HeaderSz &&

91 PackageSz == Against.PackageSz &&

92 PackageFileSz == Against.PackageFileSz &&

93 VersionSz == Against.VersionSz &&

94 DescriptionSz == Against.DescriptionSz &&

95 DependencySz == Against.DependencySz &&

96 VerFileSz == Against.VerFileSz &&

97 DescFileSz == Against.DescFileSz &&

98 ProvidesSz == Against.ProvidesSz)

99 return true;

100 return false;

101 }

102 /*}}}*/

103

104 // Cache::pkgCache - Constructor /*{{{*/

105 // ---------------------------------------------------------------------

106 /* */

 pkgCache::pkgCache(MMap *Map, bool DoMap) : Map(*Map)

108 {

    if (DoMap == true)

110 ReMap();

111 }

112 /*}}}*/

113 // Cache::ReMap - Reopen the cache file /*{{{*/

114 // ---------------------------------------------------------------------

115 /* If the file is already closed then this will open it open it. */

 bool pkgCache::ReMap()

117 {

118 // Apply the typecasts.

    HeaderP = (Header *)Map.Data();

    PkgP = (Package *)Map.Data();

    VerFileP = (VerFile *)Map.Data();

    DescFileP = (DescFile *)Map.Data();

    PkgFileP = (PackageFile *)Map.Data();

    VerP = (Version *)Map.Data();

    DescP = (Description *)Map.Data();

    ProvideP = (Provides *)Map.Data();

    TagP = (Tag *)Map.Data();

    DepP = (Dependency *)Map.Data();

    StringItemP = (StringItem *)Map.Data();

    StrP = (char *)Map.Data();

131

    if (Map.Size() == 0 || HeaderP == 0)

       return _error->Error(_("Empty package cache"));

134

135 // Check the header

136 Header DefHeader;

    if (HeaderP->Signature != DefHeader.Signature ||

138 HeaderP->Dirty == true)

       return _error->Error(_("The package cache file is corrupted"));

140

    if (HeaderP->MajorVersion != DefHeader.MajorVersion ||

142 HeaderP->MinorVersion != DefHeader.MinorVersion ||

        HeaderP->CheckSizes(DefHeader) == false)

       return _error->Error(_("The package cache file is an incompatible version"));

145

146 // Locate our VS..

    if (HeaderP->VerSysName == 0 ||

        (VS = pkgVersioningSystem::GetVS(StrP + HeaderP->VerSysName)) == 0)

       return _error->Error(_("This APT does not support the versioning system '%s'"),StrP + HeaderP->VerSysName);

150

151 // Chcek the arhcitecture

    if (HeaderP->Architecture == 0 ||

        _config->Find("APT::Architecture") != StrP + HeaderP->Architecture)

       return _error->Error(_("The package cache was built for a different architecture"));

155 return true;

156 }

157 /*}}}*/

158 // Cache::Hash - Hash a string /*{{{*/

159 // ---------------------------------------------------------------------

160 /* This is used to generate the hash entries for the HashTable. With my

161 package list from bo this function gets 94% table usage on a 512 item

162 table (480 used items) */

 unsigned long pkgCache::sHash(const string &Str) const

164 {

165 unsigned long Hash = 0;

    for (string::const_iterator I = Str.begin(); I != Str.end(); I++)

       Hash = 5*Hash + tolower_ascii(*I);

    return Hash % _count(HeaderP->HashTable);

169 }

170

 unsigned long pkgCache::sHash(const char *Str) const

172 {

173 unsigned long Hash = 0;

    for (const char *I = Str; *I != 0; I++)

       Hash = 5*Hash + tolower_ascii(*I);

    return Hash % _count(HeaderP->HashTable);

177 }

178

 unsigned long pkgCache::sHash(const srkString &Str) const

180 {

181 unsigned long Hash = 0;

    for (const char *I = Str.Start, *E = I + Str.Size; I != E; I++)

       Hash = 5*Hash + tolower_ascii(*I);

    return Hash % _count(HeaderP->HashTable);

185 }

186

187 /*}}}*/

188 // Cache::FindPkg - Locate a package by name /*{{{*/

189 // ---------------------------------------------------------------------

190 /* Returns 0 on error, pointer to the package otherwise */

 pkgCache::PkgIterator pkgCache::FindPkg(const string &Name)

192 {

    return FindPkg(srkString(Name));

194 }

195

 pkgCache::PkgIterator pkgCache::FindPkg(const srkString &Name)

197 {

198 // Look at the hash bucket

    Package *Pkg = PkgP + HeaderP->HashTable[Hash(Name)];

    for (; Pkg != PkgP; Pkg = PkgP + Pkg->NextPackage)

201 {

       if (Pkg->Name != 0 &&

           stringcasecmp(Name,StrP + Pkg->Name) == 0)

          return PkgIterator(*this,Pkg);

205 }

    return PkgIterator(*this,0);

207 }

208 /*}}}*/

209 // Cache::CompTypeDeb - Return a string describing the compare type /*{{{*/

210 // ---------------------------------------------------------------------

211 /* This returns a string representation of the dependency compare

212 type in the weird debian style.. */

 const char *pkgCache::CompTypeDeb(unsigned char Comp)

214 {

    const char *Ops[] = {"","<=",">=","<<",">>","=","!="};

    if ((unsigned)(Comp & 0xF) < 7)

       return Ops[Comp & 0xF];

218 return "";

219 }

220 /*}}}*/

221 // Cache::CompType - Return a string describing the compare type /*{{{*/

222 // ---------------------------------------------------------------------

223 /* This returns a string representation of the dependency compare

224 type */

 const char *pkgCache::CompType(unsigned char Comp)

226 {

    const char *Ops[] = {"","<=",">=","<",">","=","!="};

    if ((unsigned)(Comp & 0xF) < 7)

       return Ops[Comp & 0xF];

230 return "";

231 }

232 /*}}}*/

233 // Cache::DepType - Return a string describing the dep type /*{{{*/

234 // ---------------------------------------------------------------------

235 /* */

 const char *pkgCache::DepType(unsigned char Type)

237 {

    const char *Types[] = {"",_("Depends"),_("PreDepends"),_("Suggests"),

                           _("Recommends"),_("Conflicts"),_("Replaces"),

                           _("Obsoletes"),_("Breaks"), _("Enhances")};

    if (Type < sizeof(Types)/sizeof(*Types))

242 return Types[Type];

243 return "";

244 }

245 /*}}}*/

246 // Cache::Priority - Convert a priority value to a string /*{{{*/

247 // ---------------------------------------------------------------------

248 /* */

 const char *pkgCache::Priority(unsigned char Prio)

250 {

    const char *Mapping[] = {0,_("important"),_("required"),_("standard"),

                             _("optional"),_("extra")};

    if (Prio < _count(Mapping))

254 return Mapping[Prio];

255 return 0;

256 }

257 /*}}}*/

258 // Bases for iterator classes /*{{{*/

 void pkgCache::VerIterator::_dummy() {}

 void pkgCache::DepIterator::_dummy() {}

 void pkgCache::PrvIterator::_dummy() {}

 void pkgCache::DescIterator::_dummy() {}

263 /*}}}*/

264 // PkgIterator::operator ++ - Postfix incr /*{{{*/

265 // ---------------------------------------------------------------------

266 /* This will advance to the next logical package in the hash table. */

 void pkgCache::PkgIterator::operator ++(int) 

268 {

269 // Follow the current links

    if (Pkg != Owner->PkgP)

       Pkg = Owner->PkgP + Pkg->NextPackage;

272

273 // Follow the hash table

    while (Pkg == Owner->PkgP && (HashIndex+1) < (signed)_count(Owner->HeaderP->HashTable))

275 {

276 HashIndex++;

       Pkg = Owner->PkgP + Owner->HeaderP->HashTable[HashIndex];

278 }

279 };

280 /*}}}*/

281 // PkgIterator::State - Check the State of the package /*{{{*/

282 // ---------------------------------------------------------------------

283 /* By this we mean if it is either cleanly installed or cleanly removed. */

 pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const

285 {

    if (Pkg->InstState == pkgCache::State::ReInstReq ||

        Pkg->InstState == pkgCache::State::HoldReInstReq)

288 return NeedsUnpack;

289

    if (Pkg->CurrentState == pkgCache::State::UnPacked ||

        Pkg->CurrentState == pkgCache::State::HalfConfigured)

292 // we leave triggers alone complettely. dpkg deals with

293 // them in a hard-to-predict manner and if they get

294 // resolved by dpkg before apt run dpkg --configure on

295 // the TriggersPending package dpkg returns a error

296 //Pkg->CurrentState == pkgCache::State::TriggersAwaited

297 //Pkg->CurrentState == pkgCache::State::TriggersPending)

298 return NeedsConfigure;

299

    if (Pkg->CurrentState == pkgCache::State::HalfInstalled ||

        Pkg->InstState != pkgCache::State::Ok)

302 return NeedsUnpack;

303

304 return NeedsNothing;

305 }

306 /*}}}*/

307 // PkgIterator::CandVersion - Returns the candidate version string /*{{{*/

308 // ---------------------------------------------------------------------

309 /* Return string representing of the candidate version. */

310 const char *

 pkgCache::PkgIterator::CandVersion() const 

312 {

313 //TargetVer is empty, so don't use it.

   VerIterator version = pkgPolicy(Owner).GetCandidateVer(*this);

   if (version.IsGood())

316 return version.VerStr();

317 return 0;

318 };

319 /*}}}*/

320 // PkgIterator::CurVersion - Returns the current version string /*{{{*/

321 // ---------------------------------------------------------------------

322 /* Return string representing of the current version. */

323 const char *

 pkgCache::PkgIterator::CurVersion() const 

325 {

326 VerIterator version = CurrentVer();

   if (version.IsGood())

     return CurrentVer().VerStr();

329 return 0;

330 };

331 /*}}}*/

332 // ostream operator to handle string representation of a package /*{{{*/

333 // ---------------------------------------------------------------------

334 /* Output name < cur.rent.version -> candid.ate.version | new.est.version > (section)

335 Note that the characters <|>() are all literal above. Versions will be ommited

336 if they provide no new information (e.g. there is no newer version than candidate)

337 If no version and/or section can be found "none" is used. */

338 std::ostream&

 operator<<(ostream& out, pkgCache::PkgIterator Pkg) 

340 {

    if (Pkg.end() == true)

342 return out << "invalid package";

343

    string current = string(Pkg.CurVersion() == 0 ? "none" : Pkg.CurVersion());

    string candidate = string(Pkg.CandVersion() == 0 ? "none" : Pkg.CandVersion());

    string newest = string(Pkg.VersionList().end() ? "none" : Pkg.VersionList().VerStr());

347

    out << Pkg.Name() << " < " << current;

349 if (current != candidate)

350 out << " -> " << candidate;

    if ( newest != "none" && candidate != newest)

352 out << " | " << newest;

    out << " > ( " << string(Pkg.Section()==0?"none":Pkg.Section()) << " )";

354 return out;

355 }

356 /*}}}*/

357 // DepIterator::IsCritical - Returns true if the dep is important /*{{{*/

358 // ---------------------------------------------------------------------

359 /* Currently critical deps are defined as depends, predepends and

360 conflicts (including dpkg's Breaks fields). */

 bool pkgCache::DepIterator::IsCritical()

362 {

    if (Dep->Type == pkgCache::Dep::Conflicts ||

        Dep->Type == pkgCache::Dep::DpkgBreaks ||

        Dep->Type == pkgCache::Dep::Obsoletes ||

        Dep->Type == pkgCache::Dep::Depends ||

        Dep->Type == pkgCache::Dep::PreDepends)

368 return true;

369 return false;

370 }

371 /*}}}*/

372 // DepIterator::SmartTargetPkg - Resolve dep target pointers w/provides /*{{{*/

373 // ---------------------------------------------------------------------

374 /* This intellegently looks at dep target packages and tries to figure

375 out which package should be used. This is needed to nicely handle

376 provide mapping. If the target package has no other providing packages

377 then it returned. Otherwise the providing list is looked at to

378 see if there is one one unique providing package if so it is returned.

379 Otherwise true is returned and the target package is set. The return

380 result indicates whether the node should be expandable

381

382 In Conjunction with the DepCache the value of Result may not be

383 super-good since the policy may have made it uninstallable. Using

384 AllTargets is better in this case. */

 bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result)

386 {

387 Result = TargetPkg();

388

389 // No provides at all

    if (Result->ProvidesList == 0)

391 return false;

392

393 // There is the Base package and the providing ones which is at least 2

    if (Result->VersionList != 0)

395 return true;

396

397 /* We have to skip over indirect provisions of the package that

398 owns the dependency. For instance, if libc5-dev depends on the

399 virtual package libc-dev which is provided by libc5-dev and libc6-dev

400 we must ignore libc5-dev when considering the provides list. */

401 PrvIterator PStart = Result.ProvidesList();

    for (; PStart.end() != true && PStart.OwnerPkg() == ParentPkg(); PStart++);

403

404 // Nothing but indirect self provides

    if (PStart.end() == true)

406 return false;

407

408 // Check for single packages in the provides list

409 PrvIterator P = PStart;

    for (; P.end() != true; P++)

411 {

412 // Skip over self provides

       if (P.OwnerPkg() == ParentPkg())

414 continue;

       if (PStart.OwnerPkg() != P.OwnerPkg())

416 break;

417 }

418

419 Result = PStart.OwnerPkg();

420

421 // Check for non dups

    if (P.end() != true)

423 return true;

424

425 return false;

426 }

427 /*}}}*/

428 // DepIterator::AllTargets - Returns the set of all possible targets /*{{{*/

429 // ---------------------------------------------------------------------

430 /* This is a more useful version of TargetPkg() that follows versioned

431 provides. It includes every possible package-version that could satisfy

432 the dependency. The last item in the list has a 0. The resulting pointer

433 must be delete [] 'd */

 pkgCache::Version **pkgCache::DepIterator::AllTargets()

435 {

436 Version **Res = 0;

437 unsigned long Size =0;

438 while (1)

439 {

440 Version **End = Res;

441 PkgIterator DPkg = TargetPkg();

442

443 // Walk along the actual package providing versions

       for (VerIterator I = DPkg.VersionList(); I.end() == false; I++)

445 {

          if (Owner->VS->CheckDep(I.VerStr(),Dep->CompareOp,TargetVer()) == false)

447 continue;

448

          if ((Dep->Type == pkgCache::Dep::Conflicts ||

               Dep->Type == pkgCache::Dep::DpkgBreaks ||

               Dep->Type == pkgCache::Dep::Obsoletes) &&

              ParentPkg() == I.ParentPkg())

453 continue;

454

455 Size++;

          if (Res != 0)

457 *End++ = I;

458 }

459

460 // Follow all provides

       for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; I++)

462 {

          if (Owner->VS->CheckDep(I.ProvideVersion(),Dep->CompareOp,TargetVer()) == false)

464 continue;

465

          if ((Dep->Type == pkgCache::Dep::Conflicts ||

               Dep->Type == pkgCache::Dep::DpkgBreaks ||

               Dep->Type == pkgCache::Dep::Obsoletes) &&

              ParentPkg() == I.OwnerPkg())

470 continue;

471

472 Size++;

          if (Res != 0)

             *End++ = I.OwnerVer();

475 }

476

477 // Do it again and write it into the array

       if (Res == 0)

479 {

          Res = new Version *[Size+1];

481 Size = 0;

482 }

483 else

484 {

485 *End = 0;

486 break;

487 }

488 }

489

490 return Res;

491 }

492 /*}}}*/

493 // DepIterator::GlobOr - Compute an OR group /*{{{*/

494 // ---------------------------------------------------------------------

495 /* This Takes an iterator, iterates past the current dependency grouping

496 and returns Start and End so that so End is the final element

497 in the group, if End == Start then D is End++ and End is the

498 dependency D was pointing to. Use in loops to iterate sensibly. */

 void pkgCache::DepIterator::GlobOr(DepIterator &Start,DepIterator &End)

500 {

501 // Compute a single dependency element (glob or)

502 Start = *this;

503 End = *this;

    for (bool LastOR = true; end() == false && LastOR == true;)

505 {

       LastOR = (Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;

507 (*this)++;

       if (LastOR == true)

509 End = (*this);

510 }

511 }

512 /*}}}*/

513 // VerIterator::CompareVer - Fast version compare for same pkgs /*{{{*/

514 // ---------------------------------------------------------------------

515 /* This just looks over the version list to see if B is listed before A. In

516 most cases this will return in under 4 checks, ver lists are short. */

 int pkgCache::VerIterator::CompareVer(const VerIterator &B) const

518 {

519 // Check if they are equal

    if (*this == B)

521 return 0;

    if (end() == true)

523 return -1;

    if (B.end() == true)

525 return 1;

526

527 /* Start at A and look for B. If B is found then A > B otherwise

528 B was before A so A < B */

529 VerIterator I = *this;

    for (;I.end() == false; I++)

531 if (I == B)

532 return 1;

533 return -1;

534 }

535 /*}}}*/

536 // VerIterator::Downloadable - Checks if the version is downloadable /*{{{*/

537 // ---------------------------------------------------------------------

538 /* */

 bool pkgCache::VerIterator::Downloadable() const

540 {

541 VerFileIterator Files = FileList();

    for (; Files.end() == false; Files++)

       if ((Files.File()->Flags & pkgCache::Flag::NotSource) != pkgCache::Flag::NotSource)

544 return true;

545 return false;

546 }

547 /*}}}*/

548 // VerIterator::Automatic - Check if this version is 'automatic' /*{{{*/

549 // ---------------------------------------------------------------------

550 /* This checks to see if any of the versions files are not NotAutomatic.

551 True if this version is selectable for automatic installation. */

 bool pkgCache::VerIterator::Automatic() const

553 {

554 VerFileIterator Files = FileList();

    for (; Files.end() == false; Files++)

       if ((Files.File()->Flags & pkgCache::Flag::NotAutomatic) != pkgCache::Flag::NotAutomatic)

557 return true;

558 return false;

559 }

560 /*}}}*/

561 // VerIterator::NewestFile - Return the newest file version relation /*{{{*/

562 // ---------------------------------------------------------------------

563 /* This looks at the version numbers associated with all of the sources

564 this version is in and returns the highest.*/

 pkgCache::VerFileIterator pkgCache::VerIterator::NewestFile() const

566 {

567 VerFileIterator Files = FileList();

568 VerFileIterator Highest = Files;

    for (; Files.end() == false; Files++)

570 {

       if (Owner->VS->CmpReleaseVer(Files.File().Version(),Highest.File().Version()) > 0)

572 Highest = Files;

573 }

574

575 return Highest;

576 }

577 /*}}}*/

578 // VerIterator::RelStr - Release description string /*{{{*/

579 // ---------------------------------------------------------------------

580 /* This describes the version from a release-centric manner. The output is a

581 list of Label:Version/Archive */

 string pkgCache::VerIterator::RelStr()

583 {

584 bool First = true;

585 string Res;

    for (pkgCache::VerFileIterator I = this->FileList(); I.end() == false; I++)

587 {

588 // Do not print 'not source' entries'

       pkgCache::PkgFileIterator File = I.File();

       if ((File->Flags & pkgCache::Flag::NotSource) == pkgCache::Flag::NotSource)

591 continue;

592

593 // See if we have already printed this out..

594 bool Seen = false;

       for (pkgCache::VerFileIterator J = this->FileList(); I != J; J++)

596 {

          pkgCache::PkgFileIterator File2 = J.File();

          if (File2->Label == 0 || File->Label == 0)

599 continue;

600

          if (strcmp(File.Label(),File2.Label()) != 0)

602 continue;

603

          if (File2->Version == File->Version)

605 {

606 Seen = true;

607 break;

608 }

          if (File2->Version == 0 || File->Version == 0)

610 break;

          if (strcmp(File.Version(),File2.Version()) == 0)

612 Seen = true;

613 }

614

       if (Seen == true)

616 continue;

617

       if (First == false)

619 Res += ", ";

620 else

621 First = false;

622

       if (File->Label != 0)

          Res = Res + File.Label() + ':';

625

       if (File->Archive != 0)

627 {

          if (File->Version == 0)

629 Res += File.Archive();

630 else

             Res = Res + File.Version() + '/' +  File.Archive();

632 }

633 else

634 {

635 // No release file, print the host name that this came from

          if (File->Site == 0 || File.Site()[0] == 0)

637 Res += "localhost";

638 else

639 Res += File.Site();

640 }

641 }

642 return Res;

643 }

644 /*}}}*/

645 // PkgFileIterator::IsOk - Checks if the cache is in sync with the file /*{{{*/

646 // ---------------------------------------------------------------------

647 /* This stats the file and compares its stats with the ones that were

648 stored during generation. Date checks should probably also be

649 included here. */

 bool pkgCache::PkgFileIterator::IsOk()

651 {

652 struct stat Buf;

    if (stat(FileName(),&Buf) != 0)

654 return false;

655

    if (Buf.st_size != (signed)File->Size || Buf.st_mtime != File->mtime)

657 return false;

658

659 return true;

660 }

661 /*}}}*/

662 // PkgFileIterator::RelStr - Return the release string /*{{{*/

663 // ---------------------------------------------------------------------

664 /* */

 string pkgCache::PkgFileIterator::RelStr()

666 {

667 string Res;

    if (Version() != 0)

       Res = Res + (Res.empty() == true?"v=":",v=") + Version();

    if (Origin() != 0)

       Res = Res + (Res.empty() == true?"o=":",o=")  + Origin();

    if (Archive() != 0)

       Res = Res + (Res.empty() == true?"a=":",a=")  + Archive();

    if (Label() != 0)

       Res = Res + (Res.empty() == true?"l=":",l=")  + Label();

    if (Component() != 0)

       Res = Res + (Res.empty() == true?"c=":",c=")  + Component();

678 return Res;

679 }

680 /*}}}*/

681 // VerIterator::TranslatedDescription - Return the a DescIter for locale/*{{{*/

682 // ---------------------------------------------------------------------

683 /* return a DescIter for the current locale or the default if none is

684 * found

685 */

 pkgCache::DescIterator pkgCache::VerIterator::TranslatedDescription() const

687 {

    pkgCache::DescIterator DescDefault = DescriptionList();

689 pkgCache::DescIterator Desc = DescDefault;

    for (; Desc.end() == false; Desc++)

       if (pkgIndexFile::LanguageCode() == Desc.LanguageCode())

692 break;

    if (Desc.end() == true) 

694 Desc = DescDefault;

695 return Desc;

696 };

697

698 /*}}}*/