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