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

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 #include "error.H"
  28 #include "pTraits.H"
  29 #include "Swap.H"
  30
  31 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  32
  33 template<class T>
  34 inline Foam::UList<T>::UList()
  35 :
  36     size_(0),
  37     v_(0)
  38 {}
  39
  40
  41 template<class T>
  42 inline Foam::UList<T>::UList(T* __restrict__ v, label size)
  43 :
  44     size_(size),
  45     v_(v)
  46 {}
  47
  48
  49 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  50
  51 template<class T>
  52 inline const Foam::UList<T>& Foam::UList<T>::null()
  53 {
  54     return *reinterpret_cast< UList<T>* >(0);
  55 }
  56
  57
  58 template<class T>
  59 inline Foam::label Foam::UList<T>::fcIndex(const label i) const
  60 {
  61     return (i == size()-1 ? 0 : i+1);
  62 }
  63
  64
  65 template<class T>
  66 inline Foam::label Foam::UList<T>::rcIndex(const label i) const
  67 {
  68     return (i ? i-1 : size()-1);
  69 }
  70
  71
  72 // Check start is within valid range (0 ... size-1).
  73 template<class T>
  74 inline void Foam::UList<T>::checkStart(const label start) const
  75 {
  76     if (start<0 || (start && start>=size_))
  77     {
  78         FatalErrorIn("UList<T>::checkStart(const label)")
  79             << "start " << start << " out of range 0 ... " << max(size_-1, 0)
  80             << abort(FatalError);
  81     }
  82 }
  83
  84
  85 // Check size is within valid range (0 ... size).
  86 template<class T>
  87 inline void Foam::UList<T>::checkSize(const label size) const
  88 {
  89     if (size<0 || size>size_)
  90     {
  91         FatalErrorIn("UList<T>::checkSize(const label)")
  92             << "size " << size << " out of range 0 ... " << size_
  93             << abort(FatalError);
  94     }
  95 }
  96
  97
  98 // Check index i is within valid range (0 ... size-1).
  99 template<class T>
 100 inline void Foam::UList<T>::checkIndex(const label i) const
 101 {
 102     if (!size_)
 103     {
 104         FatalErrorIn("UList<T>::checkIndex(const label)")
 105             << "attempt to access element from zero sized list"
 106             << abort(FatalError);
 107     }
 108     else if (i<0 || i>=size_)
 109     {
 110         FatalErrorIn("UList<T>::checkIndex(const label)")
 111             << "index " << i << " out of range 0 ... " << size_-1
 112             << abort(FatalError);
 113     }
 114 }
 115
 116
 117 template<class T>
 118 inline const T* Foam::UList<T>::cdata() const
 119 {
 120     return v_;
 121 }
 122
 123
 124 template<class T>
 125 inline T* Foam::UList<T>::data()
 126 {
 127     return v_;
 128 }
 129
 130
 131 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 132
 133
 134 // element access
 135 template<class T>
 136 inline T& Foam::UList<T>::operator[](const label i)
 137 {
 138 #   ifdef FULLDEBUG
 139     checkIndex(i);
 140 #   endif
 141     return v_[i];
 142 }
 143
 144
 145 namespace Foam
 146 {
 147
 148     // Template specialization for bool
 149     template<>
 150     inline const bool& Foam::UList<bool>::operator[](const label i) const
 151     {
 152         // lazy evaluation - return false for out-of-range
 153         if (i < size_)
 154         {
 155             return v_[i];
 156         }
 157         else
 158         {
 159             return Foam::pTraits<bool>::zero;
 160         }
 161     }
 162
 163 } // end of namespace Foam
 164
 165
 166 // const element access
 167 template<class T>
 168 inline const T& Foam::UList<T>::operator[](const label i) const
 169 {
 170 #   ifdef FULLDEBUG
 171     checkIndex(i);
 172 #   endif
 173     return v_[i];
 174 }
 175
 176
 177 // Allow cast to a const List<T>&
 178 template<class T>
 179 inline Foam::UList<T>::operator const Foam::List<T>&() const
 180 {
 181     return *reinterpret_cast<const List<T>*>(this);
 182 }
 183
 184
 185 // * * * * * * * * * * * * * * STL Member Functions  * * * * * * * * * * * * //
 186
 187 template<class T>
 188 inline typename Foam::UList<T>::iterator
 189 Foam::UList<T>::begin()
 190 {
 191     return v_;
 192 }
 193
 194 template<class T>
 195 inline typename Foam::UList<T>::const_iterator
 196 Foam::UList<T>::begin() const
 197 {
 198     return v_;
 199 }
 200
 201 template<class T>
 202 inline typename Foam::UList<T>::const_iterator
 203 Foam::UList<T>::cbegin() const
 204 {
 205     return v_;
 206 }
 207
 208 template<class T>
 209 inline typename Foam::UList<T>::iterator
 210 Foam::UList<T>::end()
 211 {
 212     return &v_[size_];
 213 }
 214
 215 template<class T>
 216 inline typename Foam::UList<T>::const_iterator
 217 Foam::UList<T>::end() const
 218 {
 219     return &v_[size_];
 220 }
 221
 222 template<class T>
 223 inline typename Foam::UList<T>::const_iterator
 224 Foam::UList<T>::cend() const
 225 {
 226     return &v_[size_];
 227 }
 228
 229 template<class T>
 230 inline typename Foam::UList<T>::iterator
 231 Foam::UList<T>::rbegin()
 232 {
 233     return &v_[size_-1];
 234 }
 235
 236 template<class T>
 237 inline typename Foam::UList<T>::const_iterator
 238 Foam::UList<T>::rbegin() const
 239 {
 240     return &v_[size_-1];
 241 }
 242
 243 template<class T>
 244 inline typename Foam::UList<T>::const_iterator
 245 Foam::UList<T>::crbegin() const
 246 {
 247     return &v_[size_-1];
 248 }
 249
 250 template<class T>
 251 inline typename Foam::UList<T>::iterator
 252 Foam::UList<T>::rend()
 253 {
 254     return &v_[-1];
 255 }
 256
 257 template<class T>
 258 inline typename Foam::UList<T>::const_iterator
 259 Foam::UList<T>::rend() const
 260 {
 261     return &v_[-1];
 262 }
 263
 264 template<class T>
 265 inline typename Foam::UList<T>::const_iterator
 266 Foam::UList<T>::crend() const
 267 {
 268     return &v_[-1];
 269 }
 270
 271 template<class T>
 272 inline Foam::label Foam::UList<T>::size() const
 273 {
 274     return size_;
 275 }
 276
 277
 278 template<class T>
 279 inline Foam::label Foam::UList<T>::max_size() const
 280 {
 281     return labelMax;
 282 }
 283
 284
 285 template<class T>
 286 inline bool Foam::UList<T>::empty() const
 287 {
 288     return !size_;
 289 }
 290
 291
 292 // * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 293
 294 template<class T>
 295 inline void Foam::reverse(UList<T>& ul, const label n)
 296 {
 297     for (int i=0; i<n/2; i++)
 298     {
 299         Swap(ul[i], ul[n-1-i]);
 300     }
 301 }
 302
 303 template<class T>
 304 inline void Foam::reverse(UList<T>& ul)
 305 {
 306     reverse(ul, ul.size());
 307 }
 308
 309
 310 // ************************************************************************* //