delay build-dep variable initialisation until needed

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

diff --git a/apt-pkg/pkgcachegen.cc b/apt-pkg/pkgcachegen.cc
index 02ec39e0cbbd0a78d80b4bcd3c57554da66c9e5c..a26237296045d9eb4ca97f485f0e680d0a8cde87 100644 (file)
--- a/apt-pkg/pkgcachegen.cc
+++ b/apt-pkg/pkgcachegen.cc
@@ -49,6 +49,7 @@ static bool IsDuplicateDescription(pkgCache::DescIterator Desc,
                            MD5SumValue const &CurMd5, std::string const &CurLang);
 
 using std::string;
                            MD5SumValue const &CurMd5, std::string const &CurLang);
 
 using std::string;

+using APT::StringView;

 
 // CacheGenerator::pkgCacheGenerator - Constructor                     /*{{{*/
 // ---------------------------------------------------------------------
 
 // CacheGenerator::pkgCacheGenerator - Constructor                     /*{{{*/
 // ---------------------------------------------------------------------


@@ -307,8 +308,6 @@ bool pkgCacheGenerator::MergeListPackage(ListParser &List, pkgCache::PkgIterator
 
    // Find the right version to write the description
    MD5SumValue CurMd5 = List.Description_md5();
 
    // Find the right version to write the description
    MD5SumValue CurMd5 = List.Description_md5();

-   if (CurMd5.Value().empty() == true && List.Description("").empty() == true)
-      return true;

    std::vector<std::string> availDesc = List.AvailableDescriptionLanguages();
    for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
    {
    std::vector<std::string> availDesc = List.AvailableDescriptionLanguages();
    for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
    {


@@ -443,8 +442,6 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
 
    /* Record the Description(s) based on their master md5sum */
    MD5SumValue CurMd5 = List.Description_md5();
 
    /* Record the Description(s) based on their master md5sum */
    MD5SumValue CurMd5 = List.Description_md5();

-   if (CurMd5.Value().empty() == true && List.Description("").empty() == true)
-      return true;

 
    /* Before we add a new description we first search in the group for
       a version with a description of the same MD5 - if so we reuse this
 
    /* Before we add a new description we first search in the group for
       a version with a description of the same MD5 - if so we reuse this


@@ -501,7 +498,7 @@ bool pkgCacheGenerator::AddNewDescription(ListParser &List, pkgCache::VerIterato
 // CacheGenerator::NewGroup - Add a new group                          /*{{{*/
 // ---------------------------------------------------------------------
 /* This creates a new group structure and adds it to the hash table */
 // CacheGenerator::NewGroup - Add a new group                          /*{{{*/
 // ---------------------------------------------------------------------
 /* This creates a new group structure and adds it to the hash table */

-bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name)
+bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, StringView Name)

 {
    Grp = Cache.FindGrp(Name);
    if (Grp.end() == false)
 {
    Grp = Cache.FindGrp(Name);
    if (Grp.end() == false)


@@ -521,7 +518,8 @@ bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name)
    // Insert it into the hash table
    unsigned long const Hash = Cache.Hash(Name);
    map_pointer_t *insertAt = &Cache.HeaderP->GrpHashTableP()[Hash];
    // Insert it into the hash table
    unsigned long const Hash = Cache.Hash(Name);
    map_pointer_t *insertAt = &Cache.HeaderP->GrpHashTableP()[Hash];

-   while (*insertAt != 0 && strcasecmp(Name.c_str(), Cache.StrP + (Cache.GrpP + *insertAt)->Name) > 0)
+
+   while (*insertAt != 0 && Name.compare(Cache.ViewString((Cache.GrpP + *insertAt)->Name)) > 0)

       insertAt = &(Cache.GrpP + *insertAt)->Next;
    Grp->Next = *insertAt;
    *insertAt = Group;
       insertAt = &(Cache.GrpP + *insertAt)->Next;
    Grp->Next = *insertAt;
    *insertAt = Group;


@@ -533,8 +531,8 @@ bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name)
 // CacheGenerator::NewPackage - Add a new package                      /*{{{*/
 // ---------------------------------------------------------------------
 /* This creates a new package structure and adds it to the hash table */
 // CacheGenerator::NewPackage - Add a new package                      /*{{{*/
 // ---------------------------------------------------------------------
 /* This creates a new package structure and adds it to the hash table */

-bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name,
-                                       const string &Arch) {
+bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg, StringView Name,
+                                       StringView Arch) {

    pkgCache::GrpIterator Grp;
    Dynamic<pkgCache::GrpIterator> DynGrp(Grp);
    if (unlikely(NewGroup(Grp, Name) == false))
    pkgCache::GrpIterator Grp;
    Dynamic<pkgCache::GrpIterator> DynGrp(Grp);
    if (unlikely(NewGroup(Grp, Name) == false))


@@ -567,7 +565,7 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
       // Insert it into the hash table
       map_id_t const Hash = Cache.Hash(Name);
       map_pointer_t *insertAt = &Cache.HeaderP->PkgHashTableP()[Hash];
       // Insert it into the hash table
       map_id_t const Hash = Cache.Hash(Name);
       map_pointer_t *insertAt = &Cache.HeaderP->PkgHashTableP()[Hash];

-      while (*insertAt != 0 && strcasecmp(Name.c_str(), Cache.StrP + (Cache.GrpP + (Cache.PkgP + *insertAt)->Group)->Name) > 0)
+      while (*insertAt != 0 && Name.compare(Cache.StrP + (Cache.GrpP + (Cache.PkgP + *insertAt)->Group)->Name) > 0)

         insertAt = &(Cache.PkgP + *insertAt)->NextPackage;
       Pkg->NextPackage = *insertAt;
       *insertAt = Package;
         insertAt = &(Cache.PkgP + *insertAt)->NextPackage;
       Pkg->NextPackage = *insertAt;
       *insertAt = Package;


@@ -640,8 +638,8 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
    if (Arch == "any")
    {
       size_t const found = Name.find(':');
    if (Arch == "any")
    {
       size_t const found = Name.find(':');

-      std::string const NameA = Name.substr(0, found);
-      std::string const ArchA = Name.substr(found + 1);
+      StringView const NameA = Name.substr(0, found);
+      StringView const ArchA = Name.substr(found + 1);

       pkgCache::PkgIterator PkgA = Cache.FindPkg(NameA, ArchA);
       if (PkgA.end() == false)
       {
       pkgCache::PkgIterator PkgA = Cache.FindPkg(NameA, ArchA);
       if (PkgA.end() == false)
       {


@@ -997,9 +995,9 @@ 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 pkgCacheListParser::NewDepends(pkgCache::VerIterator &Ver,
 /* This creates a Group and the Package to link this dependency to if
    needed and handles also the caching of the old endpoint */
 bool pkgCacheListParser::NewDepends(pkgCache::VerIterator &Ver,

-                                              const string &PackageName,
-                                              const string &Arch,
-                                              const string &Version,
+                                              StringView PackageName,
+                                              StringView Arch,
+                                              StringView Version,

                                               uint8_t const Op,
                                               uint8_t const Type)
 {
                                               uint8_t const Op,
                                               uint8_t const Type)
 {


@@ -1013,7 +1011,7 @@ bool pkgCacheListParser::NewDepends(pkgCache::VerIterator &Ver,
    {
       int const CmpOp = Op & 0x0F;
       // =-deps are used (79:1) for lockstep on same-source packages (e.g. data-packages)
    {
       int const CmpOp = Op & 0x0F;
       // =-deps are used (79:1) for lockstep on same-source packages (e.g. data-packages)

-      if (CmpOp == pkgCache::Dep::Equals && strcmp(Version.c_str(), Ver.VerStr()) == 0)
+      if (CmpOp == pkgCache::Dep::Equals && Version == Ver.VerStr())

         idxVersion = Ver->VerStr;
 
       if (idxVersion == 0)
         idxVersion = Ver->VerStr;
 
       if (idxVersion == 0)


@@ -1066,9 +1064,9 @@ bool pkgCacheListParser::NewDepends(pkgCache::VerIterator &Ver,
                                                                        /*}}}*/
 // ListParser::NewProvides - Create a Provides element                 /*{{{*/
 bool pkgCacheListParser::NewProvides(pkgCache::VerIterator &Ver,
                                                                        /*}}}*/
 // ListParser::NewProvides - Create a Provides element                 /*{{{*/
 bool pkgCacheListParser::NewProvides(pkgCache::VerIterator &Ver,

-                                               const string &PkgName,
-                                               const string &PkgArch,
-                                               const string &Version,
+                                               StringView PkgName,
+                                               StringView PkgArch,
+                                               StringView Version,

                                                uint8_t const Flags)
 {
    pkgCache const &Cache = Owner->Cache;
                                                uint8_t const Flags)
 {
    pkgCache const &Cache = Owner->Cache;


@@ -1120,8 +1118,8 @@ bool pkgCacheGenerator::NewProvides(pkgCache::VerIterator &Ver,
 }
                                                                        /*}}}*/
 // ListParser::NewProvidesAllArch - add provides for all architectures /*{{{*/
 }
                                                                        /*}}}*/
 // ListParser::NewProvidesAllArch - add provides for all architectures /*{{{*/

-bool pkgCacheListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, string const &Package,
-                               string const &Version, uint8_t const Flags) {
+bool pkgCacheListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, StringView Package,
+                               StringView Version, uint8_t const Flags) {

    pkgCache &Cache = Owner->Cache;
    pkgCache::GrpIterator Grp = Cache.FindGrp(Package);
    Dynamic<pkgCache::GrpIterator> DynGrp(Grp);
    pkgCache &Cache = Owner->Cache;
    pkgCache::GrpIterator Grp = Cache.FindGrp(Package);
    Dynamic<pkgCache::GrpIterator> DynGrp(Grp);


@@ -1256,23 +1254,21 @@ bool pkgCacheGenerator::SelectFile(std::string const &File,
 map_stringitem_t pkgCacheGenerator::StoreString(enum StringType const type, const char *S,
                                                 unsigned int Size)
 {
 map_stringitem_t pkgCacheGenerator::StoreString(enum StringType const type, const char *S,
                                                 unsigned int Size)
 {

-   std::string const key(S, Size);
-
-   std::unordered_map<std::string,map_stringitem_t> * strings;
+   auto strings = &strMixed;

    switch(type) {
       case MIXED: strings = &strMixed; break;
       case PKGNAME: strings = &strPkgNames; break;
       case VERSIONNUMBER: strings = &strVersions; break;
       case SECTION: strings = &strSections; break;
    switch(type) {
       case MIXED: strings = &strMixed; break;
       case PKGNAME: strings = &strPkgNames; break;
       case VERSIONNUMBER: strings = &strVersions; break;
       case SECTION: strings = &strSections; break;

-      default: _error->Fatal("Unknown enum type used for string storage of '%s'", key.c_str()); return 0;
+      default: _error->Fatal("Unknown enum type used for string storage of '%.*s'", Size, S); return 0;

    }
 
    }
 

-   std::unordered_map<std::string,map_stringitem_t>::const_iterator const item = strings->find(key);
+   auto const item = strings->find({S, Size, nullptr, 0});

    if (item != strings->end())
    if (item != strings->end())

-      return item->second;
+      return item->item;

 
    map_stringitem_t const idxString = WriteStringInMap(S,Size);
 
    map_stringitem_t const idxString = WriteStringInMap(S,Size);

-   strings->insert(std::make_pair(key, idxString));
+   strings->insert({nullptr, Size, this, idxString});

    return idxString;
 }
                                                                        /*}}}*/
    return idxString;
 }
                                                                        /*}}}*/