tests: try to support spaces in TMPDIR

[apt.git] / apt-pkg / metaindex.cc

diff --git a/apt-pkg/metaindex.cc b/apt-pkg/metaindex.cc
index 2292ac3889fb72a38d5a900281637bf5534b87aa..5c095a2ad2a6d2c820cbe7d9f50ac4b6dbaef413 100644 (file)
--- a/apt-pkg/metaindex.cc
+++ b/apt-pkg/metaindex.cc
@@ -1,44 +1,102 @@
+// Include Files                                                       /*{{{*/
+#include <apt-pkg/pkgcachegen.h>
+#include <apt-pkg/indexfile.h>
+#include <apt-pkg/metaindex.h>
 
-#include <apt-pkg/strutl.h>
+#include <string>
+#include <vector>
+                                                                       /*}}}*/
 
-#include "init.h"
-#include "metaindex.h"
+std::string metaIndex::Describe() const
+{
+   return "Release";
+}
 
+pkgCache::RlsFileIterator metaIndex::FindInCache(pkgCache &Cache, bool const) const
+{
+   return pkgCache::RlsFileIterator(Cache);
+}
 
-#if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
-string metaIndex::MetaIndexInfo(const char *Type) const
+bool metaIndex::Merge(pkgCacheGenerator &Gen,OpProgress *) const
 {
-   string Info = ::URI::SiteOnly(URI) + ' ';
-   if (Dist[Dist.size() - 1] == '/')
-   {
-      if (Dist != "/")
-        Info += Dist;
-   }
-   else
-      Info += Dist;
-   Info += " ";
-   Info += Type;
-   return Info;
+   return Gen.SelectReleaseFile("", "");
 }
 
-string metaIndex::MetaIndexFile(const char *Type) const
+metaIndex::metaIndex(std::string const &URI, std::string const &Dist,
+      char const * const Type)
+: d(NULL), Indexes(NULL), Type(Type), URI(URI), Dist(Dist), Trusted(TRI_UNSET),
+   Date(0), ValidUntil(0), SupportsAcquireByHash(false), LoadedSuccessfully(TRI_UNSET)
 {
-   return _config->FindDir("Dir::State::lists") +
-      URItoFileName(MetaIndexURI(Type));
+   /* nothing */
 }
 
-string metaIndex::MetaIndexURI(const char *Type) const
+metaIndex::~metaIndex()
 {
-   string Res;
+   if (Indexes != 0)
+   {
+      for (std::vector<pkgIndexFile *>::iterator I = (*Indexes).begin();
+           I != (*Indexes).end(); ++I)
+        delete *I;
+      delete Indexes;
+   }
+   for (auto const &E: Entries)
+      delete E.second;
+}
 
-   if (Dist == "/")
-      Res = URI;
-   else if (Dist[Dist.size()-1] == '/')
-      Res = URI + Dist;
-   else
-      Res = URI + "dists/" + Dist + "/";
-   
-   Res += Type;
-   return Res;
+// one line Getters for public fields                                  /*{{{*/
+APT_PURE std::string metaIndex::GetURI() const { return URI; }
+APT_PURE std::string metaIndex::GetDist() const { return Dist; }
+APT_PURE const char* metaIndex::GetType() const { return Type; }
+APT_PURE metaIndex::TriState metaIndex::GetTrusted() const { return Trusted; }
+APT_PURE std::string metaIndex::GetSignedBy() const { return SignedBy; }
+APT_PURE std::string metaIndex::GetCodename() const { return Codename; }
+APT_PURE std::string metaIndex::GetSuite() const { return Suite; }
+APT_PURE bool metaIndex::GetSupportsAcquireByHash() const { return SupportsAcquireByHash; }
+APT_PURE time_t metaIndex::GetValidUntil() const { return ValidUntil; }
+APT_PURE time_t metaIndex::GetDate() const { return this->Date; }
+APT_PURE metaIndex::TriState metaIndex::GetLoadedSuccessfully() const { return LoadedSuccessfully; }
+
+APT_PURE bool metaIndex::CheckDist(string const &MaybeDist) const
+{
+   return (this->Codename == MaybeDist
+          || this->Suite == MaybeDist);
+}
+APT_PURE std::string metaIndex::GetExpectedDist() const
+{
+   // TODO: Used to be an explicit value set in the constructor
+   return "";
+}
+                                                                       /*}}}*/
+APT_PURE metaIndex::checkSum *metaIndex::Lookup(string const &MetaKey) const /*{{{*/
+{
+   std::map<std::string, metaIndex::checkSum* >::const_iterator sum = Entries.find(MetaKey);
+   if (sum == Entries.end())
+      return NULL;
+   return sum->second;
+}
+                                                                       /*}}}*/
+APT_PURE bool metaIndex::Exists(string const &MetaKey) const           /*{{{*/
+{
+   return Entries.find(MetaKey) != Entries.end();
+}
+                                                                       /*}}}*/
+std::vector<std::string> metaIndex::MetaKeys() const                   /*{{{*/
+{
+   std::vector<std::string> keys;
+   std::map<string,checkSum *>::const_iterator I = Entries.begin();
+   while(I != Entries.end()) {
+      keys.push_back((*I).first);
+      ++I;
+   }
+   return keys;
+}
+                                                                       /*}}}*/
+void metaIndex::swapLoad(metaIndex * const OldMetaIndex)               /*{{{*/
+{
+   std::swap(Entries, OldMetaIndex->Entries);
+   std::swap(Date, OldMetaIndex->Date);
+   std::swap(ValidUntil, OldMetaIndex->ValidUntil);
+   std::swap(SupportsAcquireByHash, OldMetaIndex->SupportsAcquireByHash);
+   std::swap(LoadedSuccessfully, OldMetaIndex->LoadedSuccessfully);
 }
-#endif
+                                                                       /*}}}*/