src/foam/containers/Lists/List/List.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 Class
  25     Foam::List
  26
  27 Description
  28     A 1D array of objects of type \<T\>, where the size of the vector
  29     is known and used for subscript bounds checking, etc.
  30
  31     Storage is allocated on free-store during construction.
  32
  33 SourceFiles
  34     List.C
  35     ListI.H
  36     ListIO.C
  37
  38 \*---------------------------------------------------------------------------*/
  39
  40 #ifndef List_H
  41 #define List_H
  42
  43 #include "UList.H"
  44 #include "autoPtr.H"
  45 #include "Xfer.H"
  46
  47 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  48
  49 namespace Foam
  50 {
  51
  52 class Istream;
  53 class Ostream;
  54
  55 // Forward declaration of friend functions and operators
  56
  57 template<class T> class List;
  58
  59 template<class T> Istream& operator>>(Istream&, List<T>&);
  60
  61 template<class T, unsigned Size> class FixedList;
  62 template<class T> class PtrList;
  63 template<class T> class SLList;
  64 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
  65     class DynamicList;
  66 template<class T> class SortableList;
  67 template<class T> class IndirectList;
  68 template<class T> class UIndirectList;
  69 template<class T> class BiIndirectList;
  70
  71 typedef UList<label> unallocLabelList;
  72
  73 /*---------------------------------------------------------------------------*\
  74                            Class List Declaration
  75 \*---------------------------------------------------------------------------*/
  76
  77 template<class T>
  78 class List
  79 :
  80     public UList<T>
  81 {
  82
  83 protected:
  84
  85     //- Override size to be inconsistent with allocated storage.
  86     //  Use with care.
  87     inline void size(const label);
  88
  89 public:
  90
  91     // Static data members
  92
  93         //- Empty list
  94         static const List<T> zero;
  95
  96
  97     // Static Member Functions
  98
  99         //- Return a null list
 100         inline static const List<T>& null();
 101
 102     // Constructors
 103
 104         //- Null constructor.
 105         inline List();
 106
 107         //- Construct with given size.
 108         explicit List(const label);
 109
 110         //- Construct with given size and value for all elements.
 111         List(const label, const T&);
 112
 113         //- Copy constructor.
 114         List(const List<T>&);
 115
 116         //- Construct by transferring the parameter contents
 117         List(const Xfer< List<T> >&);
 118
 119         //- Construct as copy or re-use as specified.
 120         List(List<T>&, bool reUse);
 121
 122         //- Construct as subset.
 123         List(const UList<T>&, const unallocLabelList& mapAddressing);
 124
 125         //- Construct given start and end iterators.
 126         template<class InputIterator>
 127         List(InputIterator first, InputIterator last);
 128
 129         //- Construct as copy of FixedList<T, Size>
 130         template<unsigned Size>
 131         List(const FixedList<T, Size>&);
 132
 133         //- Construct as copy of PtrList<T>
 134         List(const PtrList<T>&);
 135
 136         //- Construct as copy of SLList<T>
 137         List(const SLList<T>&);
 138
 139         //- Construct as copy of IndirectList<T>
 140         List(const IndirectList<T>&);
 141
 142         //- Construct as copy of UIndirectList<T>
 143         List(const UIndirectList<T>&);
 144
 145         //- Construct as copy of BiIndirectList<T>
 146         List(const BiIndirectList<T>&);
 147
 148         //- Construct from Istream.
 149         List(Istream&);
 150
 151         //- Clone
 152         inline autoPtr<List<T> > clone() const;
 153
 154
 155     // Destructor
 156
 157         ~List();
 158
 159
 160     // Related types
 161
 162         //- Declare type of subList
 163         typedef SubList<T> subList;
 164
 165
 166     // Member Functions
 167
 168         //- Return the number of elements in the UList.
 169         inline label size() const;
 170
 171
 172         // Edit
 173
 174             //- Reset size of List.
 175             inline void resize(const label);
 176
 177             //- Reset size of List and value for new elements.
 178             inline void resize(const label, const T&);
 179
 180             //- Reset size of List.
 181             void setSize(const label);
 182
 183             //- Reset size of List and value for new elements.
 184             void setSize(const label, const T&);
 185
 186             //- Clear the list, i.e. set size to zero.
 187             void clear();
 188
 189             //- Append a List at the end of this list
 190             inline void append(const UList<T>&);
 191
 192             //- Append a UIndirectList at the end of this list
 193             inline void append(const UIndirectList<T>&);
 194
 195             //- Transfer the contents of the argument List into this list
 196             //  and annull the argument list.
 197             void transfer(List<T>&);
 198
 199             //- Transfer the contents of the argument List into this list
 200             //  and annull the argument list.
 201             template<unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 202             void transfer(DynamicList<T, SizeInc, SizeMult, SizeDiv>&);
 203
 204             //- Transfer the contents of the argument List into this list
 205             //  and annull the argument list.
 206             void transfer(SortableList<T>&);
 207
 208             //- Transfer contents to the Xfer container
 209             inline Xfer< List<T> > xfer();
 210
 211             //- Return subscript-checked element of UList.
 212             inline T& newElmt(const label);
 213
 214     // Member operators
 215
 216         //- Assignment from UList operator. Takes linear time.
 217         void operator=(const UList<T>&);
 218
 219         //- Assignment operator. Takes linear time.
 220         void operator=(const List<T>&);
 221
 222         //- Assignment from SLList operator. Takes linear time.
 223         void operator=(const SLList<T>&);
 224
 225         //- Assignment from IndirectList operator. Takes linear time.
 226         void operator=(const IndirectList<T>&);
 227
 228         //- Assignment from UIndirectList operator. Takes linear time.
 229         void operator=(const UIndirectList<T>&);
 230
 231         //- Assignment from BiIndirectList operator. Takes linear time.
 232         void operator=(const BiIndirectList<T>&);
 233
 234         //- Assignment of all entries to the given value
 235         inline void operator=(const T&);
 236
 237
 238     // Istream operator
 239
 240 #ifndef SWIG
 241         //- Read List from Istream, discarding contents of existing List.
 242         friend Istream& operator>> <T>(Istream&, List<T>&);
 243 #endif
 244 };
 245
 246
 247 //- Read a bracket-delimited list, or handle a single value as list of size 1.
 248 //  For example,
 249 //  @code
 250 //      wList = readList<word>(IStringStream("(patch1 patch2 patch3)")());
 251 //      wList = readList<word>(IStringStream("patch0")());
 252 //  @endcode
 253 //  Mostly useful for handling command-line arguments.
 254 template<class T>
 255 List<T> readList(Istream&);
 256
 257
 258 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 259
 260 } // End namespace Foam
 261
 262 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 263
 264 #   include "ListI.H"
 265
 266 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 267
 268 #ifdef NoRepository
 269 #   include "List.C"
 270 #endif
 271
 272 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 273
 274 #endif
 275
 276 // ************************************************************************* //