for (auto& -> for (const auto&

lubynets · lubynets · commit 22712e8925fa · 2025-06-12T13:40:57.000+02:00
diff --git a/core/BranchConfig.hpp b/core/BranchConfig.hpp
@@ -113,7 +113,7 @@ class BranchConfig : public VectorConfig<int>, public VectorConfig<float>, publi
   }
   template<typename T>
   void AddFields(const std::vector<std::string>& names, const std::string& title = "") {
-    for (auto& n : names) {
+    for (const auto& n : names) {
       GuaranteeFieldNameVacancy(n);
     }
     VectorConfig<T>::AddFields(names, title);
@@ -127,7 +127,7 @@ class BranchConfig : public VectorConfig<int>, public VectorConfig<float>, publi
   void RemoveField(const std::string& name);
 
   void RemoveFields(const std::vector<std::string>& names) {
-    for (auto& n : names) {
+    for (const auto& n : names) {
       RemoveField(n);
     }
   }
diff --git a/core/Configuration.cpp b/core/Configuration.cpp
@@ -65,7 +65,7 @@ BranchConfig& Configuration::GetBranchConfig(const std::string& name) {
 }
 
 const BranchConfig& Configuration::GetBranchConfig(const std::string& name) const {
-  for (auto& branch : branches_) {
+  for (const auto& branch : branches_) {
     if (branch.second.GetName() == name)
       return branch.second;
   }
@@ -187,7 +187,7 @@ void Configuration::RemoveBranchConfig(const std::string& branchname) {
 
 std::vector<std::string> Configuration::GetMatchesOfBranch(const std::string& branchname) const {
   std::vector<std::string> matches{};
-  for (auto& ma : matches_) {
+  for (const auto& ma : matches_) {
     if (ma.GetFirstBranchName() == branchname || ma.GetSecondBranchName() == branchname)
       matches.emplace_back(ma.GetDataBranchName());
   }
diff --git a/core/Configuration.hpp b/core/Configuration.hpp
@@ -102,7 +102,7 @@ class Configuration : public TObject {
 
   static MatchingIndex MakeMatchingIndex(const std::vector<MatchingConfig>& matches) {
     MatchingIndex result;
-    for (auto& match : matches) {
+    for (const auto& match : matches) {
       std::array<std::string, 2> map_key{match.GetFirstBranchName(), match.GetSecondBranchName()};
       auto emplace_result = result.emplace(map_key, match.GetDataBranchName());
       if (!emplace_result.second) {
@@ -114,7 +114,7 @@ class Configuration : public TObject {
 
   static std::vector<MatchingConfig> MakeMatchConfigsFromIndex(const MatchingIndex& matching_index) {
     std::vector<MatchingConfig> result;
-    for (auto& matching_index_element : matching_index) {
+    for (const auto& matching_index_element : matching_index) {
       result.emplace_back(matching_index_element.first[0],
                           matching_index_element.first[1],
                           matching_index_element.second);
@@ -130,10 +130,10 @@ class Configuration : public TObject {
     * @param other
     */
   void Merge(const Configuration& other) {
-    for (auto& other_branch : other.branches_) {
+    for (const auto& other_branch : other.branches_) {
       const auto other_id = other_branch.second.GetId();
       const auto other_name = other_branch.second.GetName();
-      for (auto& local_branch : branches_) {
+      for (const auto& local_branch : branches_) {
         if (other_id == local_branch.second.GetId()) {
           throw std::runtime_error("Configurations contain branches with the same id-s");
         }
diff --git a/infra/AnalysisEntry.cpp b/infra/AnalysisEntry.cpp
@@ -9,7 +9,7 @@
 namespace AnalysisTree {
 
 AnalysisEntry::~AnalysisEntry() {
-  for (auto& br : branches_) {
+  for (const auto& br : branches_) {
     delete br.first;
   }
 }
@@ -45,7 +45,7 @@ bool AnalysisEntry::ApplyCutOnBranches(std::vector<const Branch*>& br, std::vect
     id_vec.emplace_back(br.at(i)->GetId());
   }
   bool result = ok && (!cuts_ || cuts_->Apply(bch_vec, id_vec));
-  for (auto& bv : bch_vec) {
+  for (const auto& bv : bch_vec) {
     delete bv;
   }
   return result;
@@ -77,7 +77,7 @@ double AnalysisEntry::FillVariable(const Variable& var, std::vector<const Branch
     id_vec.emplace_back(br.at(i)->GetId());
   }
   double result = var.GetValue(bch_vec, id_vec);
-  for (auto& bv : bch_vec) {
+  for (const auto& bv : bch_vec) {
     delete bv;
   }
   return result;
@@ -116,7 +116,7 @@ void AnalysisEntry::FillFromEveHeaders() {
   br_vec.reserve(branches_.size());
   cuts_vec.reserve(branches_.size());
   id_vec.reserve(branches_.size());
-  for (auto& br : branches_) {
+  for (const auto& br : branches_) {
     br_vec.emplace_back(br.first);
     cuts_vec.emplace_back(br.second);
     id_vec.emplace_back(0);
@@ -154,7 +154,7 @@ void AnalysisEntry::FillFromOneChannalizedBranch() {
     br_vec.emplace_back(br.first);
     cuts_vec.emplace_back(br.second);
   }
-  for (auto& ehi : eve_header_indices_) {
+  for (const auto& ehi : eve_header_indices_) {
     id_vec.at(ehi) = 0;
   }
 
@@ -195,7 +195,7 @@ void AnalysisEntry::FillFromTwoChannalizedBranches() {
     br_vec.emplace_back(br.first);
     cuts_vec.emplace_back(br.second);
   }
-  for (auto& ehi : eve_header_indices_) {
+  for (const auto& ehi : eve_header_indices_) {
     id_vec.at(ehi) = 0;
   }
 
@@ -216,7 +216,7 @@ void AnalysisEntry::FillFromTwoChannalizedBranches() {
 }
 
 void AnalysisEntry::FillBranchNames() {
-  for (auto& var : vars_) {
+  for (const auto& var : vars_) {
     const auto& br = var.GetBranches();
     branch_names_.insert(br.begin(), br.end());
   }
@@ -236,7 +236,7 @@ void AnalysisEntry::Init(const Configuration& conf, const std::map<std::string,
   var4weight_.Init(conf);
 
   int i{0};
-  for (auto& bn : branch_names_) {
+  for (const auto& bn : branch_names_) {
     if (conf.GetBranchConfig(bn).GetType() == DetType::kEventHeader) {
       eve_header_indices_.push_back(i);
     } else {
diff --git a/infra/AnalysisTask.test.cpp b/infra/AnalysisTask.test.cpp
@@ -61,8 +61,8 @@ class AnalysisTaskTest : public AnalysisTask {
   void Finish() override {
     AnalysisTask::Finish();
 
-    for (auto& entry : entries_test_) {
-      for (auto& var : entry) {
+    for (const auto& entry : entries_test_) {
+      for (const auto& var : entry) {
         var.mean_ /= var.n_entries_;
         var.sigma_ /= var.n_entries_;
       }
diff --git a/infra/Branch.cpp b/infra/Branch.cpp
@@ -107,7 +107,7 @@ void Branch::ClearChannels() {
 
 void Branch::CloneVariables(const AnalysisTree::BranchConfig& other) {
   auto import_fields_from_map = [this](const std::map<std::string, ConfigElement>& map, AnalysisTree::Types type) {
-    for (auto& element : map) {
+    for (const auto& element : map) {
       auto field_name = element.first;
       if (config_.HasField(field_name)) {
         std::cout << "Field '" << field_name << "' already exists" << std::endl;
@@ -190,7 +190,7 @@ void Branch::CreateMapping(const Branch* other, std::string branch_name_prefix)
 
   std::cout << "New cached mapping " << other->config_.GetName() << " --> " << config_.GetName() << std::endl;
   FieldsMapping fields_mapping;
-  for (auto& field_name_other : other->GetFieldNames()) {
+  for (const auto& field_name_other : other->GetFieldNames()) {
     std::string field_name_target = branch_name_prefix + field_name_other;
     if (!config_.HasField(field_name_target)) { continue; }
     fields_mapping.field_pairs.emplace_back(other->GetField(field_name_other), GetField(field_name_target));
@@ -208,7 +208,7 @@ void Branch::UpdateConfigHash() {
 std::vector<std::string> Branch::GetFieldNames() const {
   std::vector<std::string> result;
   auto fill_vector_from_map = [&result](const std::map<std::string, ConfigElement>& fields_map) -> void {
-    for (auto& element : fields_map) {
+    for (const auto& element : fields_map) {
       result.push_back(element.first);
     }
   };
diff --git a/infra/BranchChannel.cpp b/infra/BranchChannel.cpp
@@ -35,7 +35,7 @@ void BranchChannel::CopyContent(const BranchChannel& other, std::string branch_n
   /* Eval mapping */
   const auto& field_pairs = mapping_it->second.field_pairs;
 
-  for (auto& field_pair /* src : dst */ : field_pairs) {
+  for (const auto& field_pair /* src : dst */ : field_pairs) {
     this->SetValue(field_pair.second, other.Value(field_pair.first));
   }
 }
diff --git a/infra/BranchHashHelper.hpp b/infra/BranchHashHelper.hpp
@@ -19,7 +19,7 @@ inline std::size_t BranchConfigHasher(const AnalysisTree::BranchConfig& config)
   hash_combine(hash, static_cast<AnalysisTree::ShortInt_t>(config.GetType()));
 
   auto hash_fields = [&hash](const std::map<std::string, AnalysisTree::ConfigElement>& fields_map, Type field_type) {
-    for (auto& field : fields_map) {
+    for (const auto& field : fields_map) {
       hash_combine(hash, field.first, field.second.id_, static_cast<AnalysisTree::ShortInt_t>(field_type));
     }
   };
diff --git a/infra/Chain.cpp b/infra/Chain.cpp
@@ -113,7 +113,7 @@ void Chain::InitPointersToBranches(std::set<std::string> names) {
     if (CheckBranchExistence(branch.first) == 1)
       ANALYSISTREE_UTILS_VISIT(set_branch_address_struct(this, branch.first), branch.second);
     else if (CheckBranchExistence(branch.first) == 2)
-      ANALYSISTREE_UTILS_VISIT(set_branch_address_struct(this, (branch.first + ".").c_str()), branch.second);
+      ANALYSISTREE_UTILS_VISIT(set_branch_address_struct(this, branch.first + "."), branch.second);
     else
       throw std::runtime_error("AnalysisTree::InitPointersToBranches - Branch " + branch.first + " does not exist");
   }
@@ -225,7 +225,7 @@ std::vector<TChain*> Chain::GetTChains() {
 int Chain::CheckBranchExistence(const std::string& branchname) {
   auto v_chains = this->GetTChains();
 
-  for (auto& ch : v_chains) {
+  for (const auto& ch : v_chains) {
     auto* lob = ch->GetListOfBranches();
     const int Nbranches = lob->GetEntries();
     for (int i = 0; i < Nbranches; i++) {
diff --git a/infra/Cuts.cpp b/infra/Cuts.cpp
@@ -83,7 +83,7 @@ void Cuts::AddCut(const SimpleCut& cut) {
 }
 
 void Cuts::AddCuts(const std::vector<SimpleCut>& cuts) {
-  for (auto& cut : cuts) {
+  for (const auto& cut : cuts) {
     AddCut(cut);
   }
 }
diff --git a/infra/PlainTreeFiller.cpp b/infra/PlainTreeFiller.cpp
@@ -19,7 +19,7 @@ void PlainTreeFiller::SetFieldsToIgnore(const std::vector<std::string>& fields_t
   if (branch_name_.empty()) {
     throw std::runtime_error("PlainTreeFiller::SetFieldsToIgnore() must be called after PlainTreeFiller::AddBranch()\n");
   }
-  for (auto& fti : fields_to_ignore) {
+  for (const auto& fti : fields_to_ignore) {
     fields_to_ignore_.emplace_back((branch_name_ + "." + fti).c_str());
   }
 }
@@ -28,7 +28,7 @@ void PlainTreeFiller::SetFieldsToPreserve(const std::vector<std::string>& fields
   if (branch_name_.empty()) {
     throw std::runtime_error("PlainTreeFiller::SetFieldsToPreserve() must be called after PlainTreeFiller::AddBranch()\n");
   }
-  for (auto& fti : fields_to_preserve) {
+  for (const auto& fti : fields_to_preserve) {
     fields_to_preserve_.emplace_back((branch_name_ + "." + fti).c_str());
   }
 }
@@ -68,8 +68,8 @@ void PlainTreeFiller::Init() {
     auto mapF = config_->GetBranchConfig(branch_name_).GetMap<float>();
     auto mapI = config_->GetBranchConfig(branch_name_).GetMap<int>();
     auto mapB = config_->GetBranchConfig(branch_name_).GetMap<bool>();
-    for (auto& m : {mapF, mapI, mapB}) {
-      for (auto& me : m) {
+    for (const auto& m : {mapF, mapI, mapB}) {
+      for (const auto& me : m) {
         if (me.second.id_ < 0) defaultFieldsNames.emplace_back(me.first);
       }
     }
@@ -133,7 +133,7 @@ void PlainTreeFiller::Init() {
       plain_tree_->Branch(leaf_name.c_str(), &vars_.at(iLeaf).bool_, Form("%s/O", leaf_name.c_str()));
   }
 
-  for (auto& cm : cuts_map_) {
+  for (const auto& cm : cuts_map_) {
     if (cm.second != nullptr) {
       cm.second->Init(*(TaskManager::GetInstance()->GetChain()->GetConfiguration()));
     }
diff --git a/infra/SimpleCut.hpp b/infra/SimpleCut.hpp
@@ -46,7 +46,7 @@ class SimpleCut {
 
   SimpleCut(const std::vector<Variable>& vars, std::function<bool(std::vector<double>&)> lambda, std::string title = "") : title_(std::move(title)),
                                                                                                                            lambda_(std::move(lambda)) {
-    for (auto& var : vars) {
+    for (const auto& var : vars) {
       vars_.emplace_back(var);
     }
     FillBranchNames();
diff --git a/infra/TaskManager.cpp b/infra/TaskManager.cpp
@@ -74,12 +74,12 @@ void TaskManager::InitOutChain() {
     assert(configuration_ && data_header_ && chain_);// input should exist
     configuration_ = chain_->CloneConfiguration();
     *(data_header_) = *(chain_->GetDataHeader());
-    for (auto& brex : branches_exclude_) {
+    for (const auto& brex : branches_exclude_) {
       if (chain_->CheckBranchExistence(brex) == 1) {
         throw std::runtime_error("AnalysisTree::TaskManager::InitOutChain - Tree in the input file does not support selective cloning");
       }
       chain_->SetBranchStatus((brex + ".*").c_str(), false);
-      for (auto& maex : configuration_->GetMatchesOfBranch(brex)) {
+      for (const auto& maex : configuration_->GetMatchesOfBranch(brex)) {
         chain_->SetBranchStatus((maex + ".*").c_str(), false);
       }
       configuration_->RemoveBranchConfig(brex);

Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ class BranchConfig : public VectorConfig<int>, public VectorConfig<float>, publi`
`113`	`113`	`}`
`114`	`114`	`template<typename T>`
`115`	`115`	`void AddFields(const std::vector<std::string>& names, const std::string& title = "") {`
`116`		`- for (auto& n : names) {`
	`116`	`+ for (const auto& n : names) {`
`117`	`117`	`GuaranteeFieldNameVacancy(n);`
`118`	`118`	`}`
`119`	`119`	`VectorConfig<T>::AddFields(names, title);`
`@@ -127,7 +127,7 @@ class BranchConfig : public VectorConfig<int>, public VectorConfig<float>, publi`
`127`	`127`	`void RemoveField(const std::string& name);`
`128`	`128`
`129`	`129`	`void RemoveFields(const std::vector<std::string>& names) {`
`130`		`- for (auto& n : names) {`
	`130`	`+ for (const auto& n : names) {`
`131`	`131`	`RemoveField(n);`
`132`	`132`	`}`
`133`	`133`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ BranchConfig& Configuration::GetBranchConfig(const std::string& name) {`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`const BranchConfig& Configuration::GetBranchConfig(const std::string& name) const {`
`68`		`- for (auto& branch : branches_) {`
	`68`	`+ for (const auto& branch : branches_) {`
`69`	`69`	`if (branch.second.GetName() == name)`
`70`	`70`	`return branch.second;`
`71`	`71`	`}`
`@@ -187,7 +187,7 @@ void Configuration::RemoveBranchConfig(const std::string& branchname) {`
`187`	`187`
`188`	`188`	`std::vector<std::string> Configuration::GetMatchesOfBranch(const std::string& branchname) const {`
`189`	`189`	`std::vector<std::string> matches{};`
`190`		`- for (auto& ma : matches_) {`
	`190`	`+ for (const auto& ma : matches_) {`
`191`	`191`	`if (ma.GetFirstBranchName() == branchname \|\| ma.GetSecondBranchName() == branchname)`
`192`	`192`	`matches.emplace_back(ma.GetDataBranchName());`
`193`	`193`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`	`namespace AnalysisTree {`
`10`	`10`
`11`	`11`	`AnalysisEntry::~AnalysisEntry() {`
`12`		`- for (auto& br : branches_) {`
	`12`	`+ for (const auto& br : branches_) {`
`13`	`13`	`delete br.first;`
`14`	`14`	`}`
`15`	`15`	`}`
`@@ -45,7 +45,7 @@ bool AnalysisEntry::ApplyCutOnBranches(std::vector<const Branch*>& br, std::vect`
`45`	`45`	`id_vec.emplace_back(br.at(i)->GetId());`
`46`	`46`	`}`
`47`	`47`	`bool result = ok && (!cuts_ \|\| cuts_->Apply(bch_vec, id_vec));`
`48`		`- for (auto& bv : bch_vec) {`
	`48`	`+ for (const auto& bv : bch_vec) {`
`49`	`49`	`delete bv;`
`50`	`50`	`}`
`51`	`51`	`return result;`
`@@ -77,7 +77,7 @@ double AnalysisEntry::FillVariable(const Variable& var, std::vector<const Branch`
`77`	`77`	`id_vec.emplace_back(br.at(i)->GetId());`
`78`	`78`	`}`
`79`	`79`	`double result = var.GetValue(bch_vec, id_vec);`
`80`		`- for (auto& bv : bch_vec) {`
	`80`	`+ for (const auto& bv : bch_vec) {`
`81`	`81`	`delete bv;`
`82`	`82`	`}`
`83`	`83`	`return result;`
`@@ -116,7 +116,7 @@ void AnalysisEntry::FillFromEveHeaders() {`
`116`	`116`	`br_vec.reserve(branches_.size());`
`117`	`117`	`cuts_vec.reserve(branches_.size());`
`118`	`118`	`id_vec.reserve(branches_.size());`
`119`		`- for (auto& br : branches_) {`
	`119`	`+ for (const auto& br : branches_) {`
`120`	`120`	`br_vec.emplace_back(br.first);`
`121`	`121`	`cuts_vec.emplace_back(br.second);`
`122`	`122`	`id_vec.emplace_back(0);`
`@@ -154,7 +154,7 @@ void AnalysisEntry::FillFromOneChannalizedBranch() {`
`154`	`154`	`br_vec.emplace_back(br.first);`
`155`	`155`	`cuts_vec.emplace_back(br.second);`
`156`	`156`	`}`
`157`		`- for (auto& ehi : eve_header_indices_) {`
	`157`	`+ for (const auto& ehi : eve_header_indices_) {`
`158`	`158`	`id_vec.at(ehi) = 0;`
`159`	`159`	`}`
`160`	`160`
`@@ -195,7 +195,7 @@ void AnalysisEntry::FillFromTwoChannalizedBranches() {`
`195`	`195`	`br_vec.emplace_back(br.first);`
`196`	`196`	`cuts_vec.emplace_back(br.second);`
`197`	`197`	`}`
`198`		`- for (auto& ehi : eve_header_indices_) {`
	`198`	`+ for (const auto& ehi : eve_header_indices_) {`
`199`	`199`	`id_vec.at(ehi) = 0;`
`200`	`200`	`}`
`201`	`201`
`@@ -216,7 +216,7 @@ void AnalysisEntry::FillFromTwoChannalizedBranches() {`
`216`	`216`	`}`
`217`	`217`
`218`	`218`	`void AnalysisEntry::FillBranchNames() {`
`219`		`- for (auto& var : vars_) {`
	`219`	`+ for (const auto& var : vars_) {`
`220`	`220`	`const auto& br = var.GetBranches();`
`221`	`221`	`branch_names_.insert(br.begin(), br.end());`
`222`	`222`	`}`
`@@ -236,7 +236,7 @@ void AnalysisEntry::Init(const Configuration& conf, const std::map<std::string,`
`236`	`236`	`var4weight_.Init(conf);`
`237`	`237`
`238`	`238`	`int i{0};`
`239`		`- for (auto& bn : branch_names_) {`
	`239`	`+ for (const auto& bn : branch_names_) {`
`240`	`240`	`if (conf.GetBranchConfig(bn).GetType() == DetType::kEventHeader) {`
`241`	`241`	`eve_header_indices_.push_back(i);`
`242`	`242`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ void BranchChannel::CopyContent(const BranchChannel& other, std::string branch_n`
`35`	`35`	`/* Eval mapping */`
`36`	`36`	`const auto& field_pairs = mapping_it->second.field_pairs;`
`37`	`37`
`38`		`- for (auto& field_pair /* src : dst */ : field_pairs) {`
	`38`	`+ for (const auto& field_pair /* src : dst */ : field_pairs) {`
`39`	`39`	`this->SetValue(field_pair.second, other.Value(field_pair.first));`
`40`	`40`	`}`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ inline std::size_t BranchConfigHasher(const AnalysisTree::BranchConfig& config)`
`19`	`19`	`hash_combine(hash, static_cast<AnalysisTree::ShortInt_t>(config.GetType()));`
`20`	`20`
`21`	`21`	`auto hash_fields = [&hash](const std::map<std::string, AnalysisTree::ConfigElement>& fields_map, Type field_type) {`
`22`		`- for (auto& field : fields_map) {`
	`22`	`+ for (const auto& field : fields_map) {`
`23`	`23`	`hash_combine(hash, field.first, field.second.id_, static_cast<AnalysisTree::ShortInt_t>(field_type));`
`24`	`24`	`}`
`25`	`25`	`};`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ void Cuts::AddCut(const SimpleCut& cut) {`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`void Cuts::AddCuts(const std::vector<SimpleCut>& cuts) {`
`86`		`- for (auto& cut : cuts) {`
	`86`	`+ for (const auto& cut : cuts) {`
`87`	`87`	`AddCut(cut);`
`88`	`88`	`}`
`89`	`89`	`}`