src/OpenFOAM/containers/Lists/PtrList/PtrList.C

   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 #include "error.H"
  28
  29 #include "PtrList.H"
  30 #include "SLPtrList.H"
  31
  32 // * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
  33
  34 template<class T>
  35 Foam::PtrList<T>::PtrList()
  36 :
  37     ptrs_()
  38 {}
  39
  40
  41 template<class T>
  42 Foam::PtrList<T>::PtrList(const label s)
  43 :
  44     ptrs_(s, reinterpret_cast<T*>(0))
  45 {}
  46
  47
  48 template<class T>
  49 Foam::PtrList<T>::PtrList(const PtrList<T>& a)
  50 :
  51     ptrs_(a.size())
  52 {
  53     forAll(*this, i)
  54     {
  55         ptrs_[i] = (a[i]).clone().ptr();
  56     }
  57 }
  58
  59
  60 template<class T>
  61 template<class CloneArg>
  62 Foam::PtrList<T>::PtrList(const PtrList<T>& a, const CloneArg& cloneArg)
  63 :
  64     ptrs_(a.size())
  65 {
  66     forAll(*this, i)
  67     {
  68         ptrs_[i] = (a[i]).clone(cloneArg).ptr();
  69     }
  70 }
  71
  72
  73 template<class T>
  74 Foam::PtrList<T>::PtrList(const Xfer<PtrList<T> >& lst)
  75 {
  76     transfer(lst());
  77 }
  78
  79
  80 template<class T>
  81 Foam::PtrList<T>::PtrList(PtrList<T>& a, bool reUse)
  82 :
  83     ptrs_(a.size())
  84 {
  85     if (reUse)
  86     {
  87         forAll(*this, i)
  88         {
  89             ptrs_[i] = a.ptrs_[i];
  90             a.ptrs_[i] = NULL;
  91         }
  92         a.setSize(0);
  93     }
  94     else
  95     {
  96         forAll(*this, i)
  97         {
  98             ptrs_[i] = (a[i]).clone().ptr();
  99         }
 100     }
 101 }
 102
 103
 104 template<class T>
 105 Foam::PtrList<T>::PtrList(const SLPtrList<T>& sll)
 106 :
 107     ptrs_(sll.size())
 108 {
 109     if (sll.size())
 110     {
 111         label i = 0;
 112         for
 113         (
 114             typename SLPtrList<T>::const_iterator iter = sll.begin();
 115             iter != sll.end();
 116             ++iter
 117         )
 118         {
 119             ptrs_[i++] = (iter()).clone().ptr();
 120         }
 121     }
 122 }
 123
 124
 125 // * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * * //
 126
 127 template<class T>
 128 Foam::PtrList<T>::~PtrList()
 129 {
 130     forAll(*this, i)
 131     {
 132         if (ptrs_[i])
 133         {
 134             delete ptrs_[i];
 135         }
 136     }
 137 }
 138
 139
 140 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 141
 142 template<class T>
 143 void Foam::PtrList<T>::setSize(const label newSize)
 144 {
 145     if (newSize < 0)
 146     {
 147         FatalErrorIn("PtrList<T>::setSize(const label)")
 148             << "bad set size " << newSize
 149             << abort(FatalError);
 150     }
 151
 152     label oldSize = size();
 153
 154     if (newSize == 0)
 155     {
 156         clear();
 157     }
 158     else if (newSize < oldSize)
 159     {
 160         register label i;
 161         for (i=newSize; i<oldSize; i++)
 162         {
 163             if (ptrs_[i])
 164             {
 165                 delete ptrs_[i];
 166             }
 167         }
 168
 169         ptrs_.setSize(newSize);
 170     }
 171     else // newSize > oldSize
 172     {
 173         ptrs_.setSize(newSize);
 174
 175         register label i;
 176         for (i=oldSize; i<newSize; i++)
 177         {
 178             ptrs_[i] = NULL;
 179         }
 180     }
 181 }
 182
 183
 184 template<class T>
 185 void Foam::PtrList<T>::clear()
 186 {
 187     forAll(*this, i)
 188     {
 189         if (ptrs_[i])
 190         {
 191             delete ptrs_[i];
 192         }
 193     }
 194
 195     ptrs_.clear();
 196 }
 197
 198
 199 template<class T>
 200 void Foam::PtrList<T>::transfer(PtrList<T>& a)
 201 {
 202     clear();
 203     ptrs_.transfer(a.ptrs_);
 204 }
 205
 206
 207 template<class T>
 208 void Foam::PtrList<T>::reorder(const UList<label>& oldToNew)
 209 {
 210     if (oldToNew.size() != size())
 211     {
 212         FatalErrorIn("PtrList<T>::reorder(const UList<label>&)")
 213             << "Size of map (" << oldToNew.size()
 214             << ") not equal to list size (" << size()
 215             << ")." << abort(FatalError);
 216     }
 217
 218     List<T*> newPtrs_(ptrs_.size(), reinterpret_cast<T*>(0));
 219
 220     forAll(*this, i)
 221     {
 222         label newI = oldToNew[i];
 223
 224         if (newI < 0 || newI >= size())
 225         {
 226             FatalErrorIn("PtrList<T>::reorder(const UList<label>&)")
 227                 << "Illegal index " << newI << nl
 228                 << "Valid indices are 0.." << size()-1
 229                 << abort(FatalError);
 230         }
 231
 232         if (newPtrs_[newI])
 233         {
 234             FatalErrorIn("PtrList<T>::reorder(const UList<label>&)")
 235                 << "reorder map is not unique; element " << newI
 236                 << " already set." << abort(FatalError);
 237         }
 238         newPtrs_[newI] = ptrs_[i];
 239     }
 240
 241     forAll(newPtrs_, i)
 242     {
 243         if (!newPtrs_[i])
 244         {
 245             FatalErrorIn("PtrList<T>::reorder(const UList<label>&)")
 246                 << "Element " << i << " not set after reordering." << nl
 247                 << abort(FatalError);
 248         }
 249     }
 250
 251     ptrs_.transfer(newPtrs_);
 252 }
 253
 254
 255 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 256
 257 template<class T>
 258 Foam::PtrList<T>& Foam::PtrList<T>::operator=(const PtrList<T>& a)
 259 {
 260     if (this == &a)
 261     {
 262         FatalErrorIn("PtrList<T>::operator=(const PtrList<T>&)")
 263             << "attempted assignment to self"
 264             << abort(FatalError);
 265     }
 266
 267     if (size() == 0)
 268     {
 269         setSize(a.size());
 270
 271         forAll(*this, i)
 272         {
 273             ptrs_[i] = (a[i]).clone().ptr();
 274         }
 275     }
 276     else if (a.size() == size())
 277     {
 278         forAll(*this, i)
 279         {
 280             (*this)[i] = a[i];
 281         }
 282     }
 283     else
 284     {
 285         FatalErrorIn("PtrList::operator=(const PtrList<T>&)")
 286             << "bad size: " << a.size()
 287             << abort(FatalError);
 288     }
 289
 290
 291     return *this;
 292 }
 293
 294
 295 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 296
 297 #include "PtrListIO.C"
 298
 299 // ************************************************************************* //