src/OpenFOAM/containers/Lists/PackedList/PackedListI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25
  26 \*---------------------------------------------------------------------------*/
  27
  28 #ifndef PackedList_I
  29 #define PackedList_I
  30
  31 #include "IOstreams.H"
  32
  33 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  34
  35 namespace Foam
  36 {
  37
  38 // Calculate underlying list size
  39 template<int nBits>
  40 inline label PackedList<nBits>::intSize(const label sz)
  41 {
  42     const label nElemsPerLabel = sizeof(unsigned int)*8/nBits;
  43
  44     return (sz+nElemsPerLabel-1)/nElemsPerLabel;
  45 }
  46
  47
  48 // Convert index into index in integer array
  49 template<int nBits>
  50 inline label PackedList<nBits>::intIndex(const label i)
  51 {
  52     const label nElemsPerLabel = sizeof(unsigned int)*8/nBits;
  53
  54     // Index in underlying int array
  55     label elemI = i/nElemsPerLabel;
  56
  57     return elemI;
  58 }
  59
  60
  61 // Check index i is within valid range (0 ... size-1).
  62 template<int nBits>
  63 inline void PackedList<nBits>::checkIndex(const label i) const
  64 {
  65     if (!size_)
  66     {
  67         FatalErrorIn("PackedList<nBits>::checkIndex(const label)")
  68             << "attempt to access element from zero sized list"
  69             << abort(FatalError);
  70     }
  71     else if (i<0 || i>=size_)
  72     {
  73         FatalErrorIn("PackedList<nBits>::checkIndex(const label)")
  74             << "index " << i << " out of range 0 ... " << size_-1
  75             << abort(FatalError);
  76     }
  77 }
  78
  79
  80 // Check value is representable in nBits
  81 template<int nBits>
  82 inline void PackedList<nBits>::checkValue(const unsigned int val) const
  83 {
  84     if (val>=(1u << nBits))
  85     {
  86         FatalErrorIn("PackedList<T>::set(const unsigned int)")
  87             << "value " << label(val) << " out of range 0 ... "
  88             << label((1u << nBits)-1)
  89             << " representable by " << nBits << " bits"
  90             << abort(FatalError);
  91     }
  92 }
  93
  94 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  95
  96 // Null constructor
  97 template<int nBits>
  98 inline PackedList<nBits>::PackedList()
  99 :
 100     List<unsigned int>(0),
 101     size_(0)
 102 {}
 103
 104
 105 // Construct with given size.
 106 template<int nBits>
 107 inline PackedList<nBits>::PackedList(const label size)
 108 :
 109     List<unsigned int>(intSize(size), 0u),
 110     size_(size)
 111 {}
 112
 113
 114 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 115
 116 template<int nBits>
 117 inline label PackedList<nBits>::size() const
 118 {
 119     return size_;
 120 }
 121
 122
 123 // Get value at i
 124 template<int nBits>
 125 inline unsigned int PackedList<nBits>::get(const label i) const
 126 {
 127 #   ifdef DEBUGList
 128     checkIndex(i);
 129 #   endif
 130
 131     // Constant: number of elements that fit in an unsigned int
 132     const label nElemsPerLabel = sizeof(unsigned int)*8/nBits;
 133
 134     unsigned int mask = ((1u << nBits) - 1);
 135
 136     label indexInLabel = i % nElemsPerLabel;
 137
 138     // Starting bit in int.
 139     label startBit = nBits*indexInLabel;
 140
 141     return (List<unsigned int>::operator[](intIndex(i)) >> startBit) & mask;
 142 }
 143
 144
 145 template<int nBits>
 146 inline unsigned int PackedList<nBits>::operator[](const label i) const
 147 {
 148     return get(i);
 149 }
 150
 151
 152 // Set value at i
 153 template<int nBits>
 154 inline bool PackedList<nBits>::set(const label i, const unsigned int val)
 155 {
 156 #   ifdef DEBUGList
 157     checkIndex(i);
 158     checkValue(val);
 159 #   endif
 160
 161     // Constant: number of elements that fit in an unsigned int
 162     const label nElemsPerLabel = sizeof(unsigned int)*8/nBits;
 163
 164     unsigned int mask = ((1u << nBits) - 1);
 165
 166     label indexInLabel = i % nElemsPerLabel;
 167
 168     // Starting bit in int.
 169     label startBit = nBits*indexInLabel;
 170
 171
 172     unsigned int shiftedMask = mask << startBit;
 173
 174     unsigned int shiftedVal = val << startBit;
 175
 176     unsigned int& elem = List<unsigned int>::operator[](intIndex(i));
 177
 178     unsigned int oldElem = elem;
 179
 180     elem = (elem & ~shiftedMask) | shiftedVal;
 181
 182     return elem != oldElem;
 183 }
 184
 185
 186 template<int nBits>
 187 inline ::Foam::reference PackedList<nBits>::operator[](const label i)
 188 {
 189 #   ifdef DEBUGList
 190     checkIndex(i);
 191 #   endif
 192
 193     // Constant: number of elements that fit in an unsigned int
 194     const label nElemsPerLabel = sizeof(unsigned int)*8/nBits;
 195
 196     unsigned int mask = ((1u << nBits) - 1);
 197
 198     label indexInLabel = i % nElemsPerLabel;
 199
 200     // Starting bit in int.
 201     label startBit = nBits*indexInLabel;
 202
 203     unsigned int& elem = List<unsigned int>::operator[](intIndex(i));
 204
 205     return ::Foam::reference(elem, mask, startBit);
 206 }
 207
 208
 209 // Set all to val
 210 template<int nBits>
 211 inline void PackedList<nBits>::operator=(const unsigned int val)
 212 {
 213 #   ifdef DEBUGList
 214     checkValue(val);
 215 #   endif
 216     List<unsigned int>::operator=(val);
 217 }
 218
 219 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 220
 221 } // End namespace Foam
 222
 223 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 224
 225 #endif
 226
 227 // ************************************************************************* //