ENH: shorten the symbols a bit and remove maps of std::string for map of cmStdString

Source/cmCTest.h

@@ -206,7 +206,7 @@ private:
   };
   
   //! Map of configuration properties
-  typedef std::map<std::string, std::string> tm_DartConfigurationMap;
+  typedef std::map<cmStdString, cmStdString> tm_DartConfigurationMap;
 
   std::string             m_ToplevelPath;
   tm_DartConfigurationMap m_DartConfiguration;

Source/cmCacheManager.cxx

@@ -74,7 +74,7 @@ bool cmCacheManager::LoadCache(const char* path)
 bool cmCacheManager::LoadCache(const char* path,
                                bool internal)
 {
-  std::set<std::string> emptySet;
+  std::set<cmStdString> emptySet;
   return this->LoadCache(path, internal, emptySet, emptySet);
 }
 
@@ -155,8 +155,8 @@ bool cmCacheManager::ParseEntry(const char* entry,
 
 bool cmCacheManager::LoadCache(const char* path,
                                bool internal,
-                               std::set<std::string>& excludes,
-                               std::set<std::string>& includes)
+                               std::set<cmStdString>& excludes,
+                               std::set<cmStdString>& includes)
 {
   std::string cacheFile = path;
   cacheFile += "/CMakeCache.txt";

Source/cmCacheManager.h

@@ -103,8 +103,8 @@ public:
   bool LoadCache(const char* path);
   bool LoadCache(const char* path, bool internal);
   bool LoadCache(const char* path, bool internal, 
-                 std::set<std::string>& excludes,
-                 std::set<std::string>& includes);
+                 std::set<cmStdString>& excludes,
+                 std::set<cmStdString>& includes);
 
   ///! Save cache for given makefile.  Saves to ouput home CMakeCache.txt.
   bool SaveCache(cmMakefile*) ;

Source/cmDynamicLoader.cxx

@@ -36,7 +36,7 @@ public:
   static cmDynamicLoaderCache* GetInstance();
 
 private:
-  std::map<std::string, cmLibHandle> m_CacheMap;
+  std::map<cmStdString, cmLibHandle> m_CacheMap;
   static cmDynamicLoaderCache* Instance;
 };
 
