src/OpenFOAM/containers/Lists/List/List.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 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 Class
  26     Foam::List
  27
  28 Description
  29     A 1D array of objects of type \<T\>, where the size of the vector
  30     is known and used for subscript bounds checking, etc.
  31
  32     Storage is allocated on free-store during construction.
  33
  34 SourceFiles
  35     List.C
  36     ListI.H
  37     ListIO.C
  38
  39 \*---------------------------------------------------------------------------*/
  40
  41 #ifndef List_H
  42 #define List_H
  43
  44 #include "UList.H"
  45 #include "autoPtr.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, label Size> class FixedList;
  62 template<class T> class PtrList;
  63 template<class T> class SLList;
  64 template<class T> class IndirectList;
  65 template<class T> class BiIndirectList;
  66
  67
  68 /*---------------------------------------------------------------------------*\
  69                            Class List Declaration
  70 \*---------------------------------------------------------------------------*/
  71
  72 template<class T>
  73 class List
  74 :
  75     public UList<T>
  76 {
  77
  78 public:
  79
  80     // Constructors
  81
  82         //- Null constructor.
  83         inline List();
  84
  85         //- Construct with given size.
  86         explicit List(const label);
  87
  88         //- Construct with given size and value for all elements.
  89         List(const label, const T&);
  90
  91         //- Copy constructor.
  92         List(const List<T>&);
  93
  94         //- Construct as copy or re-use as specified.
  95         List(List<T>&, bool reUse);
  96
  97         //- Construct given size and start and end iterators.
  98         template<class InputIterator>
  99         List(InputIterator first, InputIterator last);
 100
 101         //- Construct as copy of FixedList<T, Size>
 102         template<label Size>
 103         List(const FixedList<T, Size>&);
 104
 105         //- Construct as copy of PtrList<T>
 106         List(const PtrList<T>&);
 107
 108         //- Construct as copy of SLList<T>
 109         List(const SLList<T>&);
 110
 111         //- Construct as copy of IndirectList<T>
 112         List(const IndirectList<T>&);
 113
 114         //- Construct as copy of BiIndirectList<T>
 115         List(const BiIndirectList<T>&);
 116
 117         //- Construct from Istream.
 118         List(Istream&);
 119
 120         //- Clone
 121         inline autoPtr<List<T> > clone() const;
 122
 123
 124     // Destructor
 125
 126         ~List();
 127
 128
 129     // Related types
 130
 131         //- Declare type of subList
 132         typedef SubList<T> subList;
 133
 134
 135     // Member functions
 136
 137         //- Return a null List
 138         static const List<T>& null();
 139
 140
 141         // Edit
 142
 143             //- Reset size of List.
 144             void setSize(const label);
 145
 146             //- Reset size of List and value for new elements.
 147             void setSize(const label, const T&);
 148
 149             //- Clear the list, i.e. set size to zero.
 150             void clear();
 151
 152             //- Transfer the contents of the argument List into this List
 153             //  and annull the argument list.
 154             void transfer(List<T>&);
 155
 156             //- Return subscript-checked element of UList.
 157             inline T& newElmt(const label);
 158
 159
 160     // Member operators
 161
 162         //- Assignment from UList operator. Takes linear time.
 163         void operator=(const UList<T>&);
 164
 165         //- Assignment operator. Takes linear time.
 166         void operator=(const List<T>&);
 167
 168         //- Assignment from SLList operator. Takes linear time.
 169         void operator=(const SLList<T>&);
 170
 171         //- Assignment from IndirectList operator. Takes linear time.
 172         void operator=(const IndirectList<T>&);
 173
 174         //- Assignment from BiIndirectList operator. Takes linear time.
 175         void operator=(const BiIndirectList<T>&);
 176
 177         //- Assignment of all entries to the given value
 178         inline void operator=(const T&);
 179
 180
 181     // Istream operator
 182
 183         //- Read List from Istream, discarding contents of existing List.
 184         friend Istream& operator>>
 185         #ifndef __CINT__
 186         <T>
 187         #endif
 188         (Istream&, List<T>&);
 189 };
 190
 191
 192 template<class T>
 193 void sort(List<T>& a);
 194
 195 template<class T, class Cmp>
 196 void sort(List<T>& a, const Cmp&);
 197
 198 template<class T>
 199 void stableSort(List<T>& a);
 200
 201 template<class T, class Cmp>
 202 void stableSort(List<T>& a, const Cmp&);
 203
 204
 205 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 206
 207 } // End namespace Foam
 208
 209 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 210
 211 #   include "ListI.H"
 212
 213 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 214
 215 #ifdef NoRepository
 216 #   include "List.C"
 217 #endif
 218
 219 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 220
 221 #endif
 222
 223 // ************************************************************************* //