fixed spacing in the headers to get rid of some warnings and some other
[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 enum {
54
55         empty_tag = 0x0,
56         empty_index = 0xffffffff
57 };
58
59 template <
60         int tag_shift, 
61         int index_mask
62 > class CTR_TaggedIndex {
63 public:
64         CTR_TaggedIndex(
65         ) : 
66                 m_val ((empty_tag << tag_shift) | (empty_index & index_mask))
67         {
68         }
69
70         CTR_TaggedIndex(
71                 const int val
72         ) :
73                 m_val ((val & index_mask) | ((empty_tag << tag_shift) & (~index_mask))) {
74         }
75
76         CTR_TaggedIndex(
77                 const unsigned int val
78         ) :
79                 m_val ((val & index_mask) | ((empty_tag << tag_shift) & (~index_mask))) {
80         }
81
82         CTR_TaggedIndex(
83                 const long int val
84         ) :
85                 m_val ( ((long int) val & index_mask)
86                                 | ( (empty_tag << tag_shift)
87                                         & (~index_mask)) ) {
88         }
89
90         CTR_TaggedIndex(
91                 const long unsigned int val
92         ) :
93                 m_val ( ((long unsigned int)val & index_mask)
94                                 | ( (empty_tag << tag_shift)
95                                         & (~index_mask) ) ) {
96         }
97
98
99         CTR_TaggedIndex(
100                 const CTR_TaggedIndex &my_index
101         ):
102                 m_val(my_index.m_val)
103         {
104         }
105
106                 bool 
107         operator == (
108                 const CTR_TaggedIndex& rhs
109         ) const {
110
111                 return ((this->m_val & index_mask) == (rhs.m_val & index_mask));
112         }               
113
114         operator unsigned int () const {
115                 return m_val & index_mask;
116         }
117
118         operator unsigned long int () const {
119                 return (unsigned long int)(m_val & index_mask);
120         }
121
122         operator int () const {
123                 return int(m_val & index_mask);
124         }
125
126         operator long int () const {
127                 return (long int)(m_val & index_mask);
128         }
129
130                 bool
131         IsEmpty(
132         ) const {
133                 return ((m_val & index_mask) == (empty_index & index_mask));
134         }
135
136
137         static
138                 CTR_TaggedIndex
139         Empty(
140         ) {
141                 return CTR_TaggedIndex();
142         }
143
144                 void
145         Invalidate(
146         ) {
147                 m_val = (empty_tag << tag_shift) | (empty_index & index_mask);
148         }
149
150
151                 unsigned int 
152         Tag (
153         ) const {
154                 return m_val >> tag_shift;
155         }
156         
157                 void
158         SetTag(
159                 unsigned int tag
160         ) {
161                 m_val = (m_val & index_mask) | ((tag << tag_shift) & (~index_mask));
162         }
163
164                 void
165         EmptyTag(
166         ) {
167                 m_val = (m_val & index_mask) | ((empty_tag << tag_shift) & (~index_mask));
168         }
169
170                 bool
171         IsEmptyTag(
172         ) const {
173                 return (Tag() == Empty().Tag());
174         }
175         
176         // functionals 
177
178         struct greater : std::binary_function<CTR_TaggedIndex, CTR_TaggedIndex, bool>
179         {
180                         bool 
181                 operator()(
182                         const CTR_TaggedIndex& a,
183                         const CTR_TaggedIndex& b
184                 ) const {
185                         return (int(a) > int(b));
186                 }
187         };
188         
189         
190 private :
191         CTR_TaggedIndex(
192                 const CTR_TaggedIndex *index
193         ) {}; 
194
195         unsigned int m_val;
196
197
198 };                      
199
200 #endif
201