Revert part of r51487 (those files are needed by the boolean ops code, /intern/bsp...
[blender.git] / intern / container / CTR_TaggedIndex.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file container/CTR_TaggedIndex.h
29  *  \ingroup ctr
30  */
31
32
33 /**
34
35  * Copyright (C) 2001 NaN Technologies B.V.
36  * Simple tagged index class.
37  */
38
39 #ifndef __CTR_TAGGEDINDEX_H__
40 #define __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 #include "MEM_sys_types.h"
54
55 enum {
56
57         empty_tag = 0x0,
58         empty_index = 0xffffffff
59 };
60
61 template <
62         int tag_shift, 
63         int index_mask
64 > class CTR_TaggedIndex {
65 public:
66         CTR_TaggedIndex(
67         ) : 
68                 m_val ((empty_tag << tag_shift) | (empty_index & index_mask))
69         {
70         }
71
72         CTR_TaggedIndex(
73                 const int val
74         ) :
75                 m_val ((val & index_mask) | ((empty_tag << tag_shift) & (~index_mask))) {
76         }
77
78         CTR_TaggedIndex(
79                 const unsigned int val
80         ) :
81                 m_val ((val & index_mask) | ((empty_tag << tag_shift) & (~index_mask))) {
82         }
83
84         CTR_TaggedIndex(
85                 const long int val
86         ) :
87                 m_val ( ((long int) val & index_mask)
88                                 | ( (empty_tag << tag_shift)
89                                         & (~index_mask)) ) {
90         }
91
92         CTR_TaggedIndex(
93                 const long unsigned int val
94         ) :
95                 m_val ( ((long unsigned int)val & index_mask)
96                                 | ( (empty_tag << tag_shift)
97                                         & (~index_mask) ) ) {
98         }
99
100
101 #if defined(_WIN64)
102         CTR_TaggedIndex(
103                 const uint64_t val
104         ) :
105                 m_val ( ((uint64_t)val & index_mask)
106                                 | ( (empty_tag << tag_shift)
107                                         & (~index_mask) ) ) {
108         }
109 #endif
110
111         CTR_TaggedIndex(
112                 const CTR_TaggedIndex &my_index
113         ):
114                 m_val(my_index.m_val)
115         {
116         }
117
118                 bool 
119         operator == (
120                 const CTR_TaggedIndex& rhs
121         ) const {
122
123                 return ((this->m_val & index_mask) == (rhs.m_val & index_mask));
124         }               
125
126         operator unsigned int () const {
127                 return m_val & index_mask;
128         }
129
130         operator unsigned long int () const {
131                 return (unsigned long int)(m_val & index_mask);
132         }
133
134         operator int () const {
135                 return int(m_val & index_mask);
136         }
137
138         operator long int () const {
139                 return (long int)(m_val & index_mask);
140         }
141
142 #if defined(_WIN64)
143         operator uint64_t () const {
144                         return (uint64_t)(m_val & index_mask);
145                 }
146 #endif
147
148                 bool
149         IsEmpty(
150         ) const {
151                 return ((m_val & index_mask) == (empty_index & index_mask));
152         }
153
154
155         static
156                 CTR_TaggedIndex
157         Empty(
158         ) {
159                 return CTR_TaggedIndex();
160         }
161
162                 void
163         Invalidate(
164         ) {
165                 m_val = (empty_tag << tag_shift) | (empty_index & index_mask);
166         }
167
168
169                 unsigned int 
170         Tag (
171         ) const {
172                 return m_val >> tag_shift;
173         }
174         
175                 void
176         SetTag(
177                 unsigned int tag
178         ) {
179                 m_val = (m_val & index_mask) | ((tag << tag_shift) & (~index_mask));
180         }
181
182                 void
183         EmptyTag(
184         ) {
185                 m_val = (m_val & index_mask) | ((empty_tag << tag_shift) & (~index_mask));
186         }
187
188                 bool
189         IsEmptyTag(
190         ) const {
191                 return (Tag() == Empty().Tag());
192         }
193         
194         // functionals 
195
196         struct greater : std::binary_function<CTR_TaggedIndex, CTR_TaggedIndex, bool>
197         {
198                         bool 
199                 operator()(
200                         const CTR_TaggedIndex& a,
201                         const CTR_TaggedIndex& b
202                 ) const {
203                         return (int(a) > int(b));
204                 }
205         };
206         
207         
208 private :
209         CTR_TaggedIndex(
210                 const CTR_TaggedIndex *index
211         ) {}; 
212
213         unsigned int m_val;
214
215
216 };                      
217
218 #endif
219