RNA/UI - Reset Settings to Default Values
[blender.git] / source / kernel / gen_system / GEN_Map.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29 #ifndef GEN_MAP_H
30 #define GEN_MAP_H
31
32 template <class Key, class Value>
33 class GEN_Map {
34 private:
35     struct Entry {
36         Entry (Entry *next, Key key, Value value) :
37             m_next(next),
38             m_key(key),
39             m_value(value) {}
40
41         Entry *m_next;
42         Key    m_key;
43         Value  m_value;
44     };
45  
46 public:
47     GEN_Map(int num_buckets = 100) : m_num_buckets(num_buckets) {
48         m_buckets = new Entry *[num_buckets];
49         for (int i = 0; i < num_buckets; ++i) {
50             m_buckets[i] = 0;
51         }
52     }
53
54         GEN_Map(const GEN_Map& map)
55         {
56                 m_num_buckets = map.m_num_buckets;
57                 m_buckets = new Entry *[m_num_buckets];
58
59                 for (int i = 0; i < m_num_buckets; ++i) {
60                         m_buckets[i] = 0;
61
62                         for(Entry *entry = map.m_buckets[i]; entry; entry=entry->m_next)
63                                 insert(entry->m_key, entry->m_value);
64                 }
65         }
66     
67     int size() { 
68         int count=0;
69         for (int i=0;i<m_num_buckets;i++)
70         {
71             Entry* bucket = m_buckets[i];
72             while(bucket)
73             {
74                 bucket = bucket->m_next;
75                 count++;
76             }
77         }
78         return count;
79     }
80     
81     Value* at(int index) {
82         int count=0;
83         for (int i=0;i<m_num_buckets;i++)
84         {
85             Entry* bucket = m_buckets[i];
86             while(bucket)
87             {
88                 if (count==index)
89                 {
90                     return &bucket->m_value;
91                 }
92                 bucket = bucket->m_next;
93                 count++;
94             }
95         }
96         return 0;
97     }
98
99     Key* getKey(int index) {
100         int count=0;
101         for (int i=0;i<m_num_buckets;i++)
102         {
103             Entry* bucket = m_buckets[i];
104             while(bucket)
105             {
106                 if (count==index)
107                 {
108                     return &bucket->m_key;
109                 }
110                 bucket = bucket->m_next;
111                 count++;
112             }
113         }
114         return 0;
115     }
116     
117     void clear() {
118         for (int i = 0; i < m_num_buckets; ++i) {
119             Entry *entry_ptr = m_buckets[i];
120             
121             while (entry_ptr != 0) {
122                 Entry *tmp_ptr = entry_ptr->m_next;
123                 delete entry_ptr;
124                 entry_ptr = tmp_ptr;
125             }
126             m_buckets[i] = 0;
127         }
128     }
129     
130     ~GEN_Map() {
131         clear();
132         delete [] m_buckets;
133     }
134     
135     void insert(const Key& key, const Value& value) {
136         Entry *entry_ptr = m_buckets[key.hash() % m_num_buckets];
137         while ((entry_ptr != 0) && !(key == entry_ptr->m_key)) {
138             entry_ptr = entry_ptr->m_next;
139         }
140         
141         if (entry_ptr != 0) {
142             entry_ptr->m_value = value;
143         }
144         else {
145             Entry **bucket = &m_buckets[key.hash() % m_num_buckets];
146             *bucket = new Entry(*bucket, key, value);
147         }
148     }
149
150     void remove(const Key& key) {
151         Entry **entry_ptr = &m_buckets[key.hash() % m_num_buckets];
152         while ((*entry_ptr != 0) && !(key == (*entry_ptr)->m_key)) {
153             entry_ptr = &(*entry_ptr)->m_next;
154         }
155         
156         if (*entry_ptr != 0) {
157             Entry *tmp_ptr = (*entry_ptr)->m_next;
158             delete *entry_ptr;
159             *entry_ptr = tmp_ptr;
160         }
161     }
162
163     Value *operator[](Key key) {
164         Entry *bucket = m_buckets[key.hash() % m_num_buckets];
165         while ((bucket != 0) && !(key == bucket->m_key)) {
166             bucket = bucket->m_next;
167         }
168         return bucket != 0 ? &bucket->m_value : 0;
169     }
170     
171 private:
172     int     m_num_buckets;
173     Entry **m_buckets;
174 };
175
176 #endif
177
178