src/foam/containers/Lists/UList/UListI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "error.H"
  27 #include "pTraits.H"
  28 #include "Swap.H"
  29
  30 // * * * * * * * * * * * * * * * Static Members  * * * * * * * * * * * * * * //
  31
  32 template<class T>
  33 const Foam::UList<T> Foam::UList<T>::zero;
  34
  35
  36 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  37
  38 template<class T>
  39 inline Foam::UList<T>::UList()
  40 :
  41     v_(0),
  42     size_(0)
  43 {}
  44
  45
  46 template<class T>
  47 inline Foam::UList<T>::UList(T* __restrict__ v, label size)
  48 :
  49     v_(v),
  50     size_(size)
  51 {}
  52
  53
  54 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  55
  56 template<class T>
  57 inline const Foam::UList<T>& Foam::UList<T>::null()
  58 {
  59     return zero;
  60 }
  61
  62
  63 // Reset in slicing.  HJ. 19/Oct/2008
  64 template<class T>
  65 inline void Foam::UList<T>::reset(T* __restrict__ v, label size)
  66 {
  67     v_ = v;
  68     size_ = size;
  69 }
  70
  71
  72 template<class T>
  73 inline Foam::label Foam::UList<T>::fcIndex(const label i) const
  74 {
  75     return (i == size()-1 ? 0 : i+1);
  76 }
  77
  78
  79 template<class T>
  80 inline Foam::label Foam::UList<T>::rcIndex(const label i) const
  81 {
  82     return (i ? i-1 : size()-1);
  83 }
  84
  85
  86 // Check start is within valid range (0 ... size-1).
  87 template<class T>
  88 inline void Foam::UList<T>::checkStart(const label start) const
  89 {
  90     if (start<0 || (start && start>=size_))
  91     {
  92         FatalErrorIn("UList<T>::checkStart(const label)")
  93             << "start " << start << " out of range 0 ... " << max(size_-1, 0)
  94             << abort(FatalError);
  95     }
  96 }
  97
  98
  99 // Check size is within valid range (0 ... size).
 100 template<class T>
 101 inline void Foam::UList<T>::checkSize(const label size) const
 102 {
 103     if (size<0 || size>size_)
 104     {
 105         FatalErrorIn("UList<T>::checkSize(const label)")
 106             << "size " << size << " out of range 0 ... " << size_
 107             << abort(FatalError);
 108     }
 109 }
 110
 111
 112 // Check index i is within valid range (0 ... size-1).
 113 template<class T>
 114 inline void Foam::UList<T>::checkIndex(const label i) const
 115 {
 116     if (!size_)
 117     {
 118         FatalErrorIn("UList<T>::checkIndex(const label)")
 119             << "attempt to access element from zero sized list"
 120             << abort(FatalError);
 121     }
 122     else if (i<0 || i>=size_)
 123     {
 124         FatalErrorIn("UList<T>::checkIndex(const label)")
 125             << "index " << i << " out of range 0 ... " << size_-1
 126             << abort(FatalError);
 127     }
 128 }
 129
 130
 131 template<class T>
 132 inline T& Foam::UList<T>::first()
 133 {
 134     return this->operator[](0);
 135 }
 136
 137
 138 template<class T>
 139 inline const T& Foam::UList<T>::first() const
 140 {
 141     return this->operator[](0);
 142 }
 143
 144
 145 template<class T>
 146 inline T& Foam::UList<T>::last()
 147 {
 148     return this->operator[](this->size()-1);
 149 }
 150
 151
 152 template<class T>
 153 inline const T& Foam::UList<T>::last() const
 154 {
 155     return this->operator[](this->size()-1);
 156 }
 157
 158
 159 template<class T>
 160 inline const T* Foam::UList<T>::cdata() const
 161 {
 162     return v_;
 163 }
 164
 165
 166 template<class T>
 167 inline T* Foam::UList<T>::data()
 168 {
 169     return v_;
 170 }
 171
 172
 173 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 174
 175
 176 // element access
 177 template<class T>
 178 inline T& Foam::UList<T>::operator[](const label i)
 179 {
 180 #   ifdef FULLDEBUG
 181     checkIndex(i);
 182 #   endif
 183     return v_[i];
 184 }
 185
 186
 187 namespace Foam
 188 {
 189
 190     // Template specialization for bool
 191     template<>
 192     inline const bool& UList<bool>::operator[](const label i) const
 193     {
 194         // lazy evaluation - return false for out-of-range
 195         if (i < size_)
 196         {
 197             return v_[i];
 198         }
 199         else
 200         {
 201             return pTraits<bool>::zero;
 202         }
 203     }
 204
 205 } // end of namespace Foam
 206
 207
 208 // const element access
 209 template<class T>
 210 inline const T& Foam::UList<T>::operator[](const label i) const
 211 {
 212 #   ifdef FULLDEBUG
 213     checkIndex(i);
 214 #   endif
 215     return v_[i];
 216 }
 217
 218
 219 // Allow cast to a const List<T>&
 220 template<class T>
 221 inline Foam::UList<T>::operator const Foam::List<T>&() const
 222 {
 223     return *reinterpret_cast<const List<T>*>(this);
 224 }
 225
 226
 227 // * * * * * * * * * * * * * * STL Member Functions  * * * * * * * * * * * * //
 228
 229 template<class T>
 230 inline typename Foam::UList<T>::iterator
 231 Foam::UList<T>::begin()
 232 {
 233     return v_;
 234 }
 235
 236 template<class T>
 237 inline typename Foam::UList<T>::const_iterator
 238 Foam::UList<T>::begin() const
 239 {
 240     return v_;
 241 }
 242
 243 template<class T>
 244 inline typename Foam::UList<T>::const_iterator
 245 Foam::UList<T>::cbegin() const
 246 {
 247     return v_;
 248 }
 249
 250 template<class T>
 251 inline typename Foam::UList<T>::iterator
 252 Foam::UList<T>::end()
 253 {
 254     return &v_[size_];
 255 }
 256
 257 template<class T>
 258 inline typename Foam::UList<T>::const_iterator
 259 Foam::UList<T>::end() const
 260 {
 261     return &v_[size_];
 262 }
 263
 264 template<class T>
 265 inline typename Foam::UList<T>::const_iterator
 266 Foam::UList<T>::cend() const
 267 {
 268     return &v_[size_];
 269 }
 270
 271 template<class T>
 272 inline typename Foam::UList<T>::iterator
 273 Foam::UList<T>::rbegin()
 274 {
 275     return &v_[size_-1];
 276 }
 277
 278 template<class T>
 279 inline typename Foam::UList<T>::const_iterator
 280 Foam::UList<T>::rbegin() const
 281 {
 282     return &v_[size_-1];
 283 }
 284
 285 template<class T>
 286 inline typename Foam::UList<T>::const_iterator
 287 Foam::UList<T>::crbegin() const
 288 {
 289     return &v_[size_-1];
 290 }
 291
 292 template<class T>
 293 inline typename Foam::UList<T>::iterator
 294 Foam::UList<T>::rend()
 295 {
 296     return &v_[-1];
 297 }
 298
 299 template<class T>
 300 inline typename Foam::UList<T>::const_iterator
 301 Foam::UList<T>::rend() const
 302 {
 303     return &v_[-1];
 304 }
 305
 306 template<class T>
 307 inline typename Foam::UList<T>::const_iterator
 308 Foam::UList<T>::crend() const
 309 {
 310     return &v_[-1];
 311 }
 312
 313 template<class T>
 314 inline Foam::label Foam::UList<T>::size() const
 315 {
 316     return size_;
 317 }
 318
 319
 320 template<class T>
 321 inline Foam::label Foam::UList<T>::max_size() const
 322 {
 323     return labelMax;
 324 }
 325
 326
 327 template<class T>
 328 inline bool Foam::UList<T>::empty() const
 329 {
 330     return !size_;
 331 }
 332
 333
 334 // * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 335
 336 template<class T>
 337 inline void Foam::reverse(UList<T>& ul, const label n)
 338 {
 339     for (int i=0; i<n/2; i++)
 340     {
 341         Swap(ul[i], ul[n-1-i]);
 342     }
 343 }
 344
 345 template<class T>
 346 inline void Foam::reverse(UList<T>& ul)
 347 {
 348     reverse(ul, ul.size());
 349 }
 350
 351
 352 // ************************************************************************* //