summaryrefslogtreecommitdiff
path: root/Source/cmCacheManager.h
diff options
context:
space:
mode:
Diffstat (limited to 'Source/cmCacheManager.h')
-rw-r--r--Source/cmCacheManager.h189
1 files changed, 189 insertions, 0 deletions
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
new file mode 100644
index 000000000..9c94d214c
--- /dev/null
+++ b/Source/cmCacheManager.h
@@ -0,0 +1,189 @@
+/*============================================================================
+ CMake - Cross Platform Makefile Generator
+ Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+ Distributed under the OSI-approved BSD License (the "License");
+ see accompanying file Copyright.txt for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even the
+ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the License for more information.
+============================================================================*/
+#ifndef cmCacheManager_h
+#define cmCacheManager_h
+
+#include "cmStandardIncludes.h"
+#include "cmPropertyMap.h"
+class cmMakefile;
+class cmMarkAsAdvancedCommand;
+class cmake;
+
+/** \class cmCacheManager
+ * \brief Control class for cmake's cache
+ *
+ * Load and Save CMake cache files.
+ *
+ */
+class cmCacheManager
+{
+public:
+ cmCacheManager(cmake* cm);
+ class CacheIterator;
+ friend class cmCacheManager::CacheIterator;
+ enum CacheEntryType{ BOOL=0, PATH, FILEPATH, STRING, INTERNAL,STATIC,
+ UNINITIALIZED };
+
+private:
+ struct CacheEntry
+ {
+ std::string Value;
+ CacheEntryType Type;
+ cmPropertyMap Properties;
+ const char* GetProperty(const char*) const;
+ void SetProperty(const char* property, const char* value);
+ void AppendProperty(const char* property, const char* value,
+ bool asString=false);
+ bool Initialized;
+ CacheEntry() : Value(""), Type(UNINITIALIZED), Initialized(false)
+ {}
+ };
+
+public:
+ class CacheIterator
+ {
+ public:
+ void Begin();
+ bool Find(const char*);
+ bool IsAtEnd() const;
+ void Next();
+ const char *GetName() const {
+ return this->Position->first.c_str(); }
+ const char* GetProperty(const char*) const ;
+ bool GetPropertyAsBool(const char*) const ;
+ bool PropertyExists(const char*) const;
+ void SetProperty(const char* property, const char* value);
+ void AppendProperty(const char* property, const char* value,
+ bool asString=false);
+ void SetProperty(const char* property, bool 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; }
+ void SetType(CacheEntryType ty) { this->GetEntry().Type = ty; }
+ bool Initialized() { return this->GetEntry().Initialized; }
+ cmCacheManager &Container;
+ std::map<cmStdString, 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; }
+ };
+
+ ///! return an iterator to iterate through the cache map
+ cmCacheManager::CacheIterator NewIterator()
+ {
+ return CacheIterator(*this);
+ }
+
+ /**
+ * Types for the cache entries. These are useful as
+ * hints for a cache editor program. Path should bring
+ * up a file chooser, BOOL a check box, and STRING a
+ * text entry box, FILEPATH is a full path to a file which
+ * can be different than just a path input
+ */
+ static CacheEntryType StringToType(const char*);
+ static const char* TypeToString(CacheEntryType);
+ static bool IsType(const char*);
+
+ ///! Load a cache for given makefile. Loads from ouput home.
+ bool LoadCache(cmMakefile*);
+ ///! Load a cache for given makefile. Loads from path/CMakeCache.txt.
+ bool LoadCache(const char* path);
+ bool LoadCache(const char* path, bool internal);
+ bool LoadCache(const char* path, bool internal,
+ std::set<cmStdString>& excludes,
+ std::set<cmStdString>& includes);
+
+ ///! Save cache for given makefile. Saves to ouput home CMakeCache.txt.
+ bool SaveCache(cmMakefile*) ;
+ ///! Save cache for given makefile. Saves to ouput path/CMakeCache.txt
+ bool SaveCache(const char* path) ;
+
+ ///! Delete the cache given
+ bool DeleteCache(const char* path);
+
+ ///! 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 char *key=0);
+
+ ///! Remove an entry from the cache
+ void RemoveCacheEntry(const char* key);
+
+ ///! Get the number of entries in the cache
+ int GetSize() {
+ return static_cast<int>(this->Cache.size()); }
+
+ ///! Break up a line like VAR:type="value" into var, type and value
+ static bool ParseEntry(const char* entry,
+ std::string& var,
+ std::string& value,
+ CacheEntryType& type);
+
+ ///! Get a value from the cache given a key
+ const char* GetCacheValue(const char* key) const;
+
+ /** Get the version of CMake that wrote the cache. */
+ unsigned int GetCacheMajorVersion() { return this->CacheMajorVersion; }
+ unsigned int GetCacheMinorVersion() { return this->CacheMinorVersion; }
+ bool NeedCacheCompatibility(int major, int minor);
+
+ /** Define and document CACHE entry properties. */
+ static void DefineProperties(cmake *cm);
+
+protected:
+ ///! Add an entry into the cache
+ void AddCacheEntry(const char* key, const char* value,
+ const char* helpString, CacheEntryType type);
+
+ ///! Get a cache entry object for a key
+ CacheEntry *GetCacheEntry(const char *key);
+ ///! Clean out the CMakeFiles directory if no CMakeCache.txt
+ void CleanCMakeFiles(const char* path);
+
+ // Cache version info
+ unsigned int CacheMajorVersion;
+ unsigned int CacheMinorVersion;
+private:
+ cmake* CMakeInstance;
+ typedef std::map<cmStdString, CacheEntry> CacheEntryMap;
+ static void OutputHelpString(std::ostream& fout,
+ const std::string& helpString);
+ static void OutputKey(std::ostream& fout, std::string const& key);
+ static void OutputValue(std::ostream& fout, std::string const& value);
+
+ static const char* PersistentProperties[];
+ bool ReadPropertyEntry(std::string const& key, CacheEntry& e);
+ void WritePropertyEntries(std::ostream& os, CacheIterator const& i);
+
+ CacheEntryMap Cache;
+ // Only cmake and cmMakefile should be able to add cache values
+ // the commands should never use the cmCacheManager directly
+ friend class cmMakefile; // allow access to add cache values
+ friend class cmake; // allow access to add cache values
+ friend class cmakewizard; // allow access to add cache values
+ friend class cmMarkAsAdvancedCommand; // allow access to add cache values
+};
+
+#endif