implement indextargets option 'DefaultEnabled'

[apt.git] / apt-pkg / deb / debmetaindex.cc

diff --git a/apt-pkg/deb/debmetaindex.cc b/apt-pkg/deb/debmetaindex.cc
index 00dc1eeec24581925e28d814c7c3cdb7a727f06d..08d8ef05e795c671645ec485f328214dfc59c966 100644 (file)
--- a/apt-pkg/deb/debmetaindex.cc
+++ b/apt-pkg/deb/debmetaindex.cc
@@ -145,6 +145,7 @@ static void GetIndexTargetsFor(char const * const Type, std::string const &URI,
         std::string const tplLongDesc = "$(SITE) " + APT_T_CONFIG_STR(flatArchive ? "flatDescription" : "Description", "");
         bool const IsOptional = APT_T_CONFIG_BOOL("Optional", true);
         bool const KeepCompressed = APT_T_CONFIG_BOOL("KeepCompressed", GzipIndex);
         std::string const tplLongDesc = "$(SITE) " + APT_T_CONFIG_STR(flatArchive ? "flatDescription" : "Description", "");
         bool const IsOptional = APT_T_CONFIG_BOOL("Optional", true);
         bool const KeepCompressed = APT_T_CONFIG_BOOL("KeepCompressed", GzipIndex);

+        bool const DefaultEnabled = APT_T_CONFIG_BOOL("DefaultEnabled", true);

         bool const UsePDiffs = APT_T_CONFIG_BOOL("PDiffs", E->UsePDiffs);
         std::string const CompressionTypes = APT_T_CONFIG_STR("CompressionTypes", DefCompressionTypes);
 #undef APT_T_CONFIG_BOOL
         bool const UsePDiffs = APT_T_CONFIG_BOOL("PDiffs", E->UsePDiffs);
         std::string const CompressionTypes = APT_T_CONFIG_STR("CompressionTypes", DefCompressionTypes);
 #undef APT_T_CONFIG_BOOL


@@ -185,10 +186,8 @@ static void GetIndexTargetsFor(char const * const Type, std::string const &URI,
               Options.insert(std::make_pair("REPO_URI", URI));
               Options.insert(std::make_pair("TARGET_OF", Type));
               Options.insert(std::make_pair("CREATED_BY", *T));
               Options.insert(std::make_pair("REPO_URI", URI));
               Options.insert(std::make_pair("TARGET_OF", Type));
               Options.insert(std::make_pair("CREATED_BY", *T));

-              if (UsePDiffs)
-                 Options.insert(std::make_pair("PDIFFS", "yes"));
-              else
-                 Options.insert(std::make_pair("PDIFFS", "no"));
+              Options.insert(std::make_pair("PDIFFS", UsePDiffs ? "yes" : "no"));
+              Options.insert(std::make_pair("DEFAULTENABLED", DefaultEnabled ? "yes" : "no"));

               Options.insert(std::make_pair("COMPRESSIONTYPES", CompressionTypes));
 
               IndexTarget Target(
               Options.insert(std::make_pair("COMPRESSIONTYPES", CompressionTypes));
 
               IndexTarget Target(


@@ -446,10 +445,8 @@ bool debReleaseIndex::GetIndexes(pkgAcquire *Owner, bool const &GetAll)/*{{{*/
 #undef APT_TARGET
    // special case for --print-uris
    if (GetAll)
 #undef APT_TARGET
    // special case for --print-uris
    if (GetAll)

-   {
-      for (std::vector<IndexTarget>::const_iterator Target = targets.begin(); Target != targets.end(); ++Target)
-        new pkgAcqIndex(Owner, TransactionManager, *Target);
-   }
+      for (auto const &Target: targets)
+        new pkgAcqIndex(Owner, TransactionManager, Target);

 
    return true;
 }
 
    return true;
 }


@@ -537,17 +534,16 @@ std::vector <pkgIndexFile *> *debReleaseIndex::GetIndexFiles()            /*{{{*/
       return Indexes;
 
    Indexes = new std::vector<pkgIndexFile*>();
       return Indexes;
 
    Indexes = new std::vector<pkgIndexFile*>();

-   std::vector<IndexTarget> const Targets = GetIndexTargets();

    bool const istrusted = IsTrusted();
    bool const istrusted = IsTrusted();

-   for (std::vector<IndexTarget>::const_iterator T = Targets.begin(); T != Targets.end(); ++T)
+   for (auto const &T: GetIndexTargets())

    {
    {

-      std::string const TargetName = T->Option(IndexTarget::CREATED_BY);
+      std::string const TargetName = T.Option(IndexTarget::CREATED_BY);

       if (TargetName == "Packages")
       if (TargetName == "Packages")

-        Indexes->push_back(new debPackagesIndex(*T, istrusted));
+        Indexes->push_back(new debPackagesIndex(T, istrusted));

       else if (TargetName == "Sources")
       else if (TargetName == "Sources")

-        Indexes->push_back(new debSourcesIndex(*T, istrusted));
+        Indexes->push_back(new debSourcesIndex(T, istrusted));

       else if (TargetName == "Translations")
       else if (TargetName == "Translations")

-        Indexes->push_back(new debTranslationsIndex(*T));
+        Indexes->push_back(new debTranslationsIndex(T));

    }
    return Indexes;
 }
    }
    return Indexes;
 }


