1 /*
2 Copyright (C) 2001-2006, William Joseph.
3 All Rights Reserved.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #if !defined(INCLUDED_PREFERENCEDICTIONARY_H)
23 #define INCLUDED_PREFERENCEDICTIONARY_H
24
25 #include "preferencesystem.h"
26 #include "xml/ixml.h"
27 #include "stream/stringstream.h"
28 #include "generic/callback.h"
29 #include "versionlib.h"
30 #include <map>
31
32 class PreferenceDictionary : public PreferenceSystem
33 {
34 class PreferenceEntry
35 {
36 StringImportCallback m_importer;
37 StringExportCallback m_exporter;
38 public:
PreferenceEntry(const StringImportCallback & importer,const StringExportCallback & exporter)39 PreferenceEntry(const StringImportCallback& importer, const StringExportCallback& exporter)
40 : m_importer(importer), m_exporter(exporter)
41 {
42 }
importString(const char * string)43 void importString(const char* string)
44 {
45 m_importer(string);
46 }
exportString(const StringImportCallback & importer)47 void exportString(const StringImportCallback& importer)
48 {
49 m_exporter(importer);
50 }
51 };
52
53 typedef std::map<CopiedString, PreferenceEntry> PreferenceEntries;
54 PreferenceEntries m_preferences;
55
56 typedef std::map<CopiedString, CopiedString> PreferenceCache;
57 PreferenceCache m_cache;
58
59 public:
60 typedef PreferenceEntries::iterator iterator;
61
begin()62 iterator begin()
63 {
64 return m_preferences.begin();
65 }
end()66 iterator end()
67 {
68 return m_preferences.end();
69 }
find(const char * name)70 iterator find(const char* name)
71 {
72 return m_preferences.find(name);
73 }
74
registerPreference(const char * name,const StringImportCallback & importer,const StringExportCallback & exporter)75 void registerPreference(const char* name, const StringImportCallback& importer, const StringExportCallback& exporter)
76 {
77 m_preferences.insert(PreferenceEntries::value_type(name, PreferenceEntry(importer, exporter)));
78 PreferenceCache::iterator i = m_cache.find(name);
79 if(i != m_cache.end())
80 {
81 importer((*i).second.c_str());
82 m_cache.erase(i);
83 }
84 }
85
importPref(const char * name,const char * value)86 void importPref(const char* name, const char* value)
87 {
88 PreferenceEntries::iterator i = m_preferences.find(name);
89 if(i != m_preferences.end())
90 {
91 (*i).second.importString(value);
92 }
93 else
94 {
95 m_cache.insert(PreferenceCache::value_type(name, value));
96 }
97 }
98 };
99
XMLPreference_importString(XMLImporter & importer,const char * value)100 inline void XMLPreference_importString(XMLImporter& importer, const char* value)
101 {
102 importer.write(value, string_length(value));
103 }
104 typedef ReferenceCaller1<XMLImporter, const char*, XMLPreference_importString> XMLPreferenceImportStringCaller;
105
106 class XMLPreferenceDictionaryExporter : public XMLExporter
107 {
108 class XMLQPrefElement : public XMLElement
109 {
110 const char* m_version;
111 public:
XMLQPrefElement(const char * version)112 XMLQPrefElement(const char* version) : m_version(version)
113 {
114 }
name()115 const char* name() const
116 {
117 return "qpref";
118 }
attribute(const char * name)119 const char* attribute(const char* name) const
120 {
121 if(string_equal(name, "version"))
122 {
123 return m_version;
124 }
125 return "";
126 }
forEachAttribute(XMLAttrVisitor & visitor)127 void forEachAttribute(XMLAttrVisitor& visitor) const
128 {
129 visitor.visit("version", m_version);
130 }
131 };
132
133 class XMLPreferenceElement : public XMLElement
134 {
135 const char* m_name;
136 public:
XMLPreferenceElement(const char * name)137 XMLPreferenceElement(const char* name)
138 : m_name(name)
139 {
140 }
name()141 const char* name() const
142 {
143 return "epair";
144 }
attribute(const char * name)145 const char* attribute(const char* name) const
146 {
147 if(string_equal(name, "name"))
148 return m_name;
149 return "";
150 }
forEachAttribute(XMLAttrVisitor & visitor)151 void forEachAttribute(XMLAttrVisitor& visitor) const
152 {
153 visitor.visit("name", m_name);
154 }
155 };
156
157 typedef PreferenceDictionary PreferenceEntries;
158 PreferenceEntries& m_preferences;
159 const char* m_version;
160 public:
XMLPreferenceDictionaryExporter(PreferenceDictionary & preferences,const char * version)161 XMLPreferenceDictionaryExporter(PreferenceDictionary& preferences, const char* version)
162 : m_preferences(preferences), m_version(version)
163 {
164 }
165
exportXML(XMLImporter & importer)166 void exportXML(XMLImporter& importer)
167 {
168 importer.write("\n", 1);
169
170 XMLQPrefElement qpref_element(m_version);
171 importer.pushElement(qpref_element);
172 importer.write("\n", 1);
173
174 for(PreferenceEntries::iterator i = m_preferences.begin(); i != m_preferences.end(); ++i)
175 {
176 XMLPreferenceElement epair_element((*i).first.c_str());
177
178 importer.pushElement(epair_element);
179
180 (*i).second.exportString(XMLPreferenceImportStringCaller(importer));
181
182 importer.popElement(epair_element.name());
183 importer.write("\n", 1);
184 }
185
186 importer.popElement(qpref_element.name());
187 importer.write("\n", 1);
188 }
189 };
190
191 class XMLPreferenceDictionaryImporter : public XMLImporter
192 {
193 struct xml_state_t
194 {
195 enum ETag
196 {
197 tag_qpref,
198 tag_qpref_ignore,
199 tag_epair,
200 tag_epair_ignore
201 };
202
xml_state_txml_state_t203 xml_state_t(ETag tag)
204 : m_tag(tag)
205 {
206 }
207
208 ETag m_tag;
209 CopiedString m_name;
210 StringOutputStream m_ostream;
211 };
212
213 typedef std::vector<xml_state_t> xml_stack_t;
214 xml_stack_t m_xml_stack;
215
216 typedef PreferenceDictionary PreferenceEntries;
217 PreferenceEntries& m_preferences;
218 Version m_version;
219 public:
XMLPreferenceDictionaryImporter(PreferenceDictionary & preferences,const char * version)220 XMLPreferenceDictionaryImporter(PreferenceDictionary& preferences, const char* version)
221 : m_preferences(preferences), m_version(version_parse(version))
222 {
223 }
224
pushElement(const XMLElement & element)225 void pushElement(const XMLElement& element)
226 {
227 if(m_xml_stack.empty())
228 {
229 if(string_equal(element.name(), "qpref"))
230 {
231 Version dataVersion(version_parse(element.attribute("version")));
232 if(!version_compatible(m_version, dataVersion))
233 {
234 globalOutputStream() << "qpref import: data version " << dataVersion << " is not compatible with code version " << m_version << "\n";
235 m_xml_stack.push_back(xml_state_t::tag_qpref_ignore);
236 }
237 else
238 {
239 globalOutputStream() << "qpref import: data version " << dataVersion << " is compatible with code version " << m_version << "\n";
240 m_xml_stack.push_back(xml_state_t::tag_qpref);
241 }
242 }
243 else
244 {
245 // not valid
246 }
247 }
248 else
249 {
250 switch(m_xml_stack.back().m_tag)
251 {
252 case xml_state_t::tag_qpref:
253 if(string_equal(element.name(), "epair"))
254 {
255 m_xml_stack.push_back(xml_state_t::tag_epair);
256 m_xml_stack.back().m_name = element.attribute("name");
257 }
258 else
259 {
260 // not valid
261 }
262 break;
263 case xml_state_t::tag_qpref_ignore:
264 if(string_equal(element.name(), "epair"))
265 {
266 m_xml_stack.push_back(xml_state_t::tag_epair_ignore);
267 }
268 else
269 {
270 // not valid
271 }
272 break;
273 case xml_state_t::tag_epair:
274 case xml_state_t::tag_epair_ignore:
275 // not valid
276 break;
277 }
278 }
279
280 }
popElement(const char * name)281 void popElement(const char* name)
282 {
283 if(m_xml_stack.back().m_tag == xml_state_t::tag_epair)
284 {
285 m_preferences.importPref(m_xml_stack.back().m_name.c_str(), m_xml_stack.back().m_ostream.c_str());
286 }
287 m_xml_stack.pop_back();
288 }
write(const char * buffer,std::size_t length)289 std::size_t write(const char* buffer, std::size_t length)
290 {
291 return m_xml_stack.back().m_ostream.write(buffer, length);
292 }
293 };
294
295 #endif
296