NOW I do it right: #woxblox#
[divverent/netradiant.git] / libs / uniquenames.h
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_UNIQUENAMES_H)
23 #define INCLUDED_UNIQUENAMES_H
24
25 #include "debugging/debugging.h"
26 #include <map>
27 #include "string/string.h"
28 #include "generic/static.h"
29
30 #if 1
31 class Postfix
32 {
33   unsigned int m_value;
34 public:
35   Postfix(const char* postfix) : m_value(atoi(postfix))
36   {
37   }
38   unsigned int number() const
39   {
40     return m_value;
41   }
42   void write(char* buffer) const
43   {
44     sprintf(buffer, "%u", m_value);
45   }
46   Postfix& operator++()
47   { 
48     ++m_value;
49     return *this;
50   }
51   bool operator<(const Postfix& other) const
52   {
53     return m_value < other.m_value;
54   }
55   bool operator==(const Postfix& other) const
56   {
57     return m_value == other.m_value;
58   }
59   bool operator!=(const Postfix& other) const
60   {
61     return !operator==(other);
62   }
63 };
64
65 #else
66 class Postfix
67 {
68   std::pair<unsigned int, unsigned int> m_value;
69 public:
70   Postfix(unsigned int number, unsigned int leading_zeros)
71     : m_value(leading_zeros, number)
72   {
73   }
74   Postfix(const char* postfix)
75     : m_value(number_count_leading_zeros(postfix), atoi(postfix))
76   {
77   }
78   unsigned int number() const
79   {
80     return m_value.second;
81   }
82   unsigned int leading_zeros() const
83   {
84     return m_value.first;
85   }
86   void write(char* buffer)
87   {
88     for(unsigned int count = 0; count < m_value.first; ++count, ++buffer)
89       *buffer = '0';
90     sprintf(buffer, "%u", m_value.second);
91   }
92   Postfix& operator++()
93   { 
94     ++m_value.second;
95     if(m_value.first != 0 && m_value.second % 10 == 0)
96       --m_value.first;
97     return *this;
98   }
99   bool operator<(const Postfix& other) const
100   {
101     return m_value < other.m_value;
102   }
103   bool operator==(const Postfix& other) const
104   {
105     return m_value == other.m_value;
106   }
107   bool operator!=(const Postfix& other) const
108   {
109     return !operator==(other);
110   }
111 };
112
113 #endif
114
115 typedef std::pair<CopiedString, Postfix> name_t;
116
117 inline void name_write(char* buffer, name_t name)
118 {
119   strcpy(buffer, name.first.c_str());
120   name.second.write(buffer + strlen(name.first.c_str()));
121 }
122
123 inline name_t name_read(const char* name)
124 {
125   const char* end = name + strlen(name);
126   for(const char* p = end; end != name; --p)
127   {
128     if(strrchr("1234567890", *p) == NULL)
129       break;
130     end = p;
131   }
132
133   return name_t(CopiedString(StringRange(name, end)), Postfix(end));
134 }
135
136
137 class PostFixes
138 {
139 public:
140   typedef std::map<Postfix, unsigned int> postfixes_t;
141   postfixes_t m_postfixes;
142
143 private:
144   Postfix find_first_empty() const
145   {
146     Postfix postfix("1");
147     for(postfixes_t::const_iterator i = m_postfixes.find(postfix); i != m_postfixes.end(); ++i, ++postfix)
148     {
149       if((*i).first != postfix)
150       {
151         break;
152       }
153     }
154     return postfix;
155   }
156
157 public:
158   Postfix make_unique(Postfix postfix) const
159   {
160     postfixes_t::const_iterator i = m_postfixes.find(postfix);
161     if(i == m_postfixes.end())
162     {
163       return postfix;
164     }
165     else
166     {
167       return find_first_empty();
168     }
169   }
170
171   void insert(Postfix postfix)
172   {
173     postfixes_t::iterator i = m_postfixes.find(postfix);
174     if(i == m_postfixes.end())
175     {
176       m_postfixes.insert(postfixes_t::value_type(postfix, 1));
177     }
178     else
179     {
180       ++(*i).second;
181     }
182   }
183
184   void erase(Postfix postfix)
185   {
186     postfixes_t::iterator i = m_postfixes.find(postfix);
187     if(i == m_postfixes.end())
188     {
189       // error
190     }
191     else
192     {
193       if(--(*i).second == 0)
194         m_postfixes.erase(i);
195     }
196   }
197
198   bool empty() const
199   {
200     return m_postfixes.empty();
201   }
202 };
203
204
205 class UniqueNames
206 {
207   typedef std::map<CopiedString, PostFixes> names_t;
208   names_t m_names;
209 public:
210   name_t make_unique(const name_t& name) const
211   {
212     char buf[80];
213     name_t r("","");
214         name_write(buf, name);
215     globalErrorStream() << "find unique name for " << buf << "\n";
216         globalErrorStream() << "> currently registered names:\n";
217         for(names_t::const_iterator i = m_names.begin(); i != m_names.end(); ++i)
218         {
219                 globalErrorStream() << ">> " << i->first.c_str() << ": ";
220                 for(PostFixes::postfixes_t::const_iterator j = i->second.m_postfixes.begin(); j != i->second.m_postfixes.end(); ++j)
221                 {
222                         j->first.write(buf);
223                         globalErrorStream() << " '" << buf << "'";
224                 }
225                 globalErrorStream() << "\n";
226         }
227     names_t::const_iterator i = m_names.find(name.first);
228     if(i == m_names.end())
229     {
230       r = name;
231     }
232     else
233     {
234       r = name_t(name.first, (*i).second.make_unique(name.second));
235     }
236         name_write(buf, r);
237     globalErrorStream() << "> unique name is " << buf << "\n";
238         return r;
239   }
240
241   void insert(const name_t& name)
242   {
243     m_names[name.first].insert(name.second);
244   }
245
246   void erase(const name_t& name)
247   {
248     names_t::iterator i = m_names.find(name.first);
249     if(i == m_names.end())
250     {
251       ASSERT_MESSAGE(true, "erase: name not found");
252     }
253     else
254     {
255       (*i).second.erase(name.second);
256       if((*i).second.empty())
257         m_names.erase(i);
258     }
259   }
260
261   bool empty() const
262   {
263     return m_names.empty();
264   }
265 };
266
267
268
269 #if 0
270
271 #undef ERROR_MESSAGE
272 #define ERROR_MESSAGE(message)
273
274 class TestUniqueName
275 {
276   void name_check_equal(const name_t& name, const char* string, unsigned int postfix)
277   {
278     ASSERT_MESSAGE(strcmp(name.first.c_str(), string) == 0
279       && name.second.number() == postfix,
280       "test failed!");
281   }
282   void test_refcount()
283   {
284     Names names;
285
286     names.insert(name_t("func_bleh_", "100"));
287     names.insert(name_t("func_bleh_", "100"));
288     names.insert(name_t("func_bleh_", "100"));
289
290
291     names.erase(name_t("func_bleh_", "100"));
292     names.erase(name_t("func_bleh_", "100"));
293     names.erase(name_t("func_bleh_", "100"));
294
295     ASSERT_MESSAGE(names.empty(), "test failed!");
296   }
297
298   void test_make_unique()
299   {
300     Names names;
301
302     {
303       name_t name(names.make_unique(name_t("func_bleh_", "01")));
304       name_check_equal(name, "func_bleh_", 1);
305       names.insert(name);
306     }
307     {
308       name_t name(names.make_unique(name_t("func_bleh_", "04")));
309       name_check_equal(name, "func_bleh_", 4);
310       names.insert(name);
311     }
312     {
313       name_t name(names.make_unique(name_t("func_bleh_", "04")));
314       name_check_equal(name, "func_bleh_", 2);
315       names.insert(name);
316     }
317     {
318       name_t name(names.make_unique(name_t("func_bleh_", "1")));
319       name_check_equal(name, "func_bleh_", 3);
320       names.insert(name);
321     }
322     {
323       name_t name(names.make_unique(name_t("func_bleh_", "2")));
324       name_check_equal(name, "func_bleh_", 5);
325       names.insert(name);
326     }
327     {
328       name_t name(names.make_unique(name_t("func_bleh_", "3")));
329       name_check_equal(name, "func_bleh_", 6);
330       names.insert(name);
331     }
332
333     names.erase(name_t("func_bleh_", "1"));
334     names.erase(name_t("func_bleh_", "2"));
335     names.erase(name_t("func_bleh_", "3"));
336     names.erase(name_t("func_bleh_", "4"));
337     names.erase(name_t("func_bleh_", "5"));
338     names.erase(name_t("func_bleh_", "6"));
339
340     ASSERT_MESSAGE(names.empty(), "test failed!");
341   }
342 public:
343   TestUniqueName()
344   {
345     test_refcount();
346     test_make_unique();
347   }
348 };
349
350 const TestUniqueName g_testuniquename;
351
352 #endif
353
354
355 #endif