Merge topic 'delete-algorithm'

65b81da4 cmVariableWatch: Use the cmDeleteAll algorithm with for_each.
30d2de9a cmGeneratorExpressionEvaluator: Replace own algorithm with cmDeleteAll.
4a6e795b Use the cmDeleteAll algorithm instead of trivial raw loops.
abb4a678 Add a generic algorithm for deleting items in a container.

Source/CPack/cmCPackGeneratorFactory.cxx

@@ -158,11 +158,7 @@ cmCPackGeneratorFactory::cmCPackGeneratorFactory()
 //----------------------------------------------------------------------
 cmCPackGeneratorFactory::~cmCPackGeneratorFactory()
 {
-  std::vector<cmCPackGenerator*>::iterator it;
-  for ( it = this->Generators.begin(); it != this->Generators.end(); ++ it )
-    {
-    delete *it;
-    }
+  cmDeleteAll(this->Generators);
 }
 
 //----------------------------------------------------------------------

Source/CursesDialog/cmCursesMainForm.cxx

@@ -69,11 +69,7 @@ cmCursesMainForm::~cmCursesMainForm()
   // Clean-up composites
   if (this->Entries)
     {
-    std::vector<cmCursesCacheEntryComposite*>::iterator it;
-    for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
-      {
-      delete *it;
-      }
+    cmDeleteAll(*this->Entries);
     }
   delete this->Entries;
   if (this->CMakeInstance)
@@ -188,12 +184,7 @@ void cmCursesMainForm::InitializeUI()
   // Clean old entries
   if (this->Entries)
     {
-    // Have to call delete on each pointer
-    std::vector<cmCursesCacheEntryComposite*>::iterator it;
-    for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
-      {
-      delete *it;
-      }
+    cmDeleteAll(*this->Entries);
     }
   delete this->Entries;
   this->Entries = newEntries;

Source/cmCTest.cxx

@@ -378,13 +378,7 @@ cmCTest::cmCTest()
 //----------------------------------------------------------------------
 cmCTest::~cmCTest()
 {
-  cmCTest::t_TestingHandlers::iterator it;
-  for ( it = this->TestingHandlers.begin();
-    it != this->TestingHandlers.end(); ++ it )
-    {
-    delete it->second;
-    it->second = 0;
-    }
+  cmDeleteAll(this->TestingHandlers);
   this->SetOutputLogFileName(0);
 }
 

Source/cmComputeLinkDepends.cxx

@@ -200,12 +200,7 @@ cmComputeLinkDepends
 //----------------------------------------------------------------------------
 cmComputeLinkDepends::~cmComputeLinkDepends()
 {
-  for(std::vector<DependSetList*>::iterator
-        i = this->InferredDependSets.begin();
-      i != this->InferredDependSets.end(); ++i)
-    {
-    delete *i;
-    }
+  cmDeleteAll(this->InferredDependSets);
   delete this->CCG;
 }
 

Source/cmDependsC.cxx

