List.H 7.49 KB
Newer Older
1
2
3
4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
graham's avatar
graham committed
5
    \\  /    A nd           | Copyright (C) 1991-2011 OpenCFD Ltd.
6
7
8
9
10
     \\/     M anipulation  |
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

11
12
13
14
    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
15
16
17
18
19
20
21

    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    for more details.

    You should have received a copy of the GNU General Public License
22
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
23
24
25
26
27
28
29

Class
    Foam::List

Description
    A 1D array of objects of type \<T\>, where the size of the vector
    is known and used for subscript bounds checking, etc.
30

31
32
33
34
35
36
37
38
39
40
41
42
43
44
    Storage is allocated on free-store during construction.

SourceFiles
    List.C
    ListI.H
    ListIO.C

\*---------------------------------------------------------------------------*/

#ifndef List_H
#define List_H

#include "UList.H"
#include "autoPtr.H"
Mark Olesen's avatar
Mark Olesen committed
45
#include "Xfer.H"
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

class Istream;
class Ostream;

// Forward declaration of friend functions and operators

template<class T> class List;

template<class T> Istream& operator>>(Istream&, List<T>&);

Mark Olesen's avatar
Mark Olesen committed
61
template<class T, unsigned Size> class FixedList;
62
63
template<class T> class PtrList;
template<class T> class SLList;
mattijs's avatar
mattijs committed
64
template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
65
66
    class DynamicList;
template<class T> class SortableList;
67
template<class T> class IndirectList;
mattijs's avatar
mattijs committed
68
template<class T> class UIndirectList;
69
70
template<class T> class BiIndirectList;

mattijs's avatar
mattijs committed
71
typedef UList<label> unallocLabelList;
72
73
74
75
76
77
78
79
80
81
82

/*---------------------------------------------------------------------------*\
                           Class List Declaration
\*---------------------------------------------------------------------------*/