@@ -673,20 +669,17 @@ static std::vector<std::string> parsePlusMinusOptions(std::string const &Name, /
 
    if ((val = Options.find(Name + "+")) != Options.end())
    {
 
    if ((val = Options.find(Name + "+")) != Options.end())
    {

-      std::vector<std::string> const plusArch = VectorizeString(val->second, ',');
-      for (std::vector<std::string>::const_iterator plus = plusArch.begin(); plus != plusArch.end(); ++plus)
-        if (std::find(Values.begin(), Values.end(), *plus) == Values.end())
-           Values.push_back(*plus);
+      std::vector<std::string> const plus = VectorizeString(val->second, ',');
+      std::copy_if(plus.begin(), plus.end(), std::back_inserter(Values), [&Values](std::string const &v) {
+        return std::find(Values.begin(), Values.end(), v) == Values.end();
+      });

    }
    if ((val = Options.find(Name + "-")) != Options.end())
    {
    }
    if ((val = Options.find(Name + "-")) != Options.end())
    {

-      std::vector<std::string> const minusArch = VectorizeString(val->second, ',');
-      for (std::vector<std::string>::const_iterator minus = minusArch.begin(); minus != minusArch.end(); ++minus)
-      {
-        std::vector<std::string>::iterator kill = std::find(Values.begin(), Values.end(), *minus);
-        if (kill != Values.end())
-           Values.erase(kill);
-      }
+      std::vector<std::string> const minus = VectorizeString(val->second, ',');
+      Values.erase(std::remove_if(Values.begin(), Values.end(), [&minus](std::string const &v) {
+        return std::find(minus.begin(), minus.end(), v) != minus.end();
+      }), Values.end());

    }
    return Values;
 }
    }
    return Values;
 }


@@ -742,26 +735,34 @@ class APT_HIDDEN debSLTypeDebian : public pkgSourceList::Type             /*{{{*/
       }
 
       std::vector<std::string> const alltargets = _config->FindVector(std::string("Acquire::IndexTargets::") + Name, "", true);
       }
 
       std::vector<std::string> const alltargets = _config->FindVector(std::string("Acquire::IndexTargets::") + Name, "", true);

-      std::vector<std::string> mytargets = parsePlusMinusOptions("target", Options, alltargets);
-      if (mytargets.empty() == false)
-        for (auto const &target : alltargets)
-        {
-           std::map<std::string, std::string>::const_iterator const opt = Options.find(target);
-           if (opt == Options.end())
-              continue;
-           auto const tarItr = std::find(mytargets.begin(), mytargets.end(), target);
-           bool const optValue = StringToBool(opt->second);
-           if (optValue == true && tarItr == mytargets.end())
-              mytargets.push_back(target);
-           else if (optValue == false && tarItr != mytargets.end())
-              mytargets.erase(std::remove(mytargets.begin(), mytargets.end(), target), mytargets.end());
-        }
+      std::vector<std::string> deftargets;
+      deftargets.reserve(alltargets.size());
+      std::copy_if(alltargets.begin(), alltargets.end(), std::back_inserter(deftargets), [&](std::string const &t) {
+        std::string c = "Acquire::IndexTargets::";
+        c.append(Name).append("::").append(t).append("::DefaultEnabled");
+        return _config->FindB(c, true);
+      });
+      std::vector<std::string> mytargets = parsePlusMinusOptions("target", Options, deftargets);
+      for (auto const &target : alltargets)
+      {
+        std::map<std::string, std::string>::const_iterator const opt = Options.find(target);
+        if (opt == Options.end())
+           continue;
+        auto const tarItr = std::find(mytargets.begin(), mytargets.end(), target);
+        bool const optValue = StringToBool(opt->second);
+        if (optValue == true && tarItr == mytargets.end())
+           mytargets.push_back(target);
+        else if (optValue == false && tarItr != mytargets.end())
+           mytargets.erase(std::remove(mytargets.begin(), mytargets.end(), target), mytargets.end());
+      }
+

       bool UsePDiffs = _config->FindB("Acquire::PDiffs", true);
       {
         std::map<std::string, std::string>::const_iterator const opt = Options.find("pdiffs");
         if (opt != Options.end())
            UsePDiffs = StringToBool(opt->second);
       }
       bool UsePDiffs = _config->FindB("Acquire::PDiffs", true);
       {
         std::map<std::string, std::string>::const_iterator const opt = Options.find("pdiffs");
         if (opt != Options.end())
            UsePDiffs = StringToBool(opt->second);
       }

+

       Deb->AddComponent(
            IsSrc,
            Section,
       Deb->AddComponent(
            IsSrc,
            Section,