[Cmake-commits] CMake branch, next, updated. v3.2.1-1635-gdbdae3b
Stephen Kelly
steveire at gmail.com
Wed Apr 8 12:55:23 EDT 2015
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "CMake".
The branch, next has been updated
via dbdae3b67ad5ad036750d0e31f48d9514a1c5c6a (commit)
via ba404938a202b51bb82bff8692ed08e53b061ad4 (commit)
via f3922a9a5b463420db5f7fae08efdf1b4abdfe5e (commit)
via 3e6a76e48b93b2756cd3e1f28941c79c5a8f9709 (commit)
via 9e64156725e431ae15ce92be4e470cae6edf5bd6 (commit)
via 1e2dbfce37acd1b7e7dc5bb1b45d71c5ac0c3599 (commit)
via 60a62a91c4c67859d8e8f51aafcf0eb929edc036 (commit)
from 575742d4f928f7a9e2a1c17c38de4ff4cece4ea3 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=dbdae3b67ad5ad036750d0e31f48d9514a1c5c6a
commit dbdae3b67ad5ad036750d0e31f48d9514a1c5c6a
Merge: 575742d ba40493
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Wed Apr 8 12:55:22 2015 -0400
Commit: CMake Topic Stage <kwrobot at kitware.com>
CommitDate: Wed Apr 8 12:55:22 2015 -0400
Merge topic 'refactor-cache-api' into next
ba404938 cmCacheManager: Port consumers to non-iterator API.
f3922a9a Port QtDialog to non-iterator cache API.
3e6a76e4 Port CursesDialog to non-iterator cache API.
9e641567 cmMakefile: Port away from CacheEntry.Initialized.
1e2dbfce cmCacheManager: Add non-iterator-based API.
60a62a91 cmCacheManager: Return a C string from GetValue.
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=ba404938a202b51bb82bff8692ed08e53b061ad4
commit ba404938a202b51bb82bff8692ed08e53b061ad4
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Sun Apr 5 10:48:04 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Wed Apr 8 18:47:00 2015 +0200
cmCacheManager: Port consumers to non-iterator API.
This simplifies reasoning about the follow-up commit which ports
away from cmCacheManager to a class with the same method names.
diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx
index f63df61..cc08052 100644
--- a/Source/cmFindBase.cxx
+++ b/Source/cmFindBase.cxx
@@ -366,18 +366,18 @@ bool cmFindBase::CheckForVariableInCache()
if(const char* cacheValue =
this->Makefile->GetDefinition(this->VariableName))
{
- cmCacheManager::CacheIterator it =
- this->Makefile->GetCacheManager()->
- GetCacheIterator(this->VariableName.c_str());
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ const char* cacheEntry = manager->GetCacheEntryValue(this->VariableName);
bool found = !cmSystemTools::IsNOTFOUND(cacheValue);
- bool cached = !it.IsAtEnd();
+ bool cached = cacheEntry ? true : false;
if(found)
{
// If the user specifies the entry on the command line without a
// type we should add the type and docstring but keep the
// original value. Tell the subclass implementations to do
// this.
- if(cached && it.GetType() == cmCacheManager::UNINITIALIZED)
+ if(cached && manager->GetCacheEntryType(this->VariableName)
+ == cmCacheManager::UNINITIALIZED)
{
this->AlreadyInCacheWithoutMetaInfo = true;
}
@@ -385,7 +385,8 @@ bool cmFindBase::CheckForVariableInCache()
}
else if(cached)
{
- const char* hs = it.GetProperty("HELPSTRING");
+ const char* hs = manager->GetCacheEntryProperty(this->VariableName,
+ "HELPSTRING");
this->VariableDocumentation = hs?hs:"(none)";
}
}
diff --git a/Source/cmGetPropertyCommand.cxx b/Source/cmGetPropertyCommand.cxx
index f0b2686..0e6e0c2 100644
--- a/Source/cmGetPropertyCommand.cxx
+++ b/Source/cmGetPropertyCommand.cxx
@@ -391,11 +391,10 @@ bool cmGetPropertyCommand::HandleCacheMode()
}
const char* value = 0;
- cmCacheManager::CacheIterator it =
- this->Makefile->GetCacheManager()->GetCacheIterator(this->Name.c_str());
- if(!it.IsAtEnd())
+ if(this->Makefile->GetCacheManager()->GetCacheEntryValue(this->Name))
{
- value = it.GetProperty(this->PropertyName);
+ value = this->Makefile->GetCacheManager()
+ ->GetCacheEntryProperty(this->Name, this->PropertyName);
}
this->StoreResult(value);
return true;
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index f23caa6..35394b8 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -1559,9 +1559,7 @@ void cmGlobalGenerator::CheckLocalGenerators()
cmSystemTools::IsNOTFOUND(lib->first.c_str()))
{
std::string varName = lib->first.substr(0, lib->first.size()-9);
- cmCacheManager::CacheIterator it =
- manager->GetCacheIterator(varName.c_str());
- if(it.GetPropertyAsBool("ADVANCED"))
+ if(manager->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
{
varName += " (ADVANCED)";
}
@@ -1592,9 +1590,7 @@ void cmGlobalGenerator::CheckLocalGenerators()
cmSystemTools::IsNOTFOUND(incDir->c_str()))
{
std::string varName = incDir->substr(0, incDir->size()-9);
- cmCacheManager::CacheIterator it =
- manager->GetCacheIterator(varName.c_str());
- if(it.GetPropertyAsBool("ADVANCED"))
+ if(manager->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
{
varName += " (ADVANCED)";
}
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 7c1b9c4..34b4621 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -1848,8 +1848,8 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
}
}
- this->GetCacheManager()->AddCacheEntry(name, haveVal ? val.c_str() : 0, doc,
- type);
+ this->GetCacheManager()->AddCacheEntry(name, haveVal ? val.c_str() : 0,
+ doc, type);
// if there was a definition then remove it
this->Internal->VarStack.top().Set(name, 0);
}
@@ -2499,12 +2499,10 @@ std::vector<std::string> cmMakefile
this->Internal->VarStack.top().ClosureKeys();
res.insert(res.end(), definitions.begin(), definitions.end());
}
- cmCacheManager::CacheIterator cit =
- this->GetCacheManager()->GetCacheIterator();
- for ( cit.Begin(); !cit.IsAtEnd(); cit.Next() )
- {
- res.push_back(cit.GetName());
- }
+ std::vector<std::string> cacheKeys =
+ this->GetCacheManager()->GetCacheEntryKeys();
+ res.insert(res.end(), cacheKeys.begin(), cacheKeys.end());
+
std::sort(res.begin(), res.end());
return res;
}
diff --git a/Source/cmMarkAsAdvancedCommand.cxx b/Source/cmMarkAsAdvancedCommand.cxx
index f6a2c26..cc094b1 100644
--- a/Source/cmMarkAsAdvancedCommand.cxx
+++ b/Source/cmMarkAsAdvancedCommand.cxx
@@ -37,24 +37,19 @@ bool cmMarkAsAdvancedCommand
{
std::string variable = args[i];
cmCacheManager* manager = this->Makefile->GetCacheManager();
- cmCacheManager::CacheIterator it =
- manager->GetCacheIterator(variable.c_str());
- if ( it.IsAtEnd() )
+ if (!manager->GetCacheEntryValue(variable))
{
- this->Makefile->GetCacheManager()
- ->AddCacheEntry(variable, 0, 0,
- cmCacheManager::UNINITIALIZED);
+ manager->AddCacheEntry(variable, 0, 0, cmCacheManager::UNINITIALIZED);
overwrite = true;
}
- it.Find(variable);
- if ( it.IsAtEnd() )
+ if (!manager->GetCacheEntryValue(variable))
{
cmSystemTools::Error("This should never happen...");
return false;
}
- if ( !it.PropertyExists("ADVANCED") || overwrite )
+ if (!manager->GetCacheEntryProperty(variable, "ADVANCED") || overwrite)
{
- it.SetProperty("ADVANCED", value);
+ manager->SetCacheEntryProperty(variable, "ADVANCED", value);
}
}
return true;
diff --git a/Source/cmOptionCommand.cxx b/Source/cmOptionCommand.cxx
index 60728ea..baf5b1e 100644
--- a/Source/cmOptionCommand.cxx
+++ b/Source/cmOptionCommand.cxx
@@ -42,16 +42,16 @@ bool cmOptionCommand
std::string initialValue = "Off";
// Now check and see if the value has been stored in the cache
// already, if so use that value and don't look for the program
- cmCacheManager::CacheIterator it =
- this->Makefile->GetCacheManager()->GetCacheIterator(args[0].c_str());
- if(!it.IsAtEnd())
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ const char* existingValue = manager->GetCacheEntryValue(args[0]);
+ if(existingValue)
{
- if ( it.GetType() != cmCacheManager::UNINITIALIZED )
+ if (manager->GetCacheEntryType(args[0]) != cmCacheManager::UNINITIALIZED)
{
- it.SetProperty("HELPSTRING", args[1].c_str());
+ manager->SetCacheEntryProperty(args[0], "HELPSTRING", args[1]);
return true;
}
- initialValue = it.GetValue();
+ initialValue = existingValue;
}
if(args.size() == 3)
{
diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx
index 204d95b..e17474b 100644
--- a/Source/cmSetCommand.cxx
+++ b/Source/cmSetCommand.cxx
@@ -136,9 +136,10 @@ bool cmSetCommand
}
// see if this is already in the cache
- cmCacheManager::CacheIterator it =
- this->Makefile->GetCacheManager()->GetCacheIterator(variable);
- if(!it.IsAtEnd() && (it.GetType() != cmCacheManager::UNINITIALIZED))
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ const char* existingValue = manager->GetCacheEntryValue(variable);
+ if(existingValue &&
+ (manager->GetCacheEntryType(variable) != cmCacheManager::UNINITIALIZED))
{
// if the set is trying to CACHE the value but the value
// is already in the cache and the type is not internal
diff --git a/Source/cmSetPropertyCommand.cxx b/Source/cmSetPropertyCommand.cxx
index 1150bc7..77f9fb9 100644
--- a/Source/cmSetPropertyCommand.cxx
+++ b/Source/cmSetPropertyCommand.cxx
@@ -452,11 +452,11 @@ bool cmSetPropertyCommand::HandleCacheMode()
// Get the source file.
cmMakefile* mf = this->GetMakefile();
cmake* cm = mf->GetCMakeInstance();
- cmCacheManager::CacheIterator it =
- cm->GetCacheManager()->GetCacheIterator(ni->c_str());
- if(!it.IsAtEnd())
+ const char* existingValue
+ = cm->GetCacheManager()->GetCacheEntryValue(*ni);
+ if(existingValue)
{
- if(!this->HandleCacheEntry(it))
+ if(!this->HandleCacheEntry(*ni))
{
return false;
}
@@ -474,22 +474,25 @@ bool cmSetPropertyCommand::HandleCacheMode()
}
//----------------------------------------------------------------------------
-bool cmSetPropertyCommand::HandleCacheEntry(cmCacheManager::CacheIterator& it)
+bool cmSetPropertyCommand::HandleCacheEntry(std::string const& cacheKey)
{
// Set or append the property.
const char* name = this->PropertyName.c_str();
const char* value = this->PropertyValue.c_str();
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
if (this->Remove)
{
- value = 0;
+ manager->RemoveCacheEntryProperty(cacheKey, name);
+ return true;
}
if(this->AppendMode)
{
- it.AppendProperty(name, value, this->AppendAsString);
+ manager->AppendCacheEntryProperty(cacheKey, name, value,
+ this->AppendAsString);
}
else
{
- it.SetProperty(name, value);
+ manager->SetCacheEntryProperty(cacheKey, name, value);
}
return true;
diff --git a/Source/cmSetPropertyCommand.h b/Source/cmSetPropertyCommand.h
index b06cb68..3285e60 100644
--- a/Source/cmSetPropertyCommand.h
+++ b/Source/cmSetPropertyCommand.h
@@ -61,7 +61,7 @@ private:
bool HandleTestMode();
bool HandleTest(cmTest* test);
bool HandleCacheMode();
- bool HandleCacheEntry(cmCacheManager::CacheIterator&);
+ bool HandleCacheEntry(std::string const&);
bool HandleInstallMode();
bool HandleInstall(cmInstalledFile* file);
};
diff --git a/Source/cmTryRunCommand.cxx b/Source/cmTryRunCommand.cxx
index b5280cf..911ade8 100644
--- a/Source/cmTryRunCommand.cxx
+++ b/Source/cmTryRunCommand.cxx
@@ -264,11 +264,12 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
comment.c_str(),
cmCacheManager::STRING);
- cmCacheManager::CacheIterator it = this->Makefile->GetCacheManager()->
- GetCacheIterator(this->RunResultVariable.c_str());
- if ( !it.IsAtEnd() )
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ const char* existingValue
+ = manager->GetCacheEntryValue(this->RunResultVariable);
+ if (existingValue)
{
- it.SetProperty("ADVANCED", "1");
+ manager->SetCacheEntryProperty(this->RunResultVariable, "ADVANCED", "1");
}
error = true;
@@ -290,11 +291,13 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
"PLEASE_FILL_OUT-NOTFOUND",
comment.c_str(),
cmCacheManager::STRING);
- cmCacheManager::CacheIterator it = this->Makefile->GetCacheManager()->
- GetCacheIterator(internalRunOutputName.c_str());
- if ( !it.IsAtEnd() )
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ const char* existing =
+ manager->GetCacheEntryValue(internalRunOutputName);
+ if (existing)
{
- it.SetProperty("ADVANCED", "1");
+ manager->SetCacheEntryProperty(internalRunOutputName,
+ "ADVANCED", "1");
}
error = true;
diff --git a/Source/cmVariableRequiresCommand.cxx b/Source/cmVariableRequiresCommand.cxx
index 80c1286..dd2a682 100644
--- a/Source/cmVariableRequiresCommand.cxx
+++ b/Source/cmVariableRequiresCommand.cxx
@@ -41,9 +41,9 @@ bool cmVariableRequiresCommand
requirementsMet = false;
notSet += args[i];
notSet += "\n";
- cmCacheManager::CacheIterator it =
- this->Makefile->GetCacheManager()->GetCacheIterator(args[i].c_str());
- if(!it.IsAtEnd() && it.GetPropertyAsBool("ADVANCED"))
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ if(manager->GetCacheEntryValue(args[i]) &&
+ manager->GetCacheEntryPropertyAsBool(args[i], "ADVANCED"))
{
hasAdvanced = true;
}
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 210c0ef..64b332c 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -403,17 +403,18 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
cmsys::Glob::PatternToRegex(entryPattern, true, true).c_str());
//go through all cache entries and collect the vars which will be removed
std::vector<std::string> entriesToDelete;
- cmCacheManager::CacheIterator it =
- this->CacheManager->GetCacheIterator();
- for ( it.Begin(); !it.IsAtEnd(); it.Next() )
+ std::vector<std::string> cacheKeys =
+ this->CacheManager->GetCacheEntryKeys();
+ for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
+ it != cacheKeys.end(); ++it)
{
- cmCacheManager::CacheEntryType t = it.GetType();
+ cmCacheManager::CacheEntryType t =
+ this->CacheManager->GetCacheEntryType(*it);
if(t != cmCacheManager::STATIC)
{
- std::string entryName = it.GetName();
- if (regex.find(entryName.c_str()))
+ if (regex.find(it->c_str()))
{
- entriesToDelete.push_back(entryName);
+ entriesToDelete.push_back(*it);
}
}
}
@@ -917,16 +918,18 @@ void cmake::SetDirectoriesFromFile(const char* arg)
// If there is a CMakeCache.txt file, use its settings.
if(!cachePath.empty())
{
- cmCacheManager* cachem = this->GetCacheManager();
- cmCacheManager::CacheIterator it = cachem->NewIterator();
- if(this->LoadCache(cachePath) &&
- it.Find("CMAKE_HOME_DIRECTORY"))
+ if(this->LoadCache(cachePath))
{
- this->SetHomeOutputDirectory(cachePath);
- this->SetStartOutputDirectory(cachePath);
- this->SetHomeDirectory(it.GetValue());
- this->SetStartDirectory(it.GetValue());
- return;
+ const char* existingValue =
+ this->CacheManager->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
+ if (existingValue)
+ {
+ this->SetHomeOutputDirectory(cachePath);
+ this->SetStartOutputDirectory(cachePath);
+ this->SetHomeDirectory(existingValue);
+ this->SetStartDirectory(existingValue);
+ return;
+ }
}
}
@@ -1575,11 +1578,11 @@ int cmake::ActualConfigure()
("CMAKE_USE_RELATIVE_PATHS", "OFF",
"If true, cmake will use relative paths in makefiles and projects.",
cmCacheManager::BOOL);
- cmCacheManager::CacheIterator it =
- this->CacheManager->GetCacheIterator("CMAKE_USE_RELATIVE_PATHS");
- if ( !it.PropertyExists("ADVANCED") )
+ if (!this->CacheManager->GetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
+ "ADVANCED"))
{
- it.SetProperty("ADVANCED", "1");
+ this->CacheManager->SetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
+ "ADVANCED", "1");
}
}
@@ -2314,17 +2317,9 @@ const char *cmake::GetProperty(const std::string& prop,
std::string output = "";
if ( prop == "CACHE_VARIABLES" )
{
- cmCacheManager::CacheIterator cit =
- this->GetCacheManager()->GetCacheIterator();
- for ( cit.Begin(); !cit.IsAtEnd(); cit.Next() )
- {
- if (!output.empty())
- {
- output += ";";
- }
- output += cit.GetName();
- }
- this->SetProperty("CACHE_VARIABLES", output.c_str());
+ std::vector<std::string> cacheKeys =
+ this->CacheManager->GetCacheEntryKeys();
+ this->SetProperty("CACHE_VARIABLES", cmJoin(cacheKeys, ";").c_str());
}
else if ( prop == "COMMANDS" )
{
@@ -2686,9 +2681,9 @@ void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
if(t == cmake::AUTHOR_WARNING)
{
// Allow suppression of these warnings.
- cmCacheManager::CacheIterator it = this->CacheManager
- ->GetCacheIterator("CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
- if(!it.IsAtEnd() && it.GetValueAsBool())
+ const char* suppress = this->CacheManager->GetCacheEntryValue(
+ "CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
+ if(suppress && cmSystemTools::IsOn(suppress))
{
return;
}
@@ -2801,37 +2796,42 @@ int cmake::Build(const std::string& dir,
}
std::string cachePath = dir;
cmSystemTools::ConvertToUnixSlashes(cachePath);
- cmCacheManager::CacheIterator it = this->GetCacheManager()->NewIterator();
if(!this->LoadCache(cachePath))
{
std::cerr << "Error: could not load cache\n";
return 1;
}
- if(!it.Find("CMAKE_GENERATOR"))
+ const char* cachedGenerator =
+ this->CacheManager->GetCacheEntryValue("CMAKE_GENERATOR");
+ if(!cachedGenerator)
{
std::cerr << "Error: could not find CMAKE_GENERATOR in Cache\n";
return 1;
}
cmsys::auto_ptr<cmGlobalGenerator> gen(
- this->CreateGlobalGenerator(it.GetValue()));
+ this->CreateGlobalGenerator(cachedGenerator));
if(!gen.get())
{
std::cerr << "Error: could create CMAKE_GENERATOR \""
- << it.GetValue() << "\"\n";
+ << cachedGenerator << "\"\n";
return 1;
}
std::string output;
std::string projName;
- if(!it.Find("CMAKE_PROJECT_NAME"))
+ const char* cachedProjectName =
+ this->CacheManager->GetCacheEntryValue("CMAKE_PROJECT_NAME");
+ if(!cachedProjectName)
{
std::cerr << "Error: could not find CMAKE_PROJECT_NAME in Cache\n";
return 1;
}
- projName = it.GetValue();
+ projName = cachedProjectName;
bool verbose = false;
- if(it.Find("CMAKE_VERBOSE_MAKEFILE"))
+ const char* cachedVerbose =
+ this->CacheManager->GetCacheEntryValue("CMAKE_VERBOSE_MAKEFILE");
+ if(cachedVerbose)
{
- verbose = it.GetValueAsBool();
+ verbose = cmSystemTools::IsOn(cachedVerbose);
}
return gen->Build("", dir,
projName, target,
diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx
index ac73ad0..3b518be 100644
--- a/Source/cmakemain.cxx
+++ b/Source/cmakemain.cxx
@@ -328,25 +328,31 @@ int do_cmake(int ac, char const* const* av)
int res = cm.Run(args, view_only);
if ( list_cached || list_all_cached )
{
- cmCacheManager::CacheIterator it =
- cm.GetCacheManager()->GetCacheIterator();
std::cout << "-- Cache values" << std::endl;
- for ( it.Begin(); !it.IsAtEnd(); it.Next() )
+ std::vector<std::string> keys =
+ cm.GetCacheManager()->GetCacheEntryKeys();
+ for (std::vector<std::string>::const_iterator it = keys.begin();
+ it != keys.end(); ++it)
{
- cmCacheManager::CacheEntryType t = it.GetType();
+ cmCacheManager::CacheEntryType t =
+ cm.GetCacheManager()->GetCacheEntryType(*it);
if ( t != cmCacheManager::INTERNAL && t != cmCacheManager::STATIC &&
t != cmCacheManager::UNINITIALIZED )
{
- bool advanced = it.PropertyExists("ADVANCED");
- if ( list_all_cached || !advanced)
+ const char* advancedProp =
+ cm.GetCacheManager()->GetCacheEntryProperty(*it, "ADVANCED");
+ if ( list_all_cached || !advancedProp)
{
if ( list_help )
{
- std::cout << "// " << it.GetProperty("HELPSTRING") << std::endl;
+ std::cout << "// "
+ << cm.GetCacheManager()->GetCacheEntryProperty(*it,
+ "HELPSTRING") << std::endl;
}
- std::cout << it.GetName() << ":" <<
- cmCacheManager::TypeToString(it.GetType())
- << "=" << it.GetValue() << std::endl;
+ std::cout << *it << ":" <<
+ cmCacheManager::TypeToString(t)
+ << "=" << cm.GetCacheManager()->GetCacheEntryValue(*it)
+ << std::endl;
if ( list_help )
{
std::cout << std::endl;
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=f3922a9a5b463420db5f7fae08efdf1b4abdfe5e
commit f3922a9a5b463420db5f7fae08efdf1b4abdfe5e
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Mon Apr 6 12:14:40 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Wed Apr 8 18:47:00 2015 +0200
Port QtDialog to non-iterator cache API.
diff --git a/Source/QtDialog/QCMake.cxx b/Source/QtDialog/QCMake.cxx
index 009d06e..08d53ce 100644
--- a/Source/QtDialog/QCMake.cxx
+++ b/Source/QtDialog/QCMake.cxx
@@ -110,17 +110,18 @@ void QCMake::setBinaryDirectory(const QString& _dir)
QCMakePropertyList props = this->properties();
emit this->propertiesChanged(props);
- cmCacheManager::CacheIterator itm = cachem->NewIterator();
- if ( itm.Find("CMAKE_HOME_DIRECTORY"))
+ const char* homeDir = cachem->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
+ if (homeDir)
{
- setSourceDirectory(QString::fromLocal8Bit(itm.GetValue().c_str()));
+ setSourceDirectory(QString::fromLocal8Bit(homeDir));
}
- if ( itm.Find("CMAKE_GENERATOR"))
+ const char* gen = cachem->GetCacheEntryValue("CMAKE_GENERATOR");
+ if (gen)
{
const char* extraGen = cachem
->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR");
std::string curGen = cmExternalMakefileProjectGenerator::
- CreateFullGeneratorName(itm.GetValue(), extraGen? extraGen : "");
+ CreateFullGeneratorName(gen, extraGen? extraGen : "");
this->setGenerator(QString::fromLocal8Bit(curGen.c_str()));
}
}
@@ -195,33 +196,35 @@ void QCMake::setProperties(const QCMakePropertyList& newProps)
// set the value of properties
cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
- for(cmCacheManager::CacheIterator i = cachem->NewIterator();
- !i.IsAtEnd(); i.Next())
+ std::vector<std::string> cacheKeys = cachem->GetCacheEntryKeys();
+ for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
+ it != cacheKeys.end(); ++it)
{
-
- if(i.GetType() == cmCacheManager::INTERNAL ||
- i.GetType() == cmCacheManager::STATIC)
+ cmCacheManager::CacheEntryType t = cachem->GetCacheEntryType(*it);
+ if(t == cmCacheManager::INTERNAL ||
+ t == cmCacheManager::STATIC)
{
continue;
}
QCMakeProperty prop;
- prop.Key = QString::fromLocal8Bit(i.GetName().c_str());
+ prop.Key = QString::fromLocal8Bit(it->c_str());
int idx = props.indexOf(prop);
if(idx == -1)
{
- toremove.append(QString::fromLocal8Bit(i.GetName().c_str()));
+ toremove.append(QString::fromLocal8Bit(it->c_str()));
}
else
{
prop = props[idx];
if(prop.Value.type() == QVariant::Bool)
{
- i.SetValue(prop.Value.toBool() ? "ON" : "OFF");
+ cachem->SetCacheEntryValue(*it, prop.Value.toBool() ? "ON" : "OFF");
}
else
{
- i.SetValue(prop.Value.toString().toLocal8Bit().data());
+ cachem->SetCacheEntryValue(*it,
+ prop.Value.toString().toLocal8Bit().data());
}
props.removeAt(idx);
}
@@ -279,42 +282,47 @@ QCMakePropertyList QCMake::properties() const
QCMakePropertyList ret;
cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
- for(cmCacheManager::CacheIterator i = cachem->NewIterator();
- !i.IsAtEnd(); i.Next())
+ std::vector<std::string> cacheKeys = cachem->GetCacheEntryKeys();
+ for (std::vector<std::string>::const_iterator i = cacheKeys.begin();
+ i != cacheKeys.end(); ++i)
{
-
- if(i.GetType() == cmCacheManager::INTERNAL ||
- i.GetType() == cmCacheManager::STATIC ||
- i.GetType() == cmCacheManager::UNINITIALIZED)
+ cmCacheManager::CacheEntryType t = cachem->GetCacheEntryType(*i);
+ if(t == cmCacheManager::INTERNAL ||
+ t == cmCacheManager::STATIC ||
+ t == cmCacheManager::UNINITIALIZED)
{
continue;
}
- QCMakeProperty prop;
- prop.Key = QString::fromLocal8Bit(i.GetName().c_str());
- prop.Help = QString::fromLocal8Bit(i.GetProperty("HELPSTRING"));
- prop.Value = QString::fromLocal8Bit(i.GetValue().c_str());
- prop.Advanced = i.GetPropertyAsBool("ADVANCED");
+ const char* cachedValue = cachem->GetCacheEntryValue(*i);
- if(i.GetType() == cmCacheManager::BOOL)
+ QCMakeProperty prop;
+ prop.Key = QString::fromLocal8Bit(i->c_str());
+ prop.Help = QString::fromLocal8Bit(
+ cachem->GetCacheEntryProperty(*i, "HELPSTRING"));
+ prop.Value = QString::fromLocal8Bit(cachedValue);
+ prop.Advanced = cachem->GetCacheEntryPropertyAsBool(*i, "ADVANCED");
+ if(t == cmCacheManager::BOOL)
{
prop.Type = QCMakeProperty::BOOL;
- prop.Value = cmSystemTools::IsOn(i.GetValue().c_str());
+ prop.Value = cmSystemTools::IsOn(cachedValue);
}
- else if(i.GetType() == cmCacheManager::PATH)
+ else if(t == cmCacheManager::PATH)
{
prop.Type = QCMakeProperty::PATH;
}
- else if(i.GetType() == cmCacheManager::FILEPATH)
+ else if(t == cmCacheManager::FILEPATH)
{
prop.Type = QCMakeProperty::FILEPATH;
}
- else if(i.GetType() == cmCacheManager::STRING)
+ else if(t == cmCacheManager::STRING)
{
prop.Type = QCMakeProperty::STRING;
- if (i.PropertyExists("STRINGS"))
+ const char* stringsProperty =
+ cachem->GetCacheEntryProperty(*i, "STRINGS");
+ if (stringsProperty)
{
- prop.Strings = QString::fromLocal8Bit(i.GetProperty("STRINGS")).split(";");
+ prop.Strings = QString::fromLocal8Bit(stringsProperty).split(";");
}
}
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=3e6a76e48b93b2756cd3e1f28941c79c5a8f9709
commit 3e6a76e48b93b2756cd3e1f28941c79c5a8f9709
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Mon Apr 6 12:01:35 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Wed Apr 8 18:47:00 2015 +0200
Port CursesDialog to non-iterator cache API.
diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
index 682f95f..4f028c4 100644
--- a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
@@ -18,6 +18,9 @@
#include "cmCursesFilePathWidget.h"
#include "cmCursesDummyWidget.h"
#include "../cmSystemTools.h"
+#include "../cmake.h"
+
+#include <assert.h>
cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
const std::string& key,
@@ -32,7 +35,7 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
}
cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
- const std::string& key, const cmCacheManager::CacheIterator& it, bool isNew,
+ const std::string& key, cmake *cm, bool isNew,
int labelwidth, int entrywidth)
: Key(key), LabelWidth(labelwidth), EntryWidth(entrywidth)
{
@@ -47,11 +50,13 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
}
this->Entry = 0;
- switch ( it.GetType() )
+ const char* value = cm->GetCacheManager()->GetCacheEntryValue(key);
+ assert(value);
+ switch (cm->GetCacheManager()->GetCacheEntryType(key))
{
- case cmCacheManager::BOOL:
+ case cmCacheManager::BOOL:
this->Entry = new cmCursesBoolWidget(this->EntryWidth, 1, 1, 1);
- if (cmSystemTools::IsOn(it.GetValue().c_str()))
+ if (cmSystemTools::IsOn(value))
{
static_cast<cmCursesBoolWidget*>(this->Entry)->SetValueAsBool(true);
}
@@ -62,40 +67,40 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
break;
case cmCacheManager::PATH:
this->Entry = new cmCursesPathWidget(this->EntryWidth, 1, 1, 1);
- static_cast<cmCursesPathWidget*>(this->Entry)->SetString(
- it.GetValue());
+ static_cast<cmCursesPathWidget*>(this->Entry)->SetString(value);
break;
case cmCacheManager::FILEPATH:
this->Entry = new cmCursesFilePathWidget(this->EntryWidth, 1, 1, 1);
- static_cast<cmCursesFilePathWidget*>(this->Entry)->SetString(
- it.GetValue());
+ static_cast<cmCursesFilePathWidget*>(this->Entry)->SetString(value);
break;
case cmCacheManager::STRING:
- if(it.PropertyExists("STRINGS"))
+ {
+ const char* stringsProp = cm->GetCacheManager()
+ ->GetCacheEntryProperty(key, "STRINGS");
+ if(stringsProp)
{
cmCursesOptionsWidget* ow =
new cmCursesOptionsWidget(this->EntryWidth, 1, 1, 1);
this->Entry = ow;
std::vector<std::string> options;
- cmSystemTools::ExpandListArgument(
- std::string(it.GetProperty("STRINGS")), options);
+ cmSystemTools::ExpandListArgument(stringsProp, options);
for(std::vector<std::string>::iterator
si = options.begin(); si != options.end(); ++si)
{
ow->AddOption(*si);
}
- ow->SetOption(it.GetValue());
+ ow->SetOption(value);
}
else
{
this->Entry = new cmCursesStringWidget(this->EntryWidth, 1, 1, 1);
- static_cast<cmCursesStringWidget*>(this->Entry)->SetString(
- it.GetValue());
+ static_cast<cmCursesStringWidget*>(this->Entry)->SetString(value);
}
break;
+ }
case cmCacheManager::UNINITIALIZED:
cmSystemTools::Error("Found an undefined variable: ",
- it.GetName().c_str());
+ key.c_str());
break;
default:
// TODO : put warning message here
diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.h b/Source/CursesDialog/cmCursesCacheEntryComposite.h
index 7cdf13b..dc4ee4af 100644
--- a/Source/CursesDialog/cmCursesCacheEntryComposite.h
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.h
@@ -21,7 +21,7 @@ public:
cmCursesCacheEntryComposite(const std::string& key, int labelwidth,
int entrywidth);
cmCursesCacheEntryComposite(const std::string& key,
- const cmCacheManager::CacheIterator& it,
+ cmake *cm,
bool isNew, int labelwidth, int entrywidth);
~cmCursesCacheEntryComposite();
const char* GetValue();
diff --git a/Source/CursesDialog/cmCursesMainForm.cxx b/Source/CursesDialog/cmCursesMainForm.cxx
index 1217bda..833d540 100644
--- a/Source/CursesDialog/cmCursesMainForm.cxx
+++ b/Source/CursesDialog/cmCursesMainForm.cxx
@@ -111,13 +111,17 @@ void cmCursesMainForm::InitializeUI()
// Count non-internal and non-static entries
int count=0;
- for(cmCacheManager::CacheIterator i =
- this->CMakeInstance->GetCacheManager()->NewIterator();
- !i.IsAtEnd(); i.Next())
+ std::vector<std::string> cacheKeys =
+ this->CMakeInstance->GetCacheManager()->GetCacheEntryKeys();
+
+ for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
+ it != cacheKeys.end(); ++it)
{
- if ( i.GetType() != cmCacheManager::INTERNAL &&
- i.GetType() != cmCacheManager::STATIC &&
- i.GetType() != cmCacheManager::UNINITIALIZED)
+ cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryType(*it);
+ if (t != cmCacheManager::INTERNAL &&
+ t != cmCacheManager::STATIC &&
+ t != cmCacheManager::UNINITIALIZED)
{
++count;
}
@@ -139,45 +143,49 @@ void cmCursesMainForm::InitializeUI()
// Create the composites.
// First add entries which are new
- for(cmCacheManager::CacheIterator i =
- this->CMakeInstance->GetCacheManager()->NewIterator();
- !i.IsAtEnd(); i.Next())
+ for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
+ it != cacheKeys.end(); ++it)
{
- std::string key = i.GetName();
- if ( i.GetType() == cmCacheManager::INTERNAL ||
- i.GetType() == cmCacheManager::STATIC ||
- i.GetType() == cmCacheManager::UNINITIALIZED )
+ std::string key = *it;
+ cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryType(*it);
+ if (t == cmCacheManager::INTERNAL ||
+ t == cmCacheManager::STATIC ||
+ t == cmCacheManager::UNINITIALIZED )
{
continue;
}
if (!this->LookForCacheEntry(key))
{
- newEntries->push_back(new cmCursesCacheEntryComposite(key, i,
- true, 30,
- entrywidth));
+ newEntries->push_back(new cmCursesCacheEntryComposite(key,
+ this->CMakeInstance,
+ true, 30,
+ entrywidth));
this->OkToGenerate = false;
}
}
// then add entries which are old
- for(cmCacheManager::CacheIterator i =
- this->CMakeInstance->GetCacheManager()->NewIterator();
- !i.IsAtEnd(); i.Next())
+ for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
+ it != cacheKeys.end(); ++it)
{
- std::string key = i.GetName();
- if ( i.GetType() == cmCacheManager::INTERNAL ||
- i.GetType() == cmCacheManager::STATIC ||
- i.GetType() == cmCacheManager::UNINITIALIZED )
+ std::string key = *it;
+ cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryType(*it);
+ if (t == cmCacheManager::INTERNAL ||
+ t == cmCacheManager::STATIC ||
+ t == cmCacheManager::UNINITIALIZED )
{
continue;
}
if (this->LookForCacheEntry(key))
{
- newEntries->push_back(new cmCursesCacheEntryComposite(key, i,
- false, 30,
- entrywidth));
+ newEntries->push_back(new cmCursesCacheEntryComposite(key,
+ this->CMakeInstance,
+ false, 30,
+ entrywidth));
}
}
}
@@ -216,10 +224,13 @@ void cmCursesMainForm::RePost()
std::vector<cmCursesCacheEntryComposite*>::iterator it;
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
- cmCacheManager::CacheIterator mit =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator((*it)->GetValue());
- if (mit.IsAtEnd() ||
- (!this->AdvancedMode && mit.GetPropertyAsBool("ADVANCED")))
+ const char* existingValue =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryValue((*it)->GetValue());
+ bool advanced =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
+ if (!existingValue || (!this->AdvancedMode && advanced))
{
continue;
}
@@ -245,10 +256,13 @@ void cmCursesMainForm::RePost()
std::vector<cmCursesCacheEntryComposite*>::iterator it;
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
- cmCacheManager::CacheIterator mit =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator((*it)->GetValue());
- if (mit.IsAtEnd() ||
- (!this->AdvancedMode && mit.GetPropertyAsBool("ADVANCED")))
+ const char* existingValue =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryValue((*it)->GetValue());
+ bool advanced =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
+ if (!existingValue || (!this->AdvancedMode && advanced))
{
continue;
}
@@ -314,10 +328,13 @@ void cmCursesMainForm::Render(int left, int top, int width, int height)
std::vector<cmCursesCacheEntryComposite*>::iterator it;
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
- cmCacheManager::CacheIterator mit =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator((*it)->GetValue());
- if (mit.IsAtEnd() ||
- (!this->AdvancedMode && mit.GetPropertyAsBool("ADVANCED")))
+ const char* existingValue =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryValue((*it)->GetValue());
+ bool advanced =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
+ if (!existingValue || (!this->AdvancedMode && advanced))
{
continue;
}
@@ -334,10 +351,13 @@ void cmCursesMainForm::Render(int left, int top, int width, int height)
std::vector<cmCursesCacheEntryComposite*>::iterator it;
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
- cmCacheManager::CacheIterator mit =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator((*it)->GetValue());
- if (mit.IsAtEnd() ||
- (!this->AdvancedMode && mit.GetPropertyAsBool("ADVANCED")))
+ const char* existingValue =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryValue((*it)->GetValue());
+ bool advanced =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
+ if (!existingValue || (!this->AdvancedMode && advanced))
{
continue;
}
@@ -495,11 +515,12 @@ void cmCursesMainForm::UpdateStatusBar(const char* message)
// Get the help string of the current entry
// and add it to the help string
- cmCacheManager::CacheIterator it =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator(curField);
- if (!it.IsAtEnd())
+ const char* existingValue =
+ this->CMakeInstance->GetCacheManager()->GetCacheEntryValue(curField);
+ if (existingValue)
{
- const char* hs = it.GetProperty("HELPSTRING");
+ const char* hs = this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryProperty(curField, "HELPSTRING");
if ( hs )
{
strncpy(help, hs, 127);
@@ -792,23 +813,28 @@ void cmCursesMainForm::FillCacheManagerFromUI()
size_t size = this->Entries->size();
for(size_t i=0; i < size; i++)
{
- cmCacheManager::CacheIterator it =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator(
- (*this->Entries)[i]->Key.c_str());
- if (!it.IsAtEnd())
+ std::string cacheKey = (*this->Entries)[i]->Key;
+ const char* existingValue = this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryValue(cacheKey);
+ if (existingValue)
{
- std::string oldValue = it.GetValue();
+ std::string oldValue = existingValue;
std::string newValue = (*this->Entries)[i]->Entry->GetValue();
std::string fixedOldValue;
std::string fixedNewValue;
- this->FixValue(it.GetType(), oldValue, fixedOldValue);
- this->FixValue(it.GetType(), newValue, fixedNewValue);
+ cmCacheManager::CacheEntryType t =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryType(cacheKey);
+ this->FixValue(t, oldValue, fixedOldValue);
+ this->FixValue(t, newValue, fixedNewValue);
if(!(fixedOldValue == fixedNewValue))
{
// The user has changed the value. Mark it as modified.
- it.SetProperty("MODIFIED", true);
- it.SetValue(fixedNewValue.c_str());
+ this->CMakeInstance->GetCacheManager()
+ ->SetCacheEntryBoolProperty(cacheKey, "MODIFIED", true);
+ this->CMakeInstance->GetCacheManager()
+ ->SetCacheEntryValue(cacheKey, fixedNewValue);
}
}
}
@@ -1017,12 +1043,15 @@ void cmCursesMainForm::HandleInput()
cmCursesWidget* lbl = reinterpret_cast<cmCursesWidget*>(field_userptr(
this->Fields[findex-2]));
const char* curField = lbl->GetValue();
- const char* helpString=0;
- cmCacheManager::CacheIterator it =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator(curField);
- if (!it.IsAtEnd())
+ const char* helpString = 0;
+
+ const char* existingValue =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryValue(curField);
+ if (existingValue)
{
- helpString = it.GetProperty("HELPSTRING");
+ helpString = this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryProperty(curField, "HELPSTRING");
}
if (helpString)
{
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=9e64156725e431ae15ce92be4e470cae6edf5bd6
commit 9e64156725e431ae15ce92be4e470cae6edf5bd6
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Mon Apr 6 10:46:25 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Wed Apr 8 18:47:00 2015 +0200
cmMakefile: Port away from CacheEntry.Initialized.
The API has no other external users.
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index b6eff3d..7c1b9c4 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -1810,16 +1810,17 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
{
bool haveVal = value ? true : false;
std::string val = haveVal ? value : "";
- cmCacheManager::CacheIterator it =
- this->GetCacheManager()->GetCacheIterator(name.c_str());
- if(!it.IsAtEnd() && (it.GetType() == cmCacheManager::UNINITIALIZED) &&
- it.Initialized())
+ const char* existingValue =
+ this->GetCacheManager()->GetInitializedCacheValue(name);
+ if(existingValue
+ && (this->GetCacheManager()->GetCacheEntryType(name)
+ == cmCacheManager::UNINITIALIZED))
{
// if this is not a force, then use the value from the cache
// if it is a force, then use the value being passed in
if(!force)
{
- val = it.GetValue();
+ val = existingValue;
haveVal = true;
}
if ( type == cmCacheManager::PATH || type == cmCacheManager::FILEPATH )
@@ -1842,7 +1843,7 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
}
this->GetCacheManager()->AddCacheEntry(name, nvalue.c_str(), doc, type);
- val = it.GetValue();
+ val = this->GetCacheManager()->GetInitializedCacheValue(name);
haveVal = true;
}
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=1e2dbfce37acd1b7e7dc5bb1b45d71c5ac0c3599
commit 1e2dbfce37acd1b7e7dc5bb1b45d71c5ac0c3599
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Sun Apr 5 19:50:05 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Wed Apr 8 18:47:00 2015 +0200
cmCacheManager: Add non-iterator-based API.
The iterator pattern is an unusual one for CMake, and it hinders
refactoring all configuration-time data manipulation into a
single class.
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
index d2712bb..3b02fa6 100644
--- a/Source/cmCacheManager.h
+++ b/Source/cmCacheManager.h
@@ -139,6 +139,81 @@ public:
///! Get a value from the cache given a key
const char* GetInitializedCacheValue(const std::string& key) const;
+ const char* GetCacheEntryValue(const std::string& key)
+ {
+ cmCacheManager::CacheIterator it = this->GetCacheIterator(key.c_str());
+ if (it.IsAtEnd())
+ {
+ return 0;
+ }
+ return it.GetValue();
+ }
+
+ const char* GetCacheEntryProperty(std::string const& key,
+ std::string const& propName)
+ {
+ return this->GetCacheIterator(key.c_str()).GetProperty(propName);
+ }
+
+ CacheEntryType GetCacheEntryType(std::string const& key)
+ {
+ return this->GetCacheIterator(key.c_str()).GetType();
+ }
+
+ bool GetCacheEntryPropertyAsBool(std::string const& key,
+ std::string const& propName)
+ {
+ return this->GetCacheIterator(key.c_str()).GetPropertyAsBool(propName);
+ }
+
+ void SetCacheEntryProperty(std::string const& key,
+ std::string const& propName,
+ std::string const& value)
+ {
+ this->GetCacheIterator(key.c_str()).SetProperty(propName, value.c_str());
+ }
+
+ void SetCacheEntryBoolProperty(std::string const& key,
+ std::string const& propName,
+ bool value)
+ {
+ this->GetCacheIterator(key.c_str()).SetProperty(propName, value);
+ }
+
+ void SetCacheEntryValue(std::string const& key,
+ std::string const& value)
+ {
+ this->GetCacheIterator(key.c_str()).SetValue(value.c_str());
+ }
+
+ void RemoveCacheEntryProperty(std::string const& key,
+ std::string const& propName)
+ {
+ this->GetCacheIterator(key.c_str()).SetProperty(propName, (void*)0);
+ }
+
+ void AppendCacheEntryProperty(std::string const& key,
+ std::string const& propName,
+ std::string const& value,
+ bool asString = false)
+ {
+ this->GetCacheIterator(key.c_str()).AppendProperty(propName,
+ value.c_str(),
+ asString);
+ }
+
+ std::vector<std::string> GetCacheEntryKeys()
+ {
+ std::vector<std::string> definitions;
+ definitions.reserve(this->GetSize());
+ cmCacheManager::CacheIterator cit = this->GetCacheIterator();
+ for ( cit.Begin(); !cit.IsAtEnd(); cit.Next() )
+ {
+ definitions.push_back(cit.GetName());
+ }
+ return definitions;
+ }
+
/** Get the version of CMake that wrote the cache. */
unsigned int GetCacheMajorVersion() const
{ return this->CacheMajorVersion; }
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=60a62a91c4c67859d8e8f51aafcf0eb929edc036
commit 60a62a91c4c67859d8e8f51aafcf0eb929edc036
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Wed Apr 8 18:43:46 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Wed Apr 8 18:45:51 2015 +0200
cmCacheManager: Return a C string from GetValue.
This is for consistency with other CMake access interfaces such as
definitions and properties which use a null value as a 'not present'
value. It is source compatible with existing callers, and it returns
a pointer into actual real cache entry storage.
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
index 31d302a..d2712bb 100644
--- a/Source/cmCacheManager.h
+++ b/Source/cmCacheManager.h
@@ -65,7 +65,7 @@ public:
void AppendProperty(const std::string& property, const char* value,
bool asString=false);
void SetProperty(const std::string& property, bool value);
- std::string GetValue() const { return this->GetEntry().Value; }
+ const char* GetValue() const { return this->GetEntry().Value.c_str(); }
bool GetValueAsBool() const;
void SetValue(const char*);
CacheEntryType GetType() const { return this->GetEntry().Type; }
-----------------------------------------------------------------------
Summary of changes:
hooks/post-receive
--
CMake
More information about the Cmake-commits
mailing list