Revise C++ coding style using clang-format

Run the `Utilities/Scripts/clang-format.bash` script to update
all our C++ code to a new style defined by `.clang-format`.
Use `clang-format` version 3.8.

* If you reached this commit for a line in `git blame`, re-run the blame
  operation starting at the parent of this commit to see older history
  for the content.

* See the parent commit for instructions to rebase a change across this
  style transition commit.

1 files changed, 185 insertions, 288 deletions

diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
index 30caa32..d143193 100644
--- a/Source/cmCacheManager.cxx
+++ b/Source/cmCacheManager.cxx
@@ -38,223 +38,183 @@ void cmCacheManager::CleanCMakeFiles(const std::string& path)
   std::for_each(files.begin(), files.end(), cmSystemTools::RemoveFile);
 }
 
-bool cmCacheManager::LoadCache(const std::string& path,
-                               bool internal,
+bool cmCacheManager::LoadCache(const std::string& path, bool internal,
                                std::set<std::string>& excludes,
                                std::set<std::string>& includes)
 {
   std::string cacheFile = path;
   cacheFile += "/CMakeCache.txt";
   // clear the old cache, if we are reading in internal values
-  if ( internal )
-    {
+  if (internal) {
     this->Cache.clear();
-    }
-  if(!cmSystemTools::FileExists(cacheFile.c_str()))
-    {
+  }
+  if (!cmSystemTools::FileExists(cacheFile.c_str())) {
     this->CleanCMakeFiles(path);
     return false;
-    }
+  }
 
   cmsys::ifstream fin(cacheFile.c_str());
-  if(!fin)
-    {
+  if (!fin) {
     return false;
-    }
-  const char *realbuffer;
+  }
+  const char* realbuffer;
   std::string buffer;
   std::string entryKey;
   unsigned int lineno = 0;
-  while(fin)
-    {
+  while (fin) {
     // Format is key:type=value
     std::string helpString;
     CacheEntry e;
     cmSystemTools::GetLineFromStream(fin, buffer);
     lineno++;
     realbuffer = buffer.c_str();
-    while(*realbuffer != '0' &&
-          (*realbuffer == ' ' ||
-           *realbuffer == '\t' ||
-           *realbuffer == '\r' ||
-           *realbuffer == '\n'))
-      {
-      if (*realbuffer == '\n') lineno++;
+    while (*realbuffer != '0' &&
+           (*realbuffer == ' ' || *realbuffer == '\t' || *realbuffer == '\r' ||
+            *realbuffer == '\n')) {
+      if (*realbuffer == '\n')
+        lineno++;
       realbuffer++;
-      }
+    }
     // skip blank lines and comment lines
-    if(realbuffer[0] == '#' || realbuffer[0] == 0)
-      {
+    if (realbuffer[0] == '#' || realbuffer[0] == 0) {
       continue;
-      }
-    while(realbuffer[0] == '/' && realbuffer[1] == '/')
-      {
-      if ((realbuffer[2] == '\\') && (realbuffer[3]=='n'))
-        {
+    }
+    while (realbuffer[0] == '/' && realbuffer[1] == '/') {
+      if ((realbuffer[2] == '\\') && (realbuffer[3] == 'n')) {
         helpString += "\n";
         helpString += &realbuffer[4];
-        }
-      else
-        {
+      } else {
         helpString += &realbuffer[2];
-        }
+      }
       cmSystemTools::GetLineFromStream(fin, buffer);
       lineno++;
       realbuffer = buffer.c_str();
-      if(!fin)
-        {
+      if (!fin) {
         continue;
-        }
       }
+    }
     e.SetProperty("HELPSTRING", helpString.c_str());
-    if(cmState::ParseCacheEntry(realbuffer, entryKey, e.Value, e.Type))
-      {
-      if ( excludes.find(entryKey) == excludes.end() )
-        {
+    if (cmState::ParseCacheEntry(realbuffer, entryKey, e.Value, e.Type)) {
+      if (excludes.find(entryKey) == excludes.end()) {
         // Load internal values if internal is set.
         // If the entry is not internal to the cache being loaded
         // or if it is in the list of internal entries to be
         // imported, load it.
-        if ( internal || (e.Type != cmState::INTERNAL) ||
-             (includes.find(entryKey) != includes.end()) )
-          {
+        if (internal || (e.Type != cmState::INTERNAL) ||
+            (includes.find(entryKey) != includes.end())) {
           // If we are loading the cache from another project,
           // make all loaded entries internal so that it is
           // not visible in the gui
-          if (!internal)
-            {
+          if (!internal) {
             e.Type = cmState::INTERNAL;
             helpString = "DO NOT EDIT, ";
             helpString += entryKey;
             helpString += " loaded from external file.  "
-              "To change this value edit this file: ";
+                          "To change this value edit this file: ";
             helpString += path;
-            helpString += "/CMakeCache.txt"   ;
+            helpString += "/CMakeCache.txt";
             e.SetProperty("HELPSTRING", helpString.c_str());
-            }
-          if(!this->ReadPropertyEntry(entryKey, e))
-            {
+          }
+          if (!this->ReadPropertyEntry(entryKey, e)) {
             e.Initialized = true;
             this->Cache[entryKey] = e;
-            }
           }
         }
       }
-    else
-      {
+    } else {
       std::ostringstream error;
       error << "Parse error in cache file " << cacheFile;
       error << " on line " << lineno << ". Offending entry: " << realbuffer;
       cmSystemTools::Error(error.str().c_str());
-      }
     }
+  }
   this->CacheMajorVersion = 0;
   this->CacheMinorVersion = 0;
-  if(const char* cmajor =
-                  this->GetInitializedCacheValue("CMAKE_CACHE_MAJOR_VERSION"))
-    {
-    unsigned int v=0;
-    if(sscanf(cmajor, "%u", &v) == 1)
-      {
+  if (const char* cmajor =
+        this->GetInitializedCacheValue("CMAKE_CACHE_MAJOR_VERSION")) {
+    unsigned int v = 0;
+    if (sscanf(cmajor, "%u", &v) == 1) {
       this->CacheMajorVersion = v;
-      }
-    if(const char* cminor =
-                  this->GetInitializedCacheValue("CMAKE_CACHE_MINOR_VERSION"))
-      {
-      if(sscanf(cminor, "%u", &v) == 1)
-        {
+    }
+    if (const char* cminor =
+          this->GetInitializedCacheValue("CMAKE_CACHE_MINOR_VERSION")) {
+      if (sscanf(cminor, "%u", &v) == 1) {
         this->CacheMinorVersion = v;
-        }
       }
     }
-  else
-    {
+  } else {
     // CMake version not found in the list file.
     // Set as version 0.0
     this->AddCacheEntry("CMAKE_CACHE_MINOR_VERSION", "0",
                         "Minor version of cmake used to create the "
-                        "current loaded cache", cmState::INTERNAL);
+                        "current loaded cache",
+                        cmState::INTERNAL);
     this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION", "0",
                         "Major version of cmake used to create the "
-                        "current loaded cache", cmState::INTERNAL);
-
-    }
+                        "current loaded cache",
+                        cmState::INTERNAL);
+  }
   // check to make sure the cache directory has not
   // been moved
   const char* oldDir = this->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR");
-  if (internal && oldDir)
-    {
+  if (internal && oldDir) {
     std::string currentcwd = path;
     std::string oldcwd = oldDir;
     cmSystemTools::ConvertToUnixSlashes(currentcwd);
     currentcwd += "/CMakeCache.txt";
     oldcwd += "/CMakeCache.txt";
-    if(!cmSystemTools::SameFile(oldcwd, currentcwd))
-      {
+    if (!cmSystemTools::SameFile(oldcwd, currentcwd)) {
       std::string message =
-        std::string("The current CMakeCache.txt directory ") +
-        currentcwd + std::string(" is different than the directory ") +
+        std::string("The current CMakeCache.txt directory ") + currentcwd +
+        std::string(" is different than the directory ") +
         std::string(this->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR")) +
         std::string(" where CMakeCache.txt was created. This may result "
                     "in binaries being created in the wrong place. If you "
                     "are not sure, reedit the CMakeCache.txt");
       cmSystemTools::Error(message.c_str());
-      }
     }
+  }
   return true;
 }
 
-const char* cmCacheManager::PersistentProperties[] =
-{
-  "ADVANCED",
-  "MODIFIED",
-  "STRINGS",
-  0
-};
+const char* cmCacheManager::PersistentProperties[] = { "ADVANCED", "MODIFIED",
+                                                       "STRINGS", 0 };
 
 bool cmCacheManager::ReadPropertyEntry(std::string const& entryKey,
                                        CacheEntry& e)
 {
   // All property entries are internal.
-  if(e.Type != cmState::INTERNAL)
-    {
+  if (e.Type != cmState::INTERNAL) {
     return false;
-    }
+  }
 
   const char* end = entryKey.c_str() + entryKey.size();
-  for(const char** p = this->PersistentProperties; *p; ++p)
-    {
+  for (const char** p = this->PersistentProperties; *p; ++p) {
     std::string::size_type plen = strlen(*p) + 1;
-    if(entryKey.size() > plen && *(end-plen) == '-' &&
-       strcmp(end-plen+1, *p) == 0)
-      {
+    if (entryKey.size() > plen && *(end - plen) == '-' &&
+        strcmp(end - plen + 1, *p) == 0) {
       std::string key = entryKey.substr(0, entryKey.size() - plen);
       cmCacheManager::CacheIterator it = this->GetCacheIterator(key.c_str());
-      if(it.IsAtEnd())
-        {
+      if (it.IsAtEnd()) {
         // Create an entry and store the property.
         CacheEntry& ne = this->Cache[key];
         ne.Type = cmState::UNINITIALIZED;
         ne.SetProperty(*p, e.Value.c_str());
-        }
-      else
-        {
+      } else {
         // Store this property on its entry.
         it.SetProperty(*p, e.Value.c_str());
-        }
-      return true;
       }
+      return true;
     }
+  }
   return false;
 }
 
 void cmCacheManager::WritePropertyEntries(std::ostream& os,
                                           CacheIterator const& i)
 {
-  for(const char** p = this->PersistentProperties; *p; ++p)
-    {
-    if(const char* value = i.GetProperty(*p))
-      {
+  for (const char** p = this->PersistentProperties; *p; ++p) {
+    if (const char* value = i.GetProperty(*p)) {
       std::string helpstring = *p;
       helpstring += " property for variable: ";
       helpstring += i.GetName();
@@ -267,8 +227,8 @@ void cmCacheManager::WritePropertyEntries(std::ostream& os,
       os << ":INTERNAL=";
       this->OutputValue(os, value);
       os << "\n";
-      }
     }
+  }
 }
 
 bool cmCacheManager::SaveCache(const std::string& path)
@@ -277,43 +237,44 @@ bool cmCacheManager::SaveCache(const std::string& path)
   cacheFile += "/CMakeCache.txt";
   cmGeneratedFileStream fout(cacheFile.c_str());
   fout.SetCopyIfDifferent(true);
-  if(!fout)
-    {
+  if (!fout) {
     cmSystemTools::Error("Unable to open cache file for save. ",
                          cacheFile.c_str());
     cmSystemTools::ReportLastSystemError("");
     return false;
-    }
+  }
   // before writing the cache, update the version numbers
   // to the
   char temp[1024];
   sprintf(temp, "%d", cmVersion::GetMinorVersion());
   this->AddCacheEntry("CMAKE_CACHE_MINOR_VERSION", temp,
                       "Minor version of cmake used to create the "
-                      "current loaded cache", cmState::INTERNAL);
+                      "current loaded cache",
+                      cmState::INTERNAL);
   sprintf(temp, "%d", cmVersion::GetMajorVersion());
   this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION", temp,
                       "Major version of cmake used to create the "
-                      "current loaded cache", cmState::INTERNAL);
+                      "current loaded cache",
+                      cmState::INTERNAL);
   sprintf(temp, "%d", cmVersion::GetPatchVersion());
   this->AddCacheEntry("CMAKE_CACHE_PATCH_VERSION", temp,
                       "Patch version of cmake used to create the "
-                      "current loaded cache", cmState::INTERNAL);
+                      "current loaded cache",
+                      cmState::INTERNAL);
 
   // Let us store the current working directory so that if somebody
   // Copies it, he will not be surprised
   std::string currentcwd = path;
-  if ( currentcwd[0] >= 'A' && currentcwd[0] <= 'Z' &&
-       currentcwd[1] == ':' )
-    {
+  if (currentcwd[0] >= 'A' && currentcwd[0] <= 'Z' && currentcwd[1] == ':') {
     // Cast added to avoid compiler warning. Cast is ok because
     // value is guaranteed to fit in char by the above if...
     currentcwd[0] = static_cast<char>(currentcwd[0] - 'A' + 'a');
-    }
+  }
   cmSystemTools::ConvertToUnixSlashes(currentcwd);
   this->AddCacheEntry("CMAKE_CACHEFILE_DIR", currentcwd.c_str(),
                       "This is the directory where this CMakeCache.txt"
-                      " was created", cmState::INTERNAL);
+                      " was created",
+                      cmState::INTERNAL);
 
   /* clang-format off */
   fout << "# This is the CMakeCache file.\n"
@@ -342,36 +303,30 @@ bool cmCacheManager::SaveCache(const std::string& path)
   fout << "########################\n";
   fout << "\n";
 
-  for( std::map<std::string, CacheEntry>::const_iterator i =
-         this->Cache.begin(); i != this->Cache.end(); ++i)
-    {
+  for (std::map<std::string, CacheEntry>::const_iterator i =
+         this->Cache.begin();
+       i != this->Cache.end(); ++i) {
     const CacheEntry& ce = (*i).second;
     cmState::CacheEntryType t = ce.Type;
-    if(!ce.Initialized)
-      {
+    if (!ce.Initialized) {
       /*
         // This should be added in, but is not for now.
       cmSystemTools::Error("Cache entry \"", (*i).first.c_str(),
                            "\" is uninitialized");
       */
-      }
-    else if(t != cmState::INTERNAL)
-      {
+    } else if (t != cmState::INTERNAL) {
       // Format is key:type=value
-      if(const char* help = ce.GetProperty("HELPSTRING"))
-        {
+      if (const char* help = ce.GetProperty("HELPSTRING")) {
         cmCacheManager::OutputHelpString(fout, help);
-        }
-      else
-        {
+      } else {
         cmCacheManager::OutputHelpString(fout, "Missing description");
-        }
+      }
       this->OutputKey(fout, i->first);
       fout << ":" << cmState::CacheEntryTypeToString(t) << "=";
       this->OutputValue(fout, ce.Value);
       fout << "\n\n";
-      }
     }
+  }
 
   fout << "\n";
   fout << "########################\n";
@@ -379,29 +334,25 @@ bool cmCacheManager::SaveCache(const std::string& path)
   fout << "########################\n";
   fout << "\n";
 
-  for( cmCacheManager::CacheIterator i = this->NewIterator();
-       !i.IsAtEnd(); i.Next())
-    {
-    if ( !i.Initialized() )
-      {
+  for (cmCacheManager::CacheIterator i = this->NewIterator(); !i.IsAtEnd();
+       i.Next()) {
+    if (!i.Initialized()) {
       continue;
-      }
+    }
 
     cmState::CacheEntryType t = i.GetType();
     this->WritePropertyEntries(fout, i);
-    if(t == cmState::INTERNAL)
-      {
+    if (t == cmState::INTERNAL) {
       // Format is key:type=value
-      if(const char* help = i.GetProperty("HELPSTRING"))
-        {
+      if (const char* help = i.GetProperty("HELPSTRING")) {
         this->OutputHelpString(fout, help);
-        }
+      }
       this->OutputKey(fout, i.GetName());
       fout << ":" << cmState::CacheEntryTypeToString(t) << "=";
       this->OutputValue(fout, i.GetValue());
       fout << "\n";
-      }
     }
+  }
   fout << "\n";
   fout.Close();
   std::string checkCacheFile = path;
@@ -409,14 +360,13 @@ bool cmCacheManager::SaveCache(const std::string& path)
   cmSystemTools::MakeDirectory(checkCacheFile.c_str());
   checkCacheFile += "/cmake.check_cache";
   cmsys::ofstream checkCache(checkCacheFile.c_str());
-  if(!checkCache)
-    {
+  if (!checkCache) {
     cmSystemTools::Error("Unable to open check cache file for write. ",
                          checkCacheFile.c_str());
     return false;
-    }
+  }
   checkCache << "# This file is generated by cmake for dependency checking "
-    "of the CMakeCache.txt file\n";
+                "of the CMakeCache.txt file\n";
   return true;
 }
 
@@ -426,25 +376,23 @@ bool cmCacheManager::DeleteCache(const std::string& path)
   cmSystemTools::ConvertToUnixSlashes(cacheFile);
   std::string cmakeFiles = cacheFile;
   cacheFile += "/CMakeCache.txt";
-  if(cmSystemTools::FileExists(cacheFile.c_str()))
-    {
+  if (cmSystemTools::FileExists(cacheFile.c_str())) {
     cmSystemTools::RemoveFile(cacheFile);
     // now remove the files in the CMakeFiles directory
     // this cleans up language cache files
     cmakeFiles += cmake::GetCMakeFilesDirectory();
-    if(cmSystemTools::FileIsDirectory(cmakeFiles))
-      {
+    if (cmSystemTools::FileIsDirectory(cmakeFiles)) {
       cmSystemTools::RemoveADirectory(cmakeFiles);
-      }
     }
+  }
   return true;
 }
 
 void cmCacheManager::OutputKey(std::ostream& fout, std::string const& key)
 {
   // support : in key name by double quoting
-  const char* q = (key.find(':') != key.npos ||
-                   key.find("//") == 0)? "\"" : "";
+  const char* q =
+    (key.find(':') != key.npos || key.find("//") == 0) ? "\"" : "";
   fout << q << key << q;
 }
 
@@ -452,147 +400,120 @@ void cmCacheManager::OutputValue(std::ostream& fout, std::string const& value)
 {
   // if value has trailing space or tab, enclose it in single quotes
   if (!value.empty() &&
-      (value[value.size() - 1] == ' ' ||
-       value[value.size() - 1] == '\t'))
-    {
+      (value[value.size() - 1] == ' ' || value[value.size() - 1] == '\t')) {
     fout << '\'' << value << '\'';
-    }
-  else
-    {
+  } else {
     fout << value;
-    }
+  }
 }
 
 void cmCacheManager::OutputHelpString(std::ostream& fout,
                                       const std::string& helpString)
 {
   std::string::size_type end = helpString.size();
-  if(end == 0)
-    {
+  if (end == 0) {
     return;
-    }
+  }
   std::string oneLine;
   std::string::size_type pos = 0;
-  for (std::string::size_type i=0; i<=end; i++)
-    {
-    if ((i==end)
-        || (helpString[i]=='\n')
-        || ((i-pos >= 60) && (helpString[i]==' ')))
-      {
+  for (std::string::size_type i = 0; i <= end; i++) {
+    if ((i == end) || (helpString[i] == '\n') ||
+        ((i - pos >= 60) && (helpString[i] == ' '))) {
       fout << "//";
-      if (helpString[pos] == '\n')
-        {
+      if (helpString[pos] == '\n') {
         pos++;
         fout << "\\n";
-        }
+      }
       oneLine = helpString.substr(pos, i - pos);
       fout << oneLine << "\n";
       pos = i;
-      }
     }
+  }
 }
 
 void cmCacheManager::RemoveCacheEntry(const std::string& key)
 {
   CacheEntryMap::iterator i = this->Cache.find(key);
-  if(i != this->Cache.end())
-    {
+  if (i != this->Cache.end()) {
     this->Cache.erase(i);
-    }
+  }
 }
 
-
-cmCacheManager::CacheEntry *cmCacheManager::GetCacheEntry(
-    const std::string& key)
+cmCacheManager::CacheEntry* cmCacheManager::GetCacheEntry(
+  const std::string& key)
 {
   CacheEntryMap::iterator i = this->Cache.find(key);
-  if(i != this->Cache.end())
-    {
+  if (i != this->Cache.end()) {
     return &i->second;
-    }
+  }
   return 0;
 }
 
-cmCacheManager::CacheIterator cmCacheManager::GetCacheIterator(
-  const char *key)
+cmCacheManager::CacheIterator cmCacheManager::GetCacheIterator(const char* key)
 {
   return CacheIterator(*this, key);
 }
 
-const char*
-cmCacheManager::GetInitializedCacheValue(const std::string& key) const
+const char* cmCacheManager::GetInitializedCacheValue(
+  const std::string& key) const
 {
   CacheEntryMap::const_iterator i = this->Cache.find(key);
-  if(i != this->Cache.end() &&
-    i->second.Initialized)
-    {
+  if (i != this->Cache.end() && i->second.Initialized) {
     return i->second.Value.c_str();
-    }
+  }
   return 0;
 }
 
-
 void cmCacheManager::PrintCache(std::ostream& out) const
 {
   out << "=================================================" << std::endl;
   out << "CMakeCache Contents:" << std::endl;
-  for(std::map<std::string, CacheEntry>::const_iterator i =
-        this->Cache.begin(); i != this->Cache.end(); ++i)
-    {
-    if((*i).second.Type != cmState::INTERNAL)
-      {
-      out << (*i).first << " = " << (*i).second.Value
-          << std::endl;
-      }
+  for (std::map<std::string, CacheEntry>::const_iterator i =
+         this->Cache.begin();
+       i != this->Cache.end(); ++i) {
+    if ((*i).second.Type != cmState::INTERNAL) {
+      out << (*i).first << " = " << (*i).second.Value << std::endl;
     }
+  }
   out << "\n\n";
-  out << "To change values in the CMakeCache, "
-    << std::endl << "edit CMakeCache.txt in your output directory.\n";
+  out << "To change values in the CMakeCache, " << std::endl
+      << "edit CMakeCache.txt in your output directory.\n";
   out << "=================================================" << std::endl;
 }
 
-
-void cmCacheManager::AddCacheEntry(const std::string& key,
-                                   const char* value,
+void cmCacheManager::AddCacheEntry(const std::string& key, const char* value,
                                    const char* helpString,
                                    cmState::CacheEntryType type)
 {
   CacheEntry& e = this->Cache[key];
-  if ( value )
-    {
+  if (value) {
     e.Value = value;
     e.Initialized = true;
-    }
-  else
-    {
+  } else {
     e.Value = "";
-    }
+  }
   e.Type = type;
   // make sure we only use unix style paths
-  if(type == cmState::FILEPATH || type == cmState::PATH)
-    {
-    if(e.Value.find(';') != e.Value.npos)
-      {
+  if (type == cmState::FILEPATH || type == cmState::PATH) {
+    if (e.Value.find(';') != e.Value.npos) {
       std::vector<std::string> paths;
       cmSystemTools::ExpandListArgument(e.Value, paths);
       const char* sep = "";
       e.Value = "";
-      for(std::vector<std::string>::iterator i = paths.begin();
-          i != paths.end(); ++i)
-        {
+      for (std::vector<std::string>::iterator i = paths.begin();
+           i != paths.end(); ++i) {
         cmSystemTools::ConvertToUnixSlashes(*i);
         e.Value += sep;
         e.Value += *i;
         sep = ";";
-        }
       }
-    else
-      {
+    } else {
       cmSystemTools::ConvertToUnixSlashes(e.Value);
-      }
     }
-  e.SetProperty("HELPSTRING", helpString? helpString :
-                "(This variable does not exist and should not be used)");
+  }
+  e.SetProperty("HELPSTRING", helpString
+                  ? helpString
+                  : "(This variable does not exist and should not be used)");
 }
 
 bool cmCacheManager::CacheIterator::IsAtEnd() const
@@ -613,28 +534,23 @@ bool cmCacheManager::CacheIterator::Find(const std::string& key)
 
 void cmCacheManager::CacheIterator::Next()
 {
-  if (!this->IsAtEnd())
-    {
+  if (!this->IsAtEnd()) {
     ++this->Position;
-    }
+  }
 }
 
 void cmCacheManager::CacheIterator::SetValue(const char* value)
 {
-  if (this->IsAtEnd())
-    {
+  if (this->IsAtEnd()) {
     return;
-    }
+  }
   CacheEntry* entry = &this->GetEntry();
-  if ( value )
-    {
+  if (value) {
     entry->Value = value;
     entry->Initialized = true;
-    }
-  else
-    {
+  } else {
     entry->Value = "";
-    }
+  }
 }
 
 bool cmCacheManager::CacheIterator::GetValueAsBool() const
@@ -642,98 +558,79 @@ bool cmCacheManager::CacheIterator::GetValueAsBool() const
   return cmSystemTools::IsOn(this->GetEntry().Value.c_str());
 }
 
-const char*
-cmCacheManager::CacheEntry::GetProperty(const std::string& prop) const
+const char* cmCacheManager::CacheEntry::GetProperty(
+  const std::string& prop) const
 {
-  if(prop == "TYPE")
-    {
+  if (prop == "TYPE") {
     return cmState::CacheEntryTypeToString(this->Type);
-    }
-  else if(prop == "VALUE")
-    {
+  } else if (prop == "VALUE") {
     return this->Value.c_str();
-    }
+  }
   return this->Properties.GetPropertyValue(prop);
 }
 
 void cmCacheManager::CacheEntry::SetProperty(const std::string& prop,
                                              const char* value)
 {
-  if(prop == "TYPE")
-    {
-    this->Type = cmState::StringToCacheEntryType(value? value : "STRING");
-    }
-  else if(prop == "VALUE")
-    {
-    this->Value = value? value : "";
-    }
-  else
-    {
+  if (prop == "TYPE") {
+    this->Type = cmState::StringToCacheEntryType(value ? value : "STRING");
+  } else if (prop == "VALUE") {
+    this->Value = value ? value : "";
+  } else {
     this->Properties.SetProperty(prop, value);
-    }
+  }
 }
 
 void cmCacheManager::CacheEntry::AppendProperty(const std::string& prop,
                                                 const char* value,
                                                 bool asString)
 {
-  if(prop == "TYPE")
-    {
-    this->Type = cmState::StringToCacheEntryType(value? value : "STRING");
-    }
-  else if(prop == "VALUE")
-    {
-    if(value)
-      {
-      if(!this->Value.empty() && *value && !asString)
-        {
+  if (prop == "TYPE") {
+    this->Type = cmState::StringToCacheEntryType(value ? value : "STRING");
+  } else if (prop == "VALUE") {
+    if (value) {
+      if (!this->Value.empty() && *value && !asString) {
         this->Value += ";";
-        }
-      this->Value += value;
       }
+      this->Value += value;
     }
-  else
-    {
+  } else {
     this->Properties.AppendProperty(prop, value, asString);
-    }
+  }
 }
 
 const char* cmCacheManager::CacheIterator::GetProperty(
-    const std::string& prop) const
+  const std::string& prop) const
 {
-  if(!this->IsAtEnd())
-    {
+  if (!this->IsAtEnd()) {
     return this->GetEntry().GetProperty(prop);
-    }
+  }
   return 0;
 }
 
 void cmCacheManager::CacheIterator::SetProperty(const std::string& p,
                                                 const char* v)
 {
-  if(!this->IsAtEnd())
-    {
+  if (!this->IsAtEnd()) {
     this->GetEntry().SetProperty(p, v);
-    }
+  }
 }
 
 void cmCacheManager::CacheIterator::AppendProperty(const std::string& p,
                                                    const char* v,
                                                    bool asString)
 {
-  if(!this->IsAtEnd())
-    {
+  if (!this->IsAtEnd()) {
     this->GetEntry().AppendProperty(p, v, asString);
-    }
+  }
 }
 
 bool cmCacheManager::CacheIterator::GetPropertyAsBool(
-    const std::string& prop) const
+  const std::string& prop) const
 {
-  if(const char* value = this->GetProperty(prop))
-    {
+  if (const char* value = this->GetProperty(prop)) {
     return cmSystemTools::IsOn(value);
-    }
+  }
   return false;
 }
 
@@ -743,7 +640,7 @@ void cmCacheManager::CacheIterator::SetProperty(const std::string& p, bool v)
 }
 
 bool cmCacheManager::CacheIterator::PropertyExists(
-    const std::string& prop) const
+  const std::string& prop) const
 {
-  return this->GetProperty(prop)? true:false;
+  return this->GetProperty(prop) ? true : false;
 }