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    d(NULL), 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       bool const KeepCompressed, std::map<std::string, std::string> const &Options) :
 119    URI(URI), Description(LongDesc), ShortDesc(ShortDesc), MetaKey(MetaKey),
 120    IsOptional(IsOptional), KeepCompressed(KeepCompressed), Options(Options)
 121 {
 122 }
 123                                                                         /*}}}*/
 124 std::string IndexTarget::Option(OptionKeys const EnumKey) const         /*{{{*/
 125 {
 126    std::string Key;
 127    switch (EnumKey)
 128    {
 129 #define APT_CASE(X) case X: Key = #X; break
 130       APT_CASE(SITE);
 131       APT_CASE(RELEASE);
 132       APT_CASE(COMPONENT);
 133       APT_CASE(LANGUAGE);
 134       APT_CASE(ARCHITECTURE);
 135       APT_CASE(BASE_URI);
 136       APT_CASE(REPO_URI);
 137       APT_CASE(TARGET_OF);
 138       APT_CASE(CREATED_BY);
 139 #undef APT_CASE
 140       case FILENAME: return _config->FindDir("Dir::State::lists") + URItoFileName(URI);
 141       case EXISTING_FILENAME:
 142          std::string const filename = Option(FILENAME);
 143          std::vector<std::string> const types = APT::Configuration::getCompressionTypes();
 144          for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 145          {
 146             if (t->empty())
 147                continue;
 148             std::string const file = (*t == "uncompressed") ? filename : (filename + "." + *t);
 149             if (FileExists(file))
 150                return file;
 151          }
 152          return "";
 153    }
 154    std::map<std::string,std::string>::const_iterator const M = Options.find(Key);
 155    if (M == Options.end())
 156       return "";
 157    return M->second;
 158 }
 159                                                                         /*}}}*/
 160 std::string IndexTarget::Format(std::string format) const               /*{{{*/
 161 {
 162    for (std::map<std::string, std::string>::const_iterator O = Options.begin(); O != Options.end(); ++O)
 163    {
 164       format = SubstVar(format, std::string("$(") + O->first + ")", O->second);
 165    }
 166    format = SubstVar(format, "$(METAKEY)", MetaKey);
 167    format = SubstVar(format, "$(SHORTDESC)", ShortDesc);
 168    format = SubstVar(format, "$(DESCRIPTION)", Description);
 169    format = SubstVar(format, "$(URI)", URI);
 170    format = SubstVar(format, "$(FILENAME)", Option(IndexTarget::FILENAME));
 171    return format;
 172 }
 173                                                                         /*}}}*/
 174
 175 pkgIndexTargetFile::pkgIndexTargetFile(IndexTarget const &Target, bool const Trusted) :/*{{{*/
 176    pkgIndexFile(Trusted), d(NULL), Target(Target)
 177 {
 178 }
 179                                                                         /*}}}*/
 180 std::string pkgIndexTargetFile::ArchiveURI(std::string File) const/*{{{*/
 181 {
 182    return Target.Option(IndexTarget::REPO_URI) + File;
 183 }
 184                                                                         /*}}}*/
 185 std::string pkgIndexTargetFile::Describe(bool Short) const              /*{{{*/
 186 {
 187    if (Short)
 188       return Target.Description;
 189    return Target.Description + " (" + IndexFileName() + ")";
 190 }
 191                                                                         /*}}}*/
 192 std::string pkgIndexTargetFile::IndexFileName() const                   /*{{{*/
 193 {
 194    std::string const s = Target.Option(IndexTarget::FILENAME);
 195    if (FileExists(s))
 196       return s;
 197
 198    std::vector<std::string> types = APT::Configuration::getCompressionTypes();
 199    for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 200    {
 201       std::string p = s + '.' + *t;
 202       if (FileExists(p))
 203          return p;
 204    }
 205    return s;
 206 }
 207                                                                         /*}}}*/
 208 unsigned long pkgIndexTargetFile::Size() const                          /*{{{*/
 209 {
 210    unsigned long size = 0;
 211
 212    /* we need to ignore errors here; if the lists are absent, just return 0 */
 213    _error->PushToStack();
 214
 215    FileFd f(IndexFileName(), FileFd::ReadOnly, FileFd::Extension);
 216    if (!f.Failed())
 217       size = f.Size();
 218
 219    if (_error->PendingError() == true)
 220        size = 0;
 221    _error->RevertToStack();
 222
 223    return size;
 224 }
 225                                                                         /*}}}*/
 226 bool pkgIndexTargetFile::Exists() const                                 /*{{{*/
 227 {
 228    return FileExists(IndexFileName());
 229 }
 230                                                                         /*}}}*/
 231
 232 APT_CONST pkgIndexFile::~pkgIndexFile() {}
 233 APT_CONST pkgIndexTargetFile::~pkgIndexTargetFile() {}