src/mesh/cfMesh/meshLibrary/utilities/containers/LongList/LongListI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | cfMesh: A library for mesh generation
   4    \\    /   O peration     |
   5     \\  /    A nd           | Author: Franjo Juretic (franjo.juretic@c-fields.com)
   6      \\/     M anipulation  | Copyright (C) Creative Fields, Ltd.
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of cfMesh.
  10
  11     cfMesh 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     cfMesh 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 cfMesh.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "contiguous.H"
  27
  28 template<class T, Foam::label Offset>
  29 void Foam::LongList<T, Offset>::checkIndex(const label i) const
  30 {
  31     if( (i < 0) || (i >= nextFree_) )
  32     {
  33         FatalErrorIn
  34         (
  35             "void Foam::LongList<T, label, Offset>::"
  36             "checkIndex(const label i) const"
  37         ) << "Index " << Foam::label(i) << " is not in range " << Foam::label(0)
  38             << " and " << Foam::label(nextFree_) << abort(FatalError);
  39     }
  40 }
  41
  42 template<class T, Foam::label Offset>
  43 void Foam::LongList<T, Offset>::initializeParameters()
  44 {
  45     unsigned int t = sizeof(T);
  46     label it(0);
  47
  48     while( t > 1 )
  49     {
  50         t >>= 1;
  51         ++it;
  52     }
  53
  54     shift_ = Foam::max(10, Offset - it);
  55     mask_ = 1<<shift_;
  56     mask_ -= 1;
  57 }
  58
  59 template<class T, Foam::label Offset>
  60 inline void Foam::LongList<T, Offset>::allocateSize(const label s)
  61 {
  62     if( s == 0 )
  63     {
  64         clearOut();
  65         return;
  66     }
  67
  68     const label numblock1 = ((s-1)>>shift_) + 1;
  69     const label blockSize = 1<<shift_;
  70
  71     if( numblock1 < numBlocks_ )
  72     {
  73         for(register label i=numblock1;i<numBlocks_;++i)
  74             delete [] dataPtr_[i];
  75     }
  76     else if( numblock1 > numBlocks_ )
  77     {
  78         if( numblock1 >= numAllocatedBlocks_ )
  79         {
  80             do
  81             {
  82                 numAllocatedBlocks_ += 64;
  83             } while( numblock1 > numAllocatedBlocks_ );
  84
  85             T** dataptr1 = new T*[numAllocatedBlocks_];
  86             for(register label i=0;i<numBlocks_;++i)
  87                 dataptr1[i] = dataPtr_[i];
  88
  89             if( dataPtr_ )
  90                 delete [] dataPtr_;
  91             dataPtr_ = dataptr1;
  92         }
  93
  94         for(register label i=numBlocks_;i<numblock1;++i)
  95             dataPtr_[i] = new T[blockSize];
  96     }
  97
  98     numBlocks_ = numblock1;
  99     N_ = numBlocks_ * blockSize;
 100 }
 101
 102 template<class T, Foam::label Offset>
 103 void Foam::LongList<T, Offset>::clearOut()
 104 {
 105     for(register label i=0;i<numBlocks_;++i)
 106         delete [] dataPtr_[i];
 107
 108     if( dataPtr_ )
 109     {
 110         delete [] dataPtr_;
 111         dataPtr_ = NULL;
 112     }
 113
 114     N_ = 0;
 115     numBlocks_ = 0;
 116     numAllocatedBlocks_ = 0;
 117     nextFree_ = 0;
 118 }
 119
 120 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 121
 122 //- Construct null
 123 template<class T, Foam::label Offset>
 124 inline Foam::LongList<T, Offset>::LongList()
 125 :
 126     N_(0),
 127     nextFree_(0),
 128     numBlocks_(0),
 129     numAllocatedBlocks_(0),
 130     shift_(),
 131     mask_(),
 132     dataPtr_(NULL)
 133 {
 134     initializeParameters();
 135 }
 136
 137 //- Construct given size
 138 template<class T, Foam::label Offset>
 139 inline Foam::LongList<T, Offset>::LongList(const label s)
 140 :
 141     N_(0),
 142     nextFree_(0),
 143     numBlocks_(0),
 144     numAllocatedBlocks_(0),
 145     shift_(),
 146     mask_(),
 147     dataPtr_(NULL)
 148 {
 149     initializeParameters();
 150     setSize(s);
 151 }
 152
 153
 154 //- Construct given size
 155 template<class T, Foam::label Offset>
 156 inline Foam::LongList<T, Offset>::LongList(const label s, const T& t)
 157 :
 158     N_(0),
 159     nextFree_(0),
 160     numBlocks_(0),
 161     numAllocatedBlocks_(0),
 162     shift_(),
 163     mask_(),
 164     dataPtr_(NULL)
 165 {
 166     initializeParameters();
 167     setSize(s);
 168     *this = t;
 169 }
 170
 171 template<class T, Foam::label Offset>
 172 inline Foam::LongList<T, Offset>::LongList(const LongList<T, Offset>& ol)
 173 :
 174     N_(0),
 175     nextFree_(0),
 176     numBlocks_(0),
 177     numAllocatedBlocks_(0),
 178     shift_(ol.shift_),
 179     mask_(ol.mask_),
 180     dataPtr_(NULL)
 181 {
 182     *this = ol;
 183 }
 184
 185 template<class T, Foam::label Offset>
 186 inline Foam::LongList<T, Offset>::~LongList()
 187 {
 188     clearOut();
 189 }
 190
 191 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 192
 193 template<class T, Foam::label Offset>
 194 inline Foam::label Foam::LongList<T, Offset>::size() const
 195 {
 196     return nextFree_;
 197 }
 198
 199 template<class T, Foam::label Offset>
 200 inline Foam::label Foam::LongList<T, Offset>::byteSize() const
 201 {
 202     if( !contiguous<T>() )
 203     {
 204         FatalErrorIn("LongList<T, Offset>::byteSize()")
 205             << "Cannot return the binary size of a list of "
 206                "non-primitive elements"
 207             << abort(FatalError);
 208     }
 209
 210     return nextFree_*sizeof(T);
 211 }
 212
 213 template<class T, Foam::label Offset>
 214 inline void Foam::LongList<T, Offset>::setSize(const label i)
 215 {
 216     allocateSize(i);
 217     nextFree_ = i;
 218 }
 219
 220 template<class T, Foam::label Offset>
 221 inline void Foam::LongList<T, Offset>::clear()
 222 {
 223     nextFree_ = 0;
 224 }
 225
 226
 227 template<class T, Foam::label Offset>
 228 inline Foam::LongList<T, Offset>&
 229 Foam::LongList<T, Offset>::shrink()
 230 {
 231     setSize(nextFree_);
 232     return *this;
 233 }
 234
 235 template<class T, Foam::label Offset>
 236 inline void Foam::LongList<T, Offset>::transfer(LongList<T, Offset>& ol)
 237 {
 238     clearOut();
 239     dataPtr_ = ol.dataPtr_;
 240     N_ = ol.N_;
 241     nextFree_ = ol.nextFree_;
 242     numBlocks_ = ol.numBlocks_;
 243     numAllocatedBlocks_ = ol.numAllocatedBlocks_;
 244     shift_ = ol.shift_;
 245     mask_ = ol.mask_;
 246
 247     ol.dataPtr_ = NULL;
 248     ol.N_ = 0;
 249     ol.nextFree_ = 0;
 250     ol.numBlocks_ = 0;
 251     ol.numAllocatedBlocks_ = 0;
 252 }
 253
 254
 255 template<class T, Foam::label Offset>
 256 inline void Foam::LongList<T, Offset>::append(const T& e)
 257 {
 258     if( nextFree_ >= N_ )
 259     {
 260         allocateSize(nextFree_+1);
 261     }
 262
 263     operator[](nextFree_++) = e;
 264 }
 265
 266 template<class T, Foam::label Offset>
 267 inline void Foam::LongList<T, Offset>::appendIfNotIn(const T& e)
 268 {
 269     if( !contains(e) )
 270          append(e);
 271 }
 272
 273 template<class T, Foam::label Offset>
 274 inline bool Foam::LongList<T, Offset>::contains(const T& e) const
 275 {
 276     for(register label i=0;i<nextFree_;++i)
 277         if( (*this)[i] == e )
 278             return true;
 279
 280     return false;
 281 }
 282
 283 template<class T, Foam::label Offset>
 284 inline Foam::label Foam::LongList<T, Offset>::containsAtPosition
 285 (
 286     const T& e
 287 ) const
 288 {
 289     for(register label i=0;i<nextFree_;++i)
 290         if( (*this)[i] == e )
 291             return i;
 292
 293     return -1;
 294 }
 295
 296 template<class T, Foam::label Offset>
 297 inline T Foam::LongList<T, Offset>::remove(const label i)
 298 {
 299     if( nextFree_ == 0 )
 300     {
 301         FatalErrorIn
 302         (
 303             "void Foam::LongList<T, Offset>::remove()"
 304         )   << "List is empty" << abort(FatalError);
 305     }
 306
 307     T el = operator[](i);
 308     operator[](i) = operator[](nextFree_-1);
 309     --nextFree_;
 310     return el;
 311 }
 312
 313 template<class T, Foam::label Offset>
 314 inline T Foam::LongList<T, Offset>::removeLastElement()
 315 {
 316     if( nextFree_ == 0 )
 317     {
 318         FatalErrorIn
 319         (
 320             "void Foam::LongList<T, Offset>::remove()"
 321         )   << "List is empty" << abort(FatalError);
 322     }
 323
 324     T lastEl = operator[](nextFree_-1);
 325     --nextFree_;
 326     return lastEl;
 327 }
 328
 329
 330 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 331
 332 template<class T, Foam::label Offset>
 333 inline const T& Foam::LongList<T, Offset>::operator[](const label i) const
 334 {
 335     #ifdef FULLDEBUG
 336     checkIndex(i);
 337     #endif
 338
 339     return dataPtr_[i>>shift_][i&mask_];
 340 }
 341
 342 template<class T, Foam::label Offset>
 343 inline T& Foam::LongList<T, Offset>::operator[](const label i)
 344 {
 345     #ifdef FULLDEBUG
 346     checkIndex(i);
 347     #endif
 348
 349     return dataPtr_[i>>shift_][i&mask_];
 350 }
 351
 352 template<class T, Foam::label Offset>
 353 inline T& Foam::LongList<T, Offset>::operator()(const label i)
 354 {
 355     if( i >= nextFree_ )
 356         setSize(i+1);
 357
 358     return operator[](i);
 359 }
 360
 361
 362 template<class T, Foam::label Offset>
 363 inline T& Foam::LongList<T, Offset>::newElmt(const label i)
 364 {
 365     return operator()(i);
 366 }
 367
 368 template<class T, Foam::label Offset>
 369 inline void Foam::LongList<T, Offset>::operator=(const T& t)
 370 {
 371     for(register label i=0;i<nextFree_;++i)
 372         operator[](i) = t;
 373 }
 374
 375 template<class T, Foam::label Offset>
 376 inline void Foam::LongList<T, Offset>::operator=(const LongList<T, Offset>& l)
 377 {
 378     setSize(l.size());
 379     for(register label i=0;i<l.nextFree_;++i)
 380         operator[](i) = l[i];
 381 }
 382
 383
 384 // ************************************************************************* //