use references instead of copies in the Cache generation methods

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

diff --git a/apt-pkg/pkgcachegen.cc b/apt-pkg/pkgcachegen.cc
index 5649cd6f8c41c67b6654d65d67a6dbbddcf99dbb..62e4577347d3716e3595fea1068d33679e6190ad 100644 (file)
--- a/apt-pkg/pkgcachegen.cc
+++ b/apt-pkg/pkgcachegen.cc
@@ -61,8 +61,8 @@ pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) :
 
       // Starting header
       *Cache.HeaderP = pkgCache::Header();
-      Cache.HeaderP->VerSysName = Map.WriteString(_system->VS->Label);
-      Cache.HeaderP->Architecture = Map.WriteString(_config->Find("APT::Architecture"));
+      Cache.HeaderP->VerSysName = WriteStringInMap(_system->VS->Label);
+      Cache.HeaderP->Architecture = WriteStringInMap(_config->Find("APT::Architecture"));
       Cache.ReMap();
    }
    else
@@ -96,6 +96,21 @@ pkgCacheGenerator::~pkgCacheGenerator()
    Map.Sync(0,sizeof(pkgCache::Header));
 }
                                                                        /*}}}*/
+// CacheGenerator::WriteStringInMap                                    /*{{{*/
+unsigned long pkgCacheGenerator::WriteStringInMap(const char *String,
+                                       const unsigned long &Len) {
+   return Map.WriteString(String, Len);
+}
+                                                                       /*}}}*/
+// CacheGenerator::WriteStringInMap                                    /*{{{*/
+unsigned long pkgCacheGenerator::WriteStringInMap(const char *String) {
+   return Map.WriteString(String);
+}
+                                                                       /*}}}*/
+unsigned long pkgCacheGenerator::AllocateInMap(const unsigned long &size) {/*{{{*/
+   return Map.Allocate(size);
+}
+                                                                       /*}}}*/
 // CacheGenerator::MergeList - Merge the package list                  /*{{{*/
 // ---------------------------------------------------------------------
 /* This provides the generation of the entries in the cache. Each loop
@@ -142,13 +157,14 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
         // we first process the package, then the descriptions
         // (this has the bonus that we get MMap error when we run out
         //  of MMap space)
-        if (List.UsePackage(Pkg,pkgCache::VerIterator(Cache)) == false)
+        pkgCache::VerIterator Ver(Cache);
+        if (List.UsePackage(Pkg, Ver) == false)
            return _error->Error(_("Error occurred while processing %s (UsePackage1)"),
                                 PackageName.c_str());
 
         // Find the right version to write the description
         MD5SumValue CurMd5 = List.Description_md5();
-        pkgCache::VerIterator Ver = Pkg.VersionList();
+        Ver = Pkg.VersionList();
         map_ptrloc *LastVer = &Pkg->VersionList;
 
         for (; Ver.end() == false; LastVer = &Ver->NextVer, Ver++)
@@ -342,12 +358,12 @@ bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name)
       return true;
 
    // Get a structure
-   unsigned long const Group = Map.Allocate(sizeof(pkgCache::Group));
+   unsigned long const Group = AllocateInMap(sizeof(pkgCache::Group));
    if (unlikely(Group == 0))
       return false;
 
    Grp = pkgCache::GrpIterator(Cache, Cache.GrpP + Group);
-   Grp->Name = Map.WriteString(Name);
+   Grp->Name = WriteStringInMap(Name);
    if (unlikely(Grp->Name == 0))
       return false;
 
@@ -374,7 +390,7 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
         return true;
 
    // Get a structure
-   unsigned long const Package = Map.Allocate(sizeof(pkgCache::Package));
+   unsigned long const Package = AllocateInMap(sizeof(pkgCache::Package));
    if (unlikely(Package == 0))
       return false;
    Pkg = pkgCache::PkgIterator(Cache,Cache.PkgP + Package);
@@ -418,7 +434,7 @@ bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver,
       return true;
    
    // Get a structure
-   unsigned long VerFile = Map.Allocate(sizeof(pkgCache::VerFile));
+   unsigned long VerFile = AllocateInMap(sizeof(pkgCache::VerFile));
    if (VerFile == 0)
       return 0;
    
@@ -449,7 +465,7 @@ unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
                                            unsigned long Next)
 {
    // Get a structure
-   unsigned long Version = Map.Allocate(sizeof(pkgCache::Version));
+   unsigned long Version = AllocateInMap(sizeof(pkgCache::Version));
    if (Version == 0)
       return 0;
    
@@ -457,7 +473,7 @@ unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
    Ver = pkgCache::VerIterator(Cache,Cache.VerP + Version);
    Ver->NextVer = Next;
    Ver->ID = Cache.HeaderP->VersionCount++;
-   Ver->VerStr = Map.WriteString(VerStr);
+   Ver->VerStr = WriteStringInMap(VerStr);
    if (Ver->VerStr == 0)
       return 0;
    
@@ -474,7 +490,7 @@ bool pkgCacheGenerator::NewFileDesc(pkgCache::DescIterator &Desc,
       return true;
    
    // Get a structure
-   unsigned long DescFile = Map.Allocate(sizeof(pkgCache::DescFile));
+   unsigned long DescFile = AllocateInMap(sizeof(pkgCache::DescFile));
    if (DescFile == 0)
       return false;
 
@@ -507,7 +523,7 @@ map_ptrloc pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
                                            map_ptrloc Next)
 {
    // Get a structure
-   map_ptrloc Description = Map.Allocate(sizeof(pkgCache::Description));
+   map_ptrloc Description = AllocateInMap(sizeof(pkgCache::Description));
    if (Description == 0)
       return 0;
 
@@ -515,8 +531,8 @@ map_ptrloc pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
    Desc = pkgCache::DescIterator(Cache,Cache.DescP + Description);
    Desc->NextDesc = Next;
    Desc->ID = Cache.HeaderP->DescriptionCount++;
-   Desc->language_code = Map.WriteString(Lang);
-   Desc->md5sum = Map.WriteString(md5sum.Value());
+   Desc->language_code = WriteStringInMap(Lang);
+   Desc->md5sum = WriteStringInMap(md5sum.Value());
    if (Desc->language_code == 0 || Desc->md5sum == 0)
       return 0;
 
@@ -572,10 +588,7 @@ bool pkgCacheGenerator::FinishCache(OpProgress *Progress)
                                OldDepLast);
                     // Breaks: ${self}:other (!= ${binary:Version})
                     NewDepends(D, V, V.VerStr(),
-                               pkgCache::Dep::Less, pkgCache::Dep::DpkgBreaks,
-                               OldDepLast);
-                    NewDepends(D, V, V.VerStr(),
-                               pkgCache::Dep::Greater, pkgCache::Dep::DpkgBreaks,
+                               pkgCache::Dep::NotEquals, pkgCache::Dep::DpkgBreaks,
                                OldDepLast);
                     if (V->MultiArch == pkgCache::Version::All)
                     {
@@ -610,7 +623,7 @@ bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
                                   map_ptrloc *OldDepLast)
 {
    // Get a structure
-   unsigned long const Dependency = Map.Allocate(sizeof(pkgCache::Dependency));
+   unsigned long const Dependency = AllocateInMap(sizeof(pkgCache::Dependency));
    if (unlikely(Dependency == 0))
       return false;
    
@@ -628,7 +641,7 @@ bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
         if (I->Version != 0 && I.TargetVer() == Version)
            Dep->Version = I->Version;*/
       if (Dep->Version == 0)
