src/foam/containers/Lists/PtrList/PtrListI.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
  28 #include "autoPtr.H"
  29 #include "tmp.H"
  30
  31 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  32
  33 template<class T>
  34 inline Foam::label Foam::PtrList<T>::size() const
  35 {
  36     return ptrs_.size();
  37 }
  38
  39
  40 template<class T>
  41 inline bool Foam::PtrList<T>::empty() const
  42 {
  43     return ptrs_.empty();
  44 }
  45
  46
  47 template<class T>
  48 inline void Foam::PtrList<T>::resize(const label newSize)
  49 {
  50     this->setSize(newSize);
  51 }
  52
  53
  54 template<class T>
  55 inline bool Foam::PtrList<T>::set(const label i) const
  56 {
  57     return ptrs_[i] != NULL;
  58 }
  59
  60
  61 template<class T>
  62 inline Foam::autoPtr<T> Foam::PtrList<T>::set(const label i, T* ptr)
  63 {
  64     autoPtr<T> old(ptrs_[i]);
  65
  66     ptrs_[i] = ptr;
  67
  68     return old;
  69 }
  70
  71
  72 template<class T>
  73 inline Foam::autoPtr<T> Foam::PtrList<T>::set
  74 (
  75     const label i,
  76     const autoPtr<T>& aptr
  77 )
  78 {
  79     return set(i, const_cast<autoPtr<T>&>(aptr).ptr());
  80 }
  81
  82
  83 template<class T>
  84 inline Foam::autoPtr<T> Foam::PtrList<T>::set
  85 (
  86     const label i,
  87     const tmp<T>& t
  88 )
  89 {
  90     return set(i, const_cast<tmp<T>&>(t).ptr());
  91 }
  92
  93
  94 template<class T>
  95 inline Foam::Xfer<Foam::PtrList<T> > Foam::PtrList<T>::xfer()
  96 {
  97     return xferMove(*this);
  98 }
  99
 100
 101 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 102
 103 template<class T>
 104 const T& Foam::PtrList<T>::operator[](const label i) const
 105 {
 106     if (!ptrs_[i])
 107     {
 108         FatalErrorIn("PtrList::operator[] const")
 109             << "hanging pointer, cannot dereference"
 110             << abort(FatalError);
 111     }
 112
 113     return *(ptrs_[i]);
 114 }
 115
 116
 117 template<class T>
 118 T& Foam::PtrList<T>::operator[](const label i)
 119 {
 120     if (!ptrs_[i])
 121     {
 122         FatalErrorIn("PtrList::operator[]")
 123             << "hanging pointer, cannot dereference"
 124             << abort(FatalError);
 125     }
 126
 127     return *(ptrs_[i]);
 128 }
 129
 130
 131 template<class T>
 132 const T* Foam::PtrList<T>::operator()(const label i) const
 133 {
 134     return ptrs_[i];
 135 }
 136
 137
 138 // * * * * * * * * * * * * * * * * STL iterator  * * * * * * * * * * * * * * //
 139
 140 template<class T>
 141 inline Foam::PtrList<T>::iterator::iterator(T** ptr)
 142 :
 143     ptr_(ptr)
 144 {}
 145
 146 template<class T>
 147 inline bool Foam::PtrList<T>::iterator::operator==(const iterator& iter) const
 148 {
 149     return ptr_ == iter.ptr_;
 150 }
 151
 152 template<class T>
 153 inline bool Foam::PtrList<T>::iterator::operator!=(const iterator& iter) const
 154 {
 155     return ptr_ != iter.ptr_;
 156 }
 157
 158 template<class T>
 159 inline T& Foam::PtrList<T>::iterator::operator*()
 160 {
 161     return **ptr_;
 162 }
 163
 164 template<class T>
 165 inline T& Foam::PtrList<T>::iterator::operator()()
 166 {
 167     return operator*();
 168 }
 169
 170 template<class T>
 171 inline typename Foam::PtrList<T>::iterator
 172 Foam::PtrList<T>::iterator::operator++()
 173 {
 174     ++ptr_;
 175     return *this;
 176 }
 177
 178 template<class T>
 179 inline typename Foam::PtrList<T>::iterator
 180 Foam::PtrList<T>::iterator::operator++(int)
 181 {
 182     iterator tmp = *this;
 183     ++ptr_;
 184     return tmp;
 185 }
 186
 187 template<class T>
 188 inline typename Foam::PtrList<T>::iterator
 189 Foam::PtrList<T>::iterator::operator--()
 190 {
 191     --ptr_;
 192     return *this;
 193 }
 194
 195 template<class T>
 196 inline typename Foam::PtrList<T>::iterator
 197 Foam::PtrList<T>::iterator::operator--(int)
 198 {
 199     iterator tmp = *this;
 200     --ptr_;
 201     return tmp;
 202 }
 203
 204 template<class T>
 205 inline typename Foam::PtrList<T>::iterator
 206 Foam::PtrList<T>::iterator::operator+=(label n)
 207 {
 208     ptr_ += n;
 209     return *this;
 210 }
 211
 212 template<class T>
 213 inline typename Foam::PtrList<T>::iterator
 214 Foam::operator+(const typename PtrList<T>::iterator& iter, label n)
 215 {
 216     typename PtrList<T>::iterator tmp = iter;
 217     return tmp += n;
 218 }
 219
 220 template<class T>
 221 inline typename Foam::PtrList<T>::iterator
 222 Foam::operator+(label n, const typename PtrList<T>::iterator& iter)
 223 {
 224     typename PtrList<T>::iterator tmp = iter;
 225     return tmp += n;
 226 }
 227
 228 template<class T>
 229 inline typename Foam::PtrList<T>::iterator
 230 Foam::PtrList<T>::iterator::operator-=(label n)
 231 {
 232     ptr_ -= n;
 233     return *this;
 234 }
 235
 236 template<class T>
 237 inline typename Foam::PtrList<T>::iterator
 238 Foam::operator-(const typename PtrList<T>::iterator& iter, label n)
 239 {
 240     typename PtrList<T>::iterator tmp = iter;
 241     return tmp -= n;
 242 }
 243
 244 template<class T>
 245 inline Foam::label Foam::operator-
 246 (
 247     const typename PtrList<T>::iterator& iter1,
 248     const typename PtrList<T>::iterator& iter2
 249 )
 250 {
 251     return (iter1.ptr_ - iter2.ptr_)/sizeof(T*);
 252 }
 253
 254 template<class T>
 255 inline T& Foam::PtrList<T>::iterator::operator[](label n)
 256 {
 257     return *(*this + n);
 258 }
 259
 260 template<class T>
 261 inline bool Foam::PtrList<T>::iterator::operator<(const iterator& iter) const
 262 {
 263     return ptr_ < iter.ptr_;
 264 }
 265
 266 template<class T>
 267 inline bool Foam::PtrList<T>::iterator::operator>(const iterator& iter) const
 268 {
 269     return ptr_ > iter.ptr_;
 270 }
 271
 272 template<class T>
 273 inline bool Foam::PtrList<T>::iterator::operator<=(const iterator& iter) const
 274 {
 275     return ptr_ <= iter.ptr_;
 276 }
 277
 278 template<class T>
 279 inline bool Foam::PtrList<T>::iterator::operator>=(const iterator& iter) const
 280 {
 281     return ptr_ >= iter.ptr_;
 282 }
 283
 284 template<class T>
 285 inline typename Foam::PtrList<T>::iterator
 286 Foam::PtrList<T>::begin()
 287 {
 288     return ptrs_.begin();
 289 }
 290
 291 template<class T>
 292 inline typename Foam::PtrList<T>::iterator
 293 Foam::PtrList<T>::end()
 294 {
 295     return ptrs_.end();
 296 }
 297
 298
 299
 300 // ************************************************************************* //