* return the right error code
[blender-staging.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 #if defined(_WIN64)
97         CTR_TaggedIndex(
98                 const unsigned __int64 val
99         ) :
100                 m_val ( ((unsigned __int64)val & index_mask)
101                                 | ( (empty_tag << tag_shift)
102                                         & (~index_mask) ) ) {
103         }
104 #endif
105
106         CTR_TaggedIndex(
107                 const CTR_TaggedIndex &my_index
108         ):
109                 m_val(my_index.m_val)
110         {
111         }
112
113                 bool 
114         operator == (
115                 const CTR_TaggedIndex& rhs
116         ) const {
117
118                 return ((this->m_val & index_mask) == (rhs.m_val & index_mask));
119         }               
120
121         operator unsigned int () const {
122                 return m_val & index_mask;
123         }
124
125         operator unsigned long int () const {
126                 return (unsigned long int)(m_val & index_mask);
127         }
128
129         operator int () const {
130                 return int(m_val & index_mask);
131         }
132
133         operator long int () const {
134                 return (long int)(m_val & index_mask);
135         }
136
137 #if defined(_WIN64)
138         operator unsigned __int64 () const {
139                         return (unsigned __int64)(m_val & index_mask);
140                 }
141 #endif
142
143                 bool
144         IsEmpty(
145         ) const {
146                 return ((m_val & index_mask) == (empty_index & index_mask));
147         }
148
149
150         static
151                 CTR_TaggedIndex
152         Empty(
153         ) {
154                 return CTR_TaggedIndex();
155         }
156
157                 void
158         Invalidate(
159         ) {
160                 m_val = (empty_tag << tag_shift) | (empty_index & index_mask);
161         }
162
163
164                 unsigned int 
165         Tag (
166         ) const {
167                 return m_val >> tag_shift;
168         }
169         
170                 void
171         SetTag(
172                 unsigned int tag
173         ) {
174                 m_val = (m_val & index_mask) | ((tag << tag_shift) & (~index_mask));
175         }
176
177                 void
178         EmptyTag(
179         ) {
180                 m_val = (m_val & index_mask) | ((empty_tag << tag_shift) & (~index_mask));
181         }
182
183                 bool
184         IsEmptyTag(
185         ) const {
186                 return (Tag() == Empty().Tag());
187         }
188         
189         // functionals 
190
191         struct greater : std::binary_function<CTR_TaggedIndex, CTR_TaggedIndex, bool>
192         {
193                         bool 
194                 operator()(
195                         const CTR_TaggedIndex& a,
196                         const CTR_TaggedIndex& b
197                 ) const {
198                         return (int(a) > int(b));
199                 }
200         };
201         
202         
203 private :
204         CTR_TaggedIndex(
205                 const CTR_TaggedIndex *index
206         ) {}; 
207
208         unsigned int m_val;
209
210
211 };                      
212
213 #endif
214