apt-pkg/indexfile.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: indexfile.cc,v 1.2.2.1 2003/12/24 23:09:17 mdz Exp $
   4 /* ######################################################################
   5
   6    Index File - Abstraction for an index of archive/souce file.
   7
   8    ##################################################################### */
   9                                                                         /*}}}*/
  10 // Include Files                                                        /*{{{*/
  11 #include<config.h>
  12
  13 #include <apt-pkg/configuration.h>
  14 #include <apt-pkg/indexfile.h>
  15 #include <apt-pkg/error.h>
  16 #include <apt-pkg/fileutl.h>
  17 #include <apt-pkg/aptconfiguration.h>
  18 #include <apt-pkg/pkgcache.h>
  19 #include <apt-pkg/cacheiterators.h>
  20 #include <apt-pkg/srcrecords.h>
  21 #include <apt-pkg/macros.h>
  22
  23 #include <string>
  24 #include <vector>
  25 #include <clocale>
  26 #include <cstring>
  27                                                                         /*}}}*/
  28
  29 // Global list of Item supported
  30 static  pkgIndexFile::Type *ItmList[10];
  31 pkgIndexFile::Type **pkgIndexFile::Type::GlobalList = ItmList;
  32 unsigned long pkgIndexFile::Type::GlobalListLen = 0;
  33
  34 // Type::Type - Constructor                                             /*{{{*/
  35 // ---------------------------------------------------------------------
  36 /* */
  37 pkgIndexFile::Type::Type()
  38 {
  39    ItmList[GlobalListLen] = this;
  40    GlobalListLen++;
  41    Label = NULL;
  42 }
  43                                                                         /*}}}*/
  44 // Type::GetType - Locate the type by name                              /*{{{*/
  45 // ---------------------------------------------------------------------
  46 /* */
  47 pkgIndexFile::Type *pkgIndexFile::Type::GetType(const char *Type)
  48 {
  49    for (unsigned I = 0; I != GlobalListLen; I++)
  50       if (strcmp(GlobalList[I]->Label,Type) == 0)
  51          return GlobalList[I];
  52    return 0;
  53 }
  54                                                                         /*}}}*/
  55 pkgIndexFile::pkgIndexFile(bool Trusted) :                              /*{{{*/
  56    Trusted(Trusted)
  57 {
  58 }
  59                                                                         /*}}}*/
  60 // IndexFile::ArchiveInfo - Stub                                        /*{{{*/
  61 std::string pkgIndexFile::ArchiveInfo(pkgCache::VerIterator /*Ver*/) const
  62 {
  63    return std::string();
  64 }
  65                                                                         /*}}}*/
  66 // IndexFile::FindInCache - Stub                                        /*{{{*/
  67 pkgCache::PkgFileIterator pkgIndexFile::FindInCache(pkgCache &Cache) const
  68 {
  69    return pkgCache::PkgFileIterator(Cache);
  70 }
  71                                                                         /*}}}*/
  72 // IndexFile::SourceIndex - Stub                                        /*{{{*/
  73 std::string pkgIndexFile::SourceInfo(pkgSrcRecords::Parser const &/*Record*/,
  74                                 pkgSrcRecords::File const &/*File*/) const
  75 {
  76    return std::string();
  77 }
  78                                                                         /*}}}*/
  79 // IndexFile::TranslationsAvailable - Check if will use Translation     /*{{{*/
  80 // ---------------------------------------------------------------------
  81 /* */
  82 bool pkgIndexFile::TranslationsAvailable() {
  83         return (APT::Configuration::getLanguages().empty() != true);
  84 }
  85                                                                         /*}}}*/
  86 // IndexFile::CheckLanguageCode - Check the Language Code               /*{{{*/
  87 // ---------------------------------------------------------------------
  88 /* No intern need for this method anymore as the check for correctness
  89    is already done in getLanguages(). Note also that this check is
  90    rather bad (doesn't take three character like ast into account).
  91    TODO: Remove method with next API break */
  92 APT_DEPRECATED bool pkgIndexFile::CheckLanguageCode(const char *Lang)
  93 {
  94   if (strlen(Lang) == 2 || (strlen(Lang) == 5 && Lang[2] == '_'))
  95     return true;
  96
  97   if (strcmp(Lang,"C") != 0)
  98     _error->Warning("Wrong language code %s", Lang);
  99
 100   return false;
 101 }
 102                                                                         /*}}}*/
 103 // IndexFile::LanguageCode - Return the Language Code                   /*{{{*/
 104 // ---------------------------------------------------------------------
 105 /* As we have now possibly more than one LanguageCode this method is
 106    supersided by a) private classmembers or b) getLanguages().
 107    TODO: Remove method with next API break */
 108 APT_DEPRECATED std::string pkgIndexFile::LanguageCode() {
 109         if (TranslationsAvailable() == false)
 110                 return "";
 111         return APT::Configuration::getLanguages()[0];
 112 }
 113                                                                         /*}}}*/
 114
 115 // IndexTarget - Constructor                                            /*{{{*/
 116 IndexTarget::IndexTarget(std::string const &MetaKey, std::string const &ShortDesc,
 117       std::string const &LongDesc, std::string const &URI, bool const IsOptional,
 118       std::map<std::string, std::string> const &Options) :
 119    URI(URI), Description(LongDesc), ShortDesc(ShortDesc), MetaKey(MetaKey), IsOptional(IsOptional), Options(Options)
 120 {
 121 }
 122                                                                         /*}}}*/
 123 std::string IndexTarget::Option(std::string const &Key) const           /*{{{*/
 124 {
 125    std::map<std::string,std::string>::const_iterator const M = Options.find(Key);
 126    if (M == Options.end())
 127       return "";
 128    return M->second;
 129 }
 130                                                                         /*}}}*/
 131
 132 pkgIndexTargetFile::pkgIndexTargetFile(IndexTarget const &Target, bool const Trusted) :/*{{{*/
 133    pkgIndexFile(Trusted), Target(Target)
 134 {
 135 }
 136                                                                         /*}}}*/
 137 std::string pkgIndexTargetFile::ArchiveURI(std::string File) const/*{{{*/
 138 {
 139    return Target.Option("REPO_URI") + File;
 140 }
 141                                                                         /*}}}*/
 142 std::string pkgIndexTargetFile::Describe(bool Short) const              /*{{{*/
 143 {
 144    if (Short)
 145       return Target.Description;
 146    return Target.Description + " (" + IndexFileName() + ")";
 147 }
 148                                                                         /*}}}*/
 149 std::string pkgIndexTargetFile::IndexFileName() const                   /*{{{*/
 150 {
 151    std::string const s =_config->FindDir("Dir::State::lists") + URItoFileName(Target.URI);
 152    if (FileExists(s))
 153       return s;
 154
 155    std::vector<std::string> types = APT::Configuration::getCompressionTypes();
 156    for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 157    {
 158       std::string p = s + '.' + *t;
 159       if (FileExists(p))
 160          return p;
 161    }
 162    return s;
 163 }
 164                                                                         /*}}}*/
 165 unsigned long pkgIndexTargetFile::Size() const                          /*{{{*/
 166 {
 167    unsigned long size = 0;
 168
 169    /* we need to ignore errors here; if the lists are absent, just return 0 */
 170    _error->PushToStack();
 171
 172    FileFd f(IndexFileName(), FileFd::ReadOnly, FileFd::Extension);
 173    if (!f.Failed())
 174       size = f.Size();
 175
 176    if (_error->PendingError() == true)
 177        size = 0;
 178    _error->RevertToStack();
 179
 180    return size;
 181 }
 182                                                                         /*}}}*/
 183 bool pkgIndexTargetFile::Exists() const                                 /*{{{*/
 184 {
 185    return FileExists(IndexFileName());
 186 }
 187                                                                         /*}}}*/