Yes I did it again ;)
[blender.git] / intern / container / CTR_TaggedIndex.h
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 /**
33
34  * $Id$
35  * Copyright (C) 2001 NaN Technologies B.V.
36  * Simple tagged index class.
37  */
38
39 #ifndef NAN_INCLUDED_CTR_TaggedIndex_h
40 #define NAN_INCLUDED_CTR_TaggedIndex_h
41
42 /**
43  * This class is supposed to be a simple tagged index class. If these
44  * were indices into a mesh then we would never need 32 bits for such indices.
45  * It is often handy to have a few extra bits around to mark objects etc. We
46  * steal a few bits of CTR_TaggedIndex objects for this purpose. From the outside
47  * it will behave like a standard unsigned int but just carry the extra tag
48  * information around with it.
49  */
50
51 #include <functional>
52
53 #ifdef HAVE_CONFIG_H
54 #include <config.h>
55 #endif
56
57
58 enum {
59
60         empty_tag = 0x0,
61         empty_index = 0xffffffff
62 };
63
64 template <
65         int tag_shift, 
66         int index_mask
67 > class CTR_TaggedIndex {
68 public:
69         CTR_TaggedIndex(
70         ) : 
71                 m_val ((empty_tag << tag_shift) | (empty_index & index_mask))
72         {
73         }
74
75         CTR_TaggedIndex(
76                 const int val
77         ) :
78                 m_val ((val & index_mask) | ((empty_tag << tag_shift) & (~index_mask))) {
79         }
80
81         CTR_TaggedIndex(
82                 const unsigned int val
83         ) :
84                 m_val ((val & index_mask) | ((empty_tag << tag_shift) & (~index_mask))) {
85         }
86
87         CTR_TaggedIndex(
88                 const long int val
89         ) :
90                 m_val ( ((long int) val & index_mask)
91                                 | ( (empty_tag << tag_shift)
92                                         & (~index_mask)) ) {
93         }
94
95         CTR_TaggedIndex(
96                 const long unsigned int val
97         ) :
98                 m_val ( ((long unsigned int)val & index_mask)
99                                 | ( (empty_tag << tag_shift)
100                                         & (~index_mask) ) ) {
101         }
102
103
104         CTR_TaggedIndex(
105                 const CTR_TaggedIndex &my_index
106         ):
107                 m_val(my_index.m_val)
108         {
109         }
110
111                 bool 
112         operator == (
113                 const CTR_TaggedIndex& rhs
114         ) const {
115
116                 return ((this->m_val & index_mask) == (rhs.m_val & index_mask));
117         }               
118
119         operator unsigned int () const {
120                 return m_val & index_mask;
121         }
122
123         operator unsigned long int () const {
124                 return (unsigned long int)(m_val & index_mask);
125         }
126
127         operator int () const {
128                 return int(m_val & index_mask);
129         }
130
131         operator long int () const {
132                 return (long int)(m_val & index_mask);
133         }
134
135                 bool
136         IsEmpty(
137         ) const {
138                 return ((m_val & index_mask) == (empty_index & index_mask));
139         }
140
141
142         static
143                 CTR_TaggedIndex
144         Empty(
145         ) {
146                 return CTR_TaggedIndex();
147         }
148
149                 void
150         Invalidate(
151         ) {
152                 m_val = (empty_tag << tag_shift) | (empty_index & index_mask);
153         }
154
155
156                 unsigned int 
157         Tag (
158         ) const {
159                 return m_val >> tag_shift;
160         }
161         
162                 void
163         SetTag(
164                 unsigned int tag
165         ) {
166                 m_val = (m_val & index_mask) | ((tag << tag_shift) & (~index_mask));
167         }
168
169                 void
170         EmptyTag(
171         ) {
172                 m_val = (m_val & index_mask) | ((empty_tag << tag_shift) & (~index_mask));
173         }
174
175                 bool
176         IsEmptyTag(
177         ) const {
178                 return (Tag() == Empty().Tag());
179         }
180         
181         // functionals 
182
183         struct greater : std::binary_function<CTR_TaggedIndex, CTR_TaggedIndex, bool>
184         {
185                         bool 
186                 operator()(
187                         const CTR_TaggedIndex& a,
188                         const CTR_TaggedIndex& b
189                 ) const {
190                         return (int(a) > int(b));
191                 }
192         };
193         
194         
195 private :
196         CTR_TaggedIndex(
197                 const CTR_TaggedIndex *index
198         ) {}; 
199
200         unsigned int m_val;
201
202
203 };                      
204
205 #endif
206