src/foam/containers/Lists/CompactListList/CompactListList.C

   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 "CompactListList.H"
  27
  28 // * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
  29
  30 template<class T>
  31 Foam::CompactListList<T>::CompactListList(const List<List<T> >& ll)
  32 :
  33     offsets_(ll.size())
  34 {
  35     label sumSize = 0;
  36     forAll(ll, i)
  37     {
  38         sumSize += ll[i].size();
  39         offsets_[i] = sumSize;
  40     }
  41
  42     m_.setSize(sumSize);
  43
  44     label k = 0;
  45     forAll(ll, i)
  46     {
  47         const List<T>& lli = ll[i];
  48
  49         forAll(lli, j)
  50         {
  51             m_[k++] = lli[j];
  52         }
  53     }
  54 }
  55
  56
  57 template<class T>
  58 Foam::CompactListList<T>::CompactListList
  59 (
  60     const UList<label>& rowSizes
  61 )
  62 :
  63     offsets_(rowSizes.size())
  64 {
  65     label sumSize = 0;
  66     forAll(rowSizes, i)
  67     {
  68         sumSize += rowSizes[i];
  69         offsets_[i] = sumSize;
  70     }
  71
  72     m_.setSize(sumSize);
  73 }
  74
  75
  76 template<class T>
  77 Foam::CompactListList<T>::CompactListList
  78 (
  79     const UList<label>& rowSizes,
  80     const T& t
  81 )
  82 :
  83     offsets_(rowSizes.size())
  84 {
  85     label sumSize = 0;
  86     forAll(rowSizes, i)
  87     {
  88         sumSize += rowSizes[i];
  89         offsets_[i] = sumSize;
  90     }
  91
  92     m_.setSize(sumSize, t);
  93 }
  94
  95
  96 template<class T>
  97 Foam::CompactListList<T>::CompactListList
  98 (
  99     const Xfer<CompactListList<T> >& lst
 100 )
 101 {
 102     transfer(lst());
 103 }
 104
 105
 106 template<class T>
 107 Foam::CompactListList<T>::CompactListList
 108 (
 109     CompactListList<T>& lst,
 110     bool reUse
 111 )
 112 :
 113     offsets_(lst.offsets_, reUse),
 114     m_(lst.m_, reUse)
 115 {}
 116
 117
 118 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 119
 120 template<class T>
 121 void Foam::CompactListList<T>::setSize(const label nRows)
 122 {
 123     if (nRows == 0)
 124     {
 125         clear();
 126     }
 127     if (nRows < offsets_.size())
 128     {
 129         offsets_.setSize(nRows);
 130         m_.setSize(offsets_[nRows - 1]);
 131     }
 132     else if (nRows > offsets_.size())
 133     {
 134         FatalErrorIn("CompactListList<T>::setSize(const label nRows)")
 135             << "Cannot be used to extend the list from " << offsets_.size()
 136             << " to " << nRows << nl
 137             << "    Please use one of the other setSize member functions"
 138             << abort(FatalError);
 139     }
 140 }
 141
 142
 143 template<class T>
 144 void Foam::CompactListList<T>::setSize
 145 (
 146     const label nRows,
 147     const label nData
 148 )
 149 {
 150     offsets_.setSize(nRows);
 151     m_.setSize(nData);
 152 }
 153
 154
 155 template<class T>
 156 void Foam::CompactListList<T>::setSize
 157 (
 158     const label nRows,
 159     const label nData,
 160     const T& t
 161 )
 162 {
 163     offsets_.setSize(nRows);
 164     m_.setSize(nData, t);
 165 }
 166
 167
 168 template<class T>
 169 void Foam::CompactListList<T>::setSize(const UList<label>& rowSizes)
 170 {
 171     offsets_.setSize(rowSizes.size());
 172
 173     label sumSize = 0;
 174     forAll(rowSizes, i)
 175     {
 176         sumSize += rowSizes[i];
 177         offsets_[i] = sumSize;
 178     }
 179
 180     m_.setSize(sumSize);
 181 }
 182
 183
 184 template<class T>
 185 Foam::labelList Foam::CompactListList<T>::sizes() const
 186 {
 187     labelList rowSizes(offsets_.size());
 188
 189     label prevOffset = 0;
 190     forAll(offsets_, i)
 191     {
 192         rowSizes[i] = offsets_[i]-prevOffset;
 193         prevOffset = offsets_[i];
 194     }
 195     return rowSizes;
 196 }
 197
 198
 199 template<class T>
 200 void Foam::CompactListList<T>::clear()
 201 {
 202     offsets_.clear();
 203     m_.clear();
 204 }
 205
 206
 207 template<class T>
 208 void Foam::CompactListList<T>::transfer(CompactListList<T>& a)
 209 {
 210     offsets_.transfer(a.offsets_);
 211     m_.transfer(a.m_);
 212 }
 213
 214
 215 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 216
 217 template<class T>
 218 Foam::List<Foam::List<T> > Foam::CompactListList<T>::operator()() const
 219 {
 220     List<List<T> > ll(offsets_.size());
 221
 222     label offsetPrev = 0;
 223     forAll(offsets_, i)
 224     {
 225         List<T>& lst = ll[i];
 226
 227         lst.setSize(offsets_[i] - offsetPrev);
 228
 229         forAll(lst, j)
 230         {
 231             lst[j] = m_[offsetPrev + j];
 232         }
 233
 234         offsetPrev = offsets_[i];
 235     }
 236
 237     return ll;
 238 }
 239
 240
 241 // * * * * * * * * * * * * * * * *  IOStream operators * * * * * * * * * * * //
 242
 243 #include "CompactListListIO.C"
 244
 245 // ************************************************************************* //