Browse Source

elimate duplicated code in pkgIndexFile subclasses

Trade deduplication of code for a bunch of new virtuals, so it is
actually visible how the different indexes behave cleaning up the
interface at large in the process.

Git-Dch: Ignore
debian/1.8.y
David Kalnischkies 7 years ago
parent
commit
c9443c0120
  1. 15
      apt-pkg/contrib/fileutl.cc
  2. 5
      apt-pkg/contrib/fileutl.h
  3. 416
      apt-pkg/deb/debindexfile.cc
  4. 84
      apt-pkg/deb/debindexfile.h
  5. 7
      apt-pkg/deb/deblistparser.cc
  6. 2
      apt-pkg/deb/deblistparser.h
  7. 75
      apt-pkg/edsp/edspindexfile.cc
  8. 16
      apt-pkg/edsp/edspindexfile.h
  9. 8
      apt-pkg/edsp/edspsystem.cc
  10. 175
      apt-pkg/indexfile.cc
  11. 79
      apt-pkg/indexfile.h
  12. 18
      apt-pkg/pkgcachegen.cc
  13. 17
      apt-pkg/pkgcachegen.h
  14. 1
      cmdline/apt-internal-solver.cc
  15. 2
      test/integration/framework
  16. 12
      test/integration/test-apt-get-install-deb

15
apt-pkg/contrib/fileutl.cc

