CompactListListI.H 5.31 KB
Newer Older
1
2
3
4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
Mark Olesen's avatar
Mark Olesen committed
5
    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
     \\/     M anipulation  |
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

    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 2 of the License, or (at your
    option) any later version.

    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
    along with OpenFOAM; if not, write to the Free Software Foundation,
    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

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


// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

template<class T>
31
inline Foam::CompactListList<T>::CompactListList()
32
33
34
35
{}


template<class T>
36
37
38
39
40
inline Foam::CompactListList<T>::CompactListList
(
    const label nRows,
    const label nData
)
41
42
43
44
45
46
47
:
    offsets_(nRows, 0),
    m_(nData)
{}


template<class T>
48
inline Foam::CompactListList<T>::CompactListList
49
50
51
52
53
54
55
56
57
58
59
60
(
    const label nRows,
    const label nData,
    const T& t
)
:
    offsets_(nRows, 0),
    m_(nData, t)
{}


template<class T>
61
62
inline Foam::autoPtr<Foam::CompactListList<T> >
Foam::CompactListList<T>::clone() const
63
64
65
66
67
68
69
{
    return autoPtr<CompactListList<T> >(new CompactListList<T>(*this));
}


// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //

70
71
72
73
74
75
76
template<class T>
inline const Foam::CompactListList<T>& Foam::CompactListList<T>::null()
{
    return *reinterpret_cast< CompactListList<T>* >(0);
}


77
template<class T>
78
inline Foam::label Foam::CompactListList<T>::size() const
79
80
81
82
{
    return offsets_.size();
}

83

84
85
86
87
88
89
90
template<class T>
inline bool Foam::CompactListList<T>::empty() const
{
    return offsets_.empty();
}


91
template<class T>
92
inline const Foam::List<Foam::label>& Foam::CompactListList<T>::offsets() const
93
94
95
96
{
    return offsets_;
}

97

98
template<class T>
Mark Olesen's avatar
Mark Olesen committed
99
inline Foam::List<Foam::label>& Foam::CompactListList<T>::offsets()
100
101
102
103
{
    return offsets_;
}

104

105
template<class T>
106
inline const Foam::List<T>& Foam::CompactListList<T>::m() const
107
108
109
110
{
    return m_;
}

111

112
template<class T>
113
inline Foam::List<T>& Foam::CompactListList<T>::m()
114
115
116
117
118
119
{
    return m_;
}


template<class T>
120
121
122
123
124
inline Foam::label Foam::CompactListList<T>::index
(
    const label i,
    const label j
) const
125
126
127
128
129
130
131
132
133
134
135
{
    if (i == 0)
    {
        return j;
    }
    else
    {
        return offsets_[i-1] + j;
    }
}

136

137
template<class T>
138
inline Foam::label Foam::CompactListList<T>::whichRow(const label i) const
139
140
141
142
143
{
    if (i < 0 || i >= m_.size())
    {
        FatalErrorIn
        (
Mark Olesen's avatar
Mark Olesen committed
144
            "CompactListList<T>::whichRow(const label) const"
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
        )   << "Index " << i << " outside 0.." << m_.size()
            << abort(FatalError);
    }

    forAll(offsets_, rowI)
    {
        if (i < offsets_[rowI])
        {
            return rowI;
        }
    }

    return -1;
}

160

161
template<class T>
162
163
164
165
166
inline Foam::label Foam::CompactListList<T>::whichColumn
(
    const label row,
    const label i
) const
167
168
169
170
{
    return i - index(row, 0);
}

171
172

template<class T>
Mark Olesen's avatar
Mark Olesen committed
173
inline Foam::Xfer<Foam::CompactListList<T> > Foam::CompactListList<T>::xfer()
174
{
Mark Olesen's avatar
Mark Olesen committed
175
    return xferMove(*this);
176
177
178
}


179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
template<class T>
inline void Foam::CompactListList<T>::resize(const label nRows)
{
    this->setSize(nRows);
}


template<class T>
inline void Foam::CompactListList<T>::resize
(
    const label nRows,
    const label nData
)
{
    this->setSize(nRows, nData);
}


template<class T>
inline void Foam::CompactListList<T>::resize
(
    const label nRows,
    const label nData,
    const T& t
)
{
    this->setSize(nRows, nData, t);
}


template<class T>
inline void Foam::CompactListList<T>::resize(const UList<label>& rowSizes)
{
    this->setSize(rowSizes);
}


216
217
218
// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //

template<class T>
219
220
221
222
inline Foam::UList<T> Foam::CompactListList<T>::operator[]
(
    const label i
)
223
224
225
226
227
228
229
230
231
232
233
{
    if (i == 0)
    {
        return UList<T>(m_.begin(), offsets_[i]);
    }
    else
    {
        return UList<T>(&m_[offsets_[i-1]], offsets_[i] - offsets_[i-1]);
    }
}

234

235
template<class T>
236
237
238
239
inline const Foam::UList<T> Foam::CompactListList<T>::operator[]
(
    const label i
) const
240
241
242
243
244
245
246
247
248
249
250
251
252
{
    if (i == 0)
    {
        return UList<T>(m_.begin(), offsets_[i]);
    }
    else
    {
        return UList<T>(&m_[offsets_[i-1]], offsets_[i] - offsets_[i-1]);
    }
}


template<class T>
253
254
255
256
257
inline T& Foam::CompactListList<T>::operator()
(
    const label i,
    const label j
)
258
259
260
261
{
    return m_[index(i, j)];
}

262

263
template<class T>
264
inline const T& Foam::CompactListList<T>::operator()
265
266
267
268
269
270
271
272
273
274
(
    const label i,
    const label j
) const
{
    return m_[index(i, j)];
}


template<class T>
275
inline void Foam::CompactListList<T>::operator=(const T& t)
276
277
278
279
280
281
{
    m_ = t;
}


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