GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 14.7% 422 / 0 / 2878
Functions: 14.4% 97 / 0 / 675
Branches: 15.9% 331 / 0 / 2082

src/airflow/contam/PrjAirflowElementsImpl.cpp
Line Branch Exec Source
1 /***********************************************************************************************************************
2 * OpenStudio(R), Copyright (c) Alliance for Energy Innovation, LLC.
3 * See also https://openstudio.net/license
4 ***********************************************************************************************************************/
5
6 #include <algorithm>
7
8 #include "PrjAirflowElementsImpl.hpp"
9 #include "../../utilities/core/StringHelpers.hpp"
10
11 namespace openstudio {
12 namespace contam {
13 namespace detail {
14
15 ✗ void PlrOrfImpl::setDefaults() {
16 ✗ m_nr = 0;
17 ✗ m_icon = 0;
18 ✗ m_lam = PRJFLOAT("0.0");
19 ✗ m_turb = PRJFLOAT("0.0");
20 ✗ m_expt = PRJFLOAT("0.0");
21 ✗ m_area = PRJFLOAT("0.0");
22 ✗ m_dia = PRJFLOAT("0.0");
23 ✗ m_coef = PRJFLOAT("0.0");
24 ✗ m_Re = PRJFLOAT("0.0");
25 ✗ m_u_A = 0;
26 ✗ m_u_D = 0;
27 ✗ }
28
29 ✗ PlrOrfImpl::PlrOrfImpl() {
30 ✗ setDefaults();
31 ✗ }
32
33 ✗ PlrOrfImpl::PlrOrfImpl(int nr, int icon, std::string name, std::string desc) {
34 ✗ setDefaults();
35 ✗ setNr(nr);
36 ✗ setIcon(icon);
37 ✗ setName(name);
38 ✗ setDesc(desc);
39 ✗ }
40
41 ✗ PlrOrfImpl::PlrOrfImpl(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double area, double dia,
42 ✗ double coef, double Re, int u_A, int u_D) {
43 ✗ setDefaults();
44 ✗ setNr(nr);
45 ✗ setIcon(icon);
46 ✗ setName(name);
47 ✗ setDesc(desc);
48 ✗ setLam(lam);
49 ✗ setTurb(turb);
50 ✗ setExpt(expt);
51 ✗ setArea(area);
52 ✗ setDia(dia);
53 ✗ setCoef(coef);
54 ✗ setRe(Re);
55 ✗ setU_A(u_A);
56 ✗ setU_D(u_D);
57 ✗ }
58
59 ✗ PlrOrfImpl::PlrOrfImpl(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt,
60 ✗ std::string area, std::string dia, std::string coef, std::string Re, int u_A, int u_D) {
61 ✗ setDefaults();
62 ✗ setNr(nr);
63 ✗ setIcon(icon);
64 ✗ setName(name);
65 ✗ setDesc(desc);
66 ✗ setLam(lam);
67 ✗ setTurb(turb);
68 ✗ setExpt(expt);
69 ✗ setArea(area);
70 ✗ setDia(dia);
71 ✗ setCoef(coef);
72 ✗ setRe(Re);
73 ✗ setU_A(u_A);
74 ✗ setU_D(u_D);
75 ✗ }
76
77 ✗ void PlrOrfImpl::read(Reader& input) {
78 ✗ setNr(input.read<int>());
79 ✗ setIcon(input.read<int>());
80 ✗ std::string dataType = input.readString(); // Should really check this
81 ✗ setName(input.readString());
82 ✗ setDesc(input.readLine());
83 ✗ setLam(input.readNumber<std::string>());
84 ✗ setTurb(input.readNumber<std::string>());
85 ✗ setExpt(input.readNumber<std::string>());
86 ✗ setArea(input.readNumber<std::string>());
87 ✗ setDia(input.readNumber<std::string>());
88 ✗ setCoef(input.readNumber<std::string>());
89 ✗ setRe(input.readNumber<std::string>());
90 ✗ setU_A(input.read<int>());
91 ✗ setU_D(input.read<int>());
92 ✗ }
93
94 ✗ std::string PlrOrfImpl::write() {
95 ✗ std::string string;
96 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + " plr_orfc " + m_name + '\n';
97 ✗ string += m_desc + '\n';
98 ✗ string += ANY_TO_STR(m_lam) + ' ' + ANY_TO_STR(m_turb) + ' ' + ANY_TO_STR(m_expt) + ' ' + ANY_TO_STR(m_area) + ' ' + ANY_TO_STR(m_dia) + ' '
99 ✗ + ANY_TO_STR(m_coef) + ' ' + ANY_TO_STR(m_Re) + ' ' + ANY_TO_STR(m_u_A) + ' ' + ANY_TO_STR(m_u_D) + '\n';
100 ✗ return string;
101 ✗ }
102
103 ✗ void PlrOrfImpl::readDetails(Reader& input) {
104 ✗ setLam(input.readNumber<std::string>());
105 ✗ setTurb(input.readNumber<std::string>());
106 ✗ setExpt(input.readNumber<std::string>());
107 ✗ setArea(input.readNumber<std::string>());
108 ✗ setDia(input.readNumber<std::string>());
109 ✗ setCoef(input.readNumber<std::string>());
110 ✗ setRe(input.readNumber<std::string>());
111 ✗ setU_A(input.read<int>());
112 ✗ setU_D(input.read<int>());
113 ✗ }
114
115 ✗ int PlrOrfImpl::nr() const {
116 ✗ return m_nr;
117 }
118
119 ✗ void PlrOrfImpl::setNr(const int nr) {
120 ✗ m_nr = nr;
121 ✗ }
122
123 ✗ int PlrOrfImpl::icon() const {
124 ✗ return m_icon;
125 }
126
127 ✗ void PlrOrfImpl::setIcon(const int icon) {
128 ✗ m_icon = icon;
129 ✗ }
130
131 ✗ std::string PlrOrfImpl::name() const {
132 ✗ return m_name;
133 }
134
135 ✗ void PlrOrfImpl::setName(const std::string& name) {
136 ✗ m_name = name;
137 ✗ }
138
139 ✗ std::string PlrOrfImpl::desc() const {
140 ✗ return m_desc;
141 }
142
143 ✗ void PlrOrfImpl::setDesc(const std::string& desc) {
144 ✗ m_desc = desc;
145 ✗ }
146
147 ✗ double PlrOrfImpl::lam() const {
148 ✗ return openstudio::string_conversions::to<double>(m_lam);
149 }
150
151 ✗ bool PlrOrfImpl::setLam(const double lam) {
152 ✗ m_lam = openstudio::string_conversions::number(lam);
153 ✗ return true;
154 }
155
156 ✗ bool PlrOrfImpl::setLam(const std::string& lam) {
157 ✗ return assign_if_valid<double>(lam, m_lam);
158 }
159
160 ✗ double PlrOrfImpl::turb() const {
161 ✗ return openstudio::string_conversions::to<double>(m_turb);
162 }
163
164 ✗ bool PlrOrfImpl::setTurb(const double turb) {
165 ✗ m_turb = openstudio::string_conversions::number(turb);
166 ✗ return true;
167 }
168
169 ✗ bool PlrOrfImpl::setTurb(const std::string& turb) {
170 ✗ return assign_if_valid<double>(turb, m_turb);
171 }
172
173 ✗ double PlrOrfImpl::expt() const {
174 ✗ return openstudio::string_conversions::to<double>(m_expt);
175 }
176
177 ✗ bool PlrOrfImpl::setExpt(const double expt) {
178 ✗ m_expt = openstudio::string_conversions::number(expt);
179 ✗ return true;
180 }
181
182 ✗ bool PlrOrfImpl::setExpt(const std::string& expt) {
183 ✗ return assign_if_valid<double>(expt, m_expt);
184 }
185
186 ✗ double PlrOrfImpl::area() const {
187 ✗ return openstudio::string_conversions::to<double>(m_area);
188 }
189
190 ✗ bool PlrOrfImpl::setArea(const double area) {
191 ✗ m_area = openstudio::string_conversions::number(area);
192 ✗ return true;
193 }
194
195 ✗ bool PlrOrfImpl::setArea(const std::string& area) {
196 ✗ return assign_if_valid<double>(area, m_area);
197 }
198
199 ✗ double PlrOrfImpl::dia() const {
200 ✗ return openstudio::string_conversions::to<double>(m_dia);
201 }
202
203 ✗ bool PlrOrfImpl::setDia(const double dia) {
204 ✗ m_dia = openstudio::string_conversions::number(dia);
205 ✗ return true;
206 }
207
208 ✗ bool PlrOrfImpl::setDia(const std::string& dia) {
209 ✗ return assign_if_valid<double>(dia, m_dia);
210 }
211
212 ✗ double PlrOrfImpl::coef() const {
213 ✗ return openstudio::string_conversions::to<double>(m_coef);
214 }
215
216 ✗ bool PlrOrfImpl::setCoef(const double coef) {
217 ✗ m_coef = openstudio::string_conversions::number(coef);
218 ✗ return true;
219 }
220
221 ✗ bool PlrOrfImpl::setCoef(const std::string& coef) {
222 ✗ return assign_if_valid<double>(coef, m_coef);
223 }
224
225 ✗ double PlrOrfImpl::Re() const {
226 ✗ return openstudio::string_conversions::to<double>(m_Re);
227 }
228
229 ✗ bool PlrOrfImpl::setRe(const double Re) {
230 ✗ m_Re = openstudio::string_conversions::number(Re);
231 ✗ return true;
232 }
233
234 ✗ bool PlrOrfImpl::setRe(const std::string& Re) {
235 ✗ return assign_if_valid<double>(Re, m_Re);
236 }
237
238 ✗ int PlrOrfImpl::u_A() const {
239 ✗ return m_u_A;
240 }
241
242 ✗ void PlrOrfImpl::setU_A(const int u_A) {
243 ✗ m_u_A = u_A;
244 ✗ }
245
246 ✗ int PlrOrfImpl::u_D() const {
247 ✗ return m_u_D;
248 }
249
250 ✗ void PlrOrfImpl::setU_D(const int u_D) {
251 ✗ m_u_D = u_D;
252 ✗ }
253
254 39 void PlrLeakImpl::setDefaults() {
255 39 m_nr = 0;
256 39 m_icon = 0;
257
1/1
✓ Branch 1 taken 39 times.
78 m_lam = PRJFLOAT("0.0");
258
1/1
✓ Branch 1 taken 39 times.
78 m_turb = PRJFLOAT("0.0");
259
1/1
✓ Branch 1 taken 39 times.
78 m_expt = PRJFLOAT("0.0");
260
1/1
✓ Branch 1 taken 39 times.
78 m_coef = PRJFLOAT("0.0");
261
1/1
✓ Branch 1 taken 39 times.
78 m_pres = PRJFLOAT("0.0");
262
1/1
✓ Branch 1 taken 39 times.
78 m_area1 = PRJFLOAT("0.0");
263
1/1
✓ Branch 1 taken 39 times.
78 m_area2 = PRJFLOAT("0.0");
264
1/1
✓ Branch 1 taken 39 times.
39 m_area3 = PRJFLOAT("0.0");
265 39 m_u_A1 = 0;
266 39 m_u_A2 = 0;
267 39 m_u_A3 = 0;
268 39 m_u_dP = 0;
269 39 }
270
271 1 PlrLeakImpl::PlrLeakImpl() {
272
1/1
✓ Branch 1 taken 1 time.
1 setDefaults();
273 1 }
274
275 36 PlrLeakImpl::PlrLeakImpl(int nr, int icon, std::string name, std::string desc) {
276
1/1
✓ Branch 1 taken 36 times.
36 setDefaults();
277
1/1
✓ Branch 1 taken 36 times.
36 setNr(nr);
278
1/1
✓ Branch 1 taken 36 times.
36 setIcon(icon);
279
1/1
✓ Branch 1 taken 36 times.
36 setName(name);
280
1/1
✓ Branch 1 taken 36 times.
36 setDesc(desc);
281 36 }
282
283 ✗ PlrLeakImpl::PlrLeakImpl(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double coef, double pres,
284 ✗ double area1, double area2, double area3, int u_A1, int u_A2, int u_A3, int u_dP) {
285 ✗ setDefaults();
286 ✗ setNr(nr);
287 ✗ setIcon(icon);
288 ✗ setName(name);
289 ✗ setDesc(desc);
290 ✗ setLam(lam);
291 ✗ setTurb(turb);
292 ✗ setExpt(expt);
293 ✗ setCoef(coef);
294 ✗ setPres(pres);
295 ✗ setArea1(area1);
296 ✗ setArea2(area2);
297 ✗ setArea3(area3);
298 ✗ setU_A1(u_A1);
299 ✗ setU_A2(u_A2);
300 ✗ setU_A3(u_A3);
301 ✗ setU_dP(u_dP);
302 ✗ }
303
304 2 PlrLeakImpl::PlrLeakImpl(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt,
305 std::string coef, std::string pres, std::string area1, std::string area2, std::string area3, int u_A1, int u_A2,
306 2 int u_A3, int u_dP) {
307
1/1
✓ Branch 1 taken 2 times.
2 setDefaults();
308
1/1
✓ Branch 1 taken 2 times.
2 setNr(nr);
309
1/1
✓ Branch 1 taken 2 times.
2 setIcon(icon);
310
1/1
✓ Branch 1 taken 2 times.
2 setName(name);
311
1/1
✓ Branch 1 taken 2 times.
2 setDesc(desc);
312
1/1
✓ Branch 1 taken 2 times.
2 setLam(lam);
313
1/1
✓ Branch 1 taken 2 times.
2 setTurb(turb);
314
1/1
✓ Branch 1 taken 2 times.
2 setExpt(expt);
315
1/1
✓ Branch 1 taken 2 times.
2 setCoef(coef);
316
1/1
✓ Branch 1 taken 2 times.
2 setPres(pres);
317
1/1
✓ Branch 1 taken 2 times.
2 setArea1(area1);
318
1/1
✓ Branch 1 taken 2 times.
2 setArea2(area2);
319
1/1
✓ Branch 1 taken 2 times.
2 setArea3(area3);
320
1/1
✓ Branch 1 taken 2 times.
2 setU_A1(u_A1);
321
1/1
✓ Branch 1 taken 2 times.
2 setU_A2(u_A2);
322
1/1
✓ Branch 1 taken 2 times.
2 setU_A3(u_A3);
323
1/1
✓ Branch 1 taken 2 times.
2 setU_dP(u_dP);
324 2 }
325
326 ✗ void PlrLeakImpl::read(Reader& input) {
327 ✗ setNr(input.read<int>());
328 ✗ setIcon(input.read<int>());
329 ✗ std::string dataType = input.readString(); // Should really check this
330 ✗ setName(input.readString());
331 ✗ setDesc(input.readLine());
332 ✗ setLam(input.readNumber<std::string>());
333 ✗ setTurb(input.readNumber<std::string>());
334 ✗ setExpt(input.readNumber<std::string>());
335 ✗ setCoef(input.readNumber<std::string>());
336 ✗ setPres(input.readNumber<std::string>());
337 ✗ setArea1(input.readNumber<std::string>());
338 ✗ setArea2(input.readNumber<std::string>());
339 ✗ setArea3(input.readNumber<std::string>());
340 ✗ setU_A1(input.read<int>());
341 ✗ setU_A2(input.read<int>());
342 ✗ setU_A3(input.read<int>());
343 ✗ setU_dP(input.read<int>());
344 ✗ }
345
346 6 std::string PlrLeakImpl::write(std::string datatype) {
347 6 std::string string;
348
10/10
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✓ Branch 10 taken 6 times.
✓ Branch 13 taken 6 times.
✓ Branch 16 taken 6 times.
✓ Branch 19 taken 6 times.
✓ Branch 22 taken 6 times.
✓ Branch 25 taken 6 times.
✓ Branch 28 taken 6 times.
6 string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + ' ' + datatype + ' ' + m_name + '\n';
349
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 string += m_desc + '\n';
350
14/14
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✓ Branch 10 taken 6 times.
✓ Branch 13 taken 6 times.
✓ Branch 16 taken 6 times.
✓ Branch 19 taken 6 times.
✓ Branch 22 taken 6 times.
✓ Branch 25 taken 6 times.
✓ Branch 28 taken 6 times.
✓ Branch 31 taken 6 times.
✓ Branch 34 taken 6 times.
✓ Branch 37 taken 6 times.
✓ Branch 40 taken 6 times.
12 string += ANY_TO_STR(m_lam) + ' ' + ANY_TO_STR(m_turb) + ' ' + ANY_TO_STR(m_expt) + ' ' + ANY_TO_STR(m_coef) + ' ' + ANY_TO_STR(m_pres) + ' '
351
14/14
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✓ Branch 10 taken 6 times.
✓ Branch 13 taken 6 times.
✓ Branch 16 taken 6 times.
✓ Branch 19 taken 6 times.
✓ Branch 22 taken 6 times.
✓ Branch 25 taken 6 times.
✓ Branch 28 taken 6 times.
✓ Branch 31 taken 6 times.
✓ Branch 34 taken 6 times.
✓ Branch 37 taken 6 times.
✓ Branch 40 taken 6 times.
24 + ANY_TO_STR(m_area1) + ' ' + ANY_TO_STR(m_area2) + ' ' + ANY_TO_STR(m_area3) + ' ' + ANY_TO_STR(m_u_A1) + ' ' + ANY_TO_STR(m_u_A2)
352
8/8
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✓ Branch 10 taken 6 times.
✓ Branch 13 taken 6 times.
✓ Branch 16 taken 6 times.
✓ Branch 19 taken 6 times.
✓ Branch 22 taken 6 times.
18 + ' ' + ANY_TO_STR(m_u_A3) + ' ' + ANY_TO_STR(m_u_dP) + '\n';
353 6 return string;
354 ✗ }
355
356 36 void PlrLeakImpl::readDetails(Reader& input) {
357
2/2
✓ Branch 1 taken 36 times.
✓ Branch 4 taken 36 times.
36 setLam(input.readNumber<std::string>());
358
2/2
✓ Branch 1 taken 36 times.
✓ Branch 4 taken 36 times.
36 setTurb(input.readNumber<std::string>());
359
2/2
✓ Branch 1 taken 36 times.
✓ Branch 4 taken 36 times.
36 setExpt(input.readNumber<std::string>());
360
2/2
✓ Branch 1 taken 36 times.
✓ Branch 4 taken 36 times.
36 setCoef(input.readNumber<std::string>());
361
2/2
✓ Branch 1 taken 36 times.
✓ Branch 4 taken 36 times.
36 setPres(input.readNumber<std::string>());
362
2/2
✓ Branch 1 taken 36 times.
✓ Branch 4 taken 36 times.
36 setArea1(input.readNumber<std::string>());
363
2/2
✓ Branch 1 taken 36 times.
✓ Branch 4 taken 36 times.
36 setArea2(input.readNumber<std::string>());
364
2/2
✓ Branch 1 taken 36 times.
✓ Branch 4 taken 36 times.
36 setArea3(input.readNumber<std::string>());
365 36 setU_A1(input.read<int>());
366 36 setU_A2(input.read<int>());
367 36 setU_A3(input.read<int>());
368 36 setU_dP(input.read<int>());
369 36 }
370
371 1 int PlrLeakImpl::nr() const {
372 1 return m_nr;
373 }
374
375 39 void PlrLeakImpl::setNr(const int nr) {
376 39 m_nr = nr;
377 39 }
378
379 ✗ int PlrLeakImpl::icon() const {
380 ✗ return m_icon;
381 }
382
383 38 void PlrLeakImpl::setIcon(const int icon) {
384 38 m_icon = icon;
385 38 }
386
387 54 std::string PlrLeakImpl::name() const {
388 54 return m_name;
389 }
390
391 38 void PlrLeakImpl::setName(const std::string& name) {
392 38 m_name = name;
393 38 }
394
395 ✗ std::string PlrLeakImpl::desc() const {
396 ✗ return m_desc;
397 }
398
399 38 void PlrLeakImpl::setDesc(const std::string& desc) {
400 38 m_desc = desc;
401 38 }
402
403 ✗ double PlrLeakImpl::lam() const {
404 ✗ return openstudio::string_conversions::to<double>(m_lam);
405 }
406
407 ✗ bool PlrLeakImpl::setLam(const double lam) {
408 ✗ m_lam = openstudio::string_conversions::number(lam);
409 ✗ return true;
410 }
411
412 38 bool PlrLeakImpl::setLam(const std::string& lam) {
413 38 return assign_if_valid<double>(lam, m_lam);
414 }
415
416 ✗ double PlrLeakImpl::turb() const {
417 ✗ return openstudio::string_conversions::to<double>(m_turb);
418 }
419
420 ✗ bool PlrLeakImpl::setTurb(const double turb) {
421 ✗ m_turb = openstudio::string_conversions::number(turb);
422 ✗ return true;
423 }
424
425 38 bool PlrLeakImpl::setTurb(const std::string& turb) {
426 38 return assign_if_valid<double>(turb, m_turb);
427 }
428
429 ✗ double PlrLeakImpl::expt() const {
430 ✗ return openstudio::string_conversions::to<double>(m_expt);
431 }
432
433 ✗ bool PlrLeakImpl::setExpt(const double expt) {
434 ✗ m_expt = openstudio::string_conversions::number(expt);
435 ✗ return true;
436 }
437
438 38 bool PlrLeakImpl::setExpt(const std::string& expt) {
439 38 return assign_if_valid<double>(expt, m_expt);
440 }
441
442 ✗ double PlrLeakImpl::coef() const {
443 ✗ return openstudio::string_conversions::to<double>(m_coef);
444 }
445
446 ✗ bool PlrLeakImpl::setCoef(const double coef) {
447 ✗ m_coef = openstudio::string_conversions::number(coef);
448 ✗ return true;
449 }
450
451 38 bool PlrLeakImpl::setCoef(const std::string& coef) {
452 38 return assign_if_valid<double>(coef, m_coef);
453 }
454
455 ✗ double PlrLeakImpl::pres() const {
456 ✗ return openstudio::string_conversions::to<double>(m_pres);
457 }
458
459 ✗ bool PlrLeakImpl::setPres(const double pres) {
460 ✗ m_pres = openstudio::string_conversions::number(pres);
461 ✗ return true;
462 }
463
464 38 bool PlrLeakImpl::setPres(const std::string& pres) {
465 38 return assign_if_valid<double>(pres, m_pres);
466 }
467
468 ✗ double PlrLeakImpl::area1() const {
469 ✗ return openstudio::string_conversions::to<double>(m_area1);
470 }
471
472 ✗ bool PlrLeakImpl::setArea1(const double area1) {
473 ✗ m_area1 = openstudio::string_conversions::number(area1);
474 ✗ return true;
475 }
476
477 38 bool PlrLeakImpl::setArea1(const std::string& area1) {
478 38 return assign_if_valid<double>(area1, m_area1);
479 }
480
481 ✗ double PlrLeakImpl::area2() const {
482 ✗ return openstudio::string_conversions::to<double>(m_area2);
483 }
484
485 ✗ bool PlrLeakImpl::setArea2(const double area2) {
486 ✗ m_area2 = openstudio::string_conversions::number(area2);
487 ✗ return true;
488 }
489
490 38 bool PlrLeakImpl::setArea2(const std::string& area2) {
491 38 return assign_if_valid<double>(area2, m_area2);
492 }
493
494 ✗ double PlrLeakImpl::area3() const {
495 ✗ return openstudio::string_conversions::to<double>(m_area3);
496 }
497
498 ✗ bool PlrLeakImpl::setArea3(const double area3) {
499 ✗ m_area3 = openstudio::string_conversions::number(area3);
500 ✗ return true;
501 }
502
503 38 bool PlrLeakImpl::setArea3(const std::string& area3) {
504 38 return assign_if_valid<double>(area3, m_area3);
505 }
506
507 ✗ int PlrLeakImpl::u_A1() const {
508 ✗ return m_u_A1;
509 }
510
511 38 void PlrLeakImpl::setU_A1(const int u_A1) {
512 38 m_u_A1 = u_A1;
513 38 }
514
515 ✗ int PlrLeakImpl::u_A2() const {
516 ✗ return m_u_A2;
517 }
518
519 38 void PlrLeakImpl::setU_A2(const int u_A2) {
520 38 m_u_A2 = u_A2;
521 38 }
522
523 ✗ int PlrLeakImpl::u_A3() const {
524 ✗ return m_u_A3;
525 }
526
527 38 void PlrLeakImpl::setU_A3(const int u_A3) {
528 38 m_u_A3 = u_A3;
529 38 }
530
531 ✗ int PlrLeakImpl::u_dP() const {
532 ✗ return m_u_dP;
533 }
534
535 38 void PlrLeakImpl::setU_dP(const int u_dP) {
536 38 m_u_dP = u_dP;
537 38 }
538
539 ✗ void PlrConnImpl::setDefaults() {
540 ✗ m_nr = 0;
541 ✗ m_icon = 0;
542 ✗ m_lam = PRJFLOAT("0.0");
543 ✗ m_turb = PRJFLOAT("0.0");
544 ✗ m_expt = PRJFLOAT("0.0");
545 ✗ m_coef = PRJFLOAT("0.0");
546 ✗ m_area = PRJFLOAT("0.0");
547 ✗ m_u_A = 0;
548 ✗ }
549
550 ✗ PlrConnImpl::PlrConnImpl() {
551 ✗ setDefaults();
552 ✗ }
553
554 ✗ PlrConnImpl::PlrConnImpl(int nr, int icon, std::string name, std::string desc) {
555 ✗ setDefaults();
556 ✗ setNr(nr);
557 ✗ setIcon(icon);
558 ✗ setName(name);
559 ✗ setDesc(desc);
560 ✗ }
561
562 ✗ PlrConnImpl::PlrConnImpl(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double area, double coef,
563 ✗ int u_A) {
564 ✗ setDefaults();
565 ✗ setNr(nr);
566 ✗ setIcon(icon);
567 ✗ setName(name);
568 ✗ setDesc(desc);
569 ✗ setLam(lam);
570 ✗ setTurb(turb);
571 ✗ setExpt(expt);
572 ✗ setCoef(coef);
573 ✗ setArea(area);
574 ✗ setU_A(u_A);
575 ✗ }
576
577 ✗ PlrConnImpl::PlrConnImpl(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt,
578 ✗ std::string area, std::string coef, int u_A) {
579 ✗ setDefaults();
580 ✗ setNr(nr);
581 ✗ setIcon(icon);
582 ✗ setName(name);
583 ✗ setDesc(desc);
584 ✗ setLam(lam);
585 ✗ setTurb(turb);
586 ✗ setExpt(expt);
587 ✗ setCoef(coef);
588 ✗ setArea(area);
589 ✗ setU_A(u_A);
590 ✗ }
591
592 ✗ void PlrConnImpl::read(Reader& input) {
593 ✗ setNr(input.read<int>());
594 ✗ setIcon(input.read<int>());
595 ✗ std::string dataType = input.readString(); // Should really check this
596 ✗ setName(input.readString());
597 ✗ setDesc(input.readLine());
598 ✗ setLam(input.readNumber<std::string>());
599 ✗ setTurb(input.readNumber<std::string>());
600 ✗ setExpt(input.readNumber<std::string>());
601 ✗ setArea(input.readNumber<std::string>());
602 ✗ setCoef(input.readNumber<std::string>());
603 ✗ setU_A(input.read<int>());
604 ✗ }
605
606 ✗ std::string PlrConnImpl::write() {
607 ✗ std::string string;
608 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + " plr_conn " + m_name + '\n';
609 ✗ string += m_desc + '\n';
610 ✗ string += ANY_TO_STR(m_lam) + ' ' + ANY_TO_STR(m_turb) + ' ' + ANY_TO_STR(m_expt) + ' ' + ANY_TO_STR(m_area) + ' ' + ANY_TO_STR(m_coef) + ' '
611 ✗ + ANY_TO_STR(m_u_A) + '\n';
612 ✗ return string;
613 ✗ }
614
615 ✗ void PlrConnImpl::readDetails(Reader& input) {
616 ✗ setLam(input.readNumber<std::string>());
617 ✗ setTurb(input.readNumber<std::string>());
618 ✗ setExpt(input.readNumber<std::string>());
619 ✗ setArea(input.readNumber<std::string>());
620 ✗ setCoef(input.readNumber<std::string>());
621 ✗ setU_A(input.read<int>());
622 ✗ }
623
624 ✗ int PlrConnImpl::nr() const {
625 ✗ return m_nr;
626 }
627
628 ✗ void PlrConnImpl::setNr(const int nr) {
629 ✗ m_nr = nr;
630 ✗ }
631
632 ✗ int PlrConnImpl::icon() const {
633 ✗ return m_icon;
634 }
635
636 ✗ void PlrConnImpl::setIcon(const int icon) {
637 ✗ m_icon = icon;
638 ✗ }
639
640 ✗ std::string PlrConnImpl::name() const {
641 ✗ return m_name;
642 }
643
644 ✗ void PlrConnImpl::setName(const std::string& name) {
645 ✗ m_name = name;
646 ✗ }
647
648 ✗ std::string PlrConnImpl::desc() const {
649 ✗ return m_desc;
650 }
651
652 ✗ void PlrConnImpl::setDesc(const std::string& desc) {
653 ✗ m_desc = desc;
654 ✗ }
655
656 ✗ double PlrConnImpl::lam() const {
657 ✗ return openstudio::string_conversions::to<double>(m_lam);
658 }
659
660 ✗ bool PlrConnImpl::setLam(const double lam) {
661 ✗ m_lam = openstudio::string_conversions::number(lam);
662 ✗ return true;
663 }
664
665 ✗ bool PlrConnImpl::setLam(const std::string& lam) {
666 ✗ return assign_if_valid<double>(lam, m_lam);
667 }
668
669 ✗ double PlrConnImpl::turb() const {
670 ✗ return openstudio::string_conversions::to<double>(m_turb);
671 }
672
673 ✗ bool PlrConnImpl::setTurb(const double turb) {
674 ✗ m_turb = openstudio::string_conversions::number(turb);
675 ✗ return true;
676 }
677
678 ✗ bool PlrConnImpl::setTurb(const std::string& turb) {
679 ✗ return assign_if_valid<double>(turb, m_turb);
680 }
681
682 ✗ double PlrConnImpl::expt() const {
683 ✗ return openstudio::string_conversions::to<double>(m_expt);
684 }
685
686 ✗ bool PlrConnImpl::setExpt(const double expt) {
687 ✗ m_expt = openstudio::string_conversions::number(expt);
688 ✗ return true;
689 }
690
691 ✗ bool PlrConnImpl::setExpt(const std::string& expt) {
692 ✗ return assign_if_valid<double>(expt, m_expt);
693 }
694
695 ✗ double PlrConnImpl::area() const {
696 ✗ return openstudio::string_conversions::to<double>(m_area);
697 }
698
699 ✗ bool PlrConnImpl::setArea(const double area) {
700 ✗ m_area = openstudio::string_conversions::number(area);
701 ✗ return true;
702 }
703
704 ✗ bool PlrConnImpl::setArea(const std::string& area) {
705 ✗ return assign_if_valid<double>(area, m_area);
706 }
707
708 ✗ double PlrConnImpl::coef() const {
709 ✗ return openstudio::string_conversions::to<double>(m_coef);
710 }
711
712 ✗ bool PlrConnImpl::setCoef(const double coef) {
713 ✗ m_coef = openstudio::string_conversions::number(coef);
714 ✗ return true;
715 }
716
717 ✗ bool PlrConnImpl::setCoef(const std::string& coef) {
718 ✗ return assign_if_valid<double>(coef, m_coef);
719 }
720
721 ✗ int PlrConnImpl::u_A() const {
722 ✗ return m_u_A;
723 }
724
725 ✗ void PlrConnImpl::setU_A(const int u_A) {
726 ✗ m_u_A = u_A;
727 ✗ }
728
729 ✗ void PlrGeneralImpl::setDefaults() {
730 ✗ m_nr = 0;
731 ✗ m_icon = 0;
732 ✗ m_lam = PRJFLOAT("0.0");
733 ✗ m_turb = PRJFLOAT("0.0");
734 ✗ m_expt = PRJFLOAT("0.0");
735 ✗ }
736
737 ✗ PlrGeneralImpl::PlrGeneralImpl() {
738 ✗ setDefaults();
739 ✗ }
740
741 ✗ PlrGeneralImpl::PlrGeneralImpl(int nr, int icon, std::string name, std::string desc) {
742 ✗ setDefaults();
743 ✗ setNr(nr);
744 ✗ setIcon(icon);
745 ✗ setName(name);
746 ✗ setDesc(desc);
747 ✗ }
748
749 ✗ PlrGeneralImpl::PlrGeneralImpl(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt) {
750 ✗ setDefaults();
751 ✗ setNr(nr);
752 ✗ setIcon(icon);
753 ✗ setName(name);
754 ✗ setDesc(desc);
755 ✗ setLam(lam);
756 ✗ setTurb(turb);
757 ✗ setExpt(expt);
758 ✗ }
759
760 ✗ PlrGeneralImpl::PlrGeneralImpl(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt) {
761 ✗ setDefaults();
762 ✗ setNr(nr);
763 ✗ setIcon(icon);
764 ✗ setName(name);
765 ✗ setDesc(desc);
766 ✗ setLam(lam);
767 ✗ setTurb(turb);
768 ✗ setExpt(expt);
769 ✗ }
770
771 ✗ void PlrGeneralImpl::read(Reader& input) {
772 ✗ setNr(input.read<int>());
773 ✗ setIcon(input.read<int>());
774 ✗ std::string dataType = input.readString(); // Should really check this
775 ✗ setName(input.readString());
776 ✗ setDesc(input.readLine());
777 ✗ setLam(input.readNumber<std::string>());
778 ✗ setTurb(input.readNumber<std::string>());
779 ✗ setExpt(input.readNumber<std::string>());
780 ✗ }
781
782 ✗ std::string PlrGeneralImpl::write(std::string dataType) {
783 ✗ std::string string;
784 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + ' ' + dataType + ' ' + m_name + '\n';
785 ✗ string += m_desc + '\n';
786 ✗ string += ANY_TO_STR(m_lam) + ' ' + ANY_TO_STR(m_turb) + ' ' + ANY_TO_STR(m_expt) + '\n';
787 ✗ return string;
788 ✗ }
789
790 ✗ void PlrGeneralImpl::readDetails(Reader& input) {
791 ✗ setLam(input.readNumber<std::string>());
792 ✗ setTurb(input.readNumber<std::string>());
793 ✗ setExpt(input.readNumber<std::string>());
794 ✗ }
795
796 ✗ int PlrGeneralImpl::nr() const {
797 ✗ return m_nr;
798 }
799
800 ✗ void PlrGeneralImpl::setNr(const int nr) {
801 ✗ m_nr = nr;
802 ✗ }
803
804 ✗ int PlrGeneralImpl::icon() const {
805 ✗ return m_icon;
806 }
807
808 ✗ void PlrGeneralImpl::setIcon(const int icon) {
809 ✗ m_icon = icon;
810 ✗ }
811
812 ✗ std::string PlrGeneralImpl::name() const {
813 ✗ return m_name;
814 }
815
816 ✗ void PlrGeneralImpl::setName(const std::string& name) {
817 ✗ m_name = name;
818 ✗ }
819
820 ✗ std::string PlrGeneralImpl::desc() const {
821 ✗ return m_desc;
822 }
823
824 ✗ void PlrGeneralImpl::setDesc(const std::string& desc) {
825 ✗ m_desc = desc;
826 ✗ }
827
828 ✗ double PlrGeneralImpl::lam() const {
829 ✗ return openstudio::string_conversions::to<double>(m_lam);
830 }
831
832 ✗ bool PlrGeneralImpl::setLam(const double lam) {
833 ✗ m_lam = openstudio::string_conversions::number(lam);
834 ✗ return true;
835 }
836
837 ✗ bool PlrGeneralImpl::setLam(const std::string& lam) {
838 ✗ return assign_if_valid<double>(lam, m_lam);
839 }
840
841 ✗ double PlrGeneralImpl::turb() const {
842 ✗ return openstudio::string_conversions::to<double>(m_turb);
843 }
844
845 ✗ bool PlrGeneralImpl::setTurb(const double turb) {
846 ✗ m_turb = openstudio::string_conversions::number(turb);
847 ✗ return true;
848 }
849
850 ✗ bool PlrGeneralImpl::setTurb(const std::string& turb) {
851 ✗ return assign_if_valid<double>(turb, m_turb);
852 }
853
854 ✗ double PlrGeneralImpl::expt() const {
855 ✗ return openstudio::string_conversions::to<double>(m_expt);
856 }
857
858 ✗ bool PlrGeneralImpl::setExpt(const double expt) {
859 ✗ m_expt = openstudio::string_conversions::number(expt);
860 ✗ return true;
861 }
862
863 ✗ bool PlrGeneralImpl::setExpt(const std::string& expt) {
864 ✗ return assign_if_valid<double>(expt, m_expt);
865 }
866
867 76 void PlrTest1Impl::setDefaults() {
868 76 m_nr = 0;
869 76 m_icon = 0;
870
1/1
✓ Branch 1 taken 76 times.
152 m_lam = PRJFLOAT("0.0");
871
1/1
✓ Branch 1 taken 76 times.
152 m_turb = PRJFLOAT("0.0");
872
1/1
✓ Branch 1 taken 76 times.
152 m_expt = PRJFLOAT("0.0");
873
1/1
✓ Branch 1 taken 76 times.
152 m_dP = PRJFLOAT("0.0");
874
1/1
✓ Branch 1 taken 76 times.
76 m_Flow = PRJFLOAT("0.0");
875 76 m_u_P = 0;
876 76 m_u_F = 0;
877 76 }
878
879 2 PlrTest1Impl::PlrTest1Impl() {
880
1/1
✓ Branch 1 taken 2 times.
2 setDefaults();
881 2 }
882
883 72 PlrTest1Impl::PlrTest1Impl(int nr, int icon, std::string name, std::string desc) {
884
1/1
✓ Branch 1 taken 72 times.
72 setDefaults();
885
1/1
✓ Branch 1 taken 72 times.
72 setNr(nr);
886
1/1
✓ Branch 1 taken 72 times.
72 setIcon(icon);
887
1/1
✓ Branch 1 taken 72 times.
72 setName(name);
888
1/1
✓ Branch 1 taken 72 times.
72 setDesc(desc);
889 72 }
890
891 1 PlrTest1Impl::PlrTest1Impl(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double dP, double Flow,
892 1 int u_P, int u_F) {
893
1/1
✓ Branch 1 taken 1 time.
1 setDefaults();
894
1/1
✓ Branch 1 taken 1 time.
1 setNr(nr);
895
1/1
✓ Branch 1 taken 1 time.
1 setIcon(icon);
896
1/1
✓ Branch 1 taken 1 time.
1 setName(name);
897
1/1
✓ Branch 1 taken 1 time.
1 setDesc(desc);
898
1/1
✓ Branch 1 taken 1 time.
1 setLam(lam);
899
1/1
✓ Branch 1 taken 1 time.
1 setTurb(turb);
900
1/1
✓ Branch 1 taken 1 time.
1 setExpt(expt);
901
1/1
✓ Branch 1 taken 1 time.
1 setDP(dP);
902
1/1
✓ Branch 1 taken 1 time.
1 setFlow(Flow);
903
1/1
✓ Branch 1 taken 1 time.
1 setU_P(u_P);
904
1/1
✓ Branch 1 taken 1 time.
1 setU_F(u_F);
905 1 }
906
907 1 PlrTest1Impl::PlrTest1Impl(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt,
908 1 std::string dP, std::string Flow, int u_P, int u_F) {
909
1/1
✓ Branch 1 taken 1 time.
1 setDefaults();
910
1/1
✓ Branch 1 taken 1 time.
1 setNr(nr);
911
1/1
✓ Branch 1 taken 1 time.
1 setIcon(icon);
912
1/1
✓ Branch 1 taken 1 time.
1 setName(name);
913
1/1
✓ Branch 1 taken 1 time.
1 setDesc(desc);
914
1/1
✓ Branch 1 taken 1 time.
1 setLam(lam);
915
1/1
✓ Branch 1 taken 1 time.
1 setTurb(turb);
916
1/1
✓ Branch 1 taken 1 time.
1 setExpt(expt);
917
1/1
✓ Branch 1 taken 1 time.
1 setDP(dP);
918
1/1
✓ Branch 1 taken 1 time.
1 setFlow(Flow);
919
1/1
✓ Branch 1 taken 1 time.
1 setU_P(u_P);
920
1/1
✓ Branch 1 taken 1 time.
1 setU_F(u_F);
921 1 }
922
923 ✗ void PlrTest1Impl::read(Reader& input) {
924 ✗ setNr(input.read<int>());
925 ✗ setIcon(input.read<int>());
926 ✗ std::string dataType = input.readString(); // Should really check this
927 ✗ setName(input.readString());
928 ✗ setDesc(input.readLine());
929 ✗ setLam(input.readNumber<std::string>());
930 ✗ setTurb(input.readNumber<std::string>());
931 ✗ setExpt(input.readNumber<std::string>());
932 ✗ setDP(input.readNumber<std::string>());
933 ✗ setFlow(input.readNumber<std::string>());
934 ✗ setU_P(input.read<int>());
935 ✗ setU_F(input.read<int>());
936 ✗ }
937
938 12 std::string PlrTest1Impl::write() {
939 12 std::string string;
940
8/8
✓ Branch 1 taken 12 times.
✓ Branch 4 taken 12 times.
✓ Branch 7 taken 12 times.
✓ Branch 10 taken 12 times.
✓ Branch 13 taken 12 times.
✓ Branch 16 taken 12 times.
✓ Branch 19 taken 12 times.
✓ Branch 22 taken 12 times.
12 string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + " plr_test1 " + m_name + '\n';
941
2/2
✓ Branch 1 taken 12 times.
✓ Branch 4 taken 12 times.
12 string += m_desc + '\n';
942
14/14
✓ Branch 1 taken 12 times.
✓ Branch 4 taken 12 times.
✓ Branch 7 taken 12 times.
✓ Branch 10 taken 12 times.
✓ Branch 13 taken 12 times.
✓ Branch 16 taken 12 times.
✓ Branch 19 taken 12 times.
✓ Branch 22 taken 12 times.
✓ Branch 25 taken 12 times.
✓ Branch 28 taken 12 times.
✓ Branch 31 taken 12 times.
✓ Branch 34 taken 12 times.
✓ Branch 37 taken 12 times.
✓ Branch 40 taken 12 times.
24 string += ANY_TO_STR(m_lam) + ' ' + ANY_TO_STR(m_turb) + ' ' + ANY_TO_STR(m_expt) + ' ' + ANY_TO_STR(m_dP) + ' ' + ANY_TO_STR(m_Flow) + ' '
943
7/7
✓ Branch 1 taken 12 times.
✓ Branch 4 taken 12 times.
✓ Branch 7 taken 12 times.
✓ Branch 10 taken 12 times.
✓ Branch 13 taken 12 times.
✓ Branch 16 taken 12 times.
✓ Branch 19 taken 12 times.
36 + ANY_TO_STR(m_u_P) + ' ' + ANY_TO_STR(m_u_F) + '\n';
944 12 return string;
945 ✗ }
946
947 72 void PlrTest1Impl::readDetails(Reader& input) {
948
2/2
✓ Branch 1 taken 72 times.
✓ Branch 4 taken 72 times.
72 setLam(input.readNumber<std::string>());
949
2/2
✓ Branch 1 taken 72 times.
✓ Branch 4 taken 72 times.
72 setTurb(input.readNumber<std::string>());
950
2/2
✓ Branch 1 taken 72 times.
✓ Branch 4 taken 72 times.
72 setExpt(input.readNumber<std::string>());
951
2/2
✓ Branch 1 taken 72 times.
✓ Branch 4 taken 72 times.
72 setDP(input.readNumber<std::string>());
952
2/2
✓ Branch 1 taken 72 times.
✓ Branch 4 taken 72 times.
72 setFlow(input.readNumber<std::string>());
953 72 setU_P(input.read<int>());
954 72 setU_F(input.read<int>());
955 72 }
956
957 26 int PlrTest1Impl::nr() const {
958 26 return m_nr;
959 }
960
961 76 void PlrTest1Impl::setNr(const int nr) {
962 76 m_nr = nr;
963 76 }
964
965 ✗ int PlrTest1Impl::icon() const {
966 ✗ return m_icon;
967 }
968
969 74 void PlrTest1Impl::setIcon(const int icon) {
970 74 m_icon = icon;
971 74 }
972
973 132 std::string PlrTest1Impl::name() const {
974 132 return m_name;
975 }
976
977 74 void PlrTest1Impl::setName(const std::string& name) {
978 74 m_name = name;
979 74 }
980
981 ✗ std::string PlrTest1Impl::desc() const {
982 ✗ return m_desc;
983 }
984
985 74 void PlrTest1Impl::setDesc(const std::string& desc) {
986 74 m_desc = desc;
987 74 }
988
989 ✗ double PlrTest1Impl::lam() const {
990 ✗ return openstudio::string_conversions::to<double>(m_lam);
991 }
992
993 1 bool PlrTest1Impl::setLam(const double lam) {
994
1/1
✓ Branch 1 taken 1 time.
1 m_lam = openstudio::string_conversions::number(lam);
995 1 return true;
996 }
997
998 73 bool PlrTest1Impl::setLam(const std::string& lam) {
999 73 return assign_if_valid<double>(lam, m_lam);
1000 }
1001
1002 ✗ double PlrTest1Impl::turb() const {
1003 ✗ return openstudio::string_conversions::to<double>(m_turb);
1004 }
1005
1006 1 bool PlrTest1Impl::setTurb(const double turb) {
1007
1/1
✓ Branch 1 taken 1 time.
1 m_turb = openstudio::string_conversions::number(turb);
1008 1 return true;
1009 }
1010
1011 73 bool PlrTest1Impl::setTurb(const std::string& turb) {
1012 73 return assign_if_valid<double>(turb, m_turb);
1013 }
1014
1015 ✗ double PlrTest1Impl::expt() const {
1016 ✗ return openstudio::string_conversions::to<double>(m_expt);
1017 }
1018
1019 1 bool PlrTest1Impl::setExpt(const double expt) {
1020
1/1
✓ Branch 1 taken 1 time.
1 m_expt = openstudio::string_conversions::number(expt);
1021 1 return true;
1022 }
1023
1024 73 bool PlrTest1Impl::setExpt(const std::string& expt) {
1025 73 return assign_if_valid<double>(expt, m_expt);
1026 }
1027
1028 ✗ double PlrTest1Impl::dP() const {
1029 ✗ return openstudio::string_conversions::to<double>(m_dP);
1030 }
1031
1032 1 bool PlrTest1Impl::setDP(const double dP) {
1033
1/1
✓ Branch 1 taken 1 time.
1 m_dP = openstudio::string_conversions::number(dP);
1034 1 return true;
1035 }
1036
1037 73 bool PlrTest1Impl::setDP(const std::string& dP) {
1038 73 return assign_if_valid<double>(dP, m_dP);
1039 }
1040
1041 ✗ double PlrTest1Impl::Flow() const {
1042 ✗ return openstudio::string_conversions::to<double>(m_Flow);
1043 }
1044
1045 1 bool PlrTest1Impl::setFlow(const double Flow) {
1046
1/1
✓ Branch 1 taken 1 time.
1 m_Flow = openstudio::string_conversions::number(Flow);
1047 1 return true;
1048 }
1049
1050 73 bool PlrTest1Impl::setFlow(const std::string& Flow) {
1051 73 return assign_if_valid<double>(Flow, m_Flow);
1052 }
1053
1054 ✗ int PlrTest1Impl::u_P() const {
1055 ✗ return m_u_P;
1056 }
1057
1058 74 void PlrTest1Impl::setU_P(const int u_P) {
1059 74 m_u_P = u_P;
1060 74 }
1061
1062 ✗ int PlrTest1Impl::u_F() const {
1063 ✗ return m_u_F;
1064 }
1065
1066 74 void PlrTest1Impl::setU_F(const int u_F) {
1067 74 m_u_F = u_F;
1068 74 }
1069
1070 ✗ void PlrTest2Impl::setDefaults() {
1071 ✗ m_nr = 0;
1072 ✗ m_icon = 0;
1073 ✗ m_lam = PRJFLOAT("0.0");
1074 ✗ m_turb = PRJFLOAT("0.0");
1075 ✗ m_expt = PRJFLOAT("0.0");
1076 ✗ m_dP1 = PRJFLOAT("0.0");
1077 ✗ m_F1 = PRJFLOAT("0.0");
1078 ✗ m_dP2 = PRJFLOAT("0.0");
1079 ✗ m_F2 = PRJFLOAT("0.0");
1080 ✗ m_u_P1 = 0;
1081 ✗ m_u_F1 = 0;
1082 ✗ m_u_P2 = 0;
1083 ✗ m_u_F2 = 0;
1084 ✗ }
1085
1086 ✗ PlrTest2Impl::PlrTest2Impl() {
1087 ✗ setDefaults();
1088 ✗ }
1089
1090 ✗ PlrTest2Impl::PlrTest2Impl(int nr, int icon, std::string name, std::string desc) {
1091 ✗ setDefaults();
1092 ✗ setNr(nr);
1093 ✗ setIcon(icon);
1094 ✗ setName(name);
1095 ✗ setDesc(desc);
1096 ✗ }
1097
1098 ✗ PlrTest2Impl::PlrTest2Impl(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double dP1, double F1,
1099 ✗ double dP2, double F2, int u_P1, int u_F1, int u_P2, int u_F2) {
1100 ✗ setDefaults();
1101 ✗ setNr(nr);
1102 ✗ setIcon(icon);
1103 ✗ setName(name);
1104 ✗ setDesc(desc);
1105 ✗ setLam(lam);
1106 ✗ setTurb(turb);
1107 ✗ setExpt(expt);
1108 ✗ setDP1(dP1);
1109 ✗ setF1(F1);
1110 ✗ setDP2(dP2);
1111 ✗ setF2(F2);
1112 ✗ setU_P1(u_P1);
1113 ✗ setU_F1(u_F1);
1114 ✗ setU_P2(u_P2);
1115 ✗ setU_F2(u_F2);
1116 ✗ }
1117
1118 ✗ PlrTest2Impl::PlrTest2Impl(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt,
1119 ✗ std::string dP1, std::string F1, std::string dP2, std::string F2, int u_P1, int u_F1, int u_P2, int u_F2) {
1120 ✗ setDefaults();
1121 ✗ setNr(nr);
1122 ✗ setIcon(icon);
1123 ✗ setName(name);
1124 ✗ setDesc(desc);
1125 ✗ setLam(lam);
1126 ✗ setTurb(turb);
1127 ✗ setExpt(expt);
1128 ✗ setDP1(dP1);
1129 ✗ setF1(F1);
1130 ✗ setDP2(dP2);
1131 ✗ setF2(F2);
1132 ✗ setU_P1(u_P1);
1133 ✗ setU_F1(u_F1);
1134 ✗ setU_P2(u_P2);
1135 ✗ setU_F2(u_F2);
1136 ✗ }
1137
1138 ✗ void PlrTest2Impl::read(Reader& input) {
1139 ✗ setNr(input.read<int>());
1140 ✗ setIcon(input.read<int>());
1141 ✗ std::string dataType = input.readString(); // Should really check this
1142 ✗ setName(input.readString());
1143 ✗ setDesc(input.readLine());
1144 ✗ setLam(input.readNumber<std::string>());
1145 ✗ setTurb(input.readNumber<std::string>());
1146 ✗ setExpt(input.readNumber<std::string>());
1147 ✗ setDP1(input.readNumber<std::string>());
1148 ✗ setF1(input.readNumber<std::string>());
1149 ✗ setDP2(input.readNumber<std::string>());
1150 ✗ setF2(input.readNumber<std::string>());
1151 ✗ setU_P1(input.read<int>());
1152 ✗ setU_F1(input.read<int>());
1153 ✗ setU_P2(input.read<int>());
1154 ✗ setU_F2(input.read<int>());
1155 ✗ }
1156
1157 ✗ std::string PlrTest2Impl::write() {
1158 ✗ std::string string;
1159 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + " plr_test2 " + m_name + '\n';
1160 ✗ string += m_desc + '\n';
1161 ✗ string += ANY_TO_STR(m_lam) + ' ' + ANY_TO_STR(m_turb) + ' ' + ANY_TO_STR(m_expt) + ' ' + ANY_TO_STR(m_dP1) + ' ' + ANY_TO_STR(m_F1) + ' '
1162 ✗ + ANY_TO_STR(m_dP2) + ' ' + ANY_TO_STR(m_F2) + ' ' + ANY_TO_STR(m_u_P1) + ' ' + ANY_TO_STR(m_u_F1) + ' ' + ANY_TO_STR(m_u_P2) + ' '
1163 ✗ + ANY_TO_STR(m_u_F2) + '\n';
1164 ✗ return string;
1165 ✗ }
1166
1167 ✗ void PlrTest2Impl::readDetails(Reader& input) {
1168 ✗ setLam(input.readNumber<std::string>());
1169 ✗ setTurb(input.readNumber<std::string>());
1170 ✗ setExpt(input.readNumber<std::string>());
1171 ✗ setDP1(input.readNumber<std::string>());
1172 ✗ setF1(input.readNumber<std::string>());
1173 ✗ setDP2(input.readNumber<std::string>());
1174 ✗ setF2(input.readNumber<std::string>());
1175 ✗ setU_P1(input.read<int>());
1176 ✗ setU_F1(input.read<int>());
1177 ✗ setU_P2(input.read<int>());
1178 ✗ setU_F2(input.read<int>());
1179 ✗ }
1180
1181 ✗ int PlrTest2Impl::nr() const {
1182 ✗ return m_nr;
1183 }
1184
1185 ✗ void PlrTest2Impl::setNr(const int nr) {
1186 ✗ m_nr = nr;
1187 ✗ }
1188
1189 ✗ int PlrTest2Impl::icon() const {
1190 ✗ return m_icon;
1191 }
1192
1193 ✗ void PlrTest2Impl::setIcon(const int icon) {
1194 ✗ m_icon = icon;
1195 ✗ }
1196
1197 ✗ std::string PlrTest2Impl::name() const {
1198 ✗ return m_name;
1199 }
1200
1201 ✗ void PlrTest2Impl::setName(const std::string& name) {
1202 ✗ m_name = name;
1203 ✗ }
1204
1205 ✗ std::string PlrTest2Impl::desc() const {
1206 ✗ return m_desc;
1207 }
1208
1209 ✗ void PlrTest2Impl::setDesc(const std::string& desc) {
1210 ✗ m_desc = desc;
1211 ✗ }
1212
1213 ✗ double PlrTest2Impl::lam() const {
1214 ✗ return openstudio::string_conversions::to<double>(m_lam);
1215 }
1216
1217 ✗ bool PlrTest2Impl::setLam(const double lam) {
1218 ✗ m_lam = openstudio::string_conversions::number(lam);
1219 ✗ return true;
1220 }
1221
1222 ✗ bool PlrTest2Impl::setLam(const std::string& lam) {
1223 ✗ return assign_if_valid<double>(lam, m_lam);
1224 }
1225
1226 ✗ double PlrTest2Impl::turb() const {
1227 ✗ return openstudio::string_conversions::to<double>(m_turb);
1228 }
1229
1230 ✗ bool PlrTest2Impl::setTurb(const double turb) {
1231 ✗ m_turb = openstudio::string_conversions::number(turb);
1232 ✗ return true;
1233 }
1234
1235 ✗ bool PlrTest2Impl::setTurb(const std::string& turb) {
1236 ✗ return assign_if_valid<double>(turb, m_turb);
1237 }
1238
1239 ✗ double PlrTest2Impl::expt() const {
1240 ✗ return openstudio::string_conversions::to<double>(m_expt);
1241 }
1242
1243 ✗ bool PlrTest2Impl::setExpt(const double expt) {
1244 ✗ m_expt = openstudio::string_conversions::number(expt);
1245 ✗ return true;
1246 }
1247
1248 ✗ bool PlrTest2Impl::setExpt(const std::string& expt) {
1249 ✗ return assign_if_valid<double>(expt, m_expt);
1250 }
1251
1252 ✗ double PlrTest2Impl::dP1() const {
1253 ✗ return openstudio::string_conversions::to<double>(m_dP1);
1254 }
1255
1256 ✗ bool PlrTest2Impl::setDP1(const double dP1) {
1257 ✗ m_dP1 = openstudio::string_conversions::number(dP1);
1258 ✗ return true;
1259 }
1260
1261 ✗ bool PlrTest2Impl::setDP1(const std::string& dP1) {
1262 ✗ return assign_if_valid<double>(dP1, m_dP1);
1263 }
1264
1265 ✗ double PlrTest2Impl::F1() const {
1266 ✗ return openstudio::string_conversions::to<double>(m_F1);
1267 }
1268
1269 ✗ bool PlrTest2Impl::setF1(const double F1) {
1270 ✗ m_F1 = openstudio::string_conversions::number(F1);
1271 ✗ return true;
1272 }
1273
1274 ✗ bool PlrTest2Impl::setF1(const std::string& F1) {
1275 ✗ return assign_if_valid<double>(F1, m_F1);
1276 }
1277
1278 ✗ double PlrTest2Impl::dP2() const {
1279 ✗ return openstudio::string_conversions::to<double>(m_dP2);
1280 }
1281
1282 ✗ bool PlrTest2Impl::setDP2(const double dP2) {
1283 ✗ m_dP2 = openstudio::string_conversions::number(dP2);
1284 ✗ return true;
1285 }
1286
1287 ✗ bool PlrTest2Impl::setDP2(const std::string& dP2) {
1288 ✗ return assign_if_valid<double>(dP2, m_dP2);
1289 }
1290
1291 ✗ double PlrTest2Impl::F2() const {
1292 ✗ return openstudio::string_conversions::to<double>(m_F2);
1293 }
1294
1295 ✗ bool PlrTest2Impl::setF2(const double F2) {
1296 ✗ m_F2 = openstudio::string_conversions::number(F2);
1297 ✗ return true;
1298 }
1299
1300 ✗ bool PlrTest2Impl::setF2(const std::string& F2) {
1301 ✗ return assign_if_valid<double>(F2, m_F2);
1302 }
1303
1304 ✗ int PlrTest2Impl::u_P1() const {
1305 ✗ return m_u_P1;
1306 }
1307
1308 ✗ void PlrTest2Impl::setU_P1(const int u_P1) {
1309 ✗ m_u_P1 = u_P1;
1310 ✗ }
1311
1312 ✗ int PlrTest2Impl::u_F1() const {
1313 ✗ return m_u_F1;
1314 }
1315
1316 ✗ void PlrTest2Impl::setU_F1(const int u_F1) {
1317 ✗ m_u_F1 = u_F1;
1318 ✗ }
1319
1320 ✗ int PlrTest2Impl::u_P2() const {
1321 ✗ return m_u_P2;
1322 }
1323
1324 ✗ void PlrTest2Impl::setU_P2(const int u_P2) {
1325 ✗ m_u_P2 = u_P2;
1326 ✗ }
1327
1328 ✗ int PlrTest2Impl::u_F2() const {
1329 ✗ return m_u_F2;
1330 }
1331
1332 ✗ void PlrTest2Impl::setU_F2(const int u_F2) {
1333 ✗ m_u_F2 = u_F2;
1334 ✗ }
1335
1336 ✗ void PlrCrackImpl::setDefaults() {
1337 ✗ m_nr = 0;
1338 ✗ m_icon = 0;
1339 ✗ m_lam = PRJFLOAT("0.0");
1340 ✗ m_turb = PRJFLOAT("0.0");
1341 ✗ m_expt = PRJFLOAT("0.0");
1342 ✗ m_length = PRJFLOAT("0.0");
1343 ✗ m_width = PRJFLOAT("0.0");
1344 ✗ m_u_L = 0;
1345 ✗ m_u_W = 0;
1346 ✗ }
1347
1348 ✗ PlrCrackImpl::PlrCrackImpl() {
1349 ✗ setDefaults();
1350 ✗ }
1351
1352 ✗ PlrCrackImpl::PlrCrackImpl(int nr, int icon, std::string name, std::string desc) {
1353 ✗ setDefaults();
1354 ✗ setNr(nr);
1355 ✗ setIcon(icon);
1356 ✗ setName(name);
1357 ✗ setDesc(desc);
1358 ✗ }
1359
1360 ✗ PlrCrackImpl::PlrCrackImpl(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double length,
1361 ✗ double width, int u_L, int u_W) {
1362 ✗ setDefaults();
1363 ✗ setNr(nr);
1364 ✗ setIcon(icon);
1365 ✗ setName(name);
1366 ✗ setDesc(desc);
1367 ✗ setLam(lam);
1368 ✗ setTurb(turb);
1369 ✗ setExpt(expt);
1370 ✗ setLength(length);
1371 ✗ setWidth(width);
1372 ✗ setU_L(u_L);
1373 ✗ setU_W(u_W);
1374 ✗ }
1375
1376 ✗ PlrCrackImpl::PlrCrackImpl(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt,
1377 ✗ std::string length, std::string width, int u_L, int u_W) {
1378 ✗ setDefaults();
1379 ✗ setNr(nr);
1380 ✗ setIcon(icon);
1381 ✗ setName(name);
1382 ✗ setDesc(desc);
1383 ✗ setLam(lam);
1384 ✗ setTurb(turb);
1385 ✗ setExpt(expt);
1386 ✗ setLength(length);
1387 ✗ setWidth(width);
1388 ✗ setU_L(u_L);
1389 ✗ setU_W(u_W);
1390 ✗ }
1391
1392 ✗ void PlrCrackImpl::read(Reader& input) {
1393 ✗ setNr(input.read<int>());
1394 ✗ setIcon(input.read<int>());
1395 ✗ std::string dataType = input.readString(); // Should really check this
1396 ✗ setName(input.readString());
1397 ✗ setDesc(input.readLine());
1398 ✗ setLam(input.readNumber<std::string>());
1399 ✗ setTurb(input.readNumber<std::string>());
1400 ✗ setExpt(input.readNumber<std::string>());
1401 ✗ setLength(input.readNumber<std::string>());
1402 ✗ setWidth(input.readNumber<std::string>());
1403 ✗ setU_L(input.read<int>());
1404 ✗ setU_W(input.read<int>());
1405 ✗ }
1406
1407 ✗ std::string PlrCrackImpl::write() {
1408 ✗ std::string string;
1409 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + " plr_crack " + m_name + '\n';
1410 ✗ string += m_desc + '\n';
1411 ✗ string += ANY_TO_STR(m_lam) + ' ' + ANY_TO_STR(m_turb) + ' ' + ANY_TO_STR(m_expt) + ' ' + ANY_TO_STR(m_length) + ' ' + ANY_TO_STR(m_width) + ' '
1412 ✗ + ANY_TO_STR(m_u_L) + ' ' + ANY_TO_STR(m_u_W) + '\n';
1413 ✗ return string;
1414 ✗ }
1415
1416 ✗ void PlrCrackImpl::readDetails(Reader& input) {
1417 ✗ setLam(input.readNumber<std::string>());
1418 ✗ setTurb(input.readNumber<std::string>());
1419 ✗ setExpt(input.readNumber<std::string>());
1420 ✗ setLength(input.readNumber<std::string>());
1421 ✗ setWidth(input.readNumber<std::string>());
1422 ✗ setU_L(input.read<int>());
1423 ✗ setU_W(input.read<int>());
1424 ✗ }
1425
1426 ✗ int PlrCrackImpl::nr() const {
1427 ✗ return m_nr;
1428 }
1429
1430 ✗ void PlrCrackImpl::setNr(const int nr) {
1431 ✗ m_nr = nr;
1432 ✗ }
1433
1434 ✗ int PlrCrackImpl::icon() const {
1435 ✗ return m_icon;
1436 }
1437
1438 ✗ void PlrCrackImpl::setIcon(const int icon) {
1439 ✗ m_icon = icon;
1440 ✗ }
1441
1442 ✗ std::string PlrCrackImpl::name() const {
1443 ✗ return m_name;
1444 }
1445
1446 ✗ void PlrCrackImpl::setName(const std::string& name) {
1447 ✗ m_name = name;
1448 ✗ }
1449
1450 ✗ std::string PlrCrackImpl::desc() const {
1451 ✗ return m_desc;
1452 }
1453
1454 ✗ void PlrCrackImpl::setDesc(const std::string& desc) {
1455 ✗ m_desc = desc;
1456 ✗ }
1457
1458 ✗ double PlrCrackImpl::lam() const {
1459 ✗ return openstudio::string_conversions::to<double>(m_lam);
1460 }
1461
1462 ✗ bool PlrCrackImpl::setLam(const double lam) {
1463 ✗ m_lam = openstudio::string_conversions::number(lam);
1464 ✗ return true;
1465 }
1466
1467 ✗ bool PlrCrackImpl::setLam(const std::string& lam) {
1468 ✗ return assign_if_valid<double>(lam, m_lam);
1469 }
1470
1471 ✗ double PlrCrackImpl::turb() const {
1472 ✗ return openstudio::string_conversions::to<double>(m_turb);
1473 }
1474
1475 ✗ bool PlrCrackImpl::setTurb(const double turb) {
1476 ✗ m_turb = openstudio::string_conversions::number(turb);
1477 ✗ return true;
1478 }
1479
1480 ✗ bool PlrCrackImpl::setTurb(const std::string& turb) {
1481 ✗ return assign_if_valid<double>(turb, m_turb);
1482 }
1483
1484 ✗ double PlrCrackImpl::expt() const {
1485 ✗ return openstudio::string_conversions::to<double>(m_expt);
1486 }
1487
1488 ✗ bool PlrCrackImpl::setExpt(const double expt) {
1489 ✗ m_expt = openstudio::string_conversions::number(expt);
1490 ✗ return true;
1491 }
1492
1493 ✗ bool PlrCrackImpl::setExpt(const std::string& expt) {
1494 ✗ return assign_if_valid<double>(expt, m_expt);
1495 }
1496
1497 ✗ double PlrCrackImpl::length() const {
1498 ✗ return openstudio::string_conversions::to<double>(m_length);
1499 }
1500
1501 ✗ bool PlrCrackImpl::setLength(const double length) {
1502 ✗ m_length = openstudio::string_conversions::number(length);
1503 ✗ return true;
1504 }
1505
1506 ✗ bool PlrCrackImpl::setLength(const std::string& length) {
1507 ✗ return assign_if_valid<double>(length, m_length);
1508 }
1509
1510 ✗ double PlrCrackImpl::width() const {
1511 ✗ return openstudio::string_conversions::to<double>(m_width);
1512 }
1513
1514 ✗ bool PlrCrackImpl::setWidth(const double width) {
1515 ✗ m_width = openstudio::string_conversions::number(width);
1516 ✗ return true;
1517 }
1518
1519 ✗ bool PlrCrackImpl::setWidth(const std::string& width) {
1520 ✗ return assign_if_valid<double>(width, m_width);
1521 }
1522
1523 ✗ int PlrCrackImpl::u_L() const {
1524 ✗ return m_u_L;
1525 }
1526
1527 ✗ void PlrCrackImpl::setU_L(const int u_L) {
1528 ✗ m_u_L = u_L;
1529 ✗ }
1530
1531 ✗ int PlrCrackImpl::u_W() const {
1532 ✗ return m_u_W;
1533 }
1534
1535 ✗ void PlrCrackImpl::setU_W(const int u_W) {
1536 ✗ m_u_W = u_W;
1537 ✗ }
1538
1539 6 void PlrStairImpl::setDefaults() {
1540 6 m_nr = 0;
1541 6 m_icon = 0;
1542
1/1
✓ Branch 1 taken 6 times.
12 m_lam = PRJFLOAT("0.0");
1543
1/1
✓ Branch 1 taken 6 times.
12 m_turb = PRJFLOAT("0.0");
1544
1/1
✓ Branch 1 taken 6 times.
12 m_expt = PRJFLOAT("0.0");
1545
1/1
✓ Branch 1 taken 6 times.
12 m_Ht = PRJFLOAT("0.0");
1546
1/1
✓ Branch 1 taken 6 times.
12 m_Area = PRJFLOAT("0.0");
1547
1/1
✓ Branch 1 taken 6 times.
6 m_peo = PRJFLOAT("0.0");
1548 6 m_tread = 0;
1549 6 m_u_A = 0;
1550 6 m_u_D = 0;
1551 6 }
1552
1553 ✗ PlrStairImpl::PlrStairImpl() {
1554 ✗ setDefaults();
1555 ✗ }
1556
1557 6 PlrStairImpl::PlrStairImpl(int nr, int icon, std::string name, std::string desc) {
1558
1/1
✓ Branch 1 taken 6 times.
6 setDefaults();
1559
1/1
✓ Branch 1 taken 6 times.
6 setNr(nr);
1560
1/1
✓ Branch 1 taken 6 times.
6 setIcon(icon);
1561
1/1
✓ Branch 1 taken 6 times.
6 setName(name);
1562
1/1
✓ Branch 1 taken 6 times.
6 setDesc(desc);
1563 6 }
1564
1565 ✗ PlrStairImpl::PlrStairImpl(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double Ht, double Area,
1566 ✗ double peo, int tread, int u_A, int u_D) {
1567 ✗ setDefaults();
1568 ✗ setNr(nr);
1569 ✗ setIcon(icon);
1570 ✗ setName(name);
1571 ✗ setDesc(desc);
1572 ✗ setLam(lam);
1573 ✗ setTurb(turb);
1574 ✗ setExpt(expt);
1575 ✗ setHt(Ht);
1576 ✗ setArea(Area);
1577 ✗ setPeople(peo);
1578 ✗ setTread(tread);
1579 ✗ setU_A(u_A);
1580 ✗ setU_D(u_D);
1581 ✗ }
1582
1583 ✗ PlrStairImpl::PlrStairImpl(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt,
1584 ✗ std::string Ht, std::string Area, std::string peo, int tread, int u_A, int u_D) {
1585 ✗ setDefaults();
1586 ✗ setNr(nr);
1587 ✗ setIcon(icon);
1588 ✗ setName(name);
1589 ✗ setDesc(desc);
1590 ✗ setLam(lam);
1591 ✗ setTurb(turb);
1592 ✗ setExpt(expt);
1593 ✗ setHt(Ht);
1594 ✗ setArea(Area);
1595 ✗ setPeople(peo);
1596 ✗ setTread(tread);
1597 ✗ setU_A(u_A);
1598 ✗ setU_D(u_D);
1599 ✗ }
1600
1601 ✗ void PlrStairImpl::read(Reader& input) {
1602 ✗ setNr(input.read<int>());
1603 ✗ setIcon(input.read<int>());
1604 ✗ std::string dataType = input.readString(); // Should really check this
1605 ✗ setName(input.readString());
1606 ✗ setDesc(input.readLine());
1607 ✗ setLam(input.readNumber<std::string>());
1608 ✗ setTurb(input.readNumber<std::string>());
1609 ✗ setExpt(input.readNumber<std::string>());
1610 ✗ setHt(input.readNumber<std::string>());
1611 ✗ setArea(input.readNumber<std::string>());
1612 ✗ setPeople(input.readNumber<std::string>());
1613 ✗ setTread(input.read<int>());
1614 ✗ setU_A(input.read<int>());
1615 ✗ setU_D(input.read<int>());
1616 ✗ }
1617
1618 1 std::string PlrStairImpl::write() {
1619 1 std::string string;
1620
8/8
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
✓ Branch 16 taken 1 time.
✓ Branch 19 taken 1 time.
✓ Branch 22 taken 1 time.
1 string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + " plr_stair " + m_name + '\n';
1621
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 string += m_desc + '\n';
1622
14/14
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
✓ Branch 16 taken 1 time.
✓ Branch 19 taken 1 time.
✓ Branch 22 taken 1 time.
✓ Branch 25 taken 1 time.
✓ Branch 28 taken 1 time.
✓ Branch 31 taken 1 time.
✓ Branch 34 taken 1 time.
✓ Branch 37 taken 1 time.
✓ Branch 40 taken 1 time.
2 string += ANY_TO_STR(m_lam) + ' ' + ANY_TO_STR(m_turb) + ' ' + ANY_TO_STR(m_expt) + ' ' + ANY_TO_STR(m_Ht) + ' ' + ANY_TO_STR(m_Area) + ' '
1623
13/13
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
✓ Branch 16 taken 1 time.
✓ Branch 19 taken 1 time.
✓ Branch 22 taken 1 time.
✓ Branch 25 taken 1 time.
✓ Branch 28 taken 1 time.
✓ Branch 31 taken 1 time.
✓ Branch 34 taken 1 time.
✓ Branch 37 taken 1 time.
3 + ANY_TO_STR(m_peo) + ' ' + ANY_TO_STR(m_tread) + ' ' + ANY_TO_STR(m_u_A) + ' ' + ANY_TO_STR(m_u_D) + '\n';
1624 1 return string;
1625 ✗ }
1626
1627 6 void PlrStairImpl::readDetails(Reader& input) {
1628
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setLam(input.readNumber<std::string>());
1629
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setTurb(input.readNumber<std::string>());
1630
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setExpt(input.readNumber<std::string>());
1631
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setHt(input.readNumber<std::string>());
1632
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setArea(input.readNumber<std::string>());
1633
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setPeople(input.readNumber<std::string>());
1634 6 setTread(input.read<int>());
1635 6 setU_A(input.read<int>());
1636 6 setU_D(input.read<int>());
1637 6 }
1638
1639 ✗ int PlrStairImpl::nr() const {
1640 ✗ return m_nr;
1641 }
1642
1643 6 void PlrStairImpl::setNr(const int nr) {
1644 6 m_nr = nr;
1645 6 }
1646
1647 ✗ int PlrStairImpl::icon() const {
1648 ✗ return m_icon;
1649 }
1650
1651 6 void PlrStairImpl::setIcon(const int icon) {
1652 6 m_icon = icon;
1653 6 }
1654
1655 ✗ std::string PlrStairImpl::name() const {
1656 ✗ return m_name;
1657 }
1658
1659 6 void PlrStairImpl::setName(const std::string& name) {
1660 6 m_name = name;
1661 6 }
1662
1663 ✗ std::string PlrStairImpl::desc() const {
1664 ✗ return m_desc;
1665 }
1666
1667 6 void PlrStairImpl::setDesc(const std::string& desc) {
1668 6 m_desc = desc;
1669 6 }
1670
1671 ✗ double PlrStairImpl::lam() const {
1672 ✗ return openstudio::string_conversions::to<double>(m_lam);
1673 }
1674
1675 ✗ bool PlrStairImpl::setLam(const double lam) {
1676 ✗ m_lam = openstudio::string_conversions::number(lam);
1677 ✗ return true;
1678 }
1679
1680 6 bool PlrStairImpl::setLam(const std::string& lam) {
1681 6 return assign_if_valid<double>(lam, m_lam);
1682 }
1683
1684 ✗ double PlrStairImpl::turb() const {
1685 ✗ return openstudio::string_conversions::to<double>(m_turb);
1686 }
1687
1688 ✗ bool PlrStairImpl::setTurb(const double turb) {
1689 ✗ m_turb = openstudio::string_conversions::number(turb);
1690 ✗ return true;
1691 }
1692
1693 6 bool PlrStairImpl::setTurb(const std::string& turb) {
1694 6 return assign_if_valid<double>(turb, m_turb);
1695 }
1696
1697 ✗ double PlrStairImpl::expt() const {
1698 ✗ return openstudio::string_conversions::to<double>(m_expt);
1699 }
1700
1701 ✗ bool PlrStairImpl::setExpt(const double expt) {
1702 ✗ m_expt = openstudio::string_conversions::number(expt);
1703 ✗ return true;
1704 }
1705
1706 6 bool PlrStairImpl::setExpt(const std::string& expt) {
1707 6 return assign_if_valid<double>(expt, m_expt);
1708 }
1709
1710 ✗ double PlrStairImpl::Ht() const {
1711 ✗ return openstudio::string_conversions::to<double>(m_Ht);
1712 }
1713
1714 ✗ bool PlrStairImpl::setHt(const double Ht) {
1715 ✗ m_Ht = openstudio::string_conversions::number(Ht);
1716 ✗ return true;
1717 }
1718
1719 6 bool PlrStairImpl::setHt(const std::string& Ht) {
1720 6 return assign_if_valid<double>(Ht, m_Ht);
1721 }
1722
1723 ✗ double PlrStairImpl::area() const {
1724 ✗ return openstudio::string_conversions::to<double>(m_Area);
1725 }
1726
1727 ✗ bool PlrStairImpl::setArea(const double Area) {
1728 ✗ m_Area = openstudio::string_conversions::number(Area);
1729 ✗ return true;
1730 }
1731
1732 6 bool PlrStairImpl::setArea(const std::string& Area) {
1733 6 return assign_if_valid<double>(Area, m_Area);
1734 }
1735
1736 ✗ double PlrStairImpl::people() const {
1737 ✗ return openstudio::string_conversions::to<double>(m_peo);
1738 }
1739
1740 ✗ bool PlrStairImpl::setPeople(const double peo) {
1741 ✗ m_peo = openstudio::string_conversions::number(peo);
1742 ✗ return true;
1743 }
1744
1745 6 bool PlrStairImpl::setPeople(const std::string& peo) {
1746 6 return assign_if_valid<double>(peo, m_peo);
1747 }
1748
1749 ✗ int PlrStairImpl::tread() const {
1750 ✗ return m_tread;
1751 }
1752
1753 6 void PlrStairImpl::setTread(const int tread) {
1754 6 m_tread = tread;
1755 6 }
1756
1757 ✗ int PlrStairImpl::u_A() const {
1758 ✗ return m_u_A;
1759 }
1760
1761 6 void PlrStairImpl::setU_A(const int u_A) {
1762 6 m_u_A = u_A;
1763 6 }
1764
1765 ✗ int PlrStairImpl::u_D() const {
1766 ✗ return m_u_D;
1767 }
1768
1769 6 void PlrStairImpl::setU_D(const int u_D) {
1770 6 m_u_D = u_D;
1771 6 }
1772
1773 6 void PlrShaftImpl::setDefaults() {
1774 6 m_nr = 0;
1775 6 m_icon = 0;
1776
1/1
✓ Branch 1 taken 6 times.
12 m_lam = PRJFLOAT("0.0");
1777
1/1
✓ Branch 1 taken 6 times.
12 m_turb = PRJFLOAT("0.0");
1778
1/1
✓ Branch 1 taken 6 times.
12 m_expt = PRJFLOAT("0.0");
1779
1/1
✓ Branch 1 taken 6 times.
12 m_Ht = PRJFLOAT("0.0");
1780
1/1
✓ Branch 1 taken 6 times.
12 m_area = PRJFLOAT("0.0");
1781
1/1
✓ Branch 1 taken 6 times.
12 m_perim = PRJFLOAT("0.0");
1782
1/1
✓ Branch 1 taken 6 times.
6 m_rough = PRJFLOAT("0.0");
1783 6 m_u_A = 0;
1784 6 m_u_D = 0;
1785 6 m_u_P = 0;
1786 6 m_u_R = 0;
1787 6 }
1788
1789 ✗ PlrShaftImpl::PlrShaftImpl() {
1790 ✗ setDefaults();
1791 ✗ }
1792
1793 6 PlrShaftImpl::PlrShaftImpl(int nr, int icon, std::string name, std::string desc) {
1794
1/1
✓ Branch 1 taken 6 times.
6 setDefaults();
1795
1/1
✓ Branch 1 taken 6 times.
6 setNr(nr);
1796
1/1
✓ Branch 1 taken 6 times.
6 setIcon(icon);
1797
1/1
✓ Branch 1 taken 6 times.
6 setName(name);
1798
1/1
✓ Branch 1 taken 6 times.
6 setDesc(desc);
1799 6 }
1800
1801 ✗ PlrShaftImpl::PlrShaftImpl(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double Ht, double area,
1802 ✗ double perim, double rough, int u_A, int u_D, int u_P, int u_R) {
1803 ✗ setDefaults();
1804 ✗ setNr(nr);
1805 ✗ setIcon(icon);
1806 ✗ setName(name);
1807 ✗ setDesc(desc);
1808 ✗ setLam(lam);
1809 ✗ setTurb(turb);
1810 ✗ setExpt(expt);
1811 ✗ setHt(Ht);
1812 ✗ setArea(area);
1813 ✗ setPerim(perim);
1814 ✗ setRough(rough);
1815 ✗ setU_A(u_A);
1816 ✗ setU_D(u_D);
1817 ✗ setU_P(u_P);
1818 ✗ setU_R(u_R);
1819 ✗ }
1820
1821 ✗ PlrShaftImpl::PlrShaftImpl(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt,
1822 ✗ std::string Ht, std::string area, std::string perim, std::string rough, int u_A, int u_D, int u_P, int u_R) {
1823 ✗ setDefaults();
1824 ✗ setNr(nr);
1825 ✗ setIcon(icon);
1826 ✗ setName(name);
1827 ✗ setDesc(desc);
1828 ✗ setLam(lam);
1829 ✗ setTurb(turb);
1830 ✗ setExpt(expt);
1831 ✗ setHt(Ht);
1832 ✗ setArea(area);
1833 ✗ setPerim(perim);
1834 ✗ setRough(rough);
1835 ✗ setU_A(u_A);
1836 ✗ setU_D(u_D);
1837 ✗ setU_P(u_P);
1838 ✗ setU_R(u_R);
1839 ✗ }
1840
1841 ✗ void PlrShaftImpl::read(Reader& input) {
1842 ✗ setNr(input.read<int>());
1843 ✗ setIcon(input.read<int>());
1844 ✗ std::string dataType = input.readString(); // Should really check this
1845 ✗ setName(input.readString());
1846 ✗ setDesc(input.readLine());
1847 ✗ setLam(input.readNumber<std::string>());
1848 ✗ setTurb(input.readNumber<std::string>());
1849 ✗ setExpt(input.readNumber<std::string>());
1850 ✗ setHt(input.readNumber<std::string>());
1851 ✗ setArea(input.readNumber<std::string>());
1852 ✗ setPerim(input.readNumber<std::string>());
1853 ✗ setRough(input.readNumber<std::string>());
1854 ✗ setU_A(input.read<int>());
1855 ✗ setU_D(input.read<int>());
1856 ✗ setU_P(input.read<int>());
1857 ✗ setU_R(input.read<int>());
1858 ✗ }
1859
1860 1 std::string PlrShaftImpl::write() {
1861 1 std::string string;
1862
8/8
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
✓ Branch 16 taken 1 time.
✓ Branch 19 taken 1 time.
✓ Branch 22 taken 1 time.
1 string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + " plr_shaft " + m_name + '\n';
1863
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 string += m_desc + '\n';
1864
14/14
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
✓ Branch 16 taken 1 time.
✓ Branch 19 taken 1 time.
✓ Branch 22 taken 1 time.
✓ Branch 25 taken 1 time.
✓ Branch 28 taken 1 time.
✓ Branch 31 taken 1 time.
✓ Branch 34 taken 1 time.
✓ Branch 37 taken 1 time.
✓ Branch 40 taken 1 time.
2 string += ANY_TO_STR(m_lam) + ' ' + ANY_TO_STR(m_turb) + ' ' + ANY_TO_STR(m_expt) + ' ' + ANY_TO_STR(m_Ht) + ' ' + ANY_TO_STR(m_area) + ' '
1865
15/15
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
✓ Branch 16 taken 1 time.
✓ Branch 19 taken 1 time.
✓ Branch 22 taken 1 time.
✓ Branch 25 taken 1 time.
✓ Branch 28 taken 1 time.
✓ Branch 31 taken 1 time.
✓ Branch 34 taken 1 time.
✓ Branch 37 taken 1 time.
✓ Branch 40 taken 1 time.
✓ Branch 43 taken 1 time.
4 + ANY_TO_STR(m_perim) + ' ' + ANY_TO_STR(m_rough) + ' ' + ANY_TO_STR(m_u_A) + ' ' + ANY_TO_STR(m_u_D) + ' ' + ANY_TO_STR(m_u_P) + ' '
1866
4/4
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
3 + ANY_TO_STR(m_u_R) + '\n';
1867 1 return string;
1868 ✗ }
1869
1870 6 void PlrShaftImpl::readDetails(Reader& input) {
1871
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setLam(input.readNumber<std::string>());
1872
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setTurb(input.readNumber<std::string>());
1873
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setExpt(input.readNumber<std::string>());
1874
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setHt(input.readNumber<std::string>());
1875
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setArea(input.readNumber<std::string>());
1876
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setPerim(input.readNumber<std::string>());
1877
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setRough(input.readNumber<std::string>());
1878 6 setU_A(input.read<int>());
1879 6 setU_D(input.read<int>());
1880 6 setU_P(input.read<int>());
1881 6 setU_R(input.read<int>());
1882 6 }
1883
1884 ✗ int PlrShaftImpl::nr() const {
1885 ✗ return m_nr;
1886 }
1887
1888 6 void PlrShaftImpl::setNr(const int nr) {
1889 6 m_nr = nr;
1890 6 }
1891
1892 ✗ int PlrShaftImpl::icon() const {
1893 ✗ return m_icon;
1894 }
1895
1896 6 void PlrShaftImpl::setIcon(const int icon) {
1897 6 m_icon = icon;
1898 6 }
1899
1900 24 std::string PlrShaftImpl::name() const {
1901 24 return m_name;
1902 }
1903
1904 6 void PlrShaftImpl::setName(const std::string& name) {
1905 6 m_name = name;
1906 6 }
1907
1908 ✗ std::string PlrShaftImpl::desc() const {
1909 ✗ return m_desc;
1910 }
1911
1912 6 void PlrShaftImpl::setDesc(const std::string& desc) {
1913 6 m_desc = desc;
1914 6 }
1915
1916 ✗ double PlrShaftImpl::lam() const {
1917 ✗ return openstudio::string_conversions::to<double>(m_lam);
1918 }
1919
1920 ✗ bool PlrShaftImpl::setLam(const double lam) {
1921 ✗ m_lam = openstudio::string_conversions::number(lam);
1922 ✗ return true;
1923 }
1924
1925 6 bool PlrShaftImpl::setLam(const std::string& lam) {
1926 6 return assign_if_valid<double>(lam, m_lam);
1927 }
1928
1929 ✗ double PlrShaftImpl::turb() const {
1930 ✗ return openstudio::string_conversions::to<double>(m_turb);
1931 }
1932
1933 ✗ bool PlrShaftImpl::setTurb(const double turb) {
1934 ✗ m_turb = openstudio::string_conversions::number(turb);
1935 ✗ return true;
1936 }
1937
1938 6 bool PlrShaftImpl::setTurb(const std::string& turb) {
1939 6 return assign_if_valid<double>(turb, m_turb);
1940 }
1941
1942 ✗ double PlrShaftImpl::expt() const {
1943 ✗ return openstudio::string_conversions::to<double>(m_expt);
1944 }
1945
1946 ✗ bool PlrShaftImpl::setExpt(const double expt) {
1947 ✗ m_expt = openstudio::string_conversions::number(expt);
1948 ✗ return true;
1949 }
1950
1951 6 bool PlrShaftImpl::setExpt(const std::string& expt) {
1952 6 return assign_if_valid<double>(expt, m_expt);
1953 }
1954
1955 ✗ double PlrShaftImpl::Ht() const {
1956 ✗ return openstudio::string_conversions::to<double>(m_Ht);
1957 }
1958
1959 ✗ bool PlrShaftImpl::setHt(const double Ht) {
1960 ✗ m_Ht = openstudio::string_conversions::number(Ht);
1961 ✗ return true;
1962 }
1963
1964 6 bool PlrShaftImpl::setHt(const std::string& Ht) {
1965 6 return assign_if_valid<double>(Ht, m_Ht);
1966 }
1967
1968 ✗ double PlrShaftImpl::area() const {
1969 ✗ return openstudio::string_conversions::to<double>(m_area);
1970 }
1971
1972 ✗ bool PlrShaftImpl::setArea(const double area) {
1973 ✗ m_area = openstudio::string_conversions::number(area);
1974 ✗ return true;
1975 }
1976
1977 6 bool PlrShaftImpl::setArea(const std::string& area) {
1978 6 return assign_if_valid<double>(area, m_area);
1979 }
1980
1981 ✗ double PlrShaftImpl::perim() const {
1982 ✗ return openstudio::string_conversions::to<double>(m_perim);
1983 }
1984
1985 ✗ bool PlrShaftImpl::setPerim(const double perim) {
1986 ✗ m_perim = openstudio::string_conversions::number(perim);
1987 ✗ return true;
1988 }
1989
1990 6 bool PlrShaftImpl::setPerim(const std::string& perim) {
1991 6 return assign_if_valid<double>(perim, m_perim);
1992 }
1993
1994 ✗ double PlrShaftImpl::rough() const {
1995 ✗ return openstudio::string_conversions::to<double>(m_rough);
1996 }
1997
1998 ✗ bool PlrShaftImpl::setRough(const double rough) {
1999 ✗ m_rough = openstudio::string_conversions::number(rough);
2000 ✗ return true;
2001 }
2002
2003 6 bool PlrShaftImpl::setRough(const std::string& rough) {
2004 6 return assign_if_valid<double>(rough, m_rough);
2005 }
2006
2007 ✗ int PlrShaftImpl::u_A() const {
2008 ✗ return m_u_A;
2009 }
2010
2011 6 void PlrShaftImpl::setU_A(const int u_A) {
2012 6 m_u_A = u_A;
2013 6 }
2014
2015 ✗ int PlrShaftImpl::u_D() const {
2016 ✗ return m_u_D;
2017 }
2018
2019 6 void PlrShaftImpl::setU_D(const int u_D) {
2020 6 m_u_D = u_D;
2021 6 }
2022
2023 ✗ int PlrShaftImpl::u_P() const {
2024 ✗ return m_u_P;
2025 }
2026
2027 6 void PlrShaftImpl::setU_P(const int u_P) {
2028 6 m_u_P = u_P;
2029 6 }
2030
2031 ✗ int PlrShaftImpl::u_R() const {
2032 ✗ return m_u_R;
2033 }
2034
2035 6 void PlrShaftImpl::setU_R(const int u_R) {
2036 6 m_u_R = u_R;
2037 6 }
2038
2039 ✗ void PlrBackDamperImpl::setDefaults() {
2040 ✗ m_nr = 0;
2041 ✗ m_icon = 0;
2042 ✗ m_lam = PRJFLOAT("0.0");
2043 ✗ m_Cp = PRJFLOAT("0.0");
2044 ✗ m_xp = PRJFLOAT("0.0");
2045 ✗ m_Cn = PRJFLOAT("0.0");
2046 ✗ m_xn = PRJFLOAT("0.0");
2047 ✗ }
2048
2049 ✗ PlrBackDamperImpl::PlrBackDamperImpl() {
2050 ✗ setDefaults();
2051 ✗ }
2052
2053 ✗ PlrBackDamperImpl::PlrBackDamperImpl(int nr, int icon, std::string name, std::string desc) {
2054 ✗ setDefaults();
2055 ✗ setNr(nr);
2056 ✗ setIcon(icon);
2057 ✗ setName(name);
2058 ✗ setDesc(desc);
2059 ✗ }
2060
2061 ✗ PlrBackDamperImpl::PlrBackDamperImpl(int nr, int icon, std::string name, std::string desc, double lam, double Cp, double xp, double Cn,
2062 ✗ double xn) {
2063 ✗ setDefaults();
2064 ✗ setNr(nr);
2065 ✗ setIcon(icon);
2066 ✗ setName(name);
2067 ✗ setDesc(desc);
2068 ✗ setLam(lam);
2069 ✗ setCp(Cp);
2070 ✗ setXp(xp);
2071 ✗ setCn(Cn);
2072 ✗ setXn(xn);
2073 ✗ }
2074
2075 ✗ PlrBackDamperImpl::PlrBackDamperImpl(int nr, int icon, std::string name, std::string desc, std::string lam, std::string Cp, std::string xp,
2076 ✗ std::string Cn, std::string xn) {
2077 ✗ setDefaults();
2078 ✗ setNr(nr);
2079 ✗ setIcon(icon);
2080 ✗ setName(name);
2081 ✗ setDesc(desc);
2082 ✗ setLam(lam);
2083 ✗ setCp(Cp);
2084 ✗ setXp(xp);
2085 ✗ setCn(Cn);
2086 ✗ setXn(xn);
2087 ✗ }
2088
2089 ✗ void PlrBackDamperImpl::read(Reader& input) {
2090 ✗ setNr(input.read<int>());
2091 ✗ setIcon(input.read<int>());
2092 ✗ std::string dataType = input.readString(); // Should really check this
2093 ✗ setName(input.readString());
2094 ✗ setDesc(input.readLine());
2095 ✗ setLam(input.readNumber<std::string>());
2096 ✗ setCp(input.readNumber<std::string>());
2097 ✗ setXp(input.readNumber<std::string>());
2098 ✗ setCn(input.readNumber<std::string>());
2099 ✗ setXn(input.readNumber<std::string>());
2100 ✗ }
2101
2102 ✗ std::string PlrBackDamperImpl::write(std::string dataType) {
2103 ✗ std::string string;
2104 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + ' ' + dataType + ' ' + m_name + '\n';
2105 ✗ string += m_desc + '\n';
2106 ✗ string += ANY_TO_STR(m_lam) + ' ' + ANY_TO_STR(m_Cp) + ' ' + ANY_TO_STR(m_xp) + ' ' + ANY_TO_STR(m_Cn) + ' ' + ANY_TO_STR(m_xn) + '\n';
2107 ✗ return string;
2108 ✗ }
2109
2110 ✗ void PlrBackDamperImpl::readDetails(Reader& input) {
2111 ✗ setLam(input.readNumber<std::string>());
2112 ✗ setCp(input.readNumber<std::string>());
2113 ✗ setXp(input.readNumber<std::string>());
2114 ✗ setCn(input.readNumber<std::string>());
2115 ✗ setXn(input.readNumber<std::string>());
2116 ✗ }
2117
2118 ✗ int PlrBackDamperImpl::nr() const {
2119 ✗ return m_nr;
2120 }
2121
2122 ✗ void PlrBackDamperImpl::setNr(const int nr) {
2123 ✗ m_nr = nr;
2124 ✗ }
2125
2126 ✗ int PlrBackDamperImpl::icon() const {
2127 ✗ return m_icon;
2128 }
2129
2130 ✗ void PlrBackDamperImpl::setIcon(const int icon) {
2131 ✗ m_icon = icon;
2132 ✗ }
2133
2134 ✗ std::string PlrBackDamperImpl::name() const {
2135 ✗ return m_name;
2136 }
2137
2138 ✗ void PlrBackDamperImpl::setName(const std::string& name) {
2139 ✗ m_name = name;
2140 ✗ }
2141
2142 ✗ std::string PlrBackDamperImpl::desc() const {
2143 ✗ return m_desc;
2144 }
2145
2146 ✗ void PlrBackDamperImpl::setDesc(const std::string& desc) {
2147 ✗ m_desc = desc;
2148 ✗ }
2149
2150 ✗ double PlrBackDamperImpl::lam() const {
2151 ✗ return openstudio::string_conversions::to<double>(m_lam);
2152 }
2153
2154 ✗ bool PlrBackDamperImpl::setLam(const double lam) {
2155 ✗ m_lam = openstudio::string_conversions::number(lam);
2156 ✗ return true;
2157 }
2158
2159 ✗ bool PlrBackDamperImpl::setLam(const std::string& lam) {
2160 ✗ return assign_if_valid<double>(lam, m_lam);
2161 }
2162
2163 ✗ double PlrBackDamperImpl::Cp() const {
2164 ✗ return openstudio::string_conversions::to<double>(m_Cp);
2165 }
2166
2167 ✗ bool PlrBackDamperImpl::setCp(const double Cp) {
2168 ✗ m_Cp = openstudio::string_conversions::number(Cp);
2169 ✗ return true;
2170 }
2171
2172 ✗ bool PlrBackDamperImpl::setCp(const std::string& Cp) {
2173 ✗ return assign_if_valid<double>(Cp, m_Cp);
2174 }
2175
2176 ✗ double PlrBackDamperImpl::xp() const {
2177 ✗ return openstudio::string_conversions::to<double>(m_xp);
2178 }
2179
2180 ✗ bool PlrBackDamperImpl::setXp(const double xp) {
2181 ✗ m_xp = openstudio::string_conversions::number(xp);
2182 ✗ return true;
2183 }
2184
2185 ✗ bool PlrBackDamperImpl::setXp(const std::string& xp) {
2186 ✗ return assign_if_valid<double>(xp, m_xp);
2187 }
2188
2189 ✗ double PlrBackDamperImpl::Cn() const {
2190 ✗ return openstudio::string_conversions::to<double>(m_Cn);
2191 }
2192
2193 ✗ bool PlrBackDamperImpl::setCn(const double Cn) {
2194 ✗ m_Cn = openstudio::string_conversions::number(Cn);
2195 ✗ return true;
2196 }
2197
2198 ✗ bool PlrBackDamperImpl::setCn(const std::string& Cn) {
2199 ✗ return assign_if_valid<double>(Cn, m_Cn);
2200 }
2201
2202 ✗ double PlrBackDamperImpl::xn() const {
2203 ✗ return openstudio::string_conversions::to<double>(m_xn);
2204 }
2205
2206 ✗ bool PlrBackDamperImpl::setXn(const double xn) {
2207 ✗ m_xn = openstudio::string_conversions::number(xn);
2208 ✗ return true;
2209 }
2210
2211 ✗ bool PlrBackDamperImpl::setXn(const std::string& xn) {
2212 ✗ return assign_if_valid<double>(xn, m_xn);
2213 }
2214
2215 ✗ void QfrQuadraticImpl::setDefaults() {
2216 ✗ m_nr = 0;
2217 ✗ m_icon = 0;
2218 ✗ m_a = PRJFLOAT("0.0");
2219 ✗ m_b = PRJFLOAT("0.0");
2220 ✗ }
2221
2222 ✗ QfrQuadraticImpl::QfrQuadraticImpl() {
2223 ✗ setDefaults();
2224 ✗ }
2225
2226 ✗ QfrQuadraticImpl::QfrQuadraticImpl(int nr, int icon, std::string name, std::string desc) {
2227 ✗ setDefaults();
2228 ✗ setNr(nr);
2229 ✗ setIcon(icon);
2230 ✗ setName(name);
2231 ✗ setDesc(desc);
2232 ✗ }
2233
2234 ✗ QfrQuadraticImpl::QfrQuadraticImpl(int nr, int icon, std::string name, std::string desc, double a, double b) {
2235 ✗ setDefaults();
2236 ✗ setNr(nr);
2237 ✗ setIcon(icon);
2238 ✗ setName(name);
2239 ✗ setDesc(desc);
2240 ✗ setA(a);
2241 ✗ setB(b);
2242 ✗ }
2243
2244 ✗ QfrQuadraticImpl::QfrQuadraticImpl(int nr, int icon, std::string name, std::string desc, std::string a, std::string b) {
2245 ✗ setDefaults();
2246 ✗ setNr(nr);
2247 ✗ setIcon(icon);
2248 ✗ setName(name);
2249 ✗ setDesc(desc);
2250 ✗ setA(a);
2251 ✗ setB(b);
2252 ✗ }
2253
2254 ✗ void QfrQuadraticImpl::read(Reader& input) {
2255 ✗ setNr(input.read<int>());
2256 ✗ setIcon(input.read<int>());
2257 ✗ std::string dataType = input.readString(); // Should really check this
2258 ✗ setName(input.readString());
2259 ✗ setDesc(input.readLine());
2260 ✗ setA(input.readNumber<std::string>());
2261 ✗ setB(input.readNumber<std::string>());
2262 ✗ }
2263
2264 ✗ std::string QfrQuadraticImpl::write(std::string dataType) {
2265 ✗ std::string string;
2266 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + ' ' + dataType + ' ' + m_name + '\n';
2267 ✗ string += m_desc + '\n';
2268 ✗ string += ANY_TO_STR(m_a) + ' ' + ANY_TO_STR(m_b) + '\n';
2269 ✗ return string;
2270 ✗ }
2271
2272 ✗ void QfrQuadraticImpl::readDetails(Reader& input) {
2273 ✗ setA(input.readNumber<std::string>());
2274 ✗ setB(input.readNumber<std::string>());
2275 ✗ }
2276
2277 ✗ int QfrQuadraticImpl::nr() const {
2278 ✗ return m_nr;
2279 }
2280
2281 ✗ void QfrQuadraticImpl::setNr(const int nr) {
2282 ✗ m_nr = nr;
2283 ✗ }
2284
2285 ✗ int QfrQuadraticImpl::icon() const {
2286 ✗ return m_icon;
2287 }
2288
2289 ✗ void QfrQuadraticImpl::setIcon(const int icon) {
2290 ✗ m_icon = icon;
2291 ✗ }
2292
2293 ✗ std::string QfrQuadraticImpl::name() const {
2294 ✗ return m_name;
2295 }
2296
2297 ✗ void QfrQuadraticImpl::setName(const std::string& name) {
2298 ✗ m_name = name;
2299 ✗ }
2300
2301 ✗ std::string QfrQuadraticImpl::desc() const {
2302 ✗ return m_desc;
2303 }
2304
2305 ✗ void QfrQuadraticImpl::setDesc(const std::string& desc) {
2306 ✗ m_desc = desc;
2307 ✗ }
2308
2309 ✗ double QfrQuadraticImpl::a() const {
2310 ✗ return openstudio::string_conversions::to<double>(m_a);
2311 }
2312
2313 ✗ bool QfrQuadraticImpl::setA(const double a) {
2314 ✗ m_a = openstudio::string_conversions::number(a);
2315 ✗ return true;
2316 }
2317
2318 ✗ bool QfrQuadraticImpl::setA(const std::string& a) {
2319 ✗ return assign_if_valid<double>(a, m_a);
2320 }
2321
2322 ✗ double QfrQuadraticImpl::b() const {
2323 ✗ return openstudio::string_conversions::to<double>(m_b);
2324 }
2325
2326 ✗ bool QfrQuadraticImpl::setB(const double b) {
2327 ✗ m_b = openstudio::string_conversions::number(b);
2328 ✗ return true;
2329 }
2330
2331 ✗ bool QfrQuadraticImpl::setB(const std::string& b) {
2332 ✗ return assign_if_valid<double>(b, m_b);
2333 }
2334
2335 ✗ void QfrCrackImpl::setDefaults() {
2336 ✗ m_nr = 0;
2337 ✗ m_icon = 0;
2338 ✗ m_a = PRJFLOAT("0.0");
2339 ✗ m_b = PRJFLOAT("0.0");
2340 ✗ m_length = PRJFLOAT("0.0");
2341 ✗ m_width = PRJFLOAT("0.0");
2342 ✗ m_depth = PRJFLOAT("0.0");
2343 ✗ m_nB = 0;
2344 ✗ m_u_L = 0;
2345 ✗ m_u_W = 0;
2346 ✗ m_u_D = 0;
2347 ✗ }
2348
2349 ✗ QfrCrackImpl::QfrCrackImpl() {
2350 ✗ setDefaults();
2351 ✗ }
2352
2353 ✗ QfrCrackImpl::QfrCrackImpl(int nr, int icon, std::string name, std::string desc) {
2354 ✗ setDefaults();
2355 ✗ setNr(nr);
2356 ✗ setIcon(icon);
2357 ✗ setName(name);
2358 ✗ setDesc(desc);
2359 ✗ }
2360
2361 ✗ QfrCrackImpl::QfrCrackImpl(int nr, int icon, std::string name, std::string desc, double a, double b, double length, double width, double depth,
2362 ✗ int nB, int u_L, int u_W, int u_D) {
2363 ✗ setDefaults();
2364 ✗ setNr(nr);
2365 ✗ setIcon(icon);
2366 ✗ setName(name);
2367 ✗ setDesc(desc);
2368 ✗ setA(a);
2369 ✗ setB(b);
2370 ✗ setLength(length);
2371 ✗ setWidth(width);
2372 ✗ setDepth(depth);
2373 ✗ setNB(nB);
2374 ✗ setU_L(u_L);
2375 ✗ setU_W(u_W);
2376 ✗ setU_D(u_D);
2377 ✗ }
2378
2379 ✗ QfrCrackImpl::QfrCrackImpl(int nr, int icon, std::string name, std::string desc, std::string a, std::string b, std::string length,
2380 ✗ std::string width, std::string depth, int nB, int u_L, int u_W, int u_D) {
2381 ✗ setDefaults();
2382 ✗ setNr(nr);
2383 ✗ setIcon(icon);
2384 ✗ setName(name);
2385 ✗ setDesc(desc);
2386 ✗ setA(a);
2387 ✗ setB(b);
2388 ✗ setLength(length);
2389 ✗ setWidth(width);
2390 ✗ setDepth(depth);
2391 ✗ setNB(nB);
2392 ✗ setU_L(u_L);
2393 ✗ setU_W(u_W);
2394 ✗ setU_D(u_D);
2395 ✗ }
2396
2397 ✗ void QfrCrackImpl::read(Reader& input) {
2398 ✗ setNr(input.read<int>());
2399 ✗ setIcon(input.read<int>());
2400 ✗ std::string dataType = input.readString(); // Should really check this
2401 ✗ setName(input.readString());
2402 ✗ setDesc(input.readLine());
2403 ✗ setA(input.readNumber<std::string>());
2404 ✗ setB(input.readNumber<std::string>());
2405 ✗ setLength(input.readNumber<std::string>());
2406 ✗ setWidth(input.readNumber<std::string>());
2407 ✗ setDepth(input.readNumber<std::string>());
2408 ✗ setNB(input.read<int>());
2409 ✗ setU_L(input.read<int>());
2410 ✗ setU_W(input.read<int>());
2411 ✗ setU_D(input.read<int>());
2412 ✗ }
2413
2414 ✗ std::string QfrCrackImpl::write() {
2415 ✗ std::string string;
2416 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + " qfr_crack " + m_name + '\n';
2417 ✗ string += m_desc + '\n';
2418 ✗ string += ANY_TO_STR(m_a) + ' ' + ANY_TO_STR(m_b) + ' ' + ANY_TO_STR(m_length) + ' ' + ANY_TO_STR(m_width) + ' ' + ANY_TO_STR(m_depth) + ' '
2419 ✗ + ANY_TO_STR(m_nB) + ' ' + ANY_TO_STR(m_u_L) + ' ' + ANY_TO_STR(m_u_W) + ' ' + ANY_TO_STR(m_u_D) + '\n';
2420 ✗ return string;
2421 ✗ }
2422
2423 ✗ void QfrCrackImpl::readDetails(Reader& input) {
2424 ✗ setA(input.readNumber<std::string>());
2425 ✗ setB(input.readNumber<std::string>());
2426 ✗ setLength(input.readNumber<std::string>());
2427 ✗ setWidth(input.readNumber<std::string>());
2428 ✗ setDepth(input.readNumber<std::string>());
2429 ✗ setNB(input.read<int>());
2430 ✗ setU_L(input.read<int>());
2431 ✗ setU_W(input.read<int>());
2432 ✗ setU_D(input.read<int>());
2433 ✗ }
2434
2435 ✗ int QfrCrackImpl::nr() const {
2436 ✗ return m_nr;
2437 }
2438
2439 ✗ void QfrCrackImpl::setNr(const int nr) {
2440 ✗ m_nr = nr;
2441 ✗ }
2442
2443 ✗ int QfrCrackImpl::icon() const {
2444 ✗ return m_icon;
2445 }
2446
2447 ✗ void QfrCrackImpl::setIcon(const int icon) {
2448 ✗ m_icon = icon;
2449 ✗ }
2450
2451 ✗ std::string QfrCrackImpl::name() const {
2452 ✗ return m_name;
2453 }
2454
2455 ✗ void QfrCrackImpl::setName(const std::string& name) {
2456 ✗ m_name = name;
2457 ✗ }
2458
2459 ✗ std::string QfrCrackImpl::desc() const {
2460 ✗ return m_desc;
2461 }
2462
2463 ✗ void QfrCrackImpl::setDesc(const std::string& desc) {
2464 ✗ m_desc = desc;
2465 ✗ }
2466
2467 ✗ double QfrCrackImpl::a() const {
2468 ✗ return openstudio::string_conversions::to<double>(m_a);
2469 }
2470
2471 ✗ bool QfrCrackImpl::setA(const double a) {
2472 ✗ m_a = openstudio::string_conversions::number(a);
2473 ✗ return true;
2474 }
2475
2476 ✗ bool QfrCrackImpl::setA(const std::string& a) {
2477 ✗ return assign_if_valid<double>(a, m_a);
2478 }
2479
2480 ✗ double QfrCrackImpl::b() const {
2481 ✗ return openstudio::string_conversions::to<double>(m_b);
2482 }
2483
2484 ✗ bool QfrCrackImpl::setB(const double b) {
2485 ✗ m_b = openstudio::string_conversions::number(b);
2486 ✗ return true;
2487 }
2488
2489 ✗ bool QfrCrackImpl::setB(const std::string& b) {
2490 ✗ return assign_if_valid<double>(b, m_b);
2491 }
2492
2493 ✗ double QfrCrackImpl::length() const {
2494 ✗ return openstudio::string_conversions::to<double>(m_length);
2495 }
2496
2497 ✗ bool QfrCrackImpl::setLength(const double length) {
2498 ✗ m_length = openstudio::string_conversions::number(length);
2499 ✗ return true;
2500 }
2501
2502 ✗ bool QfrCrackImpl::setLength(const std::string& length) {
2503 ✗ return assign_if_valid<double>(length, m_length);
2504 }
2505
2506 ✗ double QfrCrackImpl::width() const {
2507 ✗ return openstudio::string_conversions::to<double>(m_width);
2508 }
2509
2510 ✗ bool QfrCrackImpl::setWidth(const double width) {
2511 ✗ m_width = openstudio::string_conversions::number(width);
2512 ✗ return true;
2513 }
2514
2515 ✗ bool QfrCrackImpl::setWidth(const std::string& width) {
2516 ✗ return assign_if_valid<double>(width, m_width);
2517 }
2518
2519 ✗ double QfrCrackImpl::depth() const {
2520 ✗ return openstudio::string_conversions::to<double>(m_depth);
2521 }
2522
2523 ✗ bool QfrCrackImpl::setDepth(const double depth) {
2524 ✗ m_depth = openstudio::string_conversions::number(depth);
2525 ✗ return true;
2526 }
2527
2528 ✗ bool QfrCrackImpl::setDepth(const std::string& depth) {
2529 ✗ return assign_if_valid<double>(depth, m_depth);
2530 }
2531
2532 ✗ int QfrCrackImpl::nB() const {
2533 ✗ return m_nB;
2534 }
2535
2536 ✗ void QfrCrackImpl::setNB(const int nB) {
2537 ✗ m_nB = nB;
2538 ✗ }
2539
2540 ✗ int QfrCrackImpl::u_L() const {
2541 ✗ return m_u_L;
2542 }
2543
2544 ✗ void QfrCrackImpl::setU_L(const int u_L) {
2545 ✗ m_u_L = u_L;
2546 ✗ }
2547
2548 ✗ int QfrCrackImpl::u_W() const {
2549 ✗ return m_u_W;
2550 }
2551
2552 ✗ void QfrCrackImpl::setU_W(const int u_W) {
2553 ✗ m_u_W = u_W;
2554 ✗ }
2555
2556 ✗ int QfrCrackImpl::u_D() const {
2557 ✗ return m_u_D;
2558 }
2559
2560 ✗ void QfrCrackImpl::setU_D(const int u_D) {
2561 ✗ m_u_D = u_D;
2562 ✗ }
2563
2564 ✗ void QfrTest2Impl::setDefaults() {
2565 ✗ m_nr = 0;
2566 ✗ m_icon = 0;
2567 ✗ m_a = PRJFLOAT("0.0");
2568 ✗ m_b = PRJFLOAT("0.0");
2569 ✗ m_dP1 = PRJFLOAT("0.0");
2570 ✗ m_F1 = PRJFLOAT("0.0");
2571 ✗ m_dP2 = PRJFLOAT("0.0");
2572 ✗ m_F2 = PRJFLOAT("0.0");
2573 ✗ m_u_P1 = 0;
2574 ✗ m_u_F1 = 0;
2575 ✗ m_u_P2 = 0;
2576 ✗ m_u_F2 = 0;
2577 ✗ }
2578
2579 ✗ QfrTest2Impl::QfrTest2Impl() {
2580 ✗ setDefaults();
2581 ✗ }
2582
2583 ✗ QfrTest2Impl::QfrTest2Impl(int nr, int icon, std::string name, std::string desc) {
2584 ✗ setDefaults();
2585 ✗ setNr(nr);
2586 ✗ setIcon(icon);
2587 ✗ setName(name);
2588 ✗ setDesc(desc);
2589 ✗ }
2590
2591 ✗ QfrTest2Impl::QfrTest2Impl(int nr, int icon, std::string name, std::string desc, double a, double b, double dP1, double F1, double dP2, double F2,
2592 ✗ int u_P1, int u_F1, int u_P2, int u_F2) {
2593 ✗ setDefaults();
2594 ✗ setNr(nr);
2595 ✗ setIcon(icon);
2596 ✗ setName(name);
2597 ✗ setDesc(desc);
2598 ✗ setA(a);
2599 ✗ setB(b);
2600 ✗ setDP1(dP1);
2601 ✗ setF1(F1);
2602 ✗ setDP2(dP2);
2603 ✗ setF2(F2);
2604 ✗ setU_P1(u_P1);
2605 ✗ setU_F1(u_F1);
2606 ✗ setU_P2(u_P2);
2607 ✗ setU_F2(u_F2);
2608 ✗ }
2609
2610 ✗ QfrTest2Impl::QfrTest2Impl(int nr, int icon, std::string name, std::string desc, std::string a, std::string b, std::string dP1, std::string F1,
2611 ✗ std::string dP2, std::string F2, int u_P1, int u_F1, int u_P2, int u_F2) {
2612 ✗ setDefaults();
2613 ✗ setNr(nr);
2614 ✗ setIcon(icon);
2615 ✗ setName(name);
2616 ✗ setDesc(desc);
2617 ✗ setA(a);
2618 ✗ setB(b);
2619 ✗ setDP1(dP1);
2620 ✗ setF1(F1);
2621 ✗ setDP2(dP2);
2622 ✗ setF2(F2);
2623 ✗ setU_P1(u_P1);
2624 ✗ setU_F1(u_F1);
2625 ✗ setU_P2(u_P2);
2626 ✗ setU_F2(u_F2);
2627 ✗ }
2628
2629 ✗ void QfrTest2Impl::read(Reader& input) {
2630 ✗ setNr(input.read<int>());
2631 ✗ setIcon(input.read<int>());
2632 ✗ std::string dataType = input.readString(); // Should really check this
2633 ✗ setName(input.readString());
2634 ✗ setDesc(input.readLine());
2635 ✗ setA(input.readNumber<std::string>());
2636 ✗ setB(input.readNumber<std::string>());
2637 ✗ setDP1(input.readNumber<std::string>());
2638 ✗ setF1(input.readNumber<std::string>());
2639 ✗ setDP2(input.readNumber<std::string>());
2640 ✗ setF2(input.readNumber<std::string>());
2641 ✗ setU_P1(input.read<int>());
2642 ✗ setU_F1(input.read<int>());
2643 ✗ setU_P2(input.read<int>());
2644 ✗ setU_F2(input.read<int>());
2645 ✗ }
2646
2647 ✗ std::string QfrTest2Impl::write() {
2648 ✗ std::string string;
2649 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + " qfr_test2 " + m_name + '\n';
2650 ✗ string += m_desc + '\n';
2651 ✗ string += ANY_TO_STR(m_a) + ' ' + ANY_TO_STR(m_b) + ' ' + ANY_TO_STR(m_dP1) + ' ' + ANY_TO_STR(m_F1) + ' ' + ANY_TO_STR(m_dP2) + ' '
2652 ✗ + ANY_TO_STR(m_F2) + ' ' + ANY_TO_STR(m_u_P1) + ' ' + ANY_TO_STR(m_u_F1) + ' ' + ANY_TO_STR(m_u_P2) + ' ' + ANY_TO_STR(m_u_F2) + '\n';
2653 ✗ return string;
2654 ✗ }
2655
2656 ✗ void QfrTest2Impl::readDetails(Reader& input) {
2657 ✗ setA(input.readNumber<std::string>());
2658 ✗ setB(input.readNumber<std::string>());
2659 ✗ setDP1(input.readNumber<std::string>());
2660 ✗ setF1(input.readNumber<std::string>());
2661 ✗ setDP2(input.readNumber<std::string>());
2662 ✗ setF2(input.readNumber<std::string>());
2663 ✗ setU_P1(input.read<int>());
2664 ✗ setU_F1(input.read<int>());
2665 ✗ setU_P2(input.read<int>());
2666 ✗ setU_F2(input.read<int>());
2667 ✗ }
2668
2669 ✗ int QfrTest2Impl::nr() const {
2670 ✗ return m_nr;
2671 }
2672
2673 ✗ void QfrTest2Impl::setNr(const int nr) {
2674 ✗ m_nr = nr;
2675 ✗ }
2676
2677 ✗ int QfrTest2Impl::icon() const {
2678 ✗ return m_icon;
2679 }
2680
2681 ✗ void QfrTest2Impl::setIcon(const int icon) {
2682 ✗ m_icon = icon;
2683 ✗ }
2684
2685 ✗ std::string QfrTest2Impl::name() const {
2686 ✗ return m_name;
2687 }
2688
2689 ✗ void QfrTest2Impl::setName(const std::string& name) {
2690 ✗ m_name = name;
2691 ✗ }
2692
2693 ✗ std::string QfrTest2Impl::desc() const {
2694 ✗ return m_desc;
2695 }
2696
2697 ✗ void QfrTest2Impl::setDesc(const std::string& desc) {
2698 ✗ m_desc = desc;
2699 ✗ }
2700
2701 ✗ double QfrTest2Impl::a() const {
2702 ✗ return openstudio::string_conversions::to<double>(m_a);
2703 }
2704
2705 ✗ bool QfrTest2Impl::setA(const double a) {
2706 ✗ m_a = openstudio::string_conversions::number(a);
2707 ✗ return true;
2708 }
2709
2710 ✗ bool QfrTest2Impl::setA(const std::string& a) {
2711 ✗ return assign_if_valid<double>(a, m_a);
2712 }
2713
2714 ✗ double QfrTest2Impl::b() const {
2715 ✗ return openstudio::string_conversions::to<double>(m_b);
2716 }
2717
2718 ✗ bool QfrTest2Impl::setB(const double b) {
2719 ✗ m_b = openstudio::string_conversions::number(b);
2720 ✗ return true;
2721 }
2722
2723 ✗ bool QfrTest2Impl::setB(const std::string& b) {
2724 ✗ return assign_if_valid<double>(b, m_b);
2725 }
2726
2727 ✗ double QfrTest2Impl::dP1() const {
2728 ✗ return openstudio::string_conversions::to<double>(m_dP1);
2729 }
2730
2731 ✗ bool QfrTest2Impl::setDP1(const double dP1) {
2732 ✗ m_dP1 = openstudio::string_conversions::number(dP1);
2733 ✗ return true;
2734 }
2735
2736 ✗ bool QfrTest2Impl::setDP1(const std::string& dP1) {
2737 ✗ return assign_if_valid<double>(dP1, m_dP1);
2738 }
2739
2740 ✗ double QfrTest2Impl::F1() const {
2741 ✗ return openstudio::string_conversions::to<double>(m_F1);
2742 }
2743
2744 ✗ bool QfrTest2Impl::setF1(const double F1) {
2745 ✗ m_F1 = openstudio::string_conversions::number(F1);
2746 ✗ return true;
2747 }
2748
2749 ✗ bool QfrTest2Impl::setF1(const std::string& F1) {
2750 ✗ return assign_if_valid<double>(F1, m_F1);
2751 }
2752
2753 ✗ double QfrTest2Impl::dP2() const {
2754 ✗ return openstudio::string_conversions::to<double>(m_dP2);
2755 }
2756
2757 ✗ bool QfrTest2Impl::setDP2(const double dP2) {
2758 ✗ m_dP2 = openstudio::string_conversions::number(dP2);
2759 ✗ return true;
2760 }
2761
2762 ✗ bool QfrTest2Impl::setDP2(const std::string& dP2) {
2763 ✗ return assign_if_valid<double>(dP2, m_dP2);
2764 }
2765
2766 ✗ double QfrTest2Impl::F2() const {
2767 ✗ return openstudio::string_conversions::to<double>(m_F2);
2768 }
2769
2770 ✗ bool QfrTest2Impl::setF2(const double F2) {
2771 ✗ m_F2 = openstudio::string_conversions::number(F2);
2772 ✗ return true;
2773 }
2774
2775 ✗ bool QfrTest2Impl::setF2(const std::string& F2) {
2776 ✗ return assign_if_valid<double>(F2, m_F2);
2777 }
2778
2779 ✗ int QfrTest2Impl::u_P1() const {
2780 ✗ return m_u_P1;
2781 }
2782
2783 ✗ void QfrTest2Impl::setU_P1(const int u_P1) {
2784 ✗ m_u_P1 = u_P1;
2785 ✗ }
2786
2787 ✗ int QfrTest2Impl::u_F1() const {
2788 ✗ return m_u_F1;
2789 }
2790
2791 ✗ void QfrTest2Impl::setU_F1(const int u_F1) {
2792 ✗ m_u_F1 = u_F1;
2793 ✗ }
2794
2795 ✗ int QfrTest2Impl::u_P2() const {
2796 ✗ return m_u_P2;
2797 }
2798
2799 ✗ void QfrTest2Impl::setU_P2(const int u_P2) {
2800 ✗ m_u_P2 = u_P2;
2801 ✗ }
2802
2803 ✗ int QfrTest2Impl::u_F2() const {
2804 ✗ return m_u_F2;
2805 }
2806
2807 ✗ void QfrTest2Impl::setU_F2(const int u_F2) {
2808 ✗ m_u_F2 = u_F2;
2809 ✗ }
2810
2811 ✗ void AfeDorImpl::setDefaults() {
2812 ✗ m_nr = 0;
2813 ✗ m_icon = 0;
2814 ✗ m_lam = PRJFLOAT("0.0");
2815 ✗ m_turb = PRJFLOAT("0.0");
2816 ✗ m_expt = PRJFLOAT("0.0");
2817 ✗ m_dTmin = PRJFLOAT("0.0");
2818 ✗ m_ht = PRJFLOAT("0.0");
2819 ✗ m_wd = PRJFLOAT("0.0");
2820 ✗ m_cd = PRJFLOAT("0.0");
2821 ✗ m_u_T = 0;
2822 ✗ m_u_H = 0;
2823 ✗ m_u_W = 0;
2824 ✗ }
2825
2826 ✗ AfeDorImpl::AfeDorImpl() {
2827 ✗ setDefaults();
2828 ✗ }
2829
2830 ✗ AfeDorImpl::AfeDorImpl(int nr, int icon, std::string name, std::string desc) {
2831 ✗ setDefaults();
2832 ✗ setNr(nr);
2833 ✗ setIcon(icon);
2834 ✗ setName(name);
2835 ✗ setDesc(desc);
2836 ✗ }
2837
2838 ✗ AfeDorImpl::AfeDorImpl(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double dTmin, double ht,
2839 ✗ double wd, double cd, int u_T, int u_H, int u_W) {
2840 ✗ setDefaults();
2841 ✗ setNr(nr);
2842 ✗ setIcon(icon);
2843 ✗ setName(name);
2844 ✗ setDesc(desc);
2845 ✗ setLam(lam);
2846 ✗ setTurb(turb);
2847 ✗ setExpt(expt);
2848 ✗ setDTmin(dTmin);
2849 ✗ setHeight(ht);
2850 ✗ setWidth(wd);
2851 ✗ setCd(cd);
2852 ✗ setU_T(u_T);
2853 ✗ setU_H(u_H);
2854 ✗ setU_W(u_W);
2855 ✗ }
2856
2857 ✗ AfeDorImpl::AfeDorImpl(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt,
2858 ✗ std::string dTmin, std::string ht, std::string wd, std::string cd, int u_T, int u_H, int u_W) {
2859 ✗ setDefaults();
2860 ✗ setNr(nr);
2861 ✗ setIcon(icon);
2862 ✗ setName(name);
2863 ✗ setDesc(desc);
2864 ✗ setLam(lam);
2865 ✗ setTurb(turb);
2866 ✗ setExpt(expt);
2867 ✗ setDTmin(dTmin);
2868 ✗ setHeight(ht);
2869 ✗ setWidth(wd);
2870 ✗ setCd(cd);
2871 ✗ setU_T(u_T);
2872 ✗ setU_H(u_H);
2873 ✗ setU_W(u_W);
2874 ✗ }
2875
2876 ✗ void AfeDorImpl::read(Reader& input) {
2877 ✗ setNr(input.read<int>());
2878 ✗ setIcon(input.read<int>());
2879 ✗ std::string dataType = input.readString(); // Should really check this
2880 ✗ setName(input.readString());
2881 ✗ setDesc(input.readLine());
2882 ✗ setLam(input.readNumber<std::string>());
2883 ✗ setTurb(input.readNumber<std::string>());
2884 ✗ setExpt(input.readNumber<std::string>());
2885 ✗ setDTmin(input.readNumber<std::string>());
2886 ✗ setHeight(input.readNumber<std::string>());
2887 ✗ setWidth(input.readNumber<std::string>());
2888 ✗ setCd(input.readNumber<std::string>());
2889 ✗ setU_T(input.read<int>());
2890 ✗ setU_H(input.read<int>());
2891 ✗ setU_W(input.read<int>());
2892 ✗ }
2893
2894 ✗ std::string AfeDorImpl::write() {
2895 ✗ std::string string;
2896 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + " dor_door " + m_name + '\n';
2897 ✗ string += m_desc + '\n';
2898 ✗ string += ANY_TO_STR(m_lam) + ' ' + ANY_TO_STR(m_turb) + ' ' + ANY_TO_STR(m_expt) + ' ' + ANY_TO_STR(m_dTmin) + ' ' + ANY_TO_STR(m_ht) + ' '
2899 ✗ + ANY_TO_STR(m_wd) + ' ' + ANY_TO_STR(m_cd) + ' ' + ANY_TO_STR(m_u_T) + ' ' + ANY_TO_STR(m_u_H) + ' ' + ANY_TO_STR(m_u_W) + '\n';
2900 ✗ return string;
2901 ✗ }
2902
2903 ✗ void AfeDorImpl::readDetails(Reader& input) {
2904 ✗ setLam(input.readNumber<std::string>());
2905 ✗ setTurb(input.readNumber<std::string>());
2906 ✗ setExpt(input.readNumber<std::string>());
2907 ✗ setDTmin(input.readNumber<std::string>());
2908 ✗ setHeight(input.readNumber<std::string>());
2909 ✗ setWidth(input.readNumber<std::string>());
2910 ✗ setCd(input.readNumber<std::string>());
2911 ✗ setU_T(input.read<int>());
2912 ✗ setU_H(input.read<int>());
2913 ✗ setU_W(input.read<int>());
2914 ✗ }
2915
2916 ✗ int AfeDorImpl::nr() const {
2917 ✗ return m_nr;
2918 }
2919
2920 ✗ void AfeDorImpl::setNr(const int nr) {
2921 ✗ m_nr = nr;
2922 ✗ }
2923
2924 ✗ int AfeDorImpl::icon() const {
2925 ✗ return m_icon;
2926 }
2927
2928 ✗ void AfeDorImpl::setIcon(const int icon) {
2929 ✗ m_icon = icon;
2930 ✗ }
2931
2932 ✗ std::string AfeDorImpl::name() const {
2933 ✗ return m_name;
2934 }
2935
2936 ✗ void AfeDorImpl::setName(const std::string& name) {
2937 ✗ m_name = name;
2938 ✗ }
2939
2940 ✗ std::string AfeDorImpl::desc() const {
2941 ✗ return m_desc;
2942 }
2943
2944 ✗ void AfeDorImpl::setDesc(const std::string& desc) {
2945 ✗ m_desc = desc;
2946 ✗ }
2947
2948 ✗ double AfeDorImpl::lam() const {
2949 ✗ return openstudio::string_conversions::to<double>(m_lam);
2950 }
2951
2952 ✗ bool AfeDorImpl::setLam(const double lam) {
2953 ✗ m_lam = openstudio::string_conversions::number(lam);
2954 ✗ return true;
2955 }
2956
2957 ✗ bool AfeDorImpl::setLam(const std::string& lam) {
2958 ✗ return assign_if_valid<double>(lam, m_lam);
2959 }
2960
2961 ✗ double AfeDorImpl::turb() const {
2962 ✗ return openstudio::string_conversions::to<double>(m_turb);
2963 }
2964
2965 ✗ bool AfeDorImpl::setTurb(const double turb) {
2966 ✗ m_turb = openstudio::string_conversions::number(turb);
2967 ✗ return true;
2968 }
2969
2970 ✗ bool AfeDorImpl::setTurb(const std::string& turb) {
2971 ✗ return assign_if_valid<double>(turb, m_turb);
2972 }
2973
2974 ✗ double AfeDorImpl::expt() const {
2975 ✗ return openstudio::string_conversions::to<double>(m_expt);
2976 }
2977
2978 ✗ bool AfeDorImpl::setExpt(const double expt) {
2979 ✗ m_expt = openstudio::string_conversions::number(expt);
2980 ✗ return true;
2981 }
2982
2983 ✗ bool AfeDorImpl::setExpt(const std::string& expt) {
2984 ✗ return assign_if_valid<double>(expt, m_expt);
2985 }
2986
2987 ✗ double AfeDorImpl::dTmin() const {
2988 ✗ return openstudio::string_conversions::to<double>(m_dTmin);
2989 }
2990
2991 ✗ bool AfeDorImpl::setDTmin(const double dTmin) {
2992 ✗ m_dTmin = openstudio::string_conversions::number(dTmin);
2993 ✗ return true;
2994 }
2995
2996 ✗ bool AfeDorImpl::setDTmin(const std::string& dTmin) {
2997 ✗ return assign_if_valid<double>(dTmin, m_dTmin);
2998 }
2999
3000 ✗ double AfeDorImpl::height() const {
3001 ✗ return openstudio::string_conversions::to<double>(m_ht);
3002 }
3003
3004 ✗ bool AfeDorImpl::setHeight(const double ht) {
3005 ✗ m_ht = openstudio::string_conversions::number(ht);
3006 ✗ return true;
3007 }
3008
3009 ✗ bool AfeDorImpl::setHeight(const std::string& ht) {
3010 ✗ return assign_if_valid<double>(ht, m_ht);
3011 }
3012
3013 ✗ double AfeDorImpl::width() const {
3014 ✗ return openstudio::string_conversions::to<double>(m_wd);
3015 }
3016
3017 ✗ bool AfeDorImpl::setWidth(const double wd) {
3018 ✗ m_wd = openstudio::string_conversions::number(wd);
3019 ✗ return true;
3020 }
3021
3022 ✗ bool AfeDorImpl::setWidth(const std::string& wd) {
3023 ✗ return assign_if_valid<double>(wd, m_wd);
3024 }
3025
3026 ✗ double AfeDorImpl::cd() const {
3027 ✗ return openstudio::string_conversions::to<double>(m_cd);
3028 }
3029
3030 ✗ bool AfeDorImpl::setCd(const double cd) {
3031 ✗ m_cd = openstudio::string_conversions::number(cd);
3032 ✗ return true;
3033 }
3034
3035 ✗ bool AfeDorImpl::setCd(const std::string& cd) {
3036 ✗ return assign_if_valid<double>(cd, m_cd);
3037 }
3038
3039 ✗ int AfeDorImpl::u_T() const {
3040 ✗ return m_u_T;
3041 }
3042
3043 ✗ void AfeDorImpl::setU_T(const int u_T) {
3044 ✗ m_u_T = u_T;
3045 ✗ }
3046
3047 ✗ int AfeDorImpl::u_H() const {
3048 ✗ return m_u_H;
3049 }
3050
3051 ✗ void AfeDorImpl::setU_H(const int u_H) {
3052 ✗ m_u_H = u_H;
3053 ✗ }
3054
3055 ✗ int AfeDorImpl::u_W() const {
3056 ✗ return m_u_W;
3057 }
3058
3059 ✗ void AfeDorImpl::setU_W(const int u_W) {
3060 ✗ m_u_W = u_W;
3061 ✗ }
3062
3063 ✗ void DrPl2Impl::setDefaults() {
3064 ✗ m_nr = 0;
3065 ✗ m_icon = 0;
3066 ✗ m_lam = PRJFLOAT("0.0");
3067 ✗ m_turb = PRJFLOAT("0.0");
3068 ✗ m_expt = PRJFLOAT("0.0");
3069 ✗ m_dH = PRJFLOAT("0.0");
3070 ✗ m_ht = PRJFLOAT("0.0");
3071 ✗ m_wd = PRJFLOAT("0.0");
3072 ✗ m_cd = PRJFLOAT("0.0");
3073 ✗ m_u_H = 0;
3074 ✗ m_u_W = 0;
3075 ✗ }
3076
3077 ✗ DrPl2Impl::DrPl2Impl() {
3078 ✗ setDefaults();
3079 ✗ }
3080
3081 ✗ DrPl2Impl::DrPl2Impl(int nr, int icon, std::string name, std::string desc) {
3082 ✗ setDefaults();
3083 ✗ setNr(nr);
3084 ✗ setIcon(icon);
3085 ✗ setName(name);
3086 ✗ setDesc(desc);
3087 ✗ }
3088
3089 ✗ DrPl2Impl::DrPl2Impl(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double dH, double ht, double wd,
3090 ✗ double cd, int u_H, int u_W) {
3091 ✗ setDefaults();
3092 ✗ setNr(nr);
3093 ✗ setIcon(icon);
3094 ✗ setName(name);
3095 ✗ setDesc(desc);
3096 ✗ setLam(lam);
3097 ✗ setTurb(turb);
3098 ✗ setExpt(expt);
3099 ✗ setDH(dH);
3100 ✗ setHeight(ht);
3101 ✗ setWidth(wd);
3102 ✗ setCd(cd);
3103 ✗ setU_H(u_H);
3104 ✗ setU_W(u_W);
3105 ✗ }
3106
3107 ✗ DrPl2Impl::DrPl2Impl(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string dH,
3108 ✗ std::string ht, std::string wd, std::string cd, int u_H, int u_W) {
3109 ✗ setDefaults();
3110 ✗ setNr(nr);
3111 ✗ setIcon(icon);
3112 ✗ setName(name);
3113 ✗ setDesc(desc);
3114 ✗ setLam(lam);
3115 ✗ setTurb(turb);
3116 ✗ setExpt(expt);
3117 ✗ setDH(dH);
3118 ✗ setHeight(ht);
3119 ✗ setWidth(wd);
3120 ✗ setCd(cd);
3121 ✗ setU_H(u_H);
3122 ✗ setU_W(u_W);
3123 ✗ }
3124
3125 ✗ void DrPl2Impl::read(Reader& input) {
3126 ✗ setNr(input.read<int>());
3127 ✗ setIcon(input.read<int>());
3128 ✗ std::string dataType = input.readString(); // Should really check this
3129 ✗ setName(input.readString());
3130 ✗ setDesc(input.readLine());
3131 ✗ setLam(input.readNumber<std::string>());
3132 ✗ setTurb(input.readNumber<std::string>());
3133 ✗ setExpt(input.readNumber<std::string>());
3134 ✗ setDH(input.readNumber<std::string>());
3135 ✗ setHeight(input.readNumber<std::string>());
3136 ✗ setWidth(input.readNumber<std::string>());
3137 ✗ setCd(input.readNumber<std::string>());
3138 ✗ setU_H(input.read<int>());
3139 ✗ setU_W(input.read<int>());
3140 ✗ }
3141
3142 ✗ std::string DrPl2Impl::write() {
3143 ✗ std::string string;
3144 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + " dor_pl2 " + m_name + '\n';
3145 ✗ string += m_desc + '\n';
3146 ✗ string += ANY_TO_STR(m_lam) + ' ' + ANY_TO_STR(m_turb) + ' ' + ANY_TO_STR(m_expt) + ' ' + ANY_TO_STR(m_dH) + ' ' + ANY_TO_STR(m_ht) + ' '
3147 ✗ + ANY_TO_STR(m_wd) + ' ' + ANY_TO_STR(m_cd) + ' ' + ANY_TO_STR(m_u_H) + ' ' + ANY_TO_STR(m_u_W) + '\n';
3148 ✗ return string;
3149 ✗ }
3150
3151 ✗ void DrPl2Impl::readDetails(Reader& input) {
3152 ✗ setLam(input.readNumber<std::string>());
3153 ✗ setTurb(input.readNumber<std::string>());
3154 ✗ setExpt(input.readNumber<std::string>());
3155 ✗ setDH(input.readNumber<std::string>());
3156 ✗ setHeight(input.readNumber<std::string>());
3157 ✗ setWidth(input.readNumber<std::string>());
3158 ✗ setCd(input.readNumber<std::string>());
3159 ✗ setU_H(input.read<int>());
3160 ✗ setU_W(input.read<int>());
3161 ✗ }
3162
3163 ✗ int DrPl2Impl::nr() const {
3164 ✗ return m_nr;
3165 }
3166
3167 ✗ void DrPl2Impl::setNr(const int nr) {
3168 ✗ m_nr = nr;
3169 ✗ }
3170
3171 ✗ int DrPl2Impl::icon() const {
3172 ✗ return m_icon;
3173 }
3174
3175 ✗ void DrPl2Impl::setIcon(const int icon) {
3176 ✗ m_icon = icon;
3177 ✗ }
3178
3179 ✗ std::string DrPl2Impl::name() const {
3180 ✗ return m_name;
3181 }
3182
3183 ✗ void DrPl2Impl::setName(const std::string& name) {
3184 ✗ m_name = name;
3185 ✗ }
3186
3187 ✗ std::string DrPl2Impl::desc() const {
3188 ✗ return m_desc;
3189 }
3190
3191 ✗ void DrPl2Impl::setDesc(const std::string& desc) {
3192 ✗ m_desc = desc;
3193 ✗ }
3194
3195 ✗ double DrPl2Impl::lam() const {
3196 ✗ return openstudio::string_conversions::to<double>(m_lam);
3197 }
3198
3199 ✗ bool DrPl2Impl::setLam(const double lam) {
3200 ✗ m_lam = openstudio::string_conversions::number(lam);
3201 ✗ return true;
3202 }
3203
3204 ✗ bool DrPl2Impl::setLam(const std::string& lam) {
3205 ✗ return assign_if_valid<double>(lam, m_lam);
3206 }
3207
3208 ✗ double DrPl2Impl::turb() const {
3209 ✗ return openstudio::string_conversions::to<double>(m_turb);
3210 }
3211
3212 ✗ bool DrPl2Impl::setTurb(const double turb) {
3213 ✗ m_turb = openstudio::string_conversions::number(turb);
3214 ✗ return true;
3215 }
3216
3217 ✗ bool DrPl2Impl::setTurb(const std::string& turb) {
3218 ✗ return assign_if_valid<double>(turb, m_turb);
3219 }
3220
3221 ✗ double DrPl2Impl::expt() const {
3222 ✗ return openstudio::string_conversions::to<double>(m_expt);
3223 }
3224
3225 ✗ bool DrPl2Impl::setExpt(const double expt) {
3226 ✗ m_expt = openstudio::string_conversions::number(expt);
3227 ✗ return true;
3228 }
3229
3230 ✗ bool DrPl2Impl::setExpt(const std::string& expt) {
3231 ✗ return assign_if_valid<double>(expt, m_expt);
3232 }
3233
3234 ✗ double DrPl2Impl::dH() const {
3235 ✗ return openstudio::string_conversions::to<double>(m_dH);
3236 }
3237
3238 ✗ bool DrPl2Impl::setDH(const double dH) {
3239 ✗ m_dH = openstudio::string_conversions::number(dH);
3240 ✗ return true;
3241 }
3242
3243 ✗ bool DrPl2Impl::setDH(const std::string& dH) {
3244 ✗ return assign_if_valid<double>(dH, m_dH);
3245 }
3246
3247 ✗ double DrPl2Impl::height() const {
3248 ✗ return openstudio::string_conversions::to<double>(m_ht);
3249 }
3250
3251 ✗ bool DrPl2Impl::setHeight(const double ht) {
3252 ✗ m_ht = openstudio::string_conversions::number(ht);
3253 ✗ return true;
3254 }
3255
3256 ✗ bool DrPl2Impl::setHeight(const std::string& ht) {
3257 ✗ return assign_if_valid<double>(ht, m_ht);
3258 }
3259
3260 ✗ double DrPl2Impl::width() const {
3261 ✗ return openstudio::string_conversions::to<double>(m_wd);
3262 }
3263
3264 ✗ bool DrPl2Impl::setWidth(const double wd) {
3265 ✗ m_wd = openstudio::string_conversions::number(wd);
3266 ✗ return true;
3267 }
3268
3269 ✗ bool DrPl2Impl::setWidth(const std::string& wd) {
3270 ✗ return assign_if_valid<double>(wd, m_wd);
3271 }
3272
3273 ✗ double DrPl2Impl::cd() const {
3274 ✗ return openstudio::string_conversions::to<double>(m_cd);
3275 }
3276
3277 ✗ bool DrPl2Impl::setCd(const double cd) {
3278 ✗ m_cd = openstudio::string_conversions::number(cd);
3279 ✗ return true;
3280 }
3281
3282 ✗ bool DrPl2Impl::setCd(const std::string& cd) {
3283 ✗ return assign_if_valid<double>(cd, m_cd);
3284 }
3285
3286 ✗ int DrPl2Impl::u_H() const {
3287 ✗ return m_u_H;
3288 }
3289
3290 ✗ void DrPl2Impl::setU_H(const int u_H) {
3291 ✗ m_u_H = u_H;
3292 ✗ }
3293
3294 ✗ int DrPl2Impl::u_W() const {
3295 ✗ return m_u_W;
3296 }
3297
3298 ✗ void DrPl2Impl::setU_W(const int u_W) {
3299 ✗ m_u_W = u_W;
3300 ✗ }
3301
3302 6 void AfeFlowImpl::setDefaults() {
3303 6 m_nr = 0;
3304 6 m_icon = 0;
3305
1/1
✓ Branch 1 taken 6 times.
6 m_Flow = PRJFLOAT("0.0");
3306 6 m_u_F = 0;
3307 6 }
3308
3309 ✗ AfeFlowImpl::AfeFlowImpl() {
3310 ✗ setDefaults();
3311 ✗ }
3312
3313 6 AfeFlowImpl::AfeFlowImpl(int nr, int icon, std::string name, std::string desc) {
3314
1/1
✓ Branch 1 taken 6 times.
6 setDefaults();
3315
1/1
✓ Branch 1 taken 6 times.
6 setNr(nr);
3316
1/1
✓ Branch 1 taken 6 times.
6 setIcon(icon);
3317
1/1
✓ Branch 1 taken 6 times.
6 setName(name);
3318
1/1
✓ Branch 1 taken 6 times.
6 setDesc(desc);
3319 6 }
3320
3321 ✗ AfeFlowImpl::AfeFlowImpl(int nr, int icon, std::string name, std::string desc, double Flow, int u_F) {
3322 ✗ setDefaults();
3323 ✗ setNr(nr);
3324 ✗ setIcon(icon);
3325 ✗ setName(name);
3326 ✗ setDesc(desc);
3327 ✗ setFlow(Flow);
3328 ✗ setU_F(u_F);
3329 ✗ }
3330
3331 ✗ AfeFlowImpl::AfeFlowImpl(int nr, int icon, std::string name, std::string desc, std::string Flow, int u_F) {
3332 ✗ setDefaults();
3333 ✗ setNr(nr);
3334 ✗ setIcon(icon);
3335 ✗ setName(name);
3336 ✗ setDesc(desc);
3337 ✗ setFlow(Flow);
3338 ✗ setU_F(u_F);
3339 ✗ }
3340
3341 ✗ void AfeFlowImpl::read(Reader& input) {
3342 ✗ setNr(input.read<int>());
3343 ✗ setIcon(input.read<int>());
3344 ✗ std::string dataType = input.readString(); // Should really check this
3345 ✗ setName(input.readString());
3346 ✗ setDesc(input.readLine());
3347 ✗ setFlow(input.readNumber<std::string>());
3348 ✗ setU_F(input.read<int>());
3349 ✗ }
3350
3351 1 std::string AfeFlowImpl::write(std::string dataType) {
3352 1 std::string string;
3353
10/10
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
✓ Branch 16 taken 1 time.
✓ Branch 19 taken 1 time.
✓ Branch 22 taken 1 time.
✓ Branch 25 taken 1 time.
✓ Branch 28 taken 1 time.
1 string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + ' ' + dataType + ' ' + m_name + '\n';
3354
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 string += m_desc + '\n';
3355
6/6
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
✓ Branch 16 taken 1 time.
1 string += ANY_TO_STR(m_Flow) + ' ' + ANY_TO_STR(m_u_F) + '\n';
3356 1 return string;
3357 ✗ }
3358
3359 6 void AfeFlowImpl::readDetails(Reader& input) {
3360
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 setFlow(input.readNumber<std::string>());
3361 6 setU_F(input.read<int>());
3362 6 }
3363
3364 ✗ int AfeFlowImpl::nr() const {
3365 ✗ return m_nr;
3366 }
3367
3368 6 void AfeFlowImpl::setNr(const int nr) {
3369 6 m_nr = nr;
3370 6 }
3371
3372 ✗ int AfeFlowImpl::icon() const {
3373 ✗ return m_icon;
3374 }
3375
3376 6 void AfeFlowImpl::setIcon(const int icon) {
3377 6 m_icon = icon;
3378 6 }
3379
3380 24 std::string AfeFlowImpl::name() const {
3381 24 return m_name;
3382 }
3383
3384 6 void AfeFlowImpl::setName(const std::string& name) {
3385 6 m_name = name;
3386 6 }
3387
3388 ✗ std::string AfeFlowImpl::desc() const {
3389 ✗ return m_desc;
3390 }
3391
3392 6 void AfeFlowImpl::setDesc(const std::string& desc) {
3393 6 m_desc = desc;
3394 6 }
3395
3396 ✗ double AfeFlowImpl::Flow() const {
3397 ✗ return openstudio::string_conversions::to<double>(m_Flow);
3398 }
3399
3400 ✗ bool AfeFlowImpl::setFlow(const double Flow) {
3401 ✗ m_Flow = openstudio::string_conversions::number(Flow);
3402 ✗ return true;
3403 }
3404
3405 6 bool AfeFlowImpl::setFlow(const std::string& Flow) {
3406 6 return assign_if_valid<double>(Flow, m_Flow);
3407 }
3408
3409 ✗ int AfeFlowImpl::u_F() const {
3410 ✗ return m_u_F;
3411 }
3412
3413 6 void AfeFlowImpl::setU_F(const int u_F) {
3414 6 m_u_F = u_F;
3415 6 }
3416
3417 ✗ void AfeFanImpl::setDefaults() {
3418 ✗ m_nr = 0;
3419 ✗ m_icon = 0;
3420 ✗ m_lam = PRJFLOAT("0.0");
3421 ✗ m_turb = PRJFLOAT("0.0");
3422 ✗ m_expt = PRJFLOAT("0.0");
3423 ✗ m_rdens = PRJFLOAT("0.0");
3424 ✗ m_fdf = PRJFLOAT("0.0");
3425 ✗ m_sop = PRJFLOAT("0.0");
3426 ✗ m_off = PRJFLOAT("0.0");
3427 ✗ m_Sarea = PRJFLOAT("0.0");
3428 ✗ m_u_Sa = 0;
3429 ✗ }
3430
3431 ✗ AfeFanImpl::AfeFanImpl() {
3432 ✗ setDefaults();
3433 ✗ }
3434
3435 ✗ AfeFanImpl::AfeFanImpl(int nr, int icon, std::string name, std::string desc) {
3436 ✗ setDefaults();
3437 ✗ setNr(nr);
3438 ✗ setIcon(icon);
3439 ✗ setName(name);
3440 ✗ setDesc(desc);
3441 ✗ }
3442
3443 ✗ AfeFanImpl::AfeFanImpl(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double rdens, double fdf,
3444 ✗ double sop, double off, std::vector<double> fpc, double Sarea, int u_Sa, std::vector<FanDataPoint> data) {
3445 ✗ setDefaults();
3446 ✗ setNr(nr);
3447 ✗ setIcon(icon);
3448 ✗ setName(name);
3449 ✗ setDesc(desc);
3450 ✗ setLam(lam);
3451 ✗ setTurb(turb);
3452 ✗ setExpt(expt);
3453 ✗ setRdens(rdens);
3454 ✗ setFdf(fdf);
3455 ✗ setSop(sop);
3456 ✗ setOff(off);
3457 ✗ setFpc(fpc);
3458 ✗ setSarea(Sarea);
3459 ✗ setU_Sa(u_Sa);
3460 ✗ setData(data);
3461 ✗ }
3462
3463 ✗ AfeFanImpl::AfeFanImpl(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt,
3464 std::string rdens, std::string fdf, std::string sop, std::string off, std::vector<std::string> fpc, std::string Sarea,
3465 ✗ int u_Sa, std::vector<FanDataPoint> data) {
3466 ✗ setDefaults();
3467 ✗ setNr(nr);
3468 ✗ setIcon(icon);
3469 ✗ setName(name);
3470 ✗ setDesc(desc);
3471 ✗ setLam(lam);
3472 ✗ setTurb(turb);
3473 ✗ setExpt(expt);
3474 ✗ setRdens(rdens);
3475 ✗ setFdf(fdf);
3476 ✗ setSop(sop);
3477 ✗ setOff(off);
3478 ✗ setFpc(fpc);
3479 ✗ setSarea(Sarea);
3480 ✗ setU_Sa(u_Sa);
3481 ✗ setData(data);
3482 ✗ }
3483
3484 ✗ void AfeFanImpl::read(Reader& input) {
3485 ✗ setNr(input.read<int>());
3486 ✗ setIcon(input.read<int>());
3487 ✗ std::string dataType = input.readString(); // Should really check this
3488 ✗ setName(input.readString());
3489 ✗ setDesc(input.readLine());
3490 ✗ setLam(input.readNumber<std::string>());
3491 ✗ setTurb(input.readNumber<std::string>());
3492 ✗ setExpt(input.readNumber<std::string>());
3493 ✗ setRdens(input.readNumber<std::string>());
3494 ✗ setFdf(input.readNumber<std::string>());
3495 ✗ setSop(input.readNumber<std::string>());
3496 ✗ setOff(input.readNumber<std::string>());
3497 ✗ std::vector<std::string> fpc;
3498 ✗ for (int i = 0; i < 4; i++) {
3499 ✗ fpc.push_back(input.read<std::string>());
3500 }
3501 ✗ setFpc(fpc);
3502 ✗ int npts = input.read<int>();
3503 ✗ setSarea(input.readNumber<std::string>());
3504 ✗ setU_Sa(input.read<int>());
3505 ✗ std::vector<FanDataPoint> data;
3506 ✗ for (int i = 0; i < npts; i++) {
3507 ✗ FanDataPoint object;
3508 ✗ object.read(input);
3509 ✗ data.push_back(object);
3510 ✗ }
3511 ✗ setData(data);
3512 ✗ }
3513
3514 ✗ std::string AfeFanImpl::write() {
3515 ✗ std::string string;
3516 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + " fan_fan " + m_name + '\n';
3517 ✗ string += m_desc + '\n';
3518 ✗ string += ANY_TO_STR(m_lam) + ' ' + ANY_TO_STR(m_turb) + ' ' + ANY_TO_STR(m_expt) + ' ' + ANY_TO_STR(m_rdens) + ' ' + ANY_TO_STR(m_fdf) + ' '
3519 ✗ + ANY_TO_STR(m_sop) + ' ' + ANY_TO_STR(m_off) + '\n';
3520 ✗ for (int i = 0; i < 4; i++) {
3521 ✗ string += ANY_TO_STR(m_fpc[i]) + ' ';
3522 }
3523 ✗ string += '\n';
3524 ✗ string += ANY_TO_STR((int)m_data.size()) + ' ' + ANY_TO_STR(m_Sarea) + ' ' + ANY_TO_STR(m_u_Sa) + '\n';
3525 ✗ for (unsigned int i = 0; i < m_data.size(); i++) {
3526 ✗ string += m_data[i].write();
3527 }
3528 ✗ return string;
3529 ✗ }
3530
3531 ✗ void AfeFanImpl::readDetails(Reader& input) {
3532 ✗ setLam(input.readNumber<std::string>());
3533 ✗ setTurb(input.readNumber<std::string>());
3534 ✗ setExpt(input.readNumber<std::string>());
3535 ✗ setRdens(input.readNumber<std::string>());
3536 ✗ setFdf(input.readNumber<std::string>());
3537 ✗ setSop(input.readNumber<std::string>());
3538 ✗ setOff(input.readNumber<std::string>());
3539 ✗ std::vector<std::string> fpc;
3540 ✗ for (int i = 0; i < 4; i++) {
3541 ✗ fpc.push_back(input.read<std::string>());
3542 }
3543 ✗ setFpc(fpc);
3544 ✗ int npts = input.read<int>();
3545 ✗ setSarea(input.readNumber<std::string>());
3546 ✗ setU_Sa(input.read<int>());
3547 ✗ std::vector<FanDataPoint> data;
3548 ✗ for (int i = 0; i < npts; i++) {
3549 ✗ FanDataPoint object;
3550 ✗ object.read(input);
3551 ✗ data.push_back(object);
3552 ✗ }
3553 ✗ setData(data);
3554 ✗ }
3555
3556 ✗ int AfeFanImpl::nr() const {
3557 ✗ return m_nr;
3558 }
3559
3560 ✗ void AfeFanImpl::setNr(const int nr) {
3561 ✗ m_nr = nr;
3562 ✗ }
3563
3564 ✗ int AfeFanImpl::icon() const {
3565 ✗ return m_icon;
3566 }
3567
3568 ✗ void AfeFanImpl::setIcon(const int icon) {
3569 ✗ m_icon = icon;
3570 ✗ }
3571
3572 ✗ std::string AfeFanImpl::name() const {
3573 ✗ return m_name;
3574 }
3575
3576 ✗ void AfeFanImpl::setName(const std::string& name) {
3577 ✗ m_name = name;
3578 ✗ }
3579
3580 ✗ std::string AfeFanImpl::desc() const {
3581 ✗ return m_desc;
3582 }
3583
3584 ✗ void AfeFanImpl::setDesc(const std::string& desc) {
3585 ✗ m_desc = desc;
3586 ✗ }
3587
3588 ✗ double AfeFanImpl::lam() const {
3589 ✗ return openstudio::string_conversions::to<double>(m_lam);
3590 }
3591
3592 ✗ bool AfeFanImpl::setLam(const double lam) {
3593 ✗ m_lam = openstudio::string_conversions::number(lam);
3594 ✗ return true;
3595 }
3596
3597 ✗ bool AfeFanImpl::setLam(const std::string& lam) {
3598 ✗ return assign_if_valid<double>(lam, m_lam);
3599 }
3600
3601 ✗ double AfeFanImpl::turb() const {
3602 ✗ return openstudio::string_conversions::to<double>(m_turb);
3603 }
3604
3605 ✗ bool AfeFanImpl::setTurb(const double turb) {
3606 ✗ m_turb = openstudio::string_conversions::number(turb);
3607 ✗ return true;
3608 }
3609
3610 ✗ bool AfeFanImpl::setTurb(const std::string& turb) {
3611 ✗ return assign_if_valid<double>(turb, m_turb);
3612 }
3613
3614 ✗ double AfeFanImpl::expt() const {
3615 ✗ return openstudio::string_conversions::to<double>(m_expt);
3616 }
3617
3618 ✗ bool AfeFanImpl::setExpt(const double expt) {
3619 ✗ m_expt = openstudio::string_conversions::number(expt);
3620 ✗ return true;
3621 }
3622
3623 ✗ bool AfeFanImpl::setExpt(const std::string& expt) {
3624 ✗ return assign_if_valid<double>(expt, m_expt);
3625 }
3626
3627 ✗ double AfeFanImpl::rdens() const {
3628 ✗ return openstudio::string_conversions::to<double>(m_rdens);
3629 }
3630
3631 ✗ bool AfeFanImpl::setRdens(const double rdens) {
3632 ✗ m_rdens = openstudio::string_conversions::number(rdens);
3633 ✗ return true;
3634 }
3635
3636 ✗ bool AfeFanImpl::setRdens(const std::string& rdens) {
3637 ✗ return assign_if_valid<double>(rdens, m_rdens);
3638 }
3639
3640 ✗ double AfeFanImpl::fdf() const {
3641 ✗ return openstudio::string_conversions::to<double>(m_fdf);
3642 }
3643
3644 ✗ bool AfeFanImpl::setFdf(const double fdf) {
3645 ✗ m_fdf = openstudio::string_conversions::number(fdf);
3646 ✗ return true;
3647 }
3648
3649 ✗ bool AfeFanImpl::setFdf(const std::string& fdf) {
3650 ✗ return assign_if_valid<double>(fdf, m_fdf);
3651 }
3652
3653 ✗ double AfeFanImpl::sop() const {
3654 ✗ return openstudio::string_conversions::to<double>(m_sop);
3655 }
3656
3657 ✗ bool AfeFanImpl::setSop(const double sop) {
3658 ✗ m_sop = openstudio::string_conversions::number(sop);
3659 ✗ return true;
3660 }
3661
3662 ✗ bool AfeFanImpl::setSop(const std::string& sop) {
3663 ✗ return assign_if_valid<double>(sop, m_sop);
3664 }
3665
3666 ✗ double AfeFanImpl::off() const {
3667 ✗ return openstudio::string_conversions::to<double>(m_off);
3668 }
3669
3670 ✗ bool AfeFanImpl::setOff(const double off) {
3671 ✗ m_off = openstudio::string_conversions::number(off);
3672 ✗ return true;
3673 }
3674
3675 ✗ bool AfeFanImpl::setOff(const std::string& off) {
3676 ✗ return assign_if_valid<double>(off, m_off);
3677 }
3678
3679 ✗ std::vector<double> AfeFanImpl::fpc() const {
3680 ✗ std::vector<double> out;
3681 ✗ for (int i = 0; i < 4; i++) {
3682 ✗ out.push_back(openstudio::string_conversions::to<double>(m_fpc[i]));
3683 }
3684 ✗ return out;
3685 ✗ }
3686
3687 ✗ bool AfeFanImpl::setFpc(const std::vector<double>& fpc) {
3688 ✗ for (int i = 0; i < 4; i++) {
3689 ✗ m_fpc.push_back(openstudio::string_conversions::number(fpc[i]));
3690 }
3691 ✗ return true;
3692 }
3693
3694 ✗ bool AfeFanImpl::setFpc(const std::vector<std::string>& fpc) {
3695 ✗ if (std::all_of(fpc.begin(), fpc.end(), is_valid<double, std::string>)) {
3696 ✗ m_fpc = fpc;
3697 ✗ return true;
3698 } else {
3699 ✗ return false;
3700 }
3701 }
3702
3703 ✗ double AfeFanImpl::Sarea() const {
3704 ✗ return openstudio::string_conversions::to<double>(m_Sarea);
3705 }
3706
3707 ✗ bool AfeFanImpl::setSarea(const double Sarea) {
3708 ✗ m_Sarea = openstudio::string_conversions::number(Sarea);
3709 ✗ return true;
3710 }
3711
3712 ✗ bool AfeFanImpl::setSarea(const std::string& Sarea) {
3713 ✗ return assign_if_valid<double>(Sarea, m_Sarea);
3714 }
3715
3716 ✗ int AfeFanImpl::u_Sa() const {
3717 ✗ return m_u_Sa;
3718 }
3719
3720 ✗ void AfeFanImpl::setU_Sa(const int u_Sa) {
3721 ✗ m_u_Sa = u_Sa;
3722 ✗ }
3723
3724 ✗ std::vector<FanDataPoint> AfeFanImpl::data() const {
3725 ✗ return m_data;
3726 }
3727
3728 ✗ void AfeFanImpl::setData(const std::vector<FanDataPoint>& data) {
3729 ✗ m_data = data;
3730 ✗ }
3731
3732 ✗ void AfeCsfImpl::setDefaults() {
3733 ✗ m_nr = 0;
3734 ✗ m_icon = 0;
3735 ✗ m_u_x = 0;
3736 ✗ m_u_y = 0;
3737 ✗ }
3738
3739 ✗ AfeCsfImpl::AfeCsfImpl() {
3740 ✗ setDefaults();
3741 ✗ }
3742
3743 ✗ AfeCsfImpl::AfeCsfImpl(int nr, int icon, std::string name, std::string desc) {
3744 ✗ setDefaults();
3745 ✗ setNr(nr);
3746 ✗ setIcon(icon);
3747 ✗ setName(name);
3748 ✗ setDesc(desc);
3749 ✗ }
3750
3751 ✗ AfeCsfImpl::AfeCsfImpl(int nr, int icon, std::string name, std::string desc, int u_x, int u_y, std::vector<XyDataPoint> data) {
3752 ✗ setDefaults();
3753 ✗ setNr(nr);
3754 ✗ setIcon(icon);
3755 ✗ setName(name);
3756 ✗ setDesc(desc);
3757 ✗ setU_x(u_x);
3758 ✗ setU_y(u_y);
3759 ✗ setData(data);
3760 ✗ }
3761
3762 ✗ void AfeCsfImpl::read(Reader& input) {
3763 ✗ setNr(input.read<int>());
3764 ✗ setIcon(input.read<int>());
3765 ✗ std::string dataType = input.readString(); // Should really check this
3766 ✗ setName(input.readString());
3767 ✗ setDesc(input.readLine());
3768 ✗ int npts = input.read<int>();
3769 ✗ setU_x(input.read<int>());
3770 ✗ setU_y(input.read<int>());
3771 ✗ for (int i = 0; i < npts; i++) {
3772 ✗ XyDataPoint object;
3773 ✗ object.read(input);
3774 ✗ m_data.push_back(object);
3775 ✗ }
3776 ✗ }
3777
3778 ✗ void AfeCsfImpl::readDetails(Reader& input) {
3779 ✗ int npts = input.read<int>();
3780 ✗ setU_x(input.read<int>());
3781 ✗ setU_y(input.read<int>());
3782 ✗ for (int i = 0; i < npts; i++) {
3783 ✗ XyDataPoint object;
3784 ✗ object.read(input);
3785 ✗ m_data.push_back(object);
3786 ✗ }
3787 ✗ }
3788
3789 ✗ std::string AfeCsfImpl::write(std::string datatype) {
3790 ✗ std::string string;
3791 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + ' ' + datatype + ' ' + m_name + '\n';
3792 ✗ string += m_desc + '\n';
3793 ✗ string += ANY_TO_STR((int)m_data.size()) + ' ' + ANY_TO_STR(m_u_x) + ' ' + ANY_TO_STR(m_u_y) + '\n';
3794 ✗ for (unsigned int i = 0; i < m_data.size(); i++) {
3795 ✗ string += m_data[i].write();
3796 }
3797 ✗ return string;
3798 ✗ }
3799
3800 ✗ int AfeCsfImpl::nr() const {
3801 ✗ return m_nr;
3802 }
3803
3804 ✗ void AfeCsfImpl::setNr(const int nr) {
3805 ✗ m_nr = nr;
3806 ✗ }
3807
3808 ✗ int AfeCsfImpl::icon() const {
3809 ✗ return m_icon;
3810 }
3811
3812 ✗ void AfeCsfImpl::setIcon(const int icon) {
3813 ✗ m_icon = icon;
3814 ✗ }
3815
3816 ✗ std::string AfeCsfImpl::name() const {
3817 ✗ return m_name;
3818 }
3819
3820 ✗ void AfeCsfImpl::setName(const std::string& name) {
3821 ✗ m_name = name;
3822 ✗ }
3823
3824 ✗ std::string AfeCsfImpl::desc() const {
3825 ✗ return m_desc;
3826 }
3827
3828 ✗ void AfeCsfImpl::setDesc(const std::string& desc) {
3829 ✗ m_desc = desc;
3830 ✗ }
3831
3832 ✗ int AfeCsfImpl::u_x() const {
3833 ✗ return m_u_x;
3834 }
3835
3836 ✗ void AfeCsfImpl::setU_x(const int u_x) {
3837 ✗ m_u_x = u_x;
3838 ✗ }
3839
3840 ✗ int AfeCsfImpl::u_y() const {
3841 ✗ return m_u_y;
3842 }
3843
3844 ✗ void AfeCsfImpl::setU_y(const int u_y) {
3845 ✗ m_u_y = u_y;
3846 ✗ }
3847
3848 ✗ std::vector<XyDataPoint> AfeCsfImpl::data() const {
3849 ✗ return m_data;
3850 }
3851
3852 ✗ void AfeCsfImpl::setData(const std::vector<XyDataPoint>& data) {
3853 ✗ m_data = data;
3854 ✗ }
3855
3856 ✗ void AfeSupImpl::setDefaults() {
3857 ✗ m_nr = 0;
3858 ✗ m_icon = 0;
3859 ✗ m_sched = 0;
3860 ✗ m_u_H = 0;
3861 ✗ }
3862
3863 ✗ AfeSupImpl::AfeSupImpl() {
3864 ✗ setDefaults();
3865 ✗ }
3866
3867 ✗ AfeSupImpl::AfeSupImpl(int nr, int icon, std::string name, std::string desc) {
3868 ✗ setDefaults();
3869 ✗ setNr(nr);
3870 ✗ setIcon(icon);
3871 ✗ setName(name);
3872 ✗ setDesc(desc);
3873 ✗ }
3874
3875 ✗ AfeSupImpl::AfeSupImpl(int nr, int icon, std::string name, std::string desc, int sched, int u_H, std::vector<AirflowSubelementData> subelements) {
3876 ✗ setDefaults();
3877 ✗ setNr(nr);
3878 ✗ setIcon(icon);
3879 ✗ setName(name);
3880 ✗ setDesc(desc);
3881 ✗ setSched(sched);
3882 ✗ setU_H(u_H);
3883 ✗ setSubelements(subelements);
3884 ✗ }
3885
3886 ✗ void AfeSupImpl::read(Reader& input) {
3887 ✗ setNr(input.read<int>());
3888 ✗ setIcon(input.read<int>());
3889 ✗ std::string dataType = input.readString(); // Should really check this
3890 ✗ setName(input.readString());
3891 ✗ setDesc(input.readLine());
3892 ✗ int nse = input.read<int>();
3893 ✗ setSched(input.read<int>());
3894 ✗ setU_H(input.read<int>());
3895 ✗ std::vector<AirflowSubelementData> subelements;
3896 ✗ for (int i = 0; i < nse; i++) {
3897 ✗ AirflowSubelementData object;
3898 ✗ object.read(input);
3899 ✗ subelements.push_back(object);
3900 ✗ }
3901 ✗ setSubelements(subelements);
3902 ✗ }
3903
3904 ✗ std::string AfeSupImpl::write() {
3905 ✗ std::string string;
3906 ✗ string += ANY_TO_STR(m_nr) + ' ' + ANY_TO_STR(m_icon) + " sup_afe " + m_name + '\n';
3907 ✗ string += m_desc + '\n';
3908 ✗ string += ANY_TO_STR((int)m_subelements.size()) + ' ' + ANY_TO_STR(m_sched) + ' ' + ANY_TO_STR(m_u_H) + '\n';
3909 ✗ for (unsigned int i = 0; i < m_subelements.size(); i++) {
3910 ✗ string += m_subelements[i].write();
3911 }
3912 ✗ return string;
3913 ✗ }
3914
3915 ✗ void AfeSupImpl::readDetails(Reader& input) {
3916 ✗ int nse = input.read<int>();
3917 ✗ setSched(input.read<int>());
3918 ✗ setU_H(input.read<int>());
3919 ✗ std::vector<AirflowSubelementData> subelements;
3920 ✗ for (int i = 0; i < nse; i++) {
3921 ✗ AirflowSubelementData object;
3922 ✗ object.read(input);
3923 ✗ subelements.push_back(object);
3924 ✗ }
3925 ✗ setSubelements(subelements);
3926 ✗ }
3927
3928 ✗ int AfeSupImpl::nr() const {
3929 ✗ return m_nr;
3930 }
3931
3932 ✗ void AfeSupImpl::setNr(const int nr) {
3933 ✗ m_nr = nr;
3934 ✗ }
3935
3936 ✗ int AfeSupImpl::icon() const {
3937 ✗ return m_icon;
3938 }
3939
3940 ✗ void AfeSupImpl::setIcon(const int icon) {
3941 ✗ m_icon = icon;
3942 ✗ }
3943
3944 ✗ std::string AfeSupImpl::name() const {
3945 ✗ return m_name;
3946 }
3947
3948 ✗ void AfeSupImpl::setName(const std::string& name) {
3949 ✗ m_name = name;
3950 ✗ }
3951
3952 ✗ std::string AfeSupImpl::desc() const {
3953 ✗ return m_desc;
3954 }
3955
3956 ✗ void AfeSupImpl::setDesc(const std::string& desc) {
3957 ✗ m_desc = desc;
3958 ✗ }
3959
3960 ✗ int AfeSupImpl::sched() const {
3961 ✗ return m_sched;
3962 }
3963
3964 ✗ void AfeSupImpl::setSched(const int sched) {
3965 ✗ m_sched = sched;
3966 ✗ }
3967
3968 ✗ int AfeSupImpl::u_H() const {
3969 ✗ return m_u_H;
3970 }
3971
3972 ✗ void AfeSupImpl::setU_H(const int u_H) {
3973 ✗ m_u_H = u_H;
3974 ✗ }
3975
3976 ✗ std::vector<AirflowSubelementData> AfeSupImpl::subelements() const {
3977 ✗ return m_subelements;
3978 }
3979
3980 ✗ void AfeSupImpl::setSubelements(const std::vector<AirflowSubelementData>& subelements) {
3981 ✗ m_subelements = subelements;
3982 ✗ }
3983
3984 } // namespace detail
3985 } // namespace contam
3986 } // namespace openstudio
3987