@ -2115,28 +2115,27 @@ std::string GetTempDir() /*{{{*/
return string(tmpdir);
}
/*}}}*/
FileFd* GetTempFile(std::string const &Prefix, bool ImmediateUnlink) /*{{{*/
FileFd* GetTempFile(std::string const &Prefix, bool ImmediateUnlink, FileFd * const TmpFd) /*{{{*/
{
char fn[512];
FileFd *Fd = new FileFd();
FileFd * const Fd = TmpFd == NULL ? new FileFd() : TmpFd;
std::string tempdir = GetTempDir();
snprintf(fn, sizeof(fn), "%s/%s.XXXXXX",
std::string const tempdir = GetTempDir();
snprintf(fn, sizeof(fn), "%s/%s.XXXXXX",
tempdir.c_str(), Prefix.c_str());
int fd = mkstemp(fn);
int const fd = mkstemp(fn);
if(ImmediateUnlink)
unlink(fn);
if (fd < 0)
if (fd < 0)
{
_error->Errno("GetTempFile",_("Unable to mkstemp %s"), fn);
return NULL;
}
if (!Fd->OpenDescriptor(fd, FileFd::WriteOnly, FileFd::None, true))
if (!Fd->OpenDescriptor(fd, FileFd::ReadWrite, FileFd::None, true))
{
_error->Errno("GetTempFile",_("Unable to write to %s"),fn);
return NULL;
}
return Fd;
}
/*}}}*/

5
apt-pkg/contrib/fileutl.h

@ -159,8 +159,9 @@ time_t GetModificationTime(std::string const &Path);
bool Rename(std::string From, std::string To);
std::string GetTempDir();
FileFd* GetTempFile(std::string const &Prefix = "",
bool ImmediateUnlink = true);
FileFd* GetTempFile(std::string const &Prefix = "",
bool ImmediateUnlink = true,
FileFd * const TmpFd = NULL);
/** \brief Ensure the existence of the given Path
*

416
apt-pkg/deb/debindexfile.cc

@ -36,27 +36,20 @@
#include <iostream>
#include <sstream>
#include <string>
#include <memory>
#include <sys/stat.h>
/*}}}*/
using std::string;
// SourcesIndex::debSourcesIndex - Constructor /*{{{*/
// ---------------------------------------------------------------------
/* */
// Sources Index /*{{{*/
debSourcesIndex::debSourcesIndex(IndexTarget const &Target,bool const Trusted) :
pkgIndexTargetFile(Target, Trusted), d(NULL)
pkgDebianIndexTargetFile(Target, Trusted), d(NULL)
{
}
/*}}}*/
// SourcesIndex::SourceInfo - Short 1 liner describing a source /*{{{*/
// ---------------------------------------------------------------------
/* The result looks like:
http://foo/debian/ stable/main src 1.1.1 (dsc) */
string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record,
std::string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record,
pkgSrcRecords::File const &File) const
{
string Res = Target.Description;
// The result looks like: http://foo/debian/ stable/main src 1.1.1 (dsc)
std::string Res = Target.Description;
Res.erase(Target.Description.rfind(' '));
Res += " ";
@ -67,294 +60,111 @@ string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record,
Res += " (" + File.Type + ")";
return Res;
}
/*}}}*/
// SourcesIndex::CreateSrcParser - Get a parser for the source files /*{{{*/
// ---------------------------------------------------------------------
/* */
pkgSrcRecords::Parser *debSourcesIndex::CreateSrcParser() const
{
string const SourcesURI = IndexFileName();
std::string const SourcesURI = IndexFileName();
if (FileExists(SourcesURI))
return new debSrcRecordParser(SourcesURI, this);
return NULL;
}
bool debSourcesIndex::OpenListFile(FileFd &, std::string const &)
{
return true;
}
pkgCacheListParser * debSourcesIndex::CreateListParser(FileFd &)
{
return NULL;
}
uint8_t debSourcesIndex::GetIndexFlags() const
{
return 0;
}
/*}}}*/
// PackagesIndex::debPackagesIndex - Contructor /*{{{*/
// ---------------------------------------------------------------------
/* */
// Packages Index /*{{{*/
debPackagesIndex::debPackagesIndex(IndexTarget const &Target, bool const Trusted) :
pkgIndexTargetFile(Target, Trusted), d(NULL)
pkgDebianIndexTargetFile(Target, Trusted), d(NULL)
{
}
/*}}}*/
// PackagesIndex::ArchiveInfo - Short version of the archive url /*{{{*/
// ---------------------------------------------------------------------
/* This is a shorter version that is designed to be < 60 chars or so */
string debPackagesIndex::ArchiveInfo(pkgCache::VerIterator Ver) const
std::string debPackagesIndex::ArchiveInfo(pkgCache::VerIterator const &Ver) const
{
std::string const Dist = Target.Option(IndexTarget::RELEASE);
string Res = Target.Option(IndexTarget::SITE) + " " + Dist;
std::string const Component = Target.Option(IndexTarget::COMPONENT);
if (Component.empty() == false)
Res += "/" + Component;
std::string Res = Target.Description;
Res.erase(Target.Description.rfind(' '));
Res += " ";
Res += Ver.ParentPkg().Name();
Res += " ";
std::string const Dist = Target.Option(IndexTarget::RELEASE);
if (Dist.empty() == false && Dist[Dist.size() - 1] != '/')
Res.append(Ver.Arch()).append(" ");
Res += Ver.VerStr();
return Res;
}
/*}}}*/
// PackagesIndex::Merge - Load the index file into a cache /*{{{*/
// ---------------------------------------------------------------------
/* */
bool debPackagesIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
{
string const PackageFile = IndexFileName();
FileFd Pkg(PackageFile,FileFd::ReadOnly, FileFd::Extension);
debListParser Parser(&Pkg, Target.Option(IndexTarget::ARCHITECTURE));
if (_error->PendingError() == true)
return _error->Error("Problem opening %s",PackageFile.c_str());
if (Prog != NULL)
Prog->SubProgress(0, Target.Description);
std::string const URI = Target.Option(IndexTarget::REPO_URI);
std::string Dist = Target.Option(IndexTarget::RELEASE);
if (Dist.empty())
Dist = "/";
::URI Tmp(URI);
if (Gen.SelectFile(PackageFile, *this, Target.Option(IndexTarget::ARCHITECTURE), Target.Option(IndexTarget::COMPONENT)) == false)
return _error->Error("Problem with SelectFile %s",PackageFile.c_str());
// Store the IMS information
pkgCache::PkgFileIterator File = Gen.GetCurFile();
pkgCacheGenerator::Dynamic<pkgCache::PkgFileIterator> DynFile(File);
File->Size = Pkg.FileSize();
File->mtime = Pkg.ModificationTime();
if (Gen.MergeList(Parser) == false)
return _error->Error("Problem with MergeList %s",PackageFile.c_str());
return true;
}
/*}}}*/
// PackagesIndex::FindInCache - Find this index /*{{{*/
// ---------------------------------------------------------------------
/* */
pkgCache::PkgFileIterator debPackagesIndex::FindInCache(pkgCache &Cache) const
uint8_t debPackagesIndex::GetIndexFlags() const
{
string const FileName = IndexFileName();
pkgCache::PkgFileIterator File = Cache.FileBegin();
for (; File.end() == false; ++File)
{
if (File.FileName() == NULL || FileName != File.FileName())
continue;
struct stat St;
if (stat(File.FileName(),&St) != 0)
{
if (_config->FindB("Debug::pkgCacheGen", false))
std::clog << "PackagesIndex::FindInCache - stat failed on " << File.FileName() << std::endl;
return pkgCache::PkgFileIterator(Cache);
}
if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
{
if (_config->FindB("Debug::pkgCacheGen", false))
std::clog << "PackagesIndex::FindInCache - size (" << St.st_size << " <> " << File->Size
<< ") or mtime (" << St.st_mtime << " <> " << File->mtime
<< ") doesn't match for " << File.FileName() << std::endl;
return pkgCache::PkgFileIterator(Cache);
}
return File;
}
return File;
return 0;
}
/*}}}*/
// TranslationsIndex::debTranslationsIndex - Contructor /*{{{*/
// Translation-* Index /*{{{*/
debTranslationsIndex::debTranslationsIndex(IndexTarget const &Target) :
pkgIndexTargetFile(Target, true), d(NULL)
pkgDebianIndexTargetFile(Target, true), d(NULL)
{}
/*}}}*/
bool debTranslationsIndex::HasPackages() const /*{{{*/
bool debTranslationsIndex::HasPackages() const
{
return Exists();
}
/*}}}*/
// TranslationsIndex::Merge - Load the index file into a cache /*{{{*/
// ---------------------------------------------------------------------
/* */
bool debTranslationsIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
{
// Check the translation file, if in use
string const TranslationFile = IndexFileName();
if (FileExists(TranslationFile))
{
FileFd Trans(TranslationFile,FileFd::ReadOnly, FileFd::Extension);
debTranslationsParser TransParser(&Trans);
if (_error->PendingError() == true)
return false;
if (Prog != NULL)
Prog->SubProgress(0, Target.Description);
if (Gen.SelectFile(TranslationFile, *this, "", Target.Option(IndexTarget::COMPONENT), pkgCache::Flag::NotSource | pkgCache::Flag::NoPackages) == false)
return _error->Error("Problem with SelectFile %s",TranslationFile.c_str());
// Store the IMS information
pkgCache::PkgFileIterator TransFile = Gen.GetCurFile();
TransFile->Size = Trans.FileSize();
TransFile->mtime = Trans.ModificationTime();
if (Gen.MergeList(TransParser) == false)
return _error->Error("Problem with MergeList %s",TranslationFile.c_str());
}
bool debTranslationsIndex::OpenListFile(FileFd &Pkg, std::string const &FileName)
{
if (FileExists(FileName))
return pkgDebianIndexTargetFile::OpenListFile(Pkg, FileName);
return true;
}
/*}}}*/
// TranslationsIndex::FindInCache - Find this index /*{{{*/
// ---------------------------------------------------------------------
/* */
pkgCache::PkgFileIterator debTranslationsIndex::FindInCache(pkgCache &Cache) const
uint8_t debTranslationsIndex::GetIndexFlags() const
{
string FileName = IndexFileName();
pkgCache::PkgFileIterator File = Cache.FileBegin();
for (; File.end() == false; ++File)
{
if (FileName != File.FileName())
continue;
struct stat St;
if (stat(File.FileName(),&St) != 0)
{
if (_config->FindB("Debug::pkgCacheGen", false))
std::clog << "TranslationIndex::FindInCache - stat failed on " << File.FileName() << std::endl;
return pkgCache::PkgFileIterator(Cache);
}
if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
{
if (_config->FindB("Debug::pkgCacheGen", false))
std::clog << "TranslationIndex::FindInCache - size (" << St.st_size << " <> " << File->Size
<< ") or mtime (" << St.st_mtime << " <> " << File->mtime
<< ") doesn't match for " << File.FileName() << std::endl;
return pkgCache::PkgFileIterator(Cache);
}
return File;
}
return File;
return pkgCache::Flag::NotSource | pkgCache::Flag::NoPackages;
}
/*}}}*/
// StatusIndex::debStatusIndex - Constructor /*{{{*/
// ---------------------------------------------------------------------
/* */
debStatusIndex::debStatusIndex(string File) : pkgIndexFile(true), d(NULL), File(File)
std::string debTranslationsIndex::GetArchitecture() const
{
return std::string();
}
/*}}}*/
// StatusIndex::Size - Return the size of the index /*{{{*/
// ---------------------------------------------------------------------
/* */
unsigned long debStatusIndex::Size() const
pkgCacheListParser * debTranslationsIndex::CreateListParser(FileFd &Pkg)
{
struct stat S;
if (stat(File.c_str(),&S) != 0)
return 0;
return S.st_size;
}
/*}}}*/
// StatusIndex::Merge - Load the index file into a cache /*{{{*/
// ---------------------------------------------------------------------
/* */
bool debStatusIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
{
FileFd Pkg(File,FileFd::ReadOnly, FileFd::Extension);
if (_error->PendingError() == true)
return false;
debListParser Parser(&Pkg);
if (_error->PendingError() == true)
return false;
if (Prog != NULL)
Prog->SubProgress(0,File);
if (Gen.SelectFile(File, *this, "", "now", pkgCache::Flag::NotSource) == false)
return _error->Error("Problem with SelectFile %s",File.c_str());
// Store the IMS information
pkgCache::PkgFileIterator CFile = Gen.GetCurFile();
pkgCacheGenerator::Dynamic<pkgCache::PkgFileIterator> DynFile(CFile);
CFile->Size = Pkg.FileSize();
CFile->mtime = Pkg.ModificationTime();
if (Gen.MergeList(Parser) == false)
return _error->Error("Problem with MergeList %s",File.c_str());
return true;
if (Pkg.IsOpen() == false)
return NULL;
_error->PushToStack();
pkgCacheListParser * const Parser = new debTranslationsParser(&Pkg);
bool const newError = _error->PendingError();
_error->MergeWithStack();
return newError ? NULL : Parser;
}
/*}}}*/
// StatusIndex::FindInCache - Find this index /*{{{*/
// ---------------------------------------------------------------------
/* */
pkgCache::PkgFileIterator debStatusIndex::FindInCache(pkgCache &Cache) const
// dpkg/status Index /*{{{*/
debStatusIndex::debStatusIndex(std::string const &File) : pkgDebianIndexRealFile(File, true), d(NULL)
{
pkgCache::PkgFileIterator File = Cache.FileBegin();
for (; File.end() == false; ++File)
{
if (this->File != File.FileName())
continue;
struct stat St;
if (stat(File.FileName(),&St) != 0)
{
if (_config->FindB("Debug::pkgCacheGen", false))
std::clog << "StatusIndex::FindInCache - stat failed on " << File.FileName() << std::endl;
return pkgCache::PkgFileIterator(Cache);
}
if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
{
if (_config->FindB("Debug::pkgCacheGen", false))
std::clog << "StatusIndex::FindInCache - size (" << St.st_size << " <> " << File->Size
<< ") or mtime (" << St.st_mtime << " <> " << File->mtime
<< ") doesn't match for " << File.FileName() << std::endl;
return pkgCache::PkgFileIterator(Cache);
}
return File;
}
return File;
}
/*}}}*/
// StatusIndex::Exists - Check if the index is available /*{{{*/
// ---------------------------------------------------------------------
/* */
APT_CONST bool debStatusIndex::Exists() const
std::string debStatusIndex::GetArchitecture() const
{
// Abort if the file does not exist.
return true;
return std::string();
}
/*}}}*/
// debDebPkgFileIndex - Single .deb file /*{{{*/
debDebPkgFileIndex::debDebPkgFileIndex(std::string const &DebFile)
: pkgIndexFile(true), d(NULL), DebFile(DebFile)
std::string debStatusIndex::GetComponent() const
{
DebFileFullPath = flAbsPath(DebFile);
return "now";
}
std::string debDebPkgFileIndex::ArchiveURI(std::string /*File*/) const
uint8_t debStatusIndex::GetIndexFlags() const
{
return "file:" + DebFileFullPath;
return pkgCache::Flag::NotSource;
}
bool debDebPkgFileIndex::Exists() const
/*}}}*/
// DebPkgFile Index - a single .deb file as an index /*{{{*/
debDebPkgFileIndex::debDebPkgFileIndex(std::string const &DebFile)
: pkgDebianIndexRealFile(DebFile, true), d(NULL), DebFile(DebFile)
{
return FileExists(DebFile);
}
bool debDebPkgFileIndex::GetContent(std::ostream &content, std::string const &debfile)
{
struct stat Buf;
if (stat(debfile.c_str(), &Buf) != 0)
return false;
// get the control data out of the deb file via dpkg-deb -I
std::string dpkg = _config->Find("Dir::Bin::dpkg","dpkg-deb");
std::vector<const char *> Args;
@ -381,91 +191,73 @@ bool debDebPkgFileIndex::GetContent(std::ostream &content, std::string const &de
ExecWait(Child, "Popen");
content << "Filename: " << debfile << "\n";
struct stat Buf;
if (stat(debfile.c_str(), &Buf) != 0)
return false;
content << "Size: " << Buf.st_size << "\n";
return true;
}
bool debDebPkgFileIndex::Merge(pkgCacheGenerator& Gen, OpProgress* Prog) const
bool debDebPkgFileIndex::OpenListFile(FileFd &Pkg, std::string const &FileName)
{
if(Prog)
Prog->SubProgress(0, "Reading deb file");
// write the control data to a tempfile
SPtr<FileFd> DebControl = GetTempFile("deb-file-" + flNotDir(DebFile));
if(DebControl == NULL)
if (GetTempFile("deb-file-" + flNotDir(FileName), true, &Pkg) == NULL)
return false;
std::ostringstream content;
if (GetContent(content, DebFile) == false)
if (GetContent(content, FileName) == false)
return false;
std::string const contentstr = content.str();
if (contentstr.empty())
return true;
DebControl->Write(contentstr.c_str(), contentstr.length());
// rewind for the listparser
DebControl->Seek(0);
// and give it to the list parser
debDebFileParser Parser(DebControl, DebFile);
if(Gen.SelectFile(DebFile, *this, "", "now", pkgCache::Flag::LocalSource) == false)
return _error->Error("Problem with SelectFile %s", DebFile.c_str());
pkgCache::PkgFileIterator File = Gen.GetCurFile();
File->Size = DebControl->Size();
File->mtime = DebControl->ModificationTime();
if (Gen.MergeList(Parser) == false)
return _error->Error("Problem with MergeLister for %s", DebFile.c_str());
if (Pkg.Write(contentstr.c_str(), contentstr.length()) == false || Pkg.Seek(0) == false)
return false;
return true;
}
pkgCacheListParser * debDebPkgFileIndex::CreateListParser(FileFd &Pkg)
{
if (Pkg.IsOpen() == false)
return NULL;
_error->PushToStack();
pkgCacheListParser * const Parser = new debDebFileParser(&Pkg, DebFile);
bool const newError = _error->PendingError();
_error->MergeWithStack();
return newError ? NULL : Parser;
}
uint8_t debDebPkgFileIndex::GetIndexFlags() const
{
return pkgCache::Flag::LocalSource;
}
std::string debDebPkgFileIndex::GetArchitecture() const
{
return std::string();
}
std::string debDebPkgFileIndex::GetComponent() const
{
return "local-deb";
}
pkgCache::PkgFileIterator debDebPkgFileIndex::FindInCache(pkgCache &Cache) const
{
std::string const FileName = IndexFileName();
pkgCache::PkgFileIterator File = Cache.FileBegin();
for (; File.end() == false; ++File)
{
if (File.FileName() == NULL || DebFile != File.FileName())
if (File.FileName() == NULL || FileName != File.FileName())
continue;
return File;
// we can't do size checks here as file size != content size
return File;
}
return File;
}
unsigned long debDebPkgFileIndex::Size() const
{
struct stat buf;
if(stat(DebFile.c_str(), &buf) != 0)
return 0;
return buf.st_size;
}
/*}}}*/
// debDscFileIndex - a .dsc file /*{{{*/
/*}}}*/
// DscFile Index - a single .dsc file as an index /*{{{*/
debDscFileIndex::debDscFileIndex(std::string const &DscFile)
: pkgIndexFile(true), d(NULL), DscFile(DscFile)
: pkgDebianIndexRealFile(DscFile, true), d(NULL)
{
}
bool debDscFileIndex::Exists() const
{
return FileExists(DscFile);
}
unsigned long debDscFileIndex::Size() const
{
struct stat buf;
if(stat(DscFile.c_str(), &buf) == 0)
return buf.st_size;
return 0;
}
pkgSrcRecords::Parser *debDscFileIndex::CreateSrcParser() const
{
if (!FileExists(DscFile))
if (Exists() == false)
return NULL;
return new debDscRecordParser(DscFile,this);
return new debDscRecordParser(File, this);
}
/*}}}*/
@ -478,7 +270,7 @@ class APT_HIDDEN debIFTypeSrc : public pkgIndexFile::Type
class APT_HIDDEN debIFTypePkg : public pkgIndexFile::Type
{
public:
virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const APT_OVERRIDE
virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
{
return new debRecordParser(File.FileName(),*File.Cache());
};
@ -492,7 +284,7 @@ class APT_HIDDEN debIFTypeTrans : public debIFTypePkg
class APT_HIDDEN debIFTypeStatus : public pkgIndexFile::Type
{
public:
virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const APT_OVERRIDE
virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
{
return new debRecordParser(File.FileName(),*File.Cache());
};
@ -501,7 +293,7 @@ class APT_HIDDEN debIFTypeStatus : public pkgIndexFile::Type
class APT_HIDDEN debIFTypeDebPkgFile : public pkgIndexFile::Type
{
public:
virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator File) const APT_OVERRIDE
virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
{
return new debDebFileRecordParser(File.FileName());
};
@ -510,7 +302,7 @@ class APT_HIDDEN debIFTypeDebPkgFile : public pkgIndexFile::Type
class APT_HIDDEN debIFTypeDscFile : public pkgIndexFile::Type
{
public:
virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string DscFile) const APT_OVERRIDE
virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string const &DscFile) const APT_OVERRIDE
{
return new debDscRecordParser(DscFile, NULL);
};
@ -519,9 +311,9 @@ class APT_HIDDEN debIFTypeDscFile : public pkgIndexFile::Type
class APT_HIDDEN debIFTypeDebianSourceDir : public pkgIndexFile::Type
{
public:
virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string SourceDir) const APT_OVERRIDE
virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string const &SourceDir) const APT_OVERRIDE
{
return new debDscRecordParser(SourceDir + string("/debian/control"), NULL);
return new debDscRecordParser(SourceDir + std::string("/debian/control"), NULL);
};
debIFTypeDebianSourceDir() {Label = "Debian control file";};
};

84
apt-pkg/deb/debindexfile.h

@ -26,69 +26,73 @@ class OpProgress;
class pkgAcquire;
class pkgCacheGenerator;
class debStatusIndex : public pkgIndexFile
class debStatusIndex : public pkgDebianIndexRealFile
{
void * const d;
protected:
std::string File;
protected:
virtual std::string GetArchitecture() const APT_OVERRIDE;
virtual std::string GetComponent() const APT_OVERRIDE;
virtual uint8_t GetIndexFlags() const APT_OVERRIDE;
public:
public:
virtual const Type *GetType() const APT_CONST;
// Interface for acquire
virtual std::string Describe(bool /*Short*/) const APT_OVERRIDE {return File;};
// Interface for the Cache Generator
virtual bool Exists() const APT_OVERRIDE;
virtual bool HasPackages() const APT_OVERRIDE {return true;};
virtual unsigned long Size() const APT_OVERRIDE;
virtual bool Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const APT_OVERRIDE;
virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const APT_OVERRIDE;
// Abort if the file does not exist.
virtual bool Exists() const APT_OVERRIDE {return true;};
debStatusIndex(std::string File);
debStatusIndex(std::string const &File);
virtual ~debStatusIndex();
};
class debPackagesIndex : public pkgIndexTargetFile
class debPackagesIndex : public pkgDebianIndexTargetFile
{
void * const d;
public:
protected:
virtual uint8_t GetIndexFlags() const;
public:
virtual const Type *GetType() const APT_CONST;
// Stuff for accessing files on remote items
virtual std::string ArchiveInfo(pkgCache::VerIterator Ver) const APT_OVERRIDE;
virtual std::string ArchiveInfo(pkgCache::VerIterator const &Ver) const APT_OVERRIDE;
// Interface for the Cache Generator
virtual bool HasPackages() const APT_OVERRIDE {return true;};
virtual bool Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const APT_OVERRIDE;
virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const APT_OVERRIDE;
debPackagesIndex(IndexTarget const &Target, bool const Trusted);
virtual ~debPackagesIndex();
};
class debTranslationsIndex : public pkgIndexTargetFile
class debTranslationsIndex : public pkgDebianIndexTargetFile
{
void * const d;
public:
protected:
virtual std::string GetArchitecture() const APT_OVERRIDE;
virtual uint8_t GetIndexFlags() const APT_OVERRIDE;
virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) APT_OVERRIDE;
APT_HIDDEN virtual pkgCacheListParser * CreateListParser(FileFd &Pkg) APT_OVERRIDE;
public:
virtual const Type *GetType() const APT_CONST;
// Interface for the Cache Generator
virtual bool HasPackages() const APT_OVERRIDE;
virtual bool Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const APT_OVERRIDE;
virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const APT_OVERRIDE;
debTranslationsIndex(IndexTarget const &Target);
virtual ~debTranslationsIndex();
};
class debSourcesIndex : public pkgIndexTargetFile
class debSourcesIndex : public pkgDebianIndexTargetFile
{
void * const d;
virtual uint8_t GetIndexFlags() const;
virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) APT_OVERRIDE;
APT_HIDDEN virtual pkgCacheListParser * CreateListParser(FileFd &Pkg) APT_OVERRIDE;
public:
virtual const Type *GetType() const APT_CONST;
@ -107,19 +111,20 @@ class debSourcesIndex : public pkgIndexTargetFile
virtual ~debSourcesIndex();
};
class debDebPkgFileIndex : public pkgIndexFile
class debDebPkgFileIndex : public pkgDebianIndexRealFile
{
private:
void * const d;
std::string DebFile;
std::string DebFileFullPath;
public:
virtual const Type *GetType() const APT_CONST;
protected:
virtual std::string GetComponent() const APT_OVERRIDE;
virtual std::string GetArchitecture() const APT_OVERRIDE;
virtual uint8_t GetIndexFlags() const APT_OVERRIDE;
virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) APT_OVERRIDE;
APT_HIDDEN virtual pkgCacheListParser * CreateListParser(FileFd &Pkg) APT_OVERRIDE;
virtual std::string Describe(bool /*Short*/) const APT_OVERRIDE {
return DebFile;
}
public:
virtual const Type *GetType() const APT_CONST;
/** get the control (file) content of the deb file
*
@ -130,35 +135,22 @@ class debDebPkgFileIndex : public pkgIndexFile
static bool GetContent(std::ostream &content, std::string const &debfile);
// Interface for the Cache Generator
virtual bool Exists() const APT_OVERRIDE;
virtual bool HasPackages() const APT_OVERRIDE {
return true;
};
virtual unsigned long Size() const APT_OVERRIDE;
virtual bool Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const APT_OVERRIDE;
virtual bool HasPackages() const APT_OVERRIDE {return true;}
virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const APT_OVERRIDE;
// Interface for acquire
virtual std::string ArchiveURI(std::string /*File*/) const APT_OVERRIDE;
debDebPkgFileIndex(std::string const &DebFile);
virtual ~debDebPkgFileIndex();
};
class debDscFileIndex : public pkgIndexFile
class debDscFileIndex : public pkgDebianIndexRealFile
{
private:
void * const d;
std::string DscFile;
public:
virtual const Type *GetType() const APT_CONST;
virtual pkgSrcRecords::Parser *CreateSrcParser() const APT_OVERRIDE;
virtual bool Exists() const APT_OVERRIDE;
virtual bool HasPackages() const APT_OVERRIDE {return false;};
virtual unsigned long Size() const APT_OVERRIDE;
virtual std::string Describe(bool /*Short*/) const APT_OVERRIDE {
return DscFile;
};
debDscFileIndex(std::string const &DscFile);
virtual ~debDscFileIndex();

7
apt-pkg/deb/deblistparser.cc

@ -50,8 +50,9 @@ static debListParser::WordList PrioList[] = {
/* Provide an architecture and only this one and "all" will be accepted
in Step(), if no Architecture is given we will accept every arch
we would accept in general with checkArchitecture() */
debListParser::debListParser(FileFd *File, string const &Arch) : d(NULL), Tags(File),
Arch(Arch) {
debListParser::debListParser(FileFd *File, string const &Arch) :
pkgCacheListParser(), d(NULL), Tags(File), Arch(Arch)
{
if (Arch == "native")
this->Arch = _config->Find("APT::Architecture");
Architectures = APT::Configuration::getArchitectures();
@ -931,7 +932,7 @@ unsigned char debListParser::GetPrio(string Str)
bool debListParser::SameVersion(unsigned short const Hash, /*{{{*/
pkgCache::VerIterator const &Ver)
{
if (pkgCacheGenerator::ListParser::SameVersion(Hash, Ver) == false)
if (pkgCacheListParser::SameVersion(Hash, Ver) == false)
return false;
// status file has no (Download)Size, but all others are fair game
// status file is parsed last, so the first version we encounter is

2
apt-pkg/deb/deblistparser.h

@ -26,7 +26,7 @@
class FileFd;
class APT_HIDDEN debListParser : public pkgCacheGenerator::ListParser
class APT_HIDDEN debListParser : public pkgCacheListParser
{
public:

75
apt-pkg/edsp/edspindexfile.cc

@ -26,59 +26,66 @@
#include <string>
/*}}}*/
// edspIndex::edspIndex - Constructor /*{{{*/
// ---------------------------------------------------------------------
/* */
edspIndex::edspIndex(std::string File) : debStatusIndex(File), d(NULL)
// EDSP Index /*{{{*/
edspIndex::edspIndex(std::string const &File) : pkgDebianIndexRealFile(File, true), d(NULL)
{
}
/*}}}*/
// StatusIndex::Merge - Load the index file into a cache /*{{{*/
bool edspIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
std::string edspIndex::GetComponent() const
{
FileFd Pkg;
if (File != "stdin")
Pkg.Open(File, FileFd::ReadOnly);
else
Pkg.OpenDescriptor(STDIN_FILENO, FileFd::ReadOnly);
if (_error->PendingError() == true)
return false;
edspListParser Parser(&Pkg);
if (_error->PendingError() == true)
return false;
if (Prog != NULL)
Prog->SubProgress(0,File);
if (Gen.SelectFile(File, *this, "", "edsp") == false)
return _error->Error("Problem with SelectFile %s",File.c_str());
// Store the IMS information
pkgCache::PkgFileIterator CFile = Gen.GetCurFile();
pkgCacheGenerator::Dynamic<pkgCache::PkgFileIterator> DynFile(CFile);
CFile->Size = Pkg.FileSize();
CFile->mtime = Pkg.ModificationTime();
if (Gen.MergeList(Parser) == false)
return _error->Error("Problem with MergeList %s",File.c_str());
return "edsp";
}
std::string edspIndex::GetArchitecture() const
{
return std::string();
}
bool edspIndex::HasPackages() const
{
return true;
}
bool edspIndex::Exists() const
{
return true;
}
uint8_t edspIndex::GetIndexFlags() const
{
return 0;
}
bool edspIndex::OpenListFile(FileFd &Pkg, std::string const &FileName)
{
if (FileName.empty() == false && FileName != "stdin")
return pkgDebianIndexRealFile::OpenListFile(Pkg, FileName);
if (Pkg.OpenDescriptor(STDIN_FILENO, FileFd::ReadOnly) == false)
return _error->Error("Problem opening %s",FileName.c_str());
return true;
}
pkgCacheListParser * edspIndex::CreateListParser(FileFd &Pkg)
{
if (Pkg.IsOpen() == false)
return NULL;
_error->PushToStack();
pkgCacheListParser * const Parser = new edspListParser(&Pkg);
bool const newError = _error->PendingError();
_error->MergeWithStack();
return newError ? NULL : Parser;
}
/*}}}*/
// Index File types for APT /*{{{*/
class APT_HIDDEN edspIFType: public pkgIndexFile::Type
{
public:
virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator) const APT_OVERRIDE
virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &) const APT_OVERRIDE
{
// we don't have a record parser for this type as the file is not presistent
return NULL;
};
edspIFType() {Label = "EDSP scenario file";};
};
APT_HIDDEN edspIFType _apt_Universe;
APT_HIDDEN edspIFType _apt_Edsp;
const pkgIndexFile::Type *edspIndex::GetType() const
{
return &_apt_Universe;
return &_apt_Edsp;
}
/*}}}*/

16
apt-pkg/edsp/edspindexfile.h

@ -18,18 +18,24 @@
class OpProgress;
class pkgCacheGenerator;
class APT_HIDDEN edspIndex : public debStatusIndex
class APT_HIDDEN edspIndex : public pkgDebianIndexRealFile
{
/** \brief dpointer placeholder (for later in case we need it) */
void * const d;
public:
protected:
APT_HIDDEN virtual pkgCacheListParser * CreateListParser(FileFd &Pkg) APT_OVERRIDE;
virtual bool OpenListFile(FileFd &Pkg, std::string const &File) APT_OVERRIDE;
virtual uint8_t GetIndexFlags() const APT_OVERRIDE;
virtual std::string GetComponent() const APT_OVERRIDE;
virtual std::string GetArchitecture() const APT_OVERRIDE;
public:
virtual const Type *GetType() const APT_CONST;
virtual bool Exists() const APT_OVERRIDE;
virtual bool HasPackages() const APT_OVERRIDE;
virtual bool Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const APT_OVERRIDE;
edspIndex(std::string File);
edspIndex(std::string const &File);
virtual ~edspIndex();
};

8
apt-pkg/edsp/edspsystem.cc

@ -81,13 +81,9 @@ bool edspSystem::ArchiveSupported(const char * /*Type*/)
return false;
}
/*}}}*/
// System::Score - Determine if we should use the edsp system /*{{{*/
signed edspSystem::Score(Configuration const &Cnf)
// System::Score - Never use the EDSP system automatically /*{{{*/
signed edspSystem::Score(Configuration const &)
{
if (Cnf.Find("edsp::scenario", "") == "stdin")
return 1000;
if (RealFileExists(Cnf.FindFile("edsp::scenario","")) == true)
return 1000;
return -1000;
}
/*}}}*/

175
apt-pkg/indexfile.cc

@ -16,14 +16,23 @@
#include <apt-pkg/fileutl.h>
#include <apt-pkg/aptconfiguration.h>
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/pkgcachegen.h>
#include <apt-pkg/cacheiterators.h>
#include <apt-pkg/srcrecords.h>
#include <apt-pkg/progress.h>
#include <apt-pkg/macros.h>
#include <apt-pkg/deblistparser.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string>
#include <vector>
#include <clocale>
#include <cstring>
#include <memory>
/*}}}*/
// Global list of Item supported
@ -52,13 +61,13 @@ pkgIndexFile::Type *pkgIndexFile::Type::GetType(const char *Type)
return 0;
}
/*}}}*/
pkgIndexFile::pkgIndexFile(bool Trusted) : /*{{{*/
pkgIndexFile::pkgIndexFile(bool const Trusted) : /*{{{*/
d(NULL), Trusted(Trusted)
{
}
/*}}}*/
// IndexFile::ArchiveInfo - Stub /*{{{*/
std::string pkgIndexFile::ArchiveInfo(pkgCache::VerIterator /*Ver*/) const
std::string pkgIndexFile::ArchiveInfo(pkgCache::VerIterator const &/*Ver*/) const
{
return std::string();
}
@ -89,7 +98,7 @@ bool pkgIndexFile::TranslationsAvailable() {
is already done in getLanguages(). Note also that this check is
rather bad (doesn't take three character like ast into account).
TODO: Remove method with next API break */
APT_DEPRECATED bool pkgIndexFile::CheckLanguageCode(const char *Lang)
APT_DEPRECATED bool pkgIndexFile::CheckLanguageCode(const char * const Lang)
{
if (strlen(Lang) == 2 || (strlen(Lang) == 5 && Lang[2] == '_'))
return true;
@ -172,24 +181,24 @@ std::string IndexTarget::Format(std::string format) const /*{{{*/
}
/*}}}*/
pkgIndexTargetFile::pkgIndexTargetFile(IndexTarget const &Target, bool const Trusted) :/*{{{*/
pkgIndexFile(Trusted), d(NULL), Target(Target)
pkgDebianIndexTargetFile::pkgDebianIndexTargetFile(IndexTarget const &Target, bool const Trusted) :/*{{{*/
pkgDebianIndexFile(Trusted), d(NULL), Target(Target)
{
}
/*}}}*/
std::string pkgIndexTargetFile::ArchiveURI(std::string File) const/*{{{*/
std::string pkgDebianIndexTargetFile::ArchiveURI(std::string const &File) const/*{{{*/
{
return Target.Option(IndexTarget::REPO_URI) + File;
}
/*}}}*/
std::string pkgIndexTargetFile::Describe(bool Short) const /*{{{*/
std::string pkgDebianIndexTargetFile::Describe(bool const Short) const /*{{{*/
{
if (Short)
return Target.Description;
return Target.Description + " (" + IndexFileName() + ")";
}
/*}}}*/
std::string pkgIndexTargetFile::IndexFileName() const /*{{{*/
std::string pkgDebianIndexTargetFile::IndexFileName() const /*{{{*/
{
std::string const s = Target.Option(IndexTarget::FILENAME);
if (FileExists(s))
@ -205,7 +214,7 @@ std::string pkgIndexTargetFile::IndexFileName() const /*{{{*/
return s;
}
/*}}}*/
unsigned long pkgIndexTargetFile::Size() const /*{{{*/
unsigned long pkgDebianIndexTargetFile::Size() const /*{{{*/
{
unsigned long size = 0;
@ -223,11 +232,155 @@ unsigned long pkgIndexTargetFile::Size() const /*{{{*/
return size;
}
/*}}}*/
bool pkgIndexTargetFile::Exists() const /*{{{*/
bool pkgDebianIndexTargetFile::Exists() const /*{{{*/
{
return FileExists(IndexFileName());
}
/*}}}*/
std::string pkgDebianIndexTargetFile::GetArchitecture() const /*{{{*/
{
return Target.Option(IndexTarget::ARCHITECTURE);
}
/*}}}*/
std::string pkgDebianIndexTargetFile::GetComponent() const /*{{{*/
{
return Target.Option(IndexTarget::COMPONENT);
}
/*}}}*/
bool pkgDebianIndexTargetFile::OpenListFile(FileFd &Pkg, std::string const &FileName)/*{{{*/
{
if (Pkg.Open(FileName, FileFd::ReadOnly, FileFd::Extension) == false)
return _error->Error("Problem opening %s",FileName.c_str());
return true;
}
/*}}}*/
std::string pkgDebianIndexTargetFile::GetProgressDescription() const
{
return Target.Description;
}
pkgDebianIndexRealFile::pkgDebianIndexRealFile(std::string const &File, bool const Trusted) :/*{{{*/
pkgDebianIndexFile(Trusted), d(NULL), File(flAbsPath(File))
{
}
/*}}}*/
// IndexRealFile::Size - Return the size of the index /*{{{*/
unsigned long pkgDebianIndexRealFile::Size() const
{
struct stat S;
if (stat(File.c_str(),&S) != 0)
return 0;
return S.st_size;
}
/*}}}*/
bool pkgDebianIndexRealFile::Exists() const /*{{{*/
{
return FileExists(File);
}
/*}}}*/
std::string pkgDebianIndexRealFile::Describe(bool const /*Short*/) const/*{{{*/
{
return File;
}
/*}}}*/
std::string pkgDebianIndexRealFile::ArchiveURI(std::string const &/*File*/) const/*{{{*/
{
return "file:" + File;
}
/*}}}*/
std::string pkgDebianIndexRealFile::IndexFileName() const /*{{{*/
{
return File;
}
/*}}}*/
std::string pkgDebianIndexRealFile::GetProgressDescription() const
{
return File;
}
bool pkgDebianIndexRealFile::OpenListFile(FileFd &Pkg, std::string const &FileName)/*{{{*/
{
if (Pkg.Open(FileName, FileFd::ReadOnly, FileFd::None) == false)
return _error->Error("Problem opening %s",FileName.c_str());
return true;
}
/*}}}*/
pkgDebianIndexFile::pkgDebianIndexFile(bool const Trusted) : pkgIndexFile(Trusted)
{
}
pkgDebianIndexFile::~pkgDebianIndexFile()
{
}
pkgCacheListParser * pkgDebianIndexFile::CreateListParser(FileFd &Pkg)
{
if (Pkg.IsOpen() == false)
return NULL;
_error->PushToStack();
pkgCacheListParser * const Parser = new debListParser(&Pkg, GetArchitecture());
bool const newError = _error->PendingError();
_error->MergeWithStack();
return newError ? NULL : Parser;
}
bool pkgDebianIndexFile::Merge(pkgCacheGenerator &Gen,OpProgress * const Prog)
{
std::string const PackageFile = IndexFileName();
FileFd Pkg;
if (OpenListFile(Pkg, PackageFile) == false)
return false;
_error->PushToStack();
std::unique_ptr<pkgCacheListParser> Parser(CreateListParser(Pkg));
bool const newError = _error->PendingError();
if (newError == false && Parser == nullptr)
return true;
if (Parser == NULL)
return false;
if (Prog != NULL)
Prog->SubProgress(0, GetProgressDescription());
if (Gen.SelectFile(PackageFile, *this, GetArchitecture(), GetComponent(), GetIndexFlags()) == false)
return _error->Error("Problem with SelectFile %s",PackageFile.c_str());
// Store the IMS information
pkgCache::PkgFileIterator File = Gen.GetCurFile();
pkgCacheGenerator::Dynamic<pkgCache::PkgFileIterator> DynFile(File);
File->Size = Pkg.FileSize();
File->mtime = Pkg.ModificationTime();
if (Gen.MergeList(*Parser) == false)
return _error->Error("Problem with MergeList %s",PackageFile.c_str());
return true;
}
pkgCache::PkgFileIterator pkgDebianIndexFile::FindInCache(pkgCache &Cache) const
{
std::string const FileName = IndexFileName();
pkgCache::PkgFileIterator File = Cache.FileBegin();
for (; File.end() == false; ++File)
{
if (File.FileName() == NULL || FileName != File.FileName())
continue;
struct stat St;
if (stat(File.FileName(),&St) != 0)
{
if (_config->FindB("Debug::pkgCacheGen", false))
std::clog << "DebianIndexFile::FindInCache - stat failed on " << File.FileName() << std::endl;
return pkgCache::PkgFileIterator(Cache);
}
if ((map_filesize_t)St.st_size != File->Size || St.st_mtime != File->mtime)
{
if (_config->FindB("Debug::pkgCacheGen", false))
std::clog << "DebianIndexFile::FindInCache - size (" << St.st_size << " <> " << File->Size
<< ") or mtime (" << St.st_mtime << " <> " << File->mtime
<< ") doesn't match for " << File.FileName() << std::endl;
return pkgCache::PkgFileIterator(Cache);
}
return File;
}
return File;
}
APT_CONST pkgIndexFile::~pkgIndexFile() {}
APT_CONST pkgIndexTargetFile::~pkgIndexTargetFile() {}
APT_CONST pkgDebianIndexTargetFile::~pkgDebianIndexTargetFile() {}
APT_CONST pkgDebianIndexRealFile::~pkgDebianIndexRealFile() {}

79
apt-pkg/indexfile.h

@ -38,6 +38,7 @@ class pkgAcquire;
#endif
class pkgCacheGenerator;
class pkgCacheListParser;
class OpProgress;
class IndexTarget /*{{{*/
@ -105,12 +106,12 @@ class pkgIndexFile
// Global list of Items supported
static Type **GlobalList;
static unsigned long GlobalListLen;
static Type *GetType(const char *Type) APT_PURE;
static Type *GetType(const char * const Type) APT_PURE;
const char *Label;
virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator /*File*/) const {return 0;};
virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string /*File*/) const {return 0;};
virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &/*File*/) const {return 0;};
virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string const &/*File*/) const {return 0;};
Type();
virtual ~Type() {};
};
@ -118,13 +119,13 @@ class pkgIndexFile
virtual const Type *GetType() const = 0;
// Return descriptive strings of various sorts
virtual std::string ArchiveInfo(pkgCache::VerIterator Ver) const;
virtual std::string ArchiveInfo(pkgCache::VerIterator const &Ver) const;
virtual std::string SourceInfo(pkgSrcRecords::Parser const &Record,
pkgSrcRecords::File const &File) const;
virtual std::string Describe(bool Short = false) const = 0;
virtual std::string Describe(bool const Short = false) const = 0;
// Interface for acquire
virtual std::string ArchiveURI(std::string /*File*/) const {return std::string();};
virtual std::string ArchiveURI(std::string const &/*File*/) const {return std::string();};
// Interface for the record parsers
virtual pkgSrcRecords::Parser *CreateSrcParser() const {return 0;};
@ -133,40 +134,78 @@ class pkgIndexFile
virtual bool Exists() const = 0;
virtual bool HasPackages() const = 0;
virtual unsigned long Size() const = 0;
virtual bool Merge(pkgCacheGenerator &/*Gen*/, OpProgress* /*Prog*/) const { return false; };
APT_DEPRECATED virtual bool Merge(pkgCacheGenerator &Gen, OpProgress &Prog) const
{ return Merge(Gen, &Prog); };
virtual bool MergeFileProvides(pkgCacheGenerator &/*Gen*/,OpProgress* /*Prog*/) const {return true;};
APT_DEPRECATED virtual bool MergeFileProvides(pkgCacheGenerator &Gen, OpProgress &Prog) const
{return MergeFileProvides(Gen, &Prog);};
virtual bool Merge(pkgCacheGenerator &/*Gen*/, OpProgress* const /*Prog*/) { return true; };
virtual bool MergeFileProvides(pkgCacheGenerator &/*Gen*/,OpProgress* /*Prog*/) {return true;};
virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const;
static bool TranslationsAvailable();
static bool CheckLanguageCode(const char *Lang);
static bool CheckLanguageCode(const char * const Lang);
static std::string LanguageCode();
bool IsTrusted() const { return Trusted; };
explicit pkgIndexFile(bool Trusted);
explicit pkgIndexFile(bool const Trusted);
virtual ~pkgIndexFile();
};
class pkgIndexTargetFile : public pkgIndexFile
class pkgDebianIndexFile : public pkgIndexFile
{
protected:
virtual std::string IndexFileName() const = 0;
virtual std::string GetComponent() const = 0;
virtual std::string GetArchitecture() const = 0;
virtual std::string GetProgressDescription() const = 0;
virtual uint8_t GetIndexFlags() const = 0;
virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) = 0;
APT_HIDDEN virtual pkgCacheListParser * CreateListParser(FileFd &Pkg);
public:
virtual bool Merge(pkgCacheGenerator &Gen, OpProgress* const Prog) APT_OVERRIDE;
virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const APT_OVERRIDE;
pkgDebianIndexFile(bool const Trusted);
virtual ~pkgDebianIndexFile();
};
class pkgDebianIndexTargetFile : public pkgDebianIndexFile
{
void * const d;
protected:
IndexTarget const Target;
std::string IndexFileName() const;
virtual std::string IndexFileName() const APT_OVERRIDE;
virtual std::string GetComponent() const APT_OVERRIDE;
virtual std::string GetArchitecture() const APT_OVERRIDE;
virtual std::string GetProgressDescription() const APT_OVERRIDE;
virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) APT_OVERRIDE;
public:
virtual std::string ArchiveURI(std::string const &File) const APT_OVERRIDE;
virtual std::string Describe(bool const Short = false) const APT_OVERRIDE;
virtual bool Exists() const APT_OVERRIDE;
virtual unsigned long Size() const APT_OVERRIDE;
pkgDebianIndexTargetFile(IndexTarget const &Target, bool const Trusted);
virtual ~pkgDebianIndexTargetFile();
};
class pkgDebianIndexRealFile : public pkgDebianIndexFile
{
void * const d;
protected:
std::string File;
virtual std::string IndexFileName() const APT_OVERRIDE;
virtual std::string GetProgressDescription() const APT_OVERRIDE;
virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) APT_OVERRIDE;
public:
virtual std::string ArchiveURI(std::string File) const APT_OVERRIDE;
virtual std::string Describe(bool Short = false) const APT_OVERRIDE;
virtual std::string Describe(bool const /*Short*/ = false) const APT_OVERRIDE;
virtual bool Exists() const APT_OVERRIDE;
virtual unsigned long Size() const APT_OVERRIDE;
virtual std::string ArchiveURI(std::string const &/*File*/) const APT_OVERRIDE;
pkgIndexTargetFile(IndexTarget const &Target, bool const Trusted);
virtual ~pkgIndexTargetFile();
pkgDebianIndexRealFile(std::string const &File, bool const Trusted);
virtual ~pkgDebianIndexRealFile();
};
#endif

