Test-PackedList4.C 4.88 KB
Newer Older
1
2
3
4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
5
    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
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 3 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, see <http://www.gnu.org/licenses/>.

Application

Description

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

#include "uLabel.H"
31
#include "boolList.H"
32
33
#include "IOstreams.H"
#include "PackedBoolList.H"
34
#include "StringStream.H"
35
36
37
38
39
40
41
42
43

using namespace Foam;

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
//  Main program:

int main(int argc, char *argv[])
{
    PackedBoolList list1(20);
44
    // set every third one on
45
46
    forAll(list1, i)
    {
47
        list1[i] = !(i % 3);
48
49
    }

50
    Info<< "\nalternating bit pattern\n";
51
    list1.printInfo(Info, true);
52
53
54
55

    PackedBoolList list2 = ~list1;

    Info<< "\ncomplementary bit pattern\n";
56
57
58
59
60
61
62
63
64
65
    list2.printBits(Info);

    // set every other on
    forAll(list2, i)
    {
        list2[i] = !(i % 2);
    }

    Info<< "\nalternating bit pattern\n";
    list2.printBits(Info);
66
67

    list2.resize(28, false);
68
69
    list2.resize(34, true);
    list2.resize(40, false);
70
71
72
73
74
    for (label i=0; i < 4; ++i)
    {
        list2[i] = true;
    }

75
    Info<< "\nresized with false, 6 true + 6 false, bottom 4 bits true\n";
76
    list2.printInfo(Info, true);
77
78
79
80

    labelList list2Labels = list2.used();

    Info<< "\noperator|\n";
81
82
83
84
85

    list1.printBits(Info);
    list2.printBits(Info);
    Info<< "==\n";
    (list1 | list2).printBits(Info);
86
87

    Info<< "\noperator& : does trim\n";
88
    (list1 & list2).printBits(Info);
89
90

    Info<< "\noperator^\n";
91
    (list1 ^ list2).printBits(Info);
92
93
94
95
96


    Info<< "\noperator|=\n";
    {
        PackedBoolList list3 = list1;
97
        (list3 |= list2).printBits(Info);
98
99
    }

100
    Info<< "\noperator|= with labelUList\n";
101
102
    {
        PackedBoolList list3 = list1;
103
        (list3 |= list2Labels).printBits(Info);
104
105
106
107
108
    }

    Info<< "\noperator&=\n";
    {
        PackedBoolList list3 = list1;
109
        (list3 &= list2).printBits(Info);
110
111
112
113
114
    }

    Info<< "\noperator+=\n";
    {
        PackedBoolList list3 = list1;
115
        (list3 += list2).printBits(Info);
116
117
    }

118
    Info<< "\noperator+= with labelUList\n";
119
120
    {
        PackedBoolList list3 = list1;
121
        (list3 += list2Labels).printBits(Info);
122
123
124
125
126
    }

    Info<< "\noperator-=\n";
    {
        PackedBoolList list3 = list1;
127
        (list3 -= list2).printBits(Info);
128
129
    }

130
    Info<< "\noperator-= with labelUList\n";
131
132
    {
        PackedBoolList list3 = list1;
133
        (list3 -= list2Labels).printBits(Info);
134
135
    }

136
137
138
139
    PackedBoolList list4
    (
        IStringStream
        (
140
            "(1 n 1 n 1 n 1 1 off 0 0 f f 0 y yes y true y false on t)"
141
142
143
144
145
        )()
    );

    Info<< "\ntest Istream constructor\n";

146
    list4.printInfo(Info, true);
147
    Info<< list4 << " indices: " << list4.used() << nl;
148
149

    Info<< "\nassign from labelList\n";
150
    list4 = labelList{0, 1, 2, 3, 12, 13, 14, 19, 20, 21};
151

152
    list4.printInfo(Info, true);
153
    Info<< list4 << " indices: " << list4.used() << nl;
154

155
156
157
    // Not yet:
    // PackedBoolList list5{0, 1, 2, 3, 12, 13, 14, 19, 20, 21};
    // list5.printInfo(Info, true);
158
    // Info<< list5 << " indices: " << list5.used() << nl;
159

160
161
162
163
164
165
166
167
168
    Info<< "\nassign from indices\n";
    list4.read
    (
        IStringStream
        (
            "{0 1 2 3 12 13 14 19 20 21}"
        )()
    );

169

170
    list4.printInfo(Info, true);
171
    Info<< list4 << " indices: " << list4.used() << nl;
172

173
    boolList bools(list4.size());
174
175
    forAll(list4, i)
    {
176
        bools[i] = list4[i];
177
178
    }

179
    Info<< "boolList: " << bools << nl;
180
181
182
183
184
185
186
187
188
189

    // check roundabout assignments
    PackedList<2> pl2
    (
        IStringStream
        (
            "{(0 3)(1 3)(2 3)(3 3)(12 3)(13 3)(14 3)(19 3)(20 3)(21 3)}"
        )()
    );

190
    Info<< "roundabout assignment: " << pl2 << nl;
191
192
193
194
195
196
197

    list4.clear();
    forAll(pl2, i)
    {
        list4[i] = pl2[i];
    }

198
    list4.writeList(Info, -1) << nl; // indexed output
199
200

    list4.writeEntry("PackedBoolList", Info);
201

202
203
204
205
206
    return 0;
}


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