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