@@ -90,12 +90,7 @@ cmDependsC::cmDependsC(cmLocalGenerator* lg,
 cmDependsC::~cmDependsC()
 {
   this->WriteCacheFile();
-
-  for (std::map<std::string, cmIncludeLines*>::iterator it=
-         this->FileCache.begin(); it!=this->FileCache.end(); ++it)
-    {
-    delete it->second;
-    }
+  cmDeleteAll(this->FileCache);
 }
 
 //----------------------------------------------------------------------------

Source/cmDocumentation.cxx

@@ -87,12 +87,7 @@ cmDocumentation::cmDocumentation()
 //----------------------------------------------------------------------------
 cmDocumentation::~cmDocumentation()
 {
-  for(std::map<std::string,cmDocumentationSection *>::iterator i =
-        this->AllSections.begin();
-      i != this->AllSections.end(); ++i)
-    {
-    delete i->second;
-    }
+  cmDeleteAll(this->AllSections);
 }
 
 //----------------------------------------------------------------------------

Source/cmExportSet.cxx

@@ -15,10 +15,7 @@
 
 cmExportSet::~cmExportSet()
 {
-  for(unsigned int i = 0; i < this->TargetExports.size(); ++ i)
-    {
-    delete this->TargetExports[i];
-    }
+  cmDeleteAll(this->TargetExports);
 }
 
 void cmExportSet::AddTargetExport(cmTargetExport* te)

Source/cmFileLockPool.cxx

@@ -23,16 +23,8 @@ cmFileLockPool::cmFileLockPool()
 
 cmFileLockPool::~cmFileLockPool()
 {
-  for (It i = this->FunctionScopes.begin();
-      i != this->FunctionScopes.end(); ++i)
-    {
-    delete *i;
-    }
-
-  for (It i = this->FileScopes.begin(); i != this->FileScopes.end(); ++i)
-    {
-    delete *i;
-    }
+  cmDeleteAll(this->FunctionScopes);
+  cmDeleteAll(this->FileScopes);
 }
 
 void cmFileLockPool::PushFunctionScope()
@@ -148,10 +140,7 @@ cmFileLockPool::ScopePool::ScopePool()
 
 cmFileLockPool::ScopePool::~ScopePool()
 {
-  for (It i = this->Locks.begin(); i != this->Locks.end(); ++i)
-    {
-    delete *i;
-    }
+  cmDeleteAll(this->Locks);
 }
 
 cmFileLockResult cmFileLockPool::ScopePool::Lock(

Source/cmGeneratorExpression.cxx

@@ -150,15 +150,7 @@ cmCompiledGeneratorExpression::cmCompiledGeneratorExpression(
 //----------------------------------------------------------------------------
 cmCompiledGeneratorExpression::~cmCompiledGeneratorExpression()
 {
-  std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it
-                                                  = this->Evaluators.begin();
-  const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator end
-                                                  = this->Evaluators.end();
-
-  for ( ; it != end; ++it)
-    {
-    delete *it;
-    }
+  cmDeleteAll(this->Evaluators);
 }
 
 //----------------------------------------------------------------------------

Source/cmGeneratorExpressionEvaluator.cxx

@@ -2051,31 +2051,10 @@ std::string GeneratorExpressionContent::EvaluateParameters(
   return std::string();
 }
 
-//----------------------------------------------------------------------------
-static void deleteAll(const std::vector<cmGeneratorExpressionEvaluator*> &c)
-{
-  std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it
-                                                  = c.begin();
-  const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator end
-                                                  = c.end();
-  for ( ; it != end; ++it)
-    {
-    delete *it;
-    }
-}
-
 //----------------------------------------------------------------------------
 GeneratorExpressionContent::~GeneratorExpressionContent()
 {
-  deleteAll(this->IdentifierChildren);
-
-  typedef std::vector<cmGeneratorExpressionEvaluator*> EvaluatorVector;
-  std::vector<EvaluatorVector>::const_iterator pit =
-                                                  this->ParamChildren.begin();
-  const std::vector<EvaluatorVector>::const_iterator pend =
-                                                  this->ParamChildren.end();
-  for ( ; pit != pend; ++pit)
-    {
-    deleteAll(*pit);
-    }
+  cmDeleteAll(this->IdentifierChildren);
+  std::for_each(this->ParamChildren.begin(), this->ParamChildren.end(),
+                cmDeleteAll<std::vector<cmGeneratorExpressionEvaluator*> >);
 }

Source/cmGlobalGenerator.cxx

@@ -1517,27 +1517,13 @@ void cmGlobalGenerator::ClearGeneratorMembers()
     }
   this->GeneratorTargets.clear();
 
-  for(std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator
-      li = this->EvaluationFiles.begin();
-      li != this->EvaluationFiles.end();
-      ++li)
-    {
-    delete *li;
-    }
+  cmDeleteAll(this->EvaluationFiles);
   this->EvaluationFiles.clear();
 
-  for(std::map<std::string, cmExportBuildFileGenerator*>::iterator
-        i = this->BuildExportSets.begin();
-      i != this->BuildExportSets.end(); ++i)
-    {
-    delete i->second;
-    }
+  cmDeleteAll(this->BuildExportSets);
   this->BuildExportSets.clear();
 
-  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
-    {
-    delete this->LocalGenerators[i];
-    }
+  cmDeleteAll(this->LocalGenerators);
   this->LocalGenerators.clear();
 
   this->ExportSets.clear();

Source/cmInstalledFile.h

@@ -38,11 +38,7 @@ public:
 
     ~Property()
     {
-      for(ExpressionVectorType::iterator i = ValueExpressions.begin();
-        i != ValueExpressions.end(); ++i)
-        {
-        delete *i;
-        }
+      cmDeleteAll(this->ValueExpressions);
     }
 
     ExpressionVectorType ValueExpressions;

Source/cmMakeDepend.cxx

@@ -34,12 +34,7 @@ cmMakeDepend::cmMakeDepend()
 
 cmMakeDepend::~cmMakeDepend()
 {
-  for(DependInformationMapType::iterator i =
-        this->DependInformationMap.begin();
-      i != this->DependInformationMap.end(); ++i)
-    {
-    delete i->second;
-    }
+  cmDeleteAll(this->DependInformationMap);
 }
 
 

Source/cmMakefile.cxx

@@ -194,45 +194,13 @@ bool cmMakefile::NeedCacheCompatibility(int major, int minor) const
 
 cmMakefile::~cmMakefile()
 {
-  for(std::vector<cmInstallGenerator*>::iterator
-        i = this->InstallGenerators.begin();
-      i != this->InstallGenerators.end(); ++i)
-    {
-    delete *i;
-    }
-  for(std::vector<cmTestGenerator*>::iterator
-        i = this->TestGenerators.begin();
-      i != this->TestGenerators.end(); ++i)
-    {
-    delete *i;
-    }
-  for(std::vector<cmSourceFile*>::iterator i = this->SourceFiles.begin();
-      i != this->SourceFiles.end(); ++i)
-    {
-    delete *i;
-    }
-  for(std::map<std::string, cmTest*>::iterator i = this->Tests.begin();
-      i != this->Tests.end(); ++i)
-    {
-    delete i->second;
-    }
-  for(std::vector<cmTarget*>::iterator
-        i = this->ImportedTargetsOwned.begin();
-      i != this->ImportedTargetsOwned.end(); ++i)
-    {
-    delete *i;
-    }
-  for(unsigned int i=0; i < this->FinalPassCommands.size(); i++)
-    {
-    delete this->FinalPassCommands[i];
-    }
-  std::vector<cmFunctionBlocker*>::iterator pos;
-  for (pos = this->FunctionBlockers.begin();
-       pos != this->FunctionBlockers.end(); ++pos)
-    {
-    cmFunctionBlocker* b = *pos;
-    delete b;
-    }
+  cmDeleteAll(this->InstallGenerators);
+  cmDeleteAll(this->TestGenerators);
+  cmDeleteAll(this->SourceFiles);
+  cmDeleteAll(this->Tests);
+  cmDeleteAll(this->ImportedTargetsOwned);
+  cmDeleteAll(this->FinalPassCommands);
+  cmDeleteAll(this->FunctionBlockers);
   this->FunctionBlockers.clear();
   if (this->PolicyStack.size() != 1)
   {

Source/cmOrderDirectories.cxx

@@ -291,18 +291,8 @@ cmOrderDirectories::cmOrderDirectories(cmGlobalGenerator* gg,
 //----------------------------------------------------------------------------
 cmOrderDirectories::~cmOrderDirectories()
 {
-  for(std::vector<cmOrderDirectoriesConstraint*>::iterator
-        i = this->ConstraintEntries.begin();
-      i != this->ConstraintEntries.end(); ++i)
-    {
-    delete *i;
-    }
-  for(std::vector<cmOrderDirectoriesConstraint*>::iterator
-        i = this->ImplicitDirEntries.begin();
-      i != this->ImplicitDirEntries.end(); ++i)
-    {
-    delete *i;
-    }
+  cmDeleteAll(this->ConstraintEntries);
+  cmDeleteAll(this->ImplicitDirEntries);
 }
 
 //----------------------------------------------------------------------------

Source/cmPolicies.cxx

@@ -378,13 +378,7 @@ cmPolicies::cmPolicies()
 
 cmPolicies::~cmPolicies()
 {
-  // free the policies
-  std::map<cmPolicies::PolicyID,cmPolicy *>::iterator i
-    = this->Policies.begin();
-  for (;i != this->Policies.end(); ++i)
-    {
-    delete i->second;
-    }
+  cmDeleteAll(this->Policies);
 }
 
 void cmPolicies::DefinePolicy(cmPolicies::PolicyID iD,

Source/cmStandardIncludes.h

@@ -237,4 +237,31 @@ private:
   const std::string m_test;
 };
 
+namespace ContainerAlgorithms {
+
+template<typename Container>
+struct DefaultDeleter
+{
+  void operator()(typename Container::value_type value) {
+    delete value;
+  }
+};
+
+template<typename K, typename V>
+struct DefaultDeleter<std::map<K, V> >
+{
+  void operator()(typename std::map<K, V>::value_type value) {
+    delete value.second;
+  }
+};
+
+}
+
+template<typename Container>
+void cmDeleteAll(Container const& c)
+{
+  std::for_each(c.begin(), c.end(),
+                ContainerAlgorithms::DefaultDeleter<Container>());
+}
+
 #endif

Source/cmTarget.cxx

@@ -226,13 +226,7 @@ cmLinkImplItem cmTargetInternals::TargetPropertyEntry::NoLinkImplItem;
 static void deleteAndClear(
       std::vector<cmTargetInternals::TargetPropertyEntry*> &entries)
 {
-  for (std::vector<cmTargetInternals::TargetPropertyEntry*>::const_iterator
-      it = entries.begin(),
-      end = entries.end();
-      it != end; ++it)
-    {
-      delete *it;
-    }
+  cmDeleteAll(entries);
   entries.clear();
 }
 

Source/cmVariableWatch.cxx

@@ -34,21 +34,16 @@ cmVariableWatch::cmVariableWatch()
 {
 }
 
+template<typename C>
+void deleteAllSecond(typename C::value_type it)
+{
+  cmDeleteAll(it.second);
+}
+
 cmVariableWatch::~cmVariableWatch()
 {
-  cmVariableWatch::StringToVectorOfPairs::iterator svp_it;
-
-  for ( svp_it = this->WatchMap.begin();
-        svp_it != this->WatchMap.end(); ++svp_it )
-    {
-    cmVariableWatch::VectorOfPairs::iterator p_it;
-
-    for ( p_it = svp_it->second.begin();
-          p_it != svp_it->second.end(); ++p_it )
-      {
-      delete *p_it;
-      }
-    }
+  std::for_each(this->WatchMap.begin(), this->WatchMap.end(),
+                deleteAllSecond<cmVariableWatch::StringToVectorOfPairs>);
 }
 
 bool cmVariableWatch::AddWatch(const std::string& variable,

Source/cmake.cxx

@@ -171,16 +171,8 @@ cmake::~cmake()
     delete this->GlobalGenerator;
     this->GlobalGenerator = 0;
     }
-  for(RegisteredCommandsMap::iterator j = this->Commands.begin();
-      j != this->Commands.end(); ++j)
-    {
-    delete (*j).second;
-    }
-  for(RegisteredGeneratorsVector::iterator j = this->Generators.begin();
-      j != this->Generators.end(); ++j)
-    {
-    delete *j;
-    }
+  cmDeleteAll(this->Commands);
+  cmDeleteAll(this->Generators);
 #ifdef CMAKE_BUILD_WITH_CMAKE
   delete this->VariableWatch;
 #endif