template<class T>
class List
:
    public UList<T>
{

83
84
85
86
87
88
protected:

    //- Override size to be inconsistent with allocated storage.
    //  Use with care.
    inline void size(const label);

Andrew Heather's avatar
Andrew Heather committed
89

90
91
public:

92
93
94
95
96
    // Static Member Functions

        //- Return a null List
        inline static const List<T>& null();

97
98
99
100
101
102
103
104
105
106
107
108
109
110
    // Constructors

        //- Null constructor.
        inline List();

        //- Construct with given size.
        explicit List(const label);

        //- Construct with given size and value for all elements.
        List(const label, const T&);

        //- Copy constructor.
        List(const List<T>&);

111
        //- Construct by transferring the parameter contents
Andrew Heather's avatar
Andrew Heather committed
112
        List(const Xfer<List<T> >&);
113

114
115
116
        //- Construct as copy or re-use as specified.
        List(List<T>&, bool reUse);

mattijs's avatar
mattijs committed
117
        //- Construct as subset.
118
        List(const UList<T>&, const labelUList& mapAddressing);
mattijs's avatar
mattijs committed
119

120
        //- Construct given start and end iterators.
121
122
123
124
        template<class InputIterator>
        List(InputIterator first, InputIterator last);

        //- Construct as copy of FixedList<T, Size>
Mark Olesen's avatar
Mark Olesen committed
125
        template<unsigned Size>
mattijs's avatar
mattijs committed
126
        explicit List(const FixedList<T, Size>&);
127
128

        //- Construct as copy of PtrList<T>
mattijs's avatar
mattijs committed
129
        explicit List(const PtrList<T>&);
130
131

        //- Construct as copy of SLList<T>
mattijs's avatar
mattijs committed
132
        explicit List(const SLList<T>&);
133

mattijs's avatar
mattijs committed
134
        //- Construct as copy of UIndirectList<T>
mattijs's avatar
mattijs committed
135
        explicit List(const UIndirectList<T>&);
mattijs's avatar
mattijs committed
136

137
        //- Construct as copy of BiIndirectList<T>
mattijs's avatar
mattijs committed
138
        explicit List(const BiIndirectList<T>&);
139
140
141
142
143
144
145
146

        //- Construct from Istream.
        List(Istream&);

        //- Clone
        inline autoPtr<List<T> > clone() const;


Andrew Heather's avatar
Andrew Heather committed
147
148
    //- Destructor
    ~List();
149
150
151
152
153
154
155
156


    // Related types

        //- Declare type of subList
        typedef SubList<T> subList;


157
    // Member Functions
158

mattijs's avatar
mattijs committed
159
160
161
        //- Return the number of elements in the UList.
        inline label size() const;

162
163
164

        // Edit

165
166
167
168
169
170
            //- Reset size of List.
            inline void resize(const label);

            //- Reset size of List and value for new elements.
            inline void resize(const label, const T&);

171
172
173
174
175
176
177
178
179
            //- Reset size of List.
            void setSize(const label);

            //- Reset size of List and value for new elements.
            void setSize(const label, const T&);

            //- Clear the list, i.e. set size to zero.
            void clear();

180
181
182
            //- Append an element at the end of the list
            inline void append(const T&);

Mark Olesen's avatar
Mark Olesen committed
183
            //- Append a List at the end of this list
Mark Olesen's avatar
Mark Olesen committed
184
            inline void append(const UList<T>&);
Mark Olesen's avatar
Mark Olesen committed
185
186

            //- Append a UIndirectList at the end of this list
Mark Olesen's avatar
Mark Olesen committed
187
            inline void append(const UIndirectList<T>&);
Mark Olesen's avatar
Mark Olesen committed
188

Mark Olesen's avatar
Mark Olesen committed
189
            //- Transfer the contents of the argument List into this list
190
            //  and annul the argument list.
191
192
            void transfer(List<T>&);

Mark Olesen's avatar
Mark Olesen committed
193
            //- Transfer the contents of the argument List into this list
194
            //  and annul the argument list.
mattijs's avatar
mattijs committed
195
196
197
            template<unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
            void transfer(DynamicList<T, SizeInc, SizeMult, SizeDiv>&);

Mark Olesen's avatar
Mark Olesen committed
198
            //- Transfer the contents of the argument List into this list
199
            //  and annul the argument list.
200
201
            void transfer(SortableList<T>&);

Mark Olesen's avatar
Mark Olesen committed
202
            //- Transfer contents to the Xfer container
Andrew Heather's avatar
Andrew Heather committed
203
            inline Xfer<List<T> > xfer();
204

205
206
207
208
209
210
211
212
213
214
215
216
217
218
            //- Return subscript-checked element of UList.
            inline T& newElmt(const label);

    // Member operators

        //- Assignment from UList operator. Takes linear time.
        void operator=(const UList<T>&);

        //- Assignment operator. Takes linear time.
        void operator=(const List<T>&);

        //- Assignment from SLList operator. Takes linear time.
        void operator=(const SLList<T>&);

mattijs's avatar
mattijs committed
219
220
221
        //- Assignment from UIndirectList operator. Takes linear time.
        void operator=(const UIndirectList<T>&);

222
223
224
225
226
227
228
229
230
231
        //- Assignment from BiIndirectList operator. Takes linear time.
        void operator=(const BiIndirectList<T>&);

        //- Assignment of all entries to the given value
        inline void operator=(const T&);


    // Istream operator

        //- Read List from Istream, discarding contents of existing List.
Henry Weller's avatar
Henry Weller committed
232
        friend Istream& operator>> <T>
233
234
235
236
        (Istream&, List<T>&);
};


Mark Olesen's avatar
Mark Olesen committed
237
238
239
240
241
242
243
//- Read a bracket-delimited list, or handle a single value as list of size 1.
//  For example,
//  @code
//      wList = readList<word>(IStringStream("(patch1 patch2 patch3)")());
//      wList = readList<word>(IStringStream("patch0")());
//  @endcode
//  Mostly useful for handling command-line arguments.
244
template<class T>
Mark Olesen's avatar
Mark Olesen committed
245
246
List<T> readList(Istream&);

247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#   include "ListI.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#ifdef NoRepository
#   include "List.C"
#endif

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //