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

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;
 }
 									/*}}}*/

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
  *

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";};
 };

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();

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

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:
 

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;
 }
 									/*}}}*/
 

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();
 };
 

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;
 }
 									/*}}}*/

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() {}

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

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 &Package,
 				string const &Version, uint8_t const Flags) {
    pkgCache &Cache = Owner->Cache;
    pkgCache::GrpIterator const Grp = Cache.FindGrp(Package);
@@ -1188,7 +1188,7 @@ bool pkgCacheGenerator::ListParser::NewProvidesAllArch(pkgCache::VerIterator &Ve
    {
       map_stringitem_t idxProvideVersion = 0;
       if (Version.empty() == false) {
-	 idxProvideVersion = StoreString(VERSIONNUMBER, Version);
+	 idxProvideVersion = StoreString(pkgCacheGenerator::VERSIONNUMBER, Version);
 	 if (unlikely(idxProvideVersion == 0))
 	    return false;
       }
@@ -1209,7 +1209,7 @@ bool pkgCacheGenerator::ListParser::NewProvidesAllArch(pkgCache::VerIterator &Ve
    return true;
 }
 									/*}}}*/
-bool pkgCacheGenerator::ListParser::SameVersion(unsigned short const Hash,/*{{{*/
+bool pkgCacheListParser::SameVersion(unsigned short const Hash,		/*{{{*/
       pkgCache::VerIterator const &Ver)
 {
    return Hash == Ver->Hash;
@@ -1835,5 +1835,5 @@ bool pkgCacheGenerator::FinishCache(OpProgress * /*Progress*/)
 }
 									/*}}}*/
 
-pkgCacheGenerator::ListParser::ListParser() : Owner(NULL), OldDepLast(NULL), FoundFileDeps(false), d(NULL) {}
-pkgCacheGenerator::ListParser::~ListParser() {}
+pkgCacheListParser::pkgCacheListParser() : Owner(NULL), OldDepLast(NULL), FoundFileDeps(false), d(NULL) {}
+pkgCacheListParser::~pkgCacheListParser() {}

apt-pkg/pkgcachegen.h

@@ -32,10 +32,10 @@ class FileFd;
 class pkgSourceList;
 class OpProgress;
 class pkgIndexFile;
+class pkgCacheListParser;
 
 class APT_HIDDEN pkgCacheGenerator					/*{{{*/
 {
-   private:
    APT_HIDDEN map_stringitem_t WriteStringInMap(std::string const &String) { return WriteStringInMap(String.c_str()); };
    APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String);
    APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String, const unsigned long &Len);
@@ -46,10 +46,10 @@ class APT_HIDDEN pkgCacheGenerator					/*{{{*/
    std::map<std::string,map_stringitem_t> strPkgNames;
    std::map<std::string,map_stringitem_t> strVersions;
 
+   friend class pkgCacheListParser;
+   typedef pkgCacheListParser ListParser;
+
    public:
-   
-   class ListParser;
-   friend class ListParser;
 
    template<typename Iter> class Dynamic {
       public:
@@ -138,11 +138,12 @@ class APT_HIDDEN pkgCacheGenerator					/*{{{*/
 };
 									/*}}}*/
 // This is the abstract package list parser class.			/*{{{*/
-class APT_HIDDEN pkgCacheGenerator::ListParser
+class APT_HIDDEN pkgCacheListParser
 {
    pkgCacheGenerator *Owner;
    friend class pkgCacheGenerator;
-   
+   template<class T> using Dynamic = pkgCacheGenerator::Dynamic<T>;
+
    // Some cache items
    pkgCache::VerIterator OldDepVer;
    map_pointer_t *OldDepLast;
@@ -197,8 +198,8 @@ class APT_HIDDEN pkgCacheGenerator::ListParser
    virtual bool CollectFileProvides(pkgCache &/*Cache*/,
 				    pkgCache::VerIterator &/*Ver*/) {return true;};
 
-   ListParser();
-   virtual ~ListParser();
+   pkgCacheListParser();
+   virtual ~pkgCacheListParser();
 };
 									/*}}}*/
 

cmdline/apt-internal-solver.cc

@@ -109,6 +109,7 @@ int main(int argc,const char *argv[])					/*{{{*/
 	if (_config->FindI("quiet", 0) < 1)
 		_config->Set("Debug::EDSP::WriteSolution", true);
 
+	_config->Set("APT::System", "Debian APT solver interface");
 	_config->Set("APT::Solver", "internal");
 	_config->Set("edsp::scenario", "stdin");
 	int input = STDIN_FILENO;

test/integration/framework

@@ -1296,7 +1296,7 @@ testdpkgstatus() {
 	local PKGS="$(dpkg -l "$@" 2>/dev/null | grep "^${STATE}" | wc -l)"
 	if [ "$PKGS" != $NR ]; then
 		echo >&2 $PKGS
-		dpkg -l "$@" | grep '^[a-z]' >&2
+		dpkg -l "$@" | grep '^[a-z]' >&2 || true
 		msgfail
 	else
 		msgpass

test/integration/test-apt-get-install-deb

@@ -22,9 +22,9 @@ E: Couldn't find any package by regex './foo.rpm'" aptget install -qq ./foo.rpm
 mv foo.rpm foo.deb
 testfailure aptget install ./foo.deb
 testsuccess grep '^E: Sub-process Popen returned an error code' rootdir/tmp/testfailure.output
-testequal 'E: Encountered a section with no Package: header
-E: Problem with MergeLister for ./foo.deb
-E: The package lists or status file could not be parsed or opened.' tail -n 3 rootdir/tmp/testfailure.output
+testequal "E: Encountered a section with no Package: header
+E: Problem with MergeList ${TMPWORKINGDIRECTORY}/foo.deb
+E: The package lists or status file could not be parsed or opened." tail -n 3 rootdir/tmp/testfailure.output
 
 # fakeroot is currently not found, framwork needs updating
 buildsimplenativepackage 'foo' 'i386,amd64' '1.0'
@@ -45,7 +45,7 @@ The following packages have unmet dependencies:
 E: Unable to correct problems, you have held broken packages." aptget install ./incoming/foo_1.0_i386.deb ./incoming/foo_1.0_amd64.deb -s -q=0
 
 testdpkgnotinstalled 'foo'
-testsuccess aptget install ./incoming/foo_1.0_i386.deb
+testsuccess aptget install ./incoming/foo_1.0_i386.deb -o Debug::pkgCacheGen=1
 testdpkginstalled 'foo'
 
 testsuccessequal "Reading package lists...
@@ -58,5 +58,5 @@ The following NEW packages will be installed:
   foo
 0 upgraded, 1 newly installed, 1 to remove and 0 not upgraded.
 Remv foo:i386 [1.0]
-Inst foo (1.0 now [amd64])
-Conf foo (1.0 now [amd64])" aptget install ./incoming/foo_1.0_amd64.deb -s -q=0
+Inst foo (1.0 local-deb [amd64])
+Conf foo (1.0 local-deb [amd64])" aptget install ./incoming/foo_1.0_amd64.deb -s -q=0