-        if (unlikely((Dep->Version = Map.WriteString(Version)) == 0))
+        if (unlikely((Dep->Version = WriteStringInMap(Version)) == 0))
            return false;
    }
 
@@ -656,7 +669,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 pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator &Ver,
                                               const string &PackageName,
                                               const string &Arch,
                                               const string &Version,
@@ -690,7 +703,7 @@ bool pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator Ver,
 // ListParser::NewProvides - Create a Provides element                 /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator Ver,
+bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator &Ver,
                                                const string &PkgName,
                                                const string &PkgArch,
                                                const string &Version)
@@ -702,7 +715,7 @@ bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator Ver,
       return true;
    
    // Get a structure
-   unsigned long const Provides = Owner->Map.Allocate(sizeof(pkgCache::Provides));
+   unsigned long const Provides = Owner->AllocateInMap(sizeof(pkgCache::Provides));
    if (unlikely(Provides == 0))
       return false;
    Cache.HeaderP->ProvidesCount++;
@@ -737,12 +750,12 @@ bool pkgCacheGenerator::SelectFile(const string &File,const string &Site,
                                   unsigned long Flags)
 {
    // Get some space for the structure
-   CurrentFile = Cache.PkgFileP + Map.Allocate(sizeof(*CurrentFile));
+   CurrentFile = Cache.PkgFileP + AllocateInMap(sizeof(*CurrentFile));
    if (CurrentFile == Cache.PkgFileP)
       return false;
    
    // Fill it in
-   CurrentFile->FileName = Map.WriteString(File);
+   CurrentFile->FileName = WriteStringInMap(File);
    CurrentFile->Site = WriteUniqString(Site);
    CurrentFile->NextFile = Cache.HeaderP->FileList;
    CurrentFile->Flags = Flags;
@@ -794,7 +807,7 @@ unsigned long pkgCacheGenerator::WriteUniqString(const char *S,
    }
    
    // Get a structure
-   unsigned long Item = Map.Allocate(sizeof(pkgCache::StringItem));
+   unsigned long Item = AllocateInMap(sizeof(pkgCache::StringItem));
    if (Item == 0)
       return 0;
 
@@ -802,7 +815,7 @@ unsigned long pkgCacheGenerator::WriteUniqString(const char *S,
    pkgCache::StringItem *ItemP = Cache.StringItemP + Item;
    ItemP->NextItem = I - Cache.StringItemP;
    *Last = Item;
-   ItemP->String = Map.WriteString(S,Size);
+   ItemP->String = WriteStringInMap(S,Size);
    if (ItemP->String == 0)
       return 0;