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