From 80d8b20351dbfa72e3dc0ab6b9c5f3c05f674b2f Mon Sep 17 00:00:00 2001
From: Tushar Maheshwari <tushar27192@gmail.com>
Date: Fri, 17 Apr 2020 17:01:53 +0530
Subject: cmCacheManager: Cleanup CacheIterator interface
- Expose required functionality from CacheEntry.
- Modify usage in cmState member functions.
- Remove cmState access to CacheEntry members.
---
Source/cmCacheManager.cxx | 202 ++++++++++++++--------------------------------
Source/cmCacheManager.h | 195 +++++++++++++++++++-------------------------
Source/cmState.cxx | 43 +++-------
3 files changed, 153 insertions(+), 287 deletions(-)
diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
index 31a8692..35bd681 100644
--- a/Source/cmCacheManager.cxx
+++ b/Source/cmCacheManager.cxx
@@ -19,12 +19,6 @@
#include "cmSystemTools.h"
#include "cmVersion.h"
-cmCacheManager::cmCacheManager()
-{
- this->CacheMajorVersion = 0;
- this->CacheMinorVersion = 0;
-}
-
void cmCacheManager::CleanCMakeFiles(const std::string& path)
{
std::string glob = cmStrCat(path, "/CMakeFiles/*.cmake");
@@ -172,10 +166,10 @@ bool cmCacheManager::LoadCache(const std::string& path, bool internal,
}
const char* cmCacheManager::PersistentProperties[] = { "ADVANCED", "MODIFIED",
- "STRINGS", nullptr };
+ "STRINGS" };
-bool cmCacheManager::ReadPropertyEntry(std::string const& entryKey,
- CacheEntry& e)
+bool cmCacheManager::ReadPropertyEntry(const std::string& entryKey,
+ const CacheEntry& e)
{
// All property entries are internal.
if (e.Type != cmStateEnums::INTERNAL) {
@@ -183,20 +177,18 @@ bool cmCacheManager::ReadPropertyEntry(std::string const& entryKey,
}
const char* end = entryKey.c_str() + entryKey.size();
- for (const char** p = cmCacheManager::PersistentProperties; *p; ++p) {
- std::string::size_type plen = strlen(*p) + 1;
+ for (const char* p : cmCacheManager::PersistentProperties) {
+ std::string::size_type plen = strlen(p) + 1;
if (entryKey.size() > plen && *(end - plen) == '-' &&
- strcmp(end - plen + 1, *p) == 0) {
+ strcmp(end - plen + 1, p) == 0) {
std::string key = entryKey.substr(0, entryKey.size() - plen);
- cmCacheManager::CacheIterator it = this->GetCacheIterator(key);
- if (it.IsAtEnd()) {
+ if (auto entry = this->GetCacheEntry(key)) {
+ // Store this property on its entry.
+ entry->SetProperty(p, e.Value.c_str());
+ } else {
// Create an entry and store the property.
CacheEntry& ne = this->Cache[key];
- ne.Type = cmStateEnums::UNINITIALIZED;
- ne.SetProperty(*p, e.Value.c_str());
- } else {
- // Store this property on its entry.
- it.SetProperty(*p, e.Value.c_str());
+ ne.SetProperty(p, e.Value.c_str());
}
return true;
}
@@ -204,16 +196,18 @@ bool cmCacheManager::ReadPropertyEntry(std::string const& entryKey,
return false;
}
-void cmCacheManager::WritePropertyEntries(std::ostream& os, CacheIterator i,
- cmMessenger* messenger)
+void cmCacheManager::WritePropertyEntries(std::ostream& os,
+ const std::string& entryKey,
+ const CacheEntry& e,
+ cmMessenger* messenger) const
{
- for (const char** p = cmCacheManager::PersistentProperties; *p; ++p) {
- if (cmProp value = i.GetProperty(*p)) {
+ for (const char* p : cmCacheManager::PersistentProperties) {
+ if (cmProp value = e.GetProperty(p)) {
std::string helpstring =
- cmStrCat(*p, " property for variable: ", i.GetName());
+ cmStrCat(p, " property for variable: ", entryKey);
cmCacheManager::OutputHelpString(os, helpstring);
- std::string key = cmStrCat(i.GetName(), '-', *p);
+ std::string key = cmStrCat(entryKey, '-', p);
cmCacheManager::OutputKey(os, key);
os << ":INTERNAL=";
cmCacheManager::OutputValue(os, *value);
@@ -322,25 +316,24 @@ bool cmCacheManager::SaveCache(const std::string& path, cmMessenger* messenger)
"########################\n"
"\n";
- for (cmCacheManager::CacheIterator i = this->NewIterator(); !i.IsAtEnd();
- i.Next()) {
- if (!i.Initialized()) {
+ for (auto const& i : this->Cache) {
+ if (!i.second.Initialized) {
continue;
}
- cmStateEnums::CacheEntryType t = i.GetType();
- this->WritePropertyEntries(fout, i, messenger);
+ cmStateEnums::CacheEntryType t = i.second.GetType();
+ this->WritePropertyEntries(fout, i.first, i.second, messenger);
if (t == cmStateEnums::INTERNAL) {
// Format is key:type=value
- if (cmProp help = i.GetProperty("HELPSTRING")) {
+ if (cmProp help = i.second.GetProperty("HELPSTRING")) {
cmCacheManager::OutputHelpString(fout, *help);
}
- cmCacheManager::OutputKey(fout, i.GetName());
+ cmCacheManager::OutputKey(fout, i.first);
fout << ':' << cmState::CacheEntryTypeToString(t) << '=';
- cmCacheManager::OutputValue(fout, i.GetValue());
+ cmCacheManager::OutputValue(fout, i.second.GetValue());
fout << '\n';
- cmCacheManager::OutputNewlineTruncationWarning(fout, i.GetName(),
- i.GetValue(), messenger);
+ cmCacheManager::OutputNewlineTruncationWarning(
+ fout, i.first, i.second.GetValue(), messenger);
}
}
fout << '\n';
@@ -479,10 +472,7 @@ void cmCacheManager::OutputNewlineTruncationWarning(std::ostream& fout,
void cmCacheManager::RemoveCacheEntry(const std::string& key)
{
- auto i = this->Cache.find(key);
- if (i != this->Cache.end()) {
- this->Cache.erase(i);
- }
+ this->Cache.erase(key);
}
cmCacheManager::CacheEntry* cmCacheManager::GetCacheEntry(
@@ -495,22 +485,22 @@ cmCacheManager::CacheEntry* cmCacheManager::GetCacheEntry(
return nullptr;
}
-cmCacheManager::CacheIterator cmCacheManager::GetCacheIterator(
- const std::string& key)
-{
- return { *this, key.c_str() };
-}
-
-cmCacheManager::CacheIterator cmCacheManager::GetCacheIterator()
+const cmCacheManager::CacheEntry* cmCacheManager::GetCacheEntry(
+ const std::string& key) const
{
- return { *this, nullptr };
+ auto i = this->Cache.find(key);
+ if (i != this->Cache.end()) {
+ return &i->second;
+ }
+ return nullptr;
}
cmProp cmCacheManager::GetInitializedCacheValue(const std::string& key) const
{
- auto i = this->Cache.find(key);
- if (i != this->Cache.end() && i->second.Initialized) {
- return &i->second.Value;
+ if (auto entry = this->GetCacheEntry(key)) {
+ if (entry->Initialized) {
+ return &entry->GetValue();
+ }
}
return nullptr;
}
@@ -535,12 +525,7 @@ void cmCacheManager::AddCacheEntry(const std::string& key, const char* value,
cmStateEnums::CacheEntryType type)
{
CacheEntry& e = this->Cache[key];
- if (value) {
- e.Value = value;
- e.Initialized = true;
- } else {
- e.Value.clear();
- }
+ e.SetValue(value);
e.Type = type;
// make sure we only use unix style paths
if (type == cmStateEnums::FILEPATH || type == cmStateEnums::PATH) {
@@ -564,53 +549,16 @@ void cmCacheManager::AddCacheEntry(const std::string& key, const char* value,
: "(This variable does not exist and should not be used)");
}
-bool cmCacheManager::CacheIterator::IsAtEnd() const
-{
- return this->Position == this->Container.Cache.end();
-}
-
-void cmCacheManager::CacheIterator::Begin()
-{
- this->Position = this->Container.Cache.begin();
-}
-
-bool cmCacheManager::CacheIterator::Find(const std::string& key)
+void cmCacheManager::CacheEntry::SetValue(const char* value)
{
- this->Position = this->Container.Cache.find(key);
- return !this->IsAtEnd();
-}
-
-void cmCacheManager::CacheIterator::Next()
-{
- if (!this->IsAtEnd()) {
- ++this->Position;
- }
-}
-
-std::vector<std::string> cmCacheManager::CacheIterator::GetPropertyList() const
-{
- return this->GetEntry().GetPropertyList();
-}
-
-void cmCacheManager::CacheIterator::SetValue(const char* value)
-{
- if (this->IsAtEnd()) {
- return;
- }
- CacheEntry* entry = &this->GetEntry();
if (value) {
- entry->Value = value;
- entry->Initialized = true;
+ this->Value = value;
+ this->Initialized = true;
} else {
- entry->Value.clear();
+ this->Value.clear();
}
}
-bool cmCacheManager::CacheIterator::GetValueAsBool() const
-{
- return cmIsOn(this->GetEntry().Value);
-}
-
std::vector<std::string> cmCacheManager::CacheEntry::GetPropertyList() const
{
return this->Properties.GetKeys();
@@ -627,6 +575,15 @@ cmProp cmCacheManager::CacheEntry::GetProperty(const std::string& prop) const
return this->Properties.GetPropertyValue(prop);
}
+bool cmCacheManager::CacheEntry::GetPropertyAsBool(
+ const std::string& prop) const
+{
+ if (cmProp value = this->GetProperty(prop)) {
+ return cmIsOn(*value);
+ }
+ return false;
+}
+
void cmCacheManager::CacheEntry::SetProperty(const std::string& prop,
const char* value)
{
@@ -639,6 +596,11 @@ void cmCacheManager::CacheEntry::SetProperty(const std::string& prop,
}
}
+void cmCacheManager::CacheEntry::SetProperty(const std::string& p, bool v)
+{
+ this->SetProperty(p, v ? "ON" : "OFF");
+}
+
void cmCacheManager::CacheEntry::AppendProperty(const std::string& prop,
const std::string& value,
bool asString)
@@ -657,49 +619,3 @@ void cmCacheManager::CacheEntry::AppendProperty(const std::string& prop,
this->Properties.AppendProperty(prop, value, asString);
}
}
-
-cmProp cmCacheManager::CacheIterator::GetProperty(
- const std::string& prop) const
-{
- if (!this->IsAtEnd()) {
- return this->GetEntry().GetProperty(prop);
- }
- return nullptr;
-}
-
-void cmCacheManager::CacheIterator::SetProperty(const std::string& p,
- const char* v)
-{
- if (!this->IsAtEnd()) {
- this->GetEntry().SetProperty(p, v);
- }
-}
-
-void cmCacheManager::CacheIterator::AppendProperty(const std::string& p,
- const std::string& v,
- bool asString)
-{
- if (!this->IsAtEnd()) {
- this->GetEntry().AppendProperty(p, v, asString);
- }
-}
-
-bool cmCacheManager::CacheIterator::GetPropertyAsBool(
- const std::string& prop) const
-{
- if (cmProp value = this->GetProperty(prop)) {
- return cmIsOn(*value);
- }
- return false;
-}
-
-void cmCacheManager::CacheIterator::SetProperty(const std::string& p, bool v)
-{
- this->SetProperty(p, v ? "ON" : "OFF");
-}
-
-bool cmCacheManager::CacheIterator::PropertyExists(
- const std::string& prop) const
-{
- return this->GetProperty(prop) != nullptr;
-}
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
index 3db76a9..3d946b4 100644
--- a/Source/cmCacheManager.h
+++ b/Source/cmCacheManager.h
@@ -25,77 +25,33 @@ class cmMessenger;
*/
class cmCacheManager
{
-public:
- cmCacheManager();
- class CacheIterator;
- friend class cmCacheManager::CacheIterator;
-
-private:
- struct CacheEntry
+ class CacheEntry
{
- std::string Value;
- cmStateEnums::CacheEntryType Type = cmStateEnums::UNINITIALIZED;
- cmPropertyMap Properties;
- std::vector<std::string> GetPropertyList() const;
- cmProp GetProperty(const std::string&) const;
- void SetProperty(const std::string& property, const char* value);
- void AppendProperty(const std::string& property, const std::string& value,
- bool asString = false);
- bool Initialized = false;
- };
+ friend class cmCacheManager;
-public:
- class CacheIterator
- {
public:
- void Begin();
- bool Find(const std::string&);
- bool IsAtEnd() const;
- void Next();
- std::string GetName() const { return this->Position->first; }
+ const std::string& GetValue() const { return this->Value; }
+ void SetValue(const char*);
+
+ cmStateEnums::CacheEntryType GetType() const { return this->Type; }
+ void SetType(cmStateEnums::CacheEntryType ty) { this->Type = ty; }
+
std::vector<std::string> GetPropertyList() const;
- cmProp GetProperty(const std::string&) const;
- bool GetPropertyAsBool(const std::string&) const;
- bool PropertyExists(const std::string&) const;
+ cmProp GetProperty(const std::string& property) const;
+ bool GetPropertyAsBool(const std::string& property) const;
void SetProperty(const std::string& property, const char* value);
+ void SetProperty(const std::string& property, bool value);
void AppendProperty(const std::string& property, const std::string& value,
bool asString = false);
- void SetProperty(const std::string& property, bool value);
- const std::string& GetValue() const { return this->GetEntry().Value; }
- bool GetValueAsBool() const;
- void SetValue(const char*);
- cmStateEnums::CacheEntryType GetType() const
- {
- return this->GetEntry().Type;
- }
- void SetType(cmStateEnums::CacheEntryType ty)
- {
- this->GetEntry().Type = ty;
- }
- bool Initialized() { return this->GetEntry().Initialized; }
- cmCacheManager& Container;
- std::map<std::string, CacheEntry>::iterator Position;
- CacheIterator(cmCacheManager& cm)
- : Container(cm)
- {
- this->Begin();
- }
- CacheIterator(cmCacheManager& cm, const char* key)
- : Container(cm)
- {
- if (key) {
- this->Find(key);
- }
- }
private:
- CacheEntry const& GetEntry() const { return this->Position->second; }
- CacheEntry& GetEntry() { return this->Position->second; }
+ std::string Value;
+ cmStateEnums::CacheEntryType Type = cmStateEnums::UNINITIALIZED;
+ cmPropertyMap Properties;
+ bool Initialized = false;
};
- //! return an iterator to iterate through the cache map
- cmCacheManager::CacheIterator NewIterator() { return { *this }; }
-
+public:
//! Load a cache for given makefile. Loads from path/CMakeCache.txt.
bool LoadCache(const std::string& path, bool internal,
std::set<std::string>& excludes,
@@ -110,67 +66,82 @@ public:
//! Print the cache to a stream
void PrintCache(std::ostream&) const;
- //! Get the iterator for an entry with a given key.
- cmCacheManager::CacheIterator GetCacheIterator(const std::string& key);
- cmCacheManager::CacheIterator GetCacheIterator();
-
- //! Remove an entry from the cache
- void RemoveCacheEntry(const std::string& key);
-
- //! Get the number of entries in the cache
- int GetSize() { return static_cast<int>(this->Cache.size()); }
-
//! Get a value from the cache given a key
cmProp GetInitializedCacheValue(const std::string& key) const;
- cmProp GetCacheEntryValue(const std::string& key)
+ cmProp GetCacheEntryValue(const std::string& key) const
{
- cmCacheManager::CacheIterator it = this->GetCacheIterator(key);
- if (it.IsAtEnd()) {
- return nullptr;
+ if (auto entry = this->GetCacheEntry(key)) {
+ return &entry->GetValue();
}
- return &it.GetValue();
+ return nullptr;
}
- cmProp GetCacheEntryProperty(std::string const& key,
- std::string const& propName)
+ void SetCacheEntryValue(std::string const& key, std::string const& value)
{
- return this->GetCacheIterator(key).GetProperty(propName);
+ if (auto entry = this->GetCacheEntry(key)) {
+ entry->SetValue(value.c_str());
+ }
}
- cmStateEnums::CacheEntryType GetCacheEntryType(std::string const& key)
+ cmStateEnums::CacheEntryType GetCacheEntryType(std::string const& key) const
{
- return this->GetCacheIterator(key).GetType();
+ if (auto entry = this->GetCacheEntry(key)) {
+ return entry->GetType();
+ }
+ return cmStateEnums::UNINITIALIZED;
+ }
+
+ std::vector<std::string> GetCacheEntryPropertyList(
+ std::string const& key) const
+ {
+ if (auto entry = this->GetCacheEntry(key)) {
+ return entry->GetPropertyList();
+ }
+ return {};
+ }
+
+ cmProp GetCacheEntryProperty(std::string const& key,
+ std::string const& propName) const
+ {
+ if (auto entry = this->GetCacheEntry(key)) {
+ return entry->GetProperty(propName);
+ }
+ return nullptr;
}
bool GetCacheEntryPropertyAsBool(std::string const& key,
- std::string const& propName)
+ std::string const& propName) const
{
- return this->GetCacheIterator(key).GetPropertyAsBool(propName);
+ if (auto entry = this->GetCacheEntry(key)) {
+ return entry->GetPropertyAsBool(propName);
+ }
+ return false;
}
void SetCacheEntryProperty(std::string const& key,
std::string const& propName,
std::string const& value)
{
- this->GetCacheIterator(key).SetProperty(propName, value.c_str());
+ if (auto entry = this->GetCacheEntry(key)) {
+ entry->SetProperty(propName, value.c_str());
+ }
}
void SetCacheEntryBoolProperty(std::string const& key,
std::string const& propName, bool value)
{
- this->GetCacheIterator(key).SetProperty(propName, value);
- }
-
- void SetCacheEntryValue(std::string const& key, std::string const& value)
- {
- this->GetCacheIterator(key).SetValue(value.c_str());
+ if (auto entry = this->GetCacheEntry(key)) {
+ entry->SetProperty(propName, value);
+ }
}
void RemoveCacheEntryProperty(std::string const& key,
std::string const& propName)
{
- this->GetCacheIterator(key).SetProperty(propName, nullptr);
+ if (auto entry = this->GetCacheEntry(key)) {
+ entry->SetProperty(propName, nullptr);
+ }
}
void AppendCacheEntryProperty(std::string const& key,
@@ -178,16 +149,17 @@ public:
std::string const& value,
bool asString = false)
{
- this->GetCacheIterator(key).AppendProperty(propName, value, asString);
+ if (auto entry = this->GetCacheEntry(key)) {
+ entry->AppendProperty(propName, value, asString);
+ }
}
- std::vector<std::string> GetCacheEntryKeys()
+ std::vector<std::string> GetCacheEntryKeys() const
{
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());
+ definitions.reserve(this->Cache.size());
+ for (auto const& i : this->Cache) {
+ definitions.push_back(i.first);
}
return definitions;
}
@@ -196,23 +168,22 @@ public:
unsigned int GetCacheMajorVersion() const { return this->CacheMajorVersion; }
unsigned int GetCacheMinorVersion() const { return this->CacheMinorVersion; }
-protected:
//! Add an entry into the cache
void AddCacheEntry(const std::string& key, const char* value,
const char* helpString,
cmStateEnums::CacheEntryType type);
+ //! Remove an entry from the cache
+ void RemoveCacheEntry(const std::string& key);
+
+private:
//! Get a cache entry object for a key
CacheEntry* GetCacheEntry(const std::string& key);
+ const CacheEntry* GetCacheEntry(const std::string& key) const;
+
//! Clean out the CMakeFiles directory if no CMakeCache.txt
void CleanCMakeFiles(const std::string& path);
- // Cache version info
- unsigned int CacheMajorVersion;
- unsigned int CacheMinorVersion;
-
-private:
- using CacheEntryMap = std::map<std::string, CacheEntry>;
static void OutputHelpString(std::ostream& fout,
const std::string& helpString);
static void OutputWarningComment(std::ostream& fout,
@@ -228,15 +199,15 @@ private:
std::string const& value);
static const char* PersistentProperties[];
- bool ReadPropertyEntry(std::string const& key, CacheEntry& e);
- void WritePropertyEntries(std::ostream& os, CacheIterator i,
- cmMessenger* messenger);
-
- CacheEntryMap Cache;
- // Only cmake and cmState should be able to add cache values
- // the commands should never use the cmCacheManager directly
- friend class cmState; // allow access to add cache values
- friend class cmake; // allow access to add cache values
+ bool ReadPropertyEntry(const std::string& key, const CacheEntry& e);
+ void WritePropertyEntries(std::ostream& os, const std::string& entryKey,
+ const CacheEntry& e, cmMessenger* messenger) const;
+
+ std::map<std::string, CacheEntry> Cache;
+
+ // Cache version info
+ unsigned int CacheMajorVersion = 0;
+ unsigned int CacheMinorVersion = 0;
};
#endif
diff --git a/Source/cmState.cxx b/Source/cmState.cxx
index 2dfdcf7..2e748d3 100644
--- a/Source/cmState.cxx
+++ b/Source/cmState.cxx
@@ -139,28 +139,17 @@ bool cmState::DeleteCache(const std::string& path)
std::vector<std::string> cmState::GetCacheEntryKeys() const
{
- std::vector<std::string> definitions;
- definitions.reserve(this->CacheManager->GetSize());
- cmCacheManager::CacheIterator cit = this->CacheManager->GetCacheIterator();
- for (cit.Begin(); !cit.IsAtEnd(); cit.Next()) {
- definitions.push_back(cit.GetName());
- }
- return definitions;
+ return this->CacheManager->GetCacheEntryKeys();
}
cmProp cmState::GetCacheEntryValue(std::string const& key) const
{
- cmCacheManager::CacheEntry* e = this->CacheManager->GetCacheEntry(key);
- if (!e) {
- return nullptr;
- }
- return &e->Value;
+ return this->CacheManager->GetCacheEntryValue(key);
}
std::string cmState::GetSafeCacheEntryValue(std::string const& key) const
{
- cmProp val = this->GetCacheEntryValue(key);
- if (val) {
+ if (cmProp val = this->GetCacheEntryValue(key)) {
return *val;
}
return std::string();
@@ -175,8 +164,7 @@ const std::string* cmState::GetInitializedCacheValue(
cmStateEnums::CacheEntryType cmState::GetCacheEntryType(
std::string const& key) const
{
- cmCacheManager::CacheIterator it = this->CacheManager->GetCacheIterator(key);
- return it.GetType();
+ return this->CacheManager->GetCacheEntryType(key);
}
void cmState::SetCacheEntryValue(std::string const& key,
@@ -189,40 +177,32 @@ void cmState::SetCacheEntryProperty(std::string const& key,
std::string const& propertyName,
std::string const& value)
{
- cmCacheManager::CacheIterator it = this->CacheManager->GetCacheIterator(key);
- it.SetProperty(propertyName, value.c_str());
+ this->CacheManager->SetCacheEntryProperty(key, propertyName, value);
}
void cmState::SetCacheEntryBoolProperty(std::string const& key,
std::string const& propertyName,
bool value)
{
- cmCacheManager::CacheIterator it = this->CacheManager->GetCacheIterator(key);
- it.SetProperty(propertyName, value);
+ this->CacheManager->SetCacheEntryBoolProperty(key, propertyName, value);
}
std::vector<std::string> cmState::GetCacheEntryPropertyList(
const std::string& key)
{
- cmCacheManager::CacheIterator it = this->CacheManager->GetCacheIterator(key);
- return it.GetPropertyList();
+ return this->CacheManager->GetCacheEntryPropertyList(key);
}
cmProp cmState::GetCacheEntryProperty(std::string const& key,
std::string const& propertyName)
{
- cmCacheManager::CacheIterator it = this->CacheManager->GetCacheIterator(key);
- if (!it.PropertyExists(propertyName)) {
- return nullptr;
- }
- return it.GetProperty(propertyName);
+ return this->CacheManager->GetCacheEntryProperty(key, propertyName);
}
bool cmState::GetCacheEntryPropertyAsBool(std::string const& key,
std::string const& propertyName)
{
- return this->CacheManager->GetCacheIterator(key).GetPropertyAsBool(
- propertyName);
+ return this->CacheManager->GetCacheEntryPropertyAsBool(key, propertyName);
}
void cmState::AddCacheEntry(const std::string& key, const char* value,
@@ -274,14 +254,13 @@ void cmState::AppendCacheEntryProperty(const std::string& key,
const std::string& property,
const std::string& value, bool asString)
{
- this->CacheManager->GetCacheIterator(key).AppendProperty(property, value,
- asString);
+ this->CacheManager->AppendCacheEntryProperty(key, property, value, asString);
}
void cmState::RemoveCacheEntryProperty(std::string const& key,
std::string const& propertyName)
{
- this->CacheManager->GetCacheIterator(key).SetProperty(propertyName, nullptr);
+ this->CacheManager->RemoveCacheEntryProperty(key, propertyName);
}
cmStateSnapshot cmState::Reset()
--
cgit v0.12