src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  28
  29 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
  30 inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList()
  31 :
  32     List<T>(SizeInc),
  33     capacity_(SizeInc)
  34 {
  35     List<T>::size(0);
  36 }
  37
  38
  39 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
  40 inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList
  41 (
  42     const label nElem
  43 )
  44 :
  45     List<T>(nElem),
  46     capacity_(nElem)
  47 {
  48     // we could also enforce SizeInc granularity when (!SizeMult || !SizeDiv)
  49     List<T>::size(0);
  50 }
  51
  52
  53 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
  54 inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList
  55 (
  56     const DynamicList<T, SizeInc, SizeMult, SizeDiv>& lst
  57 )
  58 :
  59     List<T>(lst),
  60     capacity_(lst.size())
  61 {}
  62
  63
  64 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
  65 inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList
  66 (
  67     const UList<T>& lst
  68 )
  69 :
  70     List<T>(lst),
  71     capacity_(lst.size())
  72 {}
  73
  74
  75 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
  76 inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList
  77 (
  78     const UIndirectList<T>& lst
  79 )
  80 :
  81     List<T>(lst),
  82     capacity_(lst.size())
  83 {}
  84
  85
  86 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
  87 inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList
  88 (
  89     const Xfer<List<T> >& lst
  90 )
  91 :
  92     List<T>(lst),
  93     capacity_(List<T>::size())
  94 {}
  95
  96
  97
  98 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  99
 100 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 101 inline Foam::label Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::capacity()
 102 const
 103 {
 104     return capacity_;
 105 }
 106
 107
 108 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 109 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::setCapacity
 110 (
 111     const label nElem
 112 )
 113 {
 114     label nextFree = List<T>::size();
 115     capacity_ = nElem;
 116
 117     if (nextFree > capacity_)
 118     {
 119         // truncate addressed sizes too
 120         nextFree = capacity_;
 121     }
 122     // we could also enforce SizeInc granularity when (!SizeMult || !SizeDiv)
 123
 124     List<T>::setSize(capacity_);
 125     List<T>::size(nextFree);
 126 }
 127
 128
 129 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 130 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::reserve
 131 (
 132     const label nElem
 133 )
 134 {
 135     // allocate more capacity?
 136     if (nElem > capacity_)
 137     {
 138 // TODO: convince the compiler that division by zero does not occur
 139 //        if (SizeInc && (!SizeMult || !SizeDiv))
 140 //        {
 141 //            // resize with SizeInc as the granularity
 142 //            capacity_ = nElem;
 143 //            unsigned pad = SizeInc - (capacity_ % SizeInc);
 144 //            if (pad != SizeInc)
 145 //            {
 146 //                capacity_ += pad;
 147 //            }
 148 //        }
 149 //        else
 150         {
 151             capacity_ = max
 152             (
 153                 nElem,
 154                 label(SizeInc + capacity_ * SizeMult / SizeDiv)
 155             );
 156         }
 157
 158         // adjust allocated size, leave addressed size untouched
 159         label nextFree = List<T>::size();
 160         List<T>::setSize(capacity_);
 161         List<T>::size(nextFree);
 162     }
 163 }
 164
 165
 166 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 167 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::setSize
 168 (
 169     const label nElem
 170 )
 171 {
 172     // allocate more capacity?
 173     if (nElem > capacity_)
 174     {
 175 // TODO: convince the compiler that division by zero does not occur
 176 //        if (SizeInc && (!SizeMult || !SizeDiv))
 177 //        {
 178 //            // resize with SizeInc as the granularity
 179 //            capacity_ = nElem;
 180 //            unsigned pad = SizeInc - (capacity_ % SizeInc);
 181 //            if (pad != SizeInc)
 182 //            {
 183 //                capacity_ += pad;
 184 //            }
 185 //        }
 186 //        else
 187         {
 188             capacity_ = max
 189             (
 190                 nElem,
 191                 label(SizeInc + capacity_ * SizeMult / SizeDiv)
 192             );
 193         }
 194
 195         List<T>::setSize(capacity_);
 196     }
 197
 198     // adjust addressed size
 199     List<T>::size(nElem);
 200 }
 201
 202
 203 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 204 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::setSize
 205 (
 206     const label nElem,
 207     const T& t
 208 )
 209 {
 210     label nextFree = List<T>::size();
 211     setSize(nElem);
 212
 213     // set new elements to constant value
 214     while (nextFree < nElem)
 215     {
 216         this->operator[](nextFree++) = t;
 217     }
 218 }
 219
 220
 221 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 222 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::resize
 223 (
 224     const label nElem
 225 )
 226 {
 227     this->setSize(nElem);
 228 }
 229
 230
 231 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 232 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::resize
 233 (
 234     const label nElem,
 235     const T& t
 236 )
 237 {
 238     this->setSize(nElem, t);
 239 }
 240
 241
 242 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 243 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::clear()
 244 {
 245     List<T>::size(0);
 246 }
 247
 248
 249 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 250 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::clearStorage()
 251 {
 252     List<T>::clear();
 253     capacity_ = 0;
 254 }
 255
 256
 257 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 258 inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>&
 259 Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::shrink()
 260 {
 261     label nextFree = List<T>::size();
 262     if (capacity_ > nextFree)
 263     {
 264         // use the full list when resizing
 265         List<T>::size(capacity_);
 266
 267         // the new size
 268         capacity_ = nextFree;
 269         List<T>::setSize(capacity_);
 270         List<T>::size(nextFree);
 271     }
 272     return *this;
 273 }
 274
 275
 276 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 277 inline void
 278 Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::transfer(List<T>& lst)
 279 {
 280     capacity_ = lst.size();
 281     List<T>::transfer(lst);   // take over storage, clear addressing for lst.
 282 }
 283
 284
 285 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 286 inline void
 287 Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::transfer
 288 (
 289     DynamicList<T, SizeInc, SizeMult, SizeDiv>& lst
 290 )
 291 {
 292     // take over storage as-is (without shrink), clear addressing for lst.
 293     capacity_ = lst.capacity_;
 294     lst.capacity_ = 0;
 295
 296     List<T>::transfer(static_cast<List<T>&>(lst));
 297 }
 298
 299
 300 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 301 inline Foam::Xfer< Foam::List<T> >
 302 Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::xfer()
 303 {
 304     return xferMoveTo< List<T> >(*this);
 305 }
 306
 307
 308 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 309 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::append
 310 (
 311     const T& t
 312 )
 313 {
 314     label elemI = List<T>::size();
 315     setSize(elemI + 1);
 316
 317     this->operator[](elemI) = t;
 318 }
 319
 320
 321 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 322 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::append
 323 (
 324     const UList<T>& lst
 325 )
 326 {
 327     if (this == &lst)
 328     {
 329         FatalErrorIn
 330         (
 331             "DynamicList<T, SizeInc, SizeMult, SizeDiv>::append"
 332             "(const UList<T>&)"
 333         )   << "attempted appending to self" << abort(FatalError);
 334     }
 335
 336     label nextFree = List<T>::size();
 337     setSize(nextFree + lst.size());
 338
 339     forAll(lst, elemI)
 340     {
 341         this->operator[](nextFree++) = lst[elemI];
 342     }
 343 }
 344
 345
 346 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 347 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::append
 348 (
 349     const UIndirectList<T>& lst
 350 )
 351 {
 352     label nextFree = List<T>::size();
 353     setSize(nextFree + lst.size());
 354
 355     forAll(lst, elemI)
 356     {
 357         this->operator[](nextFree++) = lst[elemI];
 358     }
 359 }
 360
 361
 362 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 363 inline T Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::remove()
 364 {
 365     label elemI = List<T>::size() - 1;
 366
 367     if (elemI < 0)
 368     {
 369         FatalErrorIn
 370         (
 371             "Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::remove()"
 372         )   << "List is empty" << abort(FatalError);
 373     }
 374
 375     const T& val = List<T>::operator[](elemI);
 376
 377     List<T>::size(elemI);
 378
 379     return val;
 380 }
 381
 382
 383 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 384
 385 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 386 inline T& Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::operator()
 387 (
 388     const label elemI
 389 )
 390 {
 391     if (elemI >= List<T>::size())
 392     {
 393         setSize(elemI + 1);
 394     }
 395
 396     return this->operator[](elemI);
 397 }
 398
 399
 400 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 401 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::operator=
 402 (
 403     const T& t
 404 )
 405 {
 406     UList<T>::operator=(t);
 407 }
 408
 409
 410 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 411 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::operator=
 412 (
 413     const UList<T>& lst
 414 )
 415 {
 416     if (capacity_ >= lst.size())
 417     {
 418         // can copy w/o reallocating, match initial size to avoid reallocation
 419         List<T>::size(lst.size());
 420         List<T>::operator=(lst);
 421     }
 422     else
 423     {
 424         // make everything available for the copy operation
 425         List<T>::size(capacity_);
 426
 427         List<T>::operator=(lst);
 428         capacity_ = List<T>::size();
 429     }
 430 }
 431
 432
 433 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 434 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::operator=
 435 (
 436     const DynamicList<T, SizeInc, SizeMult, SizeDiv>& lst
 437 )
 438 {
 439     if (this == &lst)
 440     {
 441         FatalErrorIn
 442         (
 443             "DynamicList<T, SizeInc, SizeMult, SizeDiv>::operator="
 444             "(const DynamicList<T, SizeInc, SizeMult, SizeDiv>&)"
 445         )   << "attempted assignment to self" << abort(FatalError);
 446     }
 447
 448     if (capacity_ >= lst.size())
 449     {
 450         // can copy w/o reallocating, match initial size to avoid reallocation
 451         List<T>::size(lst.size());
 452         List<T>::operator=(lst);
 453     }
 454     else
 455     {
 456         // make everything available for the copy operation
 457         List<T>::size(capacity_);
 458
 459         List<T>::operator=(lst);
 460         capacity_ = List<T>::size();
 461     }
 462 }
 463
 464
 465 // ************************************************************************* //