apt-pkg/deb/debindexfile.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: debindexfile.cc,v 1.5.2.3 2004/01/04 19:11:00 mdz Exp $
   4 /* ######################################################################
   5
   6    Debian Specific sources.list types and the three sorts of Debian
   7    index files.
   8
   9    ##################################################################### */
  10                                                                         /*}}}*/
  11 // Include Files                                                        /*{{{*/
  12 #include <apt-pkg/debindexfile.h>
  13 #include <apt-pkg/debsrcrecords.h>
  14 #include <apt-pkg/deblistparser.h>
  15 #include <apt-pkg/debrecords.h>
  16 #include <apt-pkg/sourcelist.h>
  17 #include <apt-pkg/configuration.h>
  18 #include <apt-pkg/progress.h>
  19 #include <apt-pkg/error.h>
  20 #include <apt-pkg/strutl.h>
  21 #include <apt-pkg/acquire-item.h>
  22 #include <apt-pkg/debmetaindex.h>
  23
  24 #include <sys/stat.h>
  25                                                                         /*}}}*/
  26
  27 // SourcesIndex::debSourcesIndex - Constructor                          /*{{{*/
  28 // ---------------------------------------------------------------------
  29 /* */
  30 debSourcesIndex::debSourcesIndex(string URI,string Dist,string Section,bool Trusted) :
  31      pkgIndexFile(Trusted), URI(URI), Dist(Dist), Section(Section)
  32 {
  33 }
  34                                                                         /*}}}*/
  35 // SourcesIndex::SourceInfo - Short 1 liner describing a source         /*{{{*/
  36 // ---------------------------------------------------------------------
  37 /* The result looks like:
  38      http://foo/debian/ stable/main src 1.1.1 (dsc) */
  39 string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record,
  40                                    pkgSrcRecords::File const &File) const
  41 {
  42    string Res;
  43    Res = ::URI::NoUserPassword(URI) + ' ';
  44    if (Dist[Dist.size() - 1] == '/')
  45    {
  46       if (Dist != "/")
  47          Res += Dist;
  48    }
  49    else
  50       Res += Dist + '/' + Section;
  51
  52    Res += " ";
  53    Res += Record.Package();
  54    Res += " ";
  55    Res += Record.Version();
  56    if (File.Type.empty() == false)
  57       Res += " (" + File.Type + ")";
  58    return Res;
  59 }
  60                                                                         /*}}}*/
  61 // SourcesIndex::CreateSrcParser - Get a parser for the source files    /*{{{*/
  62 // ---------------------------------------------------------------------
  63 /* */
  64 pkgSrcRecords::Parser *debSourcesIndex::CreateSrcParser() const
  65 {
  66    string SourcesURI = URItoFileName(IndexURI("Sources"));
  67    return new debSrcRecordParser(_config->FindDir("Dir::State::lists") +
  68                                  SourcesURI,this);
  69 }
  70                                                                         /*}}}*/
  71 // SourcesIndex::Describe - Give a descriptive path to the index        /*{{{*/
  72 // ---------------------------------------------------------------------
  73 /* */
  74 string debSourcesIndex::Describe(bool Short) const
  75 {
  76    char S[300];
  77    if (Short == true)
  78       snprintf(S,sizeof(S),"%s",Info("Sources").c_str());
  79    else
  80       snprintf(S,sizeof(S),"%s (%s)",Info("Sources").c_str(),
  81                IndexFile("Sources").c_str());
  82
  83    return S;
  84 }
  85                                                                         /*}}}*/
  86 // SourcesIndex::Info - One liner describing the index URI              /*{{{*/
  87 // ---------------------------------------------------------------------
  88 /* */
  89 string debSourcesIndex::Info(const char *Type) const
  90 {
  91    string Info = ::URI::NoUserPassword(URI) + ' ';
  92    if (Dist[Dist.size() - 1] == '/')
  93    {
  94       if (Dist != "/")
  95          Info += Dist;
  96    }
  97    else
  98       Info += Dist + '/' + Section;
  99    Info += " ";
 100    Info += Type;
 101    return Info;
 102 }
 103                                                                         /*}}}*/
 104 // SourcesIndex::Index* - Return the URI to the index files             /*{{{*/
 105 // ---------------------------------------------------------------------
 106 /* */
 107 inline string debSourcesIndex::IndexFile(const char *Type) const
 108 {
 109    return URItoFileName(IndexURI(Type));
 110 }
 111 string debSourcesIndex::IndexURI(const char *Type) const
 112 {
 113    string Res;
 114    if (Dist[Dist.size() - 1] == '/')
 115    {
 116       if (Dist != "/")
 117          Res = URI + Dist;
 118       else
 119          Res = URI;
 120    }
 121    else
 122       Res = URI + "dists/" + Dist + '/' + Section +
 123       "/source/";
 124
 125    Res += Type;
 126    return Res;
 127 }
 128                                                                         /*}}}*/
 129 // SourcesIndex::Exists - Check if the index is available               /*{{{*/
 130 // ---------------------------------------------------------------------
 131 /* */
 132 bool debSourcesIndex::Exists() const
 133 {
 134    return FileExists(IndexFile("Sources"));
 135 }
 136                                                                         /*}}}*/
 137 // SourcesIndex::Size - Return the size of the index                    /*{{{*/
 138 // ---------------------------------------------------------------------
 139 /* */
 140 unsigned long debSourcesIndex::Size() const
 141 {
 142    struct stat S;
 143    if (stat(IndexFile("Sources").c_str(),&S) != 0)
 144       return 0;
 145    return S.st_size;
 146 }
 147                                                                         /*}}}*/
 148
 149 // PackagesIndex::debPackagesIndex - Contructor                         /*{{{*/
 150 // ---------------------------------------------------------------------
 151 /* */
 152 debPackagesIndex::debPackagesIndex(string const &URI, string const &Dist, string const &Section,
 153                                         bool const &Trusted, string const &Arch) :
 154                   pkgIndexFile(Trusted), URI(URI), Dist(Dist), Section(Section), Architecture(Arch)
 155 {
 156         if (Architecture == "native")
 157                 Architecture = _config->Find("APT::Architecture");
 158 }
 159                                                                         /*}}}*/
 160 // PackagesIndex::ArchiveInfo - Short version of the archive url        /*{{{*/
 161 // ---------------------------------------------------------------------
 162 /* This is a shorter version that is designed to be < 60 chars or so */
 163 string debPackagesIndex::ArchiveInfo(pkgCache::VerIterator Ver) const
 164 {
 165    string Res = ::URI::NoUserPassword(URI) + ' ';
 166    if (Dist[Dist.size() - 1] == '/')
 167    {
 168       if (Dist != "/")
 169          Res += Dist;
 170    }
 171    else
 172       Res += Dist + '/' + Section;
 173
 174    Res += " ";
 175    Res += Ver.ParentPkg().Name();
 176    Res += " ";
 177    Res += Ver.Arch();
 178    Res += " ";
 179    Res += Ver.VerStr();
 180    return Res;
 181 }
 182                                                                         /*}}}*/
 183 // PackagesIndex::Describe - Give a descriptive path to the index       /*{{{*/
 184 // ---------------------------------------------------------------------
 185 /* This should help the user find the index in the sources.list and
 186    in the filesystem for problem solving */
 187 string debPackagesIndex::Describe(bool Short) const
 188 {
 189    char S[300];
 190    if (Short == true)
 191       snprintf(S,sizeof(S),"%s",Info("Packages").c_str());
 192    else
 193       snprintf(S,sizeof(S),"%s (%s)",Info("Packages").c_str(),
 194                IndexFile("Packages").c_str());
 195    return S;
 196 }
 197                                                                         /*}}}*/
 198 // PackagesIndex::Info - One liner describing the index URI             /*{{{*/
 199 // ---------------------------------------------------------------------
 200 /* */
 201 string debPackagesIndex::Info(const char *Type) const
 202 {
 203    string Info = ::URI::NoUserPassword(URI) + ' ';
 204    if (Dist[Dist.size() - 1] == '/')
 205    {
 206       if (Dist != "/")
 207          Info += Dist;
 208    }
 209    else
 210       Info += Dist + '/' + Section;
 211    Info += " ";
 212    Info += Architecture;
 213    Info += " ";
 214    Info += Type;
 215    return Info;
 216 }
 217                                                                         /*}}}*/
 218 // PackagesIndex::Index* - Return the URI to the index files            /*{{{*/
 219 // ---------------------------------------------------------------------
 220 /* */
 221 inline string debPackagesIndex::IndexFile(const char *Type) const
 222 {
 223    return _config->FindDir("Dir::State::lists") + URItoFileName(IndexURI(Type));
 224 }
 225 string debPackagesIndex::IndexURI(const char *Type) const
 226 {
 227    string Res;
 228    if (Dist[Dist.size() - 1] == '/')
 229    {
 230       if (Dist != "/")
 231          Res = URI + Dist;
 232       else
 233          Res = URI;
 234    }
 235    else
 236       Res = URI + "dists/" + Dist + '/' + Section +
 237       "/binary-" + Architecture + '/';
 238
 239    Res += Type;
 240    return Res;
 241 }
 242                                                                         /*}}}*/
 243 // PackagesIndex::Exists - Check if the index is available              /*{{{*/
 244 // ---------------------------------------------------------------------
 245 /* */
 246 bool debPackagesIndex::Exists() const
 247 {
 248    return FileExists(IndexFile("Packages"));
 249 }
 250                                                                         /*}}}*/
 251 // PackagesIndex::Size - Return the size of the index                   /*{{{*/
 252 // ---------------------------------------------------------------------
 253 /* This is really only used for progress reporting. */
 254 unsigned long debPackagesIndex::Size() const
 255 {
 256    struct stat S;
 257    if (stat(IndexFile("Packages").c_str(),&S) != 0)
 258       return 0;
 259    return S.st_size;
 260 }
 261                                                                         /*}}}*/
 262 // PackagesIndex::Merge - Load the index file into a cache              /*{{{*/
 263 // ---------------------------------------------------------------------
 264 /* */
 265 bool debPackagesIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
 266 {
 267    string PackageFile = IndexFile("Packages");
 268    FileFd Pkg(PackageFile,FileFd::ReadOnly);
 269    debListParser Parser(&Pkg, Architecture);
 270    if (_error->PendingError() == true)
 271       return _error->Error("Problem opening %s",PackageFile.c_str());
 272    if (Prog != NULL)
 273       Prog->SubProgress(0,Info("Packages"));
 274    ::URI Tmp(URI);
 275    if (Gen.SelectFile(PackageFile,Tmp.Host,*this) == false)
 276       return _error->Error("Problem with SelectFile %s",PackageFile.c_str());
 277
 278    // Store the IMS information
 279    pkgCache::PkgFileIterator File = Gen.GetCurFile();
 280    pkgCacheGenerator::Dynamic<pkgCache::PkgFileIterator> DynFile(File);
 281    struct stat St;
 282    if (fstat(Pkg.Fd(),&St) != 0)
 283       return _error->Errno("fstat","Failed to stat");
 284    File->Size = St.st_size;
 285    File->mtime = St.st_mtime;
 286
 287    if (Gen.MergeList(Parser) == false)
 288       return _error->Error("Problem with MergeList %s",PackageFile.c_str());
 289
 290    // Check the release file
 291    string ReleaseFile = debReleaseIndex(URI,Dist).MetaIndexFile("Release");
 292    if (FileExists(ReleaseFile) == true)
 293    {
 294       FileFd Rel(ReleaseFile,FileFd::ReadOnly);
 295       if (_error->PendingError() == true)
 296          return false;
 297       Parser.LoadReleaseInfo(File,Rel,Section);
 298    }
 299
 300    return true;
 301 }
 302                                                                         /*}}}*/
 303 // PackagesIndex::FindInCache - Find this index                         /*{{{*/
 304 // ---------------------------------------------------------------------
 305 /* */
 306 pkgCache::PkgFileIterator debPackagesIndex::FindInCache(pkgCache &Cache) const
 307 {
 308    string FileName = IndexFile("Packages");
 309    pkgCache::PkgFileIterator File = Cache.FileBegin();
 310    for (; File.end() == false; File++)
 311    {
 312        if (File.FileName() == NULL || FileName != File.FileName())
 313          continue;
 314
 315       struct stat St;
 316       if (stat(File.FileName(),&St) != 0)
 317       {
 318          if (_config->FindB("Debug::pkgCacheGen", false))
 319             std::clog << "PackagesIndex::FindInCache - stat failed on " << File.FileName() << std::endl;
 320          return pkgCache::PkgFileIterator(Cache);
 321       }
 322       if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
 323       {
 324          if (_config->FindB("Debug::pkgCacheGen", false))
 325             std::clog << "PackagesIndex::FindInCache - size (" << St.st_size << " <> " << File->Size
 326                         << ") or mtime (" << St.st_mtime << " <> " << File->mtime
 327                         << ") doesn't match for " << File.FileName() << std::endl;
 328          return pkgCache::PkgFileIterator(Cache);
 329       }
 330       return File;
 331    }
 332
 333    return File;
 334 }
 335                                                                         /*}}}*/
 336
 337 // TranslationsIndex::debTranslationsIndex - Contructor                 /*{{{*/
 338 // ---------------------------------------------------------------------
 339 /* */
 340 debTranslationsIndex::debTranslationsIndex(string URI,string Dist,string Section,
 341                                                 char const * const Translation) :
 342                         pkgIndexFile(true), URI(URI), Dist(Dist), Section(Section),
 343                                 Language(Translation)
 344 {}
 345                                                                         /*}}}*/
 346 // TranslationIndex::Trans* - Return the URI to the translation files   /*{{{*/
 347 // ---------------------------------------------------------------------
 348 /* */
 349 inline string debTranslationsIndex::IndexFile(const char *Type) const
 350 {
 351    return _config->FindDir("Dir::State::lists") + URItoFileName(IndexURI(Type));
 352 }
 353 string debTranslationsIndex::IndexURI(const char *Type) const
 354 {
 355    string Res;
 356    if (Dist[Dist.size() - 1] == '/')
 357    {
 358       if (Dist != "/")
 359          Res = URI + Dist;
 360       else
 361          Res = URI;
 362    }
 363    else
 364       Res = URI + "dists/" + Dist + '/' + Section +
 365       "/i18n/Translation-";
 366
 367    Res += Type;
 368    return Res;
 369 }
 370                                                                         /*}}}*/
 371 // TranslationsIndex::GetIndexes - Fetch the index files                /*{{{*/
 372 // ---------------------------------------------------------------------
 373 /* */
 374 bool debTranslationsIndex::GetIndexes(pkgAcquire *Owner) const
 375 {
 376    if (TranslationsAvailable()) {
 377      string const TranslationFile = string("Translation-").append(Language);
 378      new pkgAcqIndexTrans(Owner, IndexURI(Language),
 379                           Info(TranslationFile.c_str()),
 380                           TranslationFile);
 381    }
 382
 383    return true;
 384 }
 385                                                                         /*}}}*/
 386 // TranslationsIndex::Describe - Give a descriptive path to the index   /*{{{*/
 387 // ---------------------------------------------------------------------
 388 /* This should help the user find the index in the sources.list and
 389    in the filesystem for problem solving */
 390 string debTranslationsIndex::Describe(bool Short) const
 391 {
 392    char S[300];
 393    if (Short == true)
 394       snprintf(S,sizeof(S),"%s",Info(TranslationFile().c_str()).c_str());
 395    else
 396       snprintf(S,sizeof(S),"%s (%s)",Info(TranslationFile().c_str()).c_str(),
 397                IndexFile(Language).c_str());
 398    return S;
 399 }
 400                                                                         /*}}}*/
 401 // TranslationsIndex::Info - One liner describing the index URI         /*{{{*/
 402 // ---------------------------------------------------------------------
 403 /* */
 404 string debTranslationsIndex::Info(const char *Type) const
 405 {
 406    string Info = ::URI::NoUserPassword(URI) + ' ';
 407    if (Dist[Dist.size() - 1] == '/')
 408    {
 409       if (Dist != "/")
 410          Info += Dist;
 411    }
 412    else
 413       Info += Dist + '/' + Section;
 414    Info += " ";
 415    Info += Type;
 416    return Info;
 417 }
 418                                                                         /*}}}*/
 419 bool debTranslationsIndex::HasPackages() const                          /*{{{*/
 420 {
 421    if(!TranslationsAvailable())
 422       return false;
 423
 424    return FileExists(IndexFile(Language));
 425 }
 426                                                                         /*}}}*/
 427 // TranslationsIndex::Exists - Check if the index is available          /*{{{*/
 428 // ---------------------------------------------------------------------
 429 /* */
 430 bool debTranslationsIndex::Exists() const
 431 {
 432    return FileExists(IndexFile(Language));
 433 }
 434                                                                         /*}}}*/
 435 // TranslationsIndex::Size - Return the size of the index               /*{{{*/
 436 // ---------------------------------------------------------------------
 437 /* This is really only used for progress reporting. */
 438 unsigned long debTranslationsIndex::Size() const
 439 {
 440    struct stat S;
 441    if (stat(IndexFile(Language).c_str(),&S) != 0)
 442       return 0;
 443    return S.st_size;
 444 }
 445                                                                         /*}}}*/
 446 // TranslationsIndex::Merge - Load the index file into a cache          /*{{{*/
 447 // ---------------------------------------------------------------------
 448 /* */
 449 bool debTranslationsIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
 450 {
 451    // Check the translation file, if in use
 452    string TranslationFile = IndexFile(Language);
 453    if (TranslationsAvailable() && FileExists(TranslationFile))
 454    {
 455      FileFd Trans(TranslationFile,FileFd::ReadOnly);
 456      debListParser TransParser(&Trans);
 457      if (_error->PendingError() == true)
 458        return false;
 459
 460      if (Prog != NULL)
 461         Prog->SubProgress(0, Info(TranslationFile.c_str()));
 462      if (Gen.SelectFile(TranslationFile,string(),*this) == false)
 463        return _error->Error("Problem with SelectFile %s",TranslationFile.c_str());
 464
 465      // Store the IMS information
 466      pkgCache::PkgFileIterator TransFile = Gen.GetCurFile();
 467      struct stat TransSt;
 468      if (fstat(Trans.Fd(),&TransSt) != 0)
 469        return _error->Errno("fstat","Failed to stat");
 470      TransFile->Size = TransSt.st_size;
 471      TransFile->mtime = TransSt.st_mtime;
 472
 473      if (Gen.MergeList(TransParser) == false)
 474        return _error->Error("Problem with MergeList %s",TranslationFile.c_str());
 475    }
 476
 477    return true;
 478 }
 479                                                                         /*}}}*/
 480 // TranslationsIndex::FindInCache - Find this index                             /*{{{*/
 481 // ---------------------------------------------------------------------
 482 /* */
 483 pkgCache::PkgFileIterator debTranslationsIndex::FindInCache(pkgCache &Cache) const
 484 {
 485    string FileName = IndexFile(Language);
 486
 487    pkgCache::PkgFileIterator File = Cache.FileBegin();
 488    for (; File.end() == false; File++)
 489    {
 490       if (FileName != File.FileName())
 491          continue;
 492
 493       struct stat St;
 494       if (stat(File.FileName(),&St) != 0)
 495       {
 496          if (_config->FindB("Debug::pkgCacheGen", false))
 497             std::clog << "TranslationIndex::FindInCache - stat failed on " << File.FileName() << std::endl;
 498          return pkgCache::PkgFileIterator(Cache);
 499       }
 500       if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
 501       {
 502          if (_config->FindB("Debug::pkgCacheGen", false))
 503             std::clog << "TranslationIndex::FindInCache - size (" << St.st_size << " <> " << File->Size
 504                         << ") or mtime (" << St.st_mtime << " <> " << File->mtime
 505                         << ") doesn't match for " << File.FileName() << std::endl;
 506          return pkgCache::PkgFileIterator(Cache);
 507       }
 508       return File;
 509    }
 510    return File;
 511 }
 512                                                                         /*}}}*/
 513 // StatusIndex::debStatusIndex - Constructor                            /*{{{*/
 514 // ---------------------------------------------------------------------
 515 /* */
 516 debStatusIndex::debStatusIndex(string File) : pkgIndexFile(true), File(File)
 517 {
 518 }
 519                                                                         /*}}}*/
 520 // StatusIndex::Size - Return the size of the index                     /*{{{*/
 521 // ---------------------------------------------------------------------
 522 /* */
 523 unsigned long debStatusIndex::Size() const
 524 {
 525    struct stat S;
 526    if (stat(File.c_str(),&S) != 0)
 527       return 0;
 528    return S.st_size;
 529 }
 530                                                                         /*}}}*/
 531 // StatusIndex::Merge - Load the index file into a cache                /*{{{*/
 532 // ---------------------------------------------------------------------
 533 /* */
 534 bool debStatusIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
 535 {
 536    FileFd Pkg(File,FileFd::ReadOnly);
 537    if (_error->PendingError() == true)
 538       return false;
 539    debListParser Parser(&Pkg);
 540    if (_error->PendingError() == true)
 541       return false;
 542
 543    if (Prog != NULL)
 544       Prog->SubProgress(0,File);
 545    if (Gen.SelectFile(File,string(),*this,pkgCache::Flag::NotSource) == false)
 546       return _error->Error("Problem with SelectFile %s",File.c_str());
 547
 548    // Store the IMS information
 549    pkgCache::PkgFileIterator CFile = Gen.GetCurFile();
 550    struct stat St;
 551    if (fstat(Pkg.Fd(),&St) != 0)
 552       return _error->Errno("fstat","Failed to stat");
 553    CFile->Size = St.st_size;
 554    CFile->mtime = St.st_mtime;
 555    CFile->Archive = Gen.WriteUniqString("now");
 556
 557    if (Gen.MergeList(Parser) == false)
 558       return _error->Error("Problem with MergeList %s",File.c_str());
 559    return true;
 560 }
 561                                                                         /*}}}*/
 562 // StatusIndex::FindInCache - Find this index                           /*{{{*/
 563 // ---------------------------------------------------------------------
 564 /* */
 565 pkgCache::PkgFileIterator debStatusIndex::FindInCache(pkgCache &Cache) const
 566 {
 567    pkgCache::PkgFileIterator File = Cache.FileBegin();
 568    for (; File.end() == false; File++)
 569    {
 570       if (this->File != File.FileName())
 571          continue;
 572
 573       struct stat St;
 574       if (stat(File.FileName(),&St) != 0)
 575       {
 576          if (_config->FindB("Debug::pkgCacheGen", false))
 577             std::clog << "StatusIndex::FindInCache - stat failed on " << File.FileName() << std::endl;
 578          return pkgCache::PkgFileIterator(Cache);
 579       }
 580       if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
 581       {
 582          if (_config->FindB("Debug::pkgCacheGen", false))
 583             std::clog << "StatusIndex::FindInCache - size (" << St.st_size << " <> " << File->Size
 584                         << ") or mtime (" << St.st_mtime << " <> " << File->mtime
 585                         << ") doesn't match for " << File.FileName() << std::endl;
 586          return pkgCache::PkgFileIterator(Cache);
 587       }
 588       return File;
 589    }
 590    return File;
 591 }
 592                                                                         /*}}}*/
 593 // StatusIndex::Exists - Check if the index is available                /*{{{*/
 594 // ---------------------------------------------------------------------
 595 /* */
 596 bool debStatusIndex::Exists() const
 597 {
 598    // Abort if the file does not exist.
 599    return true;
 600 }
 601                                                                         /*}}}*/
 602
 603 // Index File types for Debian                                          /*{{{*/
 604 class debIFTypeSrc : public pkgIndexFile::Type
 605 {
 606    public:
 607
 608    debIFTypeSrc() {Label = "Debian Source Index";};
 609 };
 610 class debIFTypePkg : public pkgIndexFile::Type
 611 {
 612    public:
 613
 614    virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
 615    {
 616       return new debRecordParser(File.FileName(),*File.Cache());
 617    };
 618    debIFTypePkg() {Label = "Debian Package Index";};
 619 };
 620 class debIFTypeTrans : public debIFTypePkg
 621 {
 622    public:
 623    debIFTypeTrans() {Label = "Debian Translation Index";};
 624 };
 625 class debIFTypeStatus : public pkgIndexFile::Type
 626 {
 627    public:
 628
 629    virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const
 630    {
 631       return new debRecordParser(File.FileName(),*File.Cache());
 632    };
 633    debIFTypeStatus() {Label = "Debian dpkg status file";};
 634 };
 635 static debIFTypeSrc _apt_Src;
 636 static debIFTypePkg _apt_Pkg;
 637 static debIFTypeTrans _apt_Trans;
 638 static debIFTypeStatus _apt_Status;
 639
 640 const pkgIndexFile::Type *debSourcesIndex::GetType() const
 641 {
 642    return &_apt_Src;
 643 }
 644 const pkgIndexFile::Type *debPackagesIndex::GetType() const
 645 {
 646    return &_apt_Pkg;
 647 }
 648 const pkgIndexFile::Type *debTranslationsIndex::GetType() const
 649 {
 650    return &_apt_Trans;
 651 }
 652 const pkgIndexFile::Type *debStatusIndex::GetType() const
 653 {
 654    return &_apt_Status;
 655 }
 656
 657                                                                         /*}}}*/