Cycles: svn merge -r40358:40411 ^/trunk/blender
[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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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 /** \file container/CTR_TaggedIndex.h
30  *  \ingroup ctr
31  */
32
33
34 /**
35
36  * $Id$
37  * Copyright (C) 2001 NaN Technologies B.V.
38  * Simple tagged index class.
39  */
40
41 #ifndef NAN_INCLUDED_CTR_TaggedIndex_h
42 #define NAN_INCLUDED_CTR_TaggedIndex_h
43
44 /**
45  * This class is supposed to be a simple tagged index class. If these
46  * were indices into a mesh then we would never need 32 bits for such indices.
47  * It is often handy to have a few extra bits around to mark objects etc. We
48  * steal a few bits of CTR_TaggedIndex objects for this purpose. From the outside
49  * it will behave like a standard unsigned int but just carry the extra tag
50  * information around with it.
51  */
52
53 #include <functional>
54
55 #include "MEM_sys_types.h"
56
57 enum {
58
59         empty_tag = 0x0,
60         empty_index = 0xffffffff
61 };
62
63 template <
64         int tag_shift, 
65         int index_mask
66 > class CTR_TaggedIndex {
67 public:
68         CTR_TaggedIndex(
69         ) : 
70                 m_val ((empty_tag << tag_shift) | (empty_index & index_mask))
71         {
72         }
73
74         CTR_TaggedIndex(
75                 const int val
76         ) :
77                 m_val ((val & index_mask) | ((empty_tag << tag_shift) & (~index_mask))) {
78         }
79
80         CTR_TaggedIndex(
81                 const unsigned int val
82         ) :
83                 m_val ((val & index_mask) | ((empty_tag << tag_shift) & (~index_mask))) {
84         }
85
86         CTR_TaggedIndex(
87                 const long int val
88         ) :
89                 m_val ( ((long int) val & index_mask)
90                                 | ( (empty_tag << tag_shift)
91                                         & (~index_mask)) ) {
92         }
93
94         CTR_TaggedIndex(
95                 const long unsigned int val
96         ) :
97                 m_val ( ((long unsigned int)val & index_mask)
98                                 | ( (empty_tag << tag_shift)
99                                         & (~index_mask) ) ) {
100         }
101
102
103 #if defined(_WIN64)
104         CTR_TaggedIndex(
105                 const uint64_t val
106         ) :
107                 m_val ( ((uint64_t)val & index_mask)
108                                 | ( (empty_tag << tag_shift)
109                                         & (~index_mask) ) ) {
110         }
111 #endif
112
113         CTR_TaggedIndex(
114                 const CTR_TaggedIndex &my_index
115         ):
116                 m_val(my_index.m_val)
117         {
118         }
119
120                 bool 
121         operator == (
122                 const CTR_TaggedIndex& rhs
123         ) const {
124
125                 return ((this->m_val & index_mask) == (rhs.m_val & index_mask));
126         }               
127
128         operator unsigned int () const {
129                 return m_val & index_mask;
130         }
131
132         operator unsigned long int () const {
133                 return (unsigned long int)(m_val & index_mask);
134         }
135
136         operator int () const {
137                 return int(m_val & index_mask);
138         }
139
140         operator long int () const {
141                 return (long int)(m_val & index_mask);
142         }
143
144 #if defined(_WIN64)
145         operator uint64_t () const {
146                         return (uint64_t)(m_val & index_mask);
147                 }
148 #endif
149
150                 bool
151         IsEmpty(
152         ) const {
153                 return ((m_val & index_mask) == (empty_index & index_mask));
154         }
155
156
157         static
158                 CTR_TaggedIndex
159         Empty(
160         ) {
161                 return CTR_TaggedIndex();
162         }
163
164                 void
165         Invalidate(
166         ) {
167                 m_val = (empty_tag << tag_shift) | (empty_index & index_mask);
168         }
169
170
171                 unsigned int 
172         Tag (
173         ) const {
174                 return m_val >> tag_shift;
175         }
176         
177                 void
178         SetTag(
179                 unsigned int tag
180         ) {
181                 m_val = (m_val & index_mask) | ((tag << tag_shift) & (~index_mask));
182         }
183
184                 void
185         EmptyTag(
186         ) {
187                 m_val = (m_val & index_mask) | ((empty_tag << tag_shift) & (~index_mask));
188         }
189
190                 bool
191         IsEmptyTag(
192         ) const {
193                 return (Tag() == Empty().Tag());
194         }
195         
196         // functionals 
197
198         struct greater : std::binary_function<CTR_TaggedIndex, CTR_TaggedIndex, bool>
199         {
200                         bool 
201                 operator()(
202                         const CTR_TaggedIndex& a,
203                         const CTR_TaggedIndex& b
204                 ) const {
205                         return (int(a) > int(b));
206                 }
207         };
208         
209         
210 private :
211         CTR_TaggedIndex(
212                 const CTR_TaggedIndex *index
213         ) {}; 
214
215         unsigned int m_val;
216
217
218 };                      
219
220 #endif
221