18
apt-pkg/pkgcachegen.cc

@ -1051,7 +1051,7 @@ bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
// ---------------------------------------------------------------------
/* This creates a Group and the Package to link this dependency to if
needed and handles also the caching of the old endpoint */
bool pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator &Ver,
bool pkgCacheListParser::NewDepends(pkgCache::VerIterator &Ver,
const string &PackageName,
const string &Arch,
const string &Version,
@ -1077,7 +1077,7 @@ bool pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator &Ver,
if (idxVersion == 0)
{
idxVersion = StoreString(VERSIONNUMBER, Version);
idxVersion = StoreString(pkgCacheGenerator::VERSIONNUMBER, Version);
if (unlikely(idxVersion == 0))
return false;
}
@ -1124,7 +1124,7 @@ bool pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator &Ver,
}
/*}}}*/
// ListParser::NewProvides - Create a Provides element /*{{{*/
bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator &Ver,
bool pkgCacheListParser::NewProvides(pkgCache::VerIterator &Ver,
const string &PkgName,
const string &PkgArch,
const string &Version,
@ -1145,7 +1145,7 @@ bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator &Ver,
map_stringitem_t idxProvideVersion = 0;
if (Version.empty() == false) {
idxProvideVersion = StoreString(VERSIONNUMBER, Version);
idxProvideVersion = StoreString(pkgCacheGenerator::VERSIONNUMBER, Version);
if (unlikely(idxProvideVersion == 0))
return false;
}
@ -1178,7 +1178,7 @@ bool pkgCacheGenerator::NewProvides(pkgCache::VerIterator &Ver,
}
/*}}}*/
// ListParser::NewProvidesAllArch - add provides for all architectures /*{{{*/
bool pkgCacheGenerator::ListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, string const &Package,
bool pkgCacheListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, string const &