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)
  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   typedef std::map<Postfix, unsigned int> postfixes_t;
 140   postfixes_t m_postfixes;
 141
 142   Postfix find_first_empty() const
 143   {
 144     Postfix postfix("1");
 145     for(postfixes_t::const_iterator i = m_postfixes.find(postfix); i != m_postfixes.end(); ++i, ++postfix)
 146     {
 147       if((*i).first != postfix)
 148       {
 149         break;
 150       }
 151     }
 152     return postfix;
 153   }
 154
 155 public:
 156   Postfix make_unique(Postfix postfix) const
 157   {
 158     postfixes_t::const_iterator i = m_postfixes.find(postfix);
 159     if(i == m_postfixes.end())
 160     {
 161       return postfix;
 162     }
 163     else
 164     {
 165       return find_first_empty();
 166     }
 167   }
 168
 169   void insert(Postfix postfix)
 170   {
 171     postfixes_t::iterator i = m_postfixes.find(postfix);
 172     if(i == m_postfixes.end())
 173     {
 174       m_postfixes.insert(postfixes_t::value_type(postfix, 1));
 175     }
 176     else
 177     {
 178       ++(*i).second;
 179     }
 180   }
 181
 182   void erase(Postfix postfix)
 183   {
 184     postfixes_t::iterator i = m_postfixes.find(postfix);
 185     if(i == m_postfixes.end())
 186     {
 187       // error
 188     }
 189     else
 190     {
 191       if(--(*i).second == 0)
 192         m_postfixes.erase(i);
 193     }
 194   }
 195
 196   bool empty() const
 197   {
 198     return m_postfixes.empty();
 199   }
 200 };
 201
 202
 203 class UniqueNames
 204 {
 205   typedef std::map<CopiedString, PostFixes> names_t;
 206   names_t m_names;
 207 public:
 208   name_t make_unique(const name_t& name) const
 209   {
 210     names_t::const_iterator i = m_names.find(name.first);
 211     if(i == m_names.end())
 212     {
 213       return name;
 214     }
 215     else
 216     {
 217       return name_t(name.first, (*i).second.make_unique(name.second));
 218     }
 219   }
 220
 221   void insert(const name_t& name)
 222   {
 223     m_names[name.first].insert(name.second);
 224   }
 225
 226   void erase(const name_t& name)
 227   {
 228     names_t::iterator i = m_names.find(name.first);
 229     if(i == m_names.end())
 230     {
 231       ASSERT_MESSAGE(true, "erase: name not found");
 232     }
 233     else
 234     {
 235       (*i).second.erase(name.second);
 236       if((*i).second.empty())
 237         m_names.erase(i);
 238     }
 239   }
 240
 241   bool empty() const
 242   {
 243     return m_names.empty();
 244   }
 245 };
 246
 247
 248
 249 #if 0
 250
 251 #undef ERROR_MESSAGE
 252 #define ERROR_MESSAGE(message)
 253
 254 class TestUniqueName
 255 {
 256   void name_check_equal(const name_t& name, const char* string, unsigned int postfix)
 257   {
 258     ASSERT_MESSAGE(strcmp(name.first.c_str(), string) == 0
 259       && name.second.number() == postfix,
 260       "test failed!");
 261   }
 262   void test_refcount()
 263   {
 264     Names names;
 265
 266     names.insert(name_t("func_bleh_", "100"));
 267     names.insert(name_t("func_bleh_", "100"));
 268     names.insert(name_t("func_bleh_", "100"));
 269
 270
 271     names.erase(name_t("func_bleh_", "100"));
 272     names.erase(name_t("func_bleh_", "100"));
 273     names.erase(name_t("func_bleh_", "100"));
 274
 275     ASSERT_MESSAGE(names.empty(), "test failed!");
 276   }
 277
 278   void test_make_unique()
 279   {
 280     Names names;
 281
 282     {
 283       name_t name(names.make_unique(name_t("func_bleh_", "01")));
 284       name_check_equal(name, "func_bleh_", 1);
 285       names.insert(name);
 286     }
 287     {
 288       name_t name(names.make_unique(name_t("func_bleh_", "04")));
 289       name_check_equal(name, "func_bleh_", 4);
 290       names.insert(name);
 291     }
 292     {
 293       name_t name(names.make_unique(name_t("func_bleh_", "04")));
 294       name_check_equal(name, "func_bleh_", 2);
 295       names.insert(name);
 296     }
 297     {
 298       name_t name(names.make_unique(name_t("func_bleh_", "1")));
 299       name_check_equal(name, "func_bleh_", 3);
 300       names.insert(name);
 301     }
 302     {
 303       name_t name(names.make_unique(name_t("func_bleh_", "2")));
 304       name_check_equal(name, "func_bleh_", 5);
 305       names.insert(name);
 306     }
 307     {
 308       name_t name(names.make_unique(name_t("func_bleh_", "3")));
 309       name_check_equal(name, "func_bleh_", 6);
 310       names.insert(name);
 311     }
 312
 313     names.erase(name_t("func_bleh_", "1"));
 314     names.erase(name_t("func_bleh_", "2"));
 315     names.erase(name_t("func_bleh_", "3"));
 316     names.erase(name_t("func_bleh_", "4"));
 317     names.erase(name_t("func_bleh_", "5"));
 318     names.erase(name_t("func_bleh_", "6"));
 319
 320     ASSERT_MESSAGE(names.empty(), "test failed!");
 321   }
 322 public:
 323   TestUniqueName()
 324   {
 325     test_refcount();
 326     test_make_unique();
 327   }
 328 };
 329
 330 const TestUniqueName g_testuniquename;
 331
 332 #endif
 333
 334
 335 #endif