src/mesh/cfMesh/utilities/containers/DynList/DynListI.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
  27 template<class T, Foam::label staticSize>
  28 inline void Foam::DynList<T, staticSize>::allocateSize(const label s)
  29 {
  30     if( s > UList<T>::size()  )
  31     {
  32         T* newData = new T[s];
  33
  34         for(label i=0;i<nextFree_;++i)
  35             newData[i] = this->operator[](i);
  36
  37         T* data = UList<T>::begin();
  38         if( data && (data != staticData_) )
  39             delete [] data;
  40
  41         //UList<T>::reset(newData, s);
  42         this->UList<T>::operator=(UList<T>(newData, s));
  43     }
  44     else if( (s > staticSize) && (s < UList<T>::size()) )
  45     {
  46         T* newData = new T[s];
  47
  48         for(label i=0;i<s;++i)
  49             newData[i] = this->operator[](i);
  50
  51         T* data = UList<T>::begin();
  52         delete [] data;
  53
  54         //UList<T>::reset(newData, s);
  55         this->UList<T>::operator=(UList<T>(newData, s));
  56     }
  57     else if( (s <= staticSize) && (UList<T>::size() > staticSize) )
  58     {
  59         for(label i=0;i<s;++i)
  60             staticData_[i] = UList<T>::operator[](i);
  61
  62         T* data = UList<T>::begin();
  63         if( data && (data != staticData_) )
  64             delete [] data;
  65
  66         //UList<T>::reset(staticData_, staticSize);
  67         this->UList<T>::operator=(UList<T>(staticData_, staticSize));
  68     }
  69 }
  70
  71 template<class T, Foam::label staticSize>
  72 inline void Foam::DynList<T, staticSize>::checkIndex(const label i) const
  73 {
  74     if( (i < 0) || (i >= nextFree_) )
  75     {
  76         FatalErrorIn
  77         (
  78             "void Foam::DynList<T, label, Offset>::"
  79             "checkIndex(const label i) const"
  80         ) << "Index " << i << " is not in range " << 0
  81             << " and " << nextFree_ << abort(FatalError);
  82     }
  83 }
  84
  85 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  86
  87 //- Construct null
  88 template<class T, Foam::label staticSize>
  89 inline Foam::DynList<T, staticSize>::DynList()
  90 :
  91     UList<T>(staticData_, staticSize),
  92     nextFree_(0)
  93 {}
  94
  95
  96 template<class T, Foam::label staticSize>
  97 inline Foam::DynList<T, staticSize>::DynList(const label s)
  98 :
  99     UList<T>(staticData_, staticSize),
 100     nextFree_(0)
 101 {
 102     setSize(s);
 103 }
 104
 105 template<class T, Foam::label staticSize>
 106 inline Foam::DynList<T, staticSize>::DynList(const label s, const T& val)
 107 :
 108     UList<T>(staticData_, staticSize),
 109     nextFree_(0)
 110 {
 111     setSize(s);
 112
 113     for(label i=0;i<s;++i)
 114         this->operator[](i) = val;
 115 }
 116
 117 template<class T, Foam::label staticSize>
 118 inline Foam::DynList<T, staticSize>::DynList(const UList<T>& ul)
 119 :
 120     UList<T>(staticData_, staticSize),
 121     nextFree_(0)
 122 {
 123     setSize(ul.size());
 124
 125     forAll(ul, i)
 126         this->operator[](i) = ul[i];
 127 }
 128
 129 template<class T, Foam::label staticSize>
 130 template<class ListType>
 131 inline Foam::DynList<T, staticSize>::DynList(const ListType& l)
 132 :
 133     UList<T>(staticData_, staticSize),
 134     nextFree_(0)
 135 {
 136     setSize(l.size());
 137     for(label i=0;i<nextFree_;++i)
 138         this->operator[](i) = l[i];
 139 }
 140
 141 //- Copy construct
 142 template<class T, Foam::label staticSize>
 143 inline Foam::DynList<T, staticSize>::DynList
 144 (
 145     const DynList<T, staticSize>& dl
 146 )
 147 :
 148     UList<T>(staticData_, staticSize),
 149     nextFree_(0)
 150 {
 151     setSize(dl.size());
 152     for(label i=0;i<nextFree_;++i)
 153         this->operator[](i) = dl[i];
 154 }
 155
 156 template<class T, Foam::label staticSize>
 157 inline Foam::DynList<T, staticSize>::~DynList()
 158 {
 159     allocateSize(0);
 160     //UList<T>::reset(NULL, 0);
 161 }
 162
 163
 164 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 165
 166 template<class T, Foam::label staticSize>
 167 inline Foam::label Foam::DynList<T, staticSize>::size() const
 168 {
 169     return nextFree_;
 170 }
 171
 172 template<class T, Foam::label staticSize>
 173 inline Foam::label Foam::DynList<T, staticSize>::byteSize() const
 174 {
 175     if( !contiguous<T>() )
 176     {
 177         FatalErrorIn("DynList<T>::byteSize()")
 178             << "Cannot return the binary size of a list of "
 179                "non-primitive elements"
 180             << abort(FatalError);
 181     }
 182
 183     return nextFree_*sizeof(T);
 184
 185 }
 186
 187 template<class T, Foam::label staticSize>
 188 inline void Foam::DynList<T, staticSize>::setSize(const label s)
 189 {
 190     allocateSize(s);
 191     nextFree_ = s;
 192 }
 193
 194
 195 template<class T, Foam::label staticSize>
 196 inline void Foam::DynList<T, staticSize>::clear()
 197 {
 198     nextFree_ = 0;
 199 }
 200
 201
 202 template<class T, Foam::label staticSize>
 203 void Foam::DynList<T, staticSize>::shrink()
 204 {
 205     allocateSize(nextFree_);
 206 }
 207
 208 template<class T, Foam::label staticSize>
 209 inline void Foam::DynList<T, staticSize>::append(const T& e)
 210 {
 211     if( nextFree_ >= UList<T>::size() )
 212     {
 213         const label newSize = 2*UList<T>::size()+2;
 214         allocateSize(newSize);
 215     }
 216
 217     UList<T>::operator[](nextFree_++) = e;
 218 }
 219
 220 template<class T, Foam::label staticSize>
 221 inline void Foam::DynList<T, staticSize>::appendIfNotIn(const T& e)
 222 {
 223     if( !contains(e) )
 224          append(e);
 225 }
 226
 227 template<class T, Foam::label staticSize>
 228 inline bool Foam::DynList<T, staticSize>::contains(const T& e) const
 229 {
 230     for(label i=0;i<nextFree_;++i)
 231     {
 232         if( UList<T>::operator[](i) == e )
 233             return true;
 234     }
 235
 236     return false;
 237 }
 238
 239 template<class T, Foam::label staticSize>
 240 inline Foam::label Foam::DynList<T, staticSize>::containsAtPosition
 241 (
 242     const T& e
 243 ) const
 244 {
 245     for(label i=0;i<nextFree_;++i)
 246     {
 247         if( UList<T>::operator[](i) == e )
 248             return i;
 249     }
 250
 251     return -1;
 252 }
 253
 254 template<class T, Foam::label staticSize>
 255 inline const T& Foam::DynList<T, staticSize>::lastElement() const
 256 {
 257     return this->operator[](nextFree_-1);
 258 }
 259
 260 template<class T, Foam::label staticSize>
 261 inline T Foam::DynList<T, staticSize>::removeLastElement()
 262 {
 263     if( nextFree_ == 0 )
 264     {
 265         FatalErrorIn
 266         (
 267             "void Foam::DynList<T, staticSize>::remove()"
 268         )   << "List is empty" << abort(FatalError);
 269     }
 270
 271     T el = UList<T>::operator[](--nextFree_);
 272     return el;
 273 }
 274
 275 template<class T, Foam::label staticSize>
 276 inline T Foam::DynList<T, staticSize>::removeElement(const label i)
 277 {
 278     if( nextFree_ == 0 )
 279     {
 280         FatalErrorIn
 281         (
 282             "void Foam::DynList<T, staticSize>::remove()"
 283         )   << "List is empty" << abort(FatalError);
 284     }
 285
 286     T el = this->operator[](i);
 287     this->operator[](i) = this->operator[](nextFree_-1);
 288     --nextFree_;
 289
 290     return el;
 291 }
 292
 293 template<class T, Foam::label staticSize>
 294 inline T& Foam::DynList<T, staticSize>::newElmt(const label i)
 295 {
 296     return this->operator()(i);
 297 }
 298
 299 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 300
 301 template<class T, Foam::label staticSize>
 302 inline T& Foam::DynList<T, staticSize>::operator()(const label i)
 303 {
 304     nextFree_ = Foam::max(nextFree_, i + 1);
 305
 306     if( nextFree_ >= UList<T>::size() )
 307     {
 308         allocateSize(2 * nextFree_+1);
 309     }
 310
 311     return this->operator[](i);
 312 }
 313
 314 template<class T, Foam::label staticSize>
 315 inline const T& Foam::DynList<T, staticSize>::operator[](const label i) const
 316 {
 317     # ifdef FULLDEBUG
 318     checkIndex(i);
 319     # endif
 320
 321     return UList<T>::operator[](i);
 322 }
 323
 324 template<class T, Foam::label staticSize>
 325 inline T& Foam::DynList<T, staticSize>::operator[](const label i)
 326 {
 327     # ifdef FULLDEBUG
 328     checkIndex(i);
 329     # endif
 330
 331     return UList<T>::operator[](i);
 332 }
 333
 334 template<class T, Foam::label staticSize>
 335 inline Foam::label Foam::DynList<T, staticSize>::fcIndex
 336 (
 337     const label index,
 338     const label offset
 339 ) const
 340 {
 341     return (index + offset) % nextFree_;
 342 }
 343
 344 template<class T, Foam::label staticSize>
 345 inline Foam::label Foam::DynList<T, staticSize>::rcIndex
 346 (
 347     const label index,
 348     const label offset
 349 ) const
 350 {
 351     return (index + nextFree_ - offset) % nextFree_;
 352 }
 353
 354 template<class T, Foam::label staticSize>
 355 inline const T& Foam::DynList<T, staticSize>::fcElement
 356 (
 357     const label index,
 358     const label offset
 359 ) const
 360 {
 361     return operator[](fcIndex(index, offset));
 362 }
 363
 364 template<class T, Foam::label staticSize>
 365 inline const T& Foam::DynList<T, staticSize>::rcElement
 366 (
 367     const label index,
 368     const label offset
 369 ) const
 370 {
 371     return operator[](rcIndex(index, offset));
 372 }
 373
 374 template<class T, Foam::label staticSize>
 375 inline void Foam::DynList<T, staticSize>::operator=(const T& t)
 376 {
 377     UList<T>::operator=(t);
 378 }
 379
 380 template<class T, Foam::label staticSize>
 381 inline void Foam::DynList<T, staticSize>::operator=
 382 (
 383     const DynList<T, staticSize>& dl
 384 )
 385 {
 386     allocateSize(dl.size());
 387     nextFree_ = dl.size();
 388
 389     for(label i=0;i<nextFree_;++i)
 390         this->operator[](i) = dl[i];
 391 }
 392
 393 template<class T, Foam::label staticSize>
 394 template<class ListType>
 395 inline void Foam::DynList<T, staticSize>::operator=(const ListType& l)
 396 {
 397     allocateSize(l.size());
 398     nextFree_ = l.size();
 399
 400     for(label i=0;i<nextFree_;++i)
 401         this->operator[](i) = l[i];
 402 }
 403
 404
 405 // ************************************************************************* //