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