List.H 7.65 KB
Newer Older
1
2
3
4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
5
    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
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;
64

mattijs's avatar
mattijs committed
65
template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
66
67
class DynamicList;

68
template<class T> class SortableList;
69
template<class T> class IndirectList;
mattijs's avatar
mattijs committed
70
template<class T> class UIndirectList;
71
72
template<class T> class BiIndirectList;

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

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

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

85
86
87
88
89
90
protected:

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

Andrew Heather's avatar
Andrew Heather committed
91

92
93
public:

94
95
96
97
98
    // Static Member Functions

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

99
100
101
102
103
104
105
106
107
108
109
    // 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&);

110
111
112
        //- Construct with given size initializing all elements to zero.
        List(const label, const zero);

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

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

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

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

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

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

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

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

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

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


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


    // Related types

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


158
    // Member Functions
159

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

163
164
165

        // Edit

166
            //- Alias for setSize(const label)
167
168
            inline void resize(const label);

169
            //- Alias for setSize(const label, const T&)
170
171
            inline void resize(const label, const T&);

172
173
174
175
176
177
178
179
180
            //- 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();

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

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

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

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

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

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

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

206
207
208
            //- Return subscript-checked element of UList.
            inline T& newElmt(const label);

209
210
211
212
213

        //- Disallow implicit shallowCopy
        void shallowCopy(const UList<T>&) = delete;


214
215
216
217
218
219
220
221
222
223
224
    // 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
225
226
227
        //- Assignment from UIndirectList operator. Takes linear time.
        void operator=(const UIndirectList<T>&);

228
229
230
231
232
233
        //- 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&);

234
235
236
        //- Assignment of all entries to zero
        inline void operator=(const zero);

237
238
239
240

    // Istream operator

        //- Read List from Istream, discarding contents of existing List.
Henry Weller's avatar
Henry Weller committed
241
        friend Istream& operator>> <T>
242
243
244
245
        (Istream&, List<T>&);
};


Mark Olesen's avatar
Mark Olesen committed
246
247
//- Read a bracket-delimited list, or handle a single value as list of size 1.
//  For example,
248
//  \code
Mark Olesen's avatar
Mark Olesen committed
249
250
//      wList = readList<word>(IStringStream("(patch1 patch2 patch3)")());
//      wList = readList<word>(IStringStream("patch0")());
251
//  \endcode
Mark Olesen's avatar
Mark Olesen committed
252
//  Mostly useful for handling command-line arguments.
253
template<class T>
Mark Olesen's avatar
Mark Olesen committed
254
255
List<T> readList(Istream&);

256
257
258
259
260
261
262

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

} // End namespace Foam

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

263
#include "ListI.H"
264
265
266
267

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

#ifdef NoRepository
268
    #include "List.C"
269
270
271
272
273
274
275
#endif

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

#endif

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