@@ -58,7 +58,7 @@ void cmDynamicLoaderCache::CacheFile(const char* path, const cmLibHandle& p)
 
 bool cmDynamicLoaderCache::GetCacheFile(const char* path, cmLibHandle& p)
 {
-  std::map<std::string, cmLibHandle>::iterator it = m_CacheMap.find(path);
+  std::map<cmStdString, cmLibHandle>::iterator it = m_CacheMap.find(path);
   if ( it != m_CacheMap.end() )
     {
     p = it->second;
@@ -69,7 +69,7 @@ bool cmDynamicLoaderCache::GetCacheFile(const char* path, cmLibHandle& p)
 
 bool cmDynamicLoaderCache::FlushCache(const char* path)
 {
-  std::map<std::string, cmLibHandle>::iterator it = m_CacheMap.find(path);
+  std::map<cmStdString, cmLibHandle>::iterator it = m_CacheMap.find(path);
   bool ret = false;
   if ( it != m_CacheMap.end() )
     {
@@ -82,7 +82,7 @@ bool cmDynamicLoaderCache::FlushCache(const char* path)
 
 void cmDynamicLoaderCache::FlushCache()
 {
-  for ( std::map<std::string, cmLibHandle>::iterator it = m_CacheMap.begin();
+  for ( std::map<cmStdString, cmLibHandle>::iterator it = m_CacheMap.begin();
         it != m_CacheMap.end(); it++ )
     {
     cmDynamicLoader::CloseLibrary(it->second);

Source/cmGlobalGenerator.cxx

@@ -436,7 +436,7 @@ void cmGlobalGenerator::Configure()
   // now do it
   this->RecursiveConfigure(lg,0.0f,0.9f);
 
-  std::set<std::string> notFoundMap;
+  std::set<cmStdString> notFoundMap;
   // after it is all done do a ConfigureFinalPass
   cmCacheManager* manager = 0;
   for (i = 0; i < m_LocalGenerators.size(); ++i)
@@ -480,7 +480,7 @@ void cmGlobalGenerator::Configure()
   if(notFoundMap.size())
     {
     std::string notFoundVars;
-    for(std::set<std::string>::iterator ii = notFoundMap.begin();
+    for(std::set<cmStdString>::iterator ii = notFoundMap.begin();
         ii != notFoundMap.end(); ++ii)
       { 
       notFoundVars += *ii;

Source/cmLoadCacheCommand.cxx

@@ -36,7 +36,7 @@ bool cmLoadCacheCommand::InitialPass(std::vector<std::string> const& args)
   // and they can not be overridden.
   bool excludeFiles=false;
   unsigned int i;
-  std::set<std::string> excludes;
+  std::set<cmStdString> excludes;
 
   for(i=0; i<args.size(); i++)
     {
@@ -58,7 +58,7 @@ bool cmLoadCacheCommand::InitialPass(std::vector<std::string> const& args)
   // If this set is empty, no internal cache entries are
   // brought in.
   bool includeFiles=false;
-  std::set<std::string> includes;
+  std::set<cmStdString> includes;
 
   for(i=0; i<args.size(); i++)
     {

Source/cmLocalUnixMakefileGenerator.cxx

@@ -693,7 +693,7 @@ void cmLocalUnixMakefileGenerator::OutputLinkLibraries(std::ostream& fout,
                                                   const cmTarget &tgt)
 {
   // Try to emit each search path once
-  std::set<std::string> emitted;
+  std::set<cmStdString> emitted;
 
   // Embed runtime search paths if possible and if required.
   bool outputRuntime = true;
@@ -1660,7 +1660,7 @@ void cmLocalUnixMakefileGenerator::OutputDependLibs(std::ostream& fout)
 {
   // Build a set of libraries that will be linked into any target in
   // this directory.
-  std::set<std::string> used;
+  std::set<cmStdString> used;
   
   // for each target
   const cmTargets &tgts = m_Makefile->GetTargets();
@@ -1669,7 +1669,7 @@ void cmLocalUnixMakefileGenerator::OutputDependLibs(std::ostream& fout)
       l != tgts.end(); l++)
     {
     // Each dependency should only be emitted once per target.
-    std::set<std::string> emitted;
+    std::set<cmStdString> emitted;
     if ((l->second.GetType() == cmTarget::SHARED_LIBRARY)
         || (l->second.GetType() == cmTarget::MODULE_LIBRARY)
         || (l->second.GetType() == cmTarget::STATIC_LIBRARY)
@@ -1734,7 +1734,7 @@ void cmLocalUnixMakefileGenerator::OutputDependLibs(std::ostream& fout)
   // build them in this makefile.  If the library is in another
   // directory, add a rule to jump to that directory and make sure it
   // exists.
-  for(std::set<std::string>::const_iterator lib = used.begin();
+  for(std::set<cmStdString>::const_iterator lib = used.begin();
       lib != used.end(); ++lib)
     {
     // loop over the list of directories that the libraries might
@@ -2315,8 +2315,8 @@ bool cmLocalUnixMakefileGenerator::OutputObjectDepends(std::ostream& fout)
 // by the class cmMakeDepend GenerateMakefile
 void cmLocalUnixMakefileGenerator::OutputCheckDepends(std::ostream& fout)
 {
-  std::set<std::string> emittedLowerPath;
-  std::set<std::string> emitted;
+  std::set<cmStdString> emittedLowerPath;
+  std::set<cmStdString> emitted;
   // Iterate over every target.
   std::map<cmStdString, cmTarget>& targets = m_Makefile->GetTargets();
   fout << "# Suppresses display of executed commands\n";
@@ -2362,7 +2362,7 @@ void cmLocalUnixMakefileGenerator::OutputCheckDepends(std::ostream& fout)
       }
     }
   fout << "\n\n# if any of these files changes run make dependlocal\n";
-  std::set<std::string>::iterator i;
+  std::set<cmStdString>::iterator i;
   for(i = emitted.begin(); i != emitted.end(); ++i)
     {
     fout << "cmake.depends: " << *i << "\n";
@@ -2371,7 +2371,7 @@ void cmLocalUnixMakefileGenerator::OutputCheckDepends(std::ostream& fout)
        << "\t$(MAKE) $(MAKESILENT) dependlocal\n\n";
   fout << "\n\n";
   fout << "# if a .h file is removed then run make dependlocal\n\n";
-  for(std::set<std::string>::iterator it = emitted.begin();
+  for(std::set<cmStdString>::iterator it = emitted.begin();
       it != emitted.end(); ++it)
     {
     fout << *it << ":\n"
@@ -2387,7 +2387,7 @@ void cmLocalUnixMakefileGenerator::OutputCustomRules(std::ostream& fout)
   // we cannot provide multiple rules for a single output
   // so we will keep track of outputs to make sure we don't write
   // two rules. First found wins
-  std::set<std::string> processedOutputs;
+  std::set<cmStdString> processedOutputs;
   
   // first output all custom rules
   const std::vector<cmSourceFile*>& sources = m_Makefile->GetSourceFiles();
@@ -2964,7 +2964,7 @@ void cmLocalUnixMakefileGenerator::OutputSourceObjectBuildRules(std::ostream& fo
 {
   fout << "# Rules to build source files :\n\n";
 
-  std::set<std::string> rules;
+  std::set<cmStdString> rules;
   
   // Iterate over every target.
   std::map<cmStdString, cmTarget>& targets = m_Makefile->GetTargets();

Source/cmMakefile.cxx

@@ -1413,7 +1413,7 @@ const char* cmMakefile::GetSafeDefinition(const char* def) const
 
 std::vector<std::string> cmMakefile::GetDefinitions(int cacheonly /* = 0 */) const
 {
-  std::map<std::string, int> definitions;
+  std::map<cmStdString, int> definitions;
   if ( !cacheonly )
     {
     DefinitionMap::const_iterator it;
@@ -1430,7 +1430,7 @@ std::vector<std::string> cmMakefile::GetDefinitions(int cacheonly /* = 0 */) con
   
   std::vector<std::string> res;
 
-  std::map<std::string, int>::iterator fit;
+  std::map<cmStdString, int>::iterator fit;
   for ( fit = definitions.begin(); fit != definitions.end(); fit ++ )
     {
     res.push_back(fit->first);

Source/cmTarget.cxx

@@ -44,7 +44,7 @@ void cmTarget::TraceVSDependencies(std::string projFile,
   std::vector<cmSourceFile*> & classes = this->GetSourceFiles();
   // use a deck to keep track of processed source files
   std::queue<std::string> srcFilesToProcess;
-  std::set<std::string> srcFilesQueued;
+  std::set<cmStdString> srcFilesQueued;
   std::string name;
   std::vector<cmSourceFile*> newClasses;
   for(std::vector<cmSourceFile*>::const_iterator i = classes.begin(); 

Source/cmakewizard.cxx

@@ -98,7 +98,7 @@ int cmakewizard::RunWizard(std::vector<std::string> const& args)
   make.SetCMakeCommand(args[0].c_str());
   make.LoadCache();
   make.SetCacheArgs(args);
-  std::map<std::string,std::string> askedCache;
+  std::map<cmStdString, cmStdString> askedCache;
   bool asked = false;
   // continue asking questions until no new questions are asked
   do