GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 7.6% 141 / 0 / 1860
Functions: 5.4% 43 / 0 / 794
Branches: 16.4% 180 / 0 / 1100

src/airflow/contam/PrjAirflowElements.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 "PrjAirflowElements.hpp"
7 #include "PrjAirflowElementsImpl.hpp"
8
9 #include "../../utilities/core/Logger.hpp"
10
11 namespace openstudio {
12 namespace contam {
13
14 126 AirflowElementType AirflowElement::convertTag(const std::string& tag) {
15 try {
16
1/1
✓ Branch 1 taken 126 times.
126 return {tag};
17 ✗ } catch (...) {
18 ✗ return AirflowElementType::UNKNOWN;
19 ✗ }
20 }
21
22 126 AirflowElement* AirflowElement::readElement(Reader& input) {
23 126 AirflowElement* out = nullptr;
24
1/1
✓ Branch 1 taken 126 times.
126 const int nr = input.read<int>();
25
1/1
✓ Branch 1 taken 126 times.
126 const int icon = input.read<int>();
26
1/1
✓ Branch 1 taken 126 times.
126 const std::string dataType = input.readString();
27
1/1
✓ Branch 1 taken 126 times.
126 const std::string name = input.readString();
28
1/1
✓ Branch 1 taken 126 times.
126 const std::string desc = input.readLine();
29
1/1
✓ Branch 1 taken 126 times.
126 const AirflowElementType kind = convertTag(dataType);
30
2/3
✓ Branch 1 taken 126 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 126 times.
126 if (kind == AirflowElementType::UNKNOWN) {
31 ✗ LOG_FREE_AND_THROW("openstudio.contam.Reader", "Unknown airflow element type '" << dataType << "' at line " << input.lineNumber());
32
2/3
✓ Branch 1 taken 126 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 126 times.
126 } else if (kind == AirflowElementType::PL_ORFC) {
33 ✗ auto* obj = new PlrOrf(nr, icon, name, desc);
34 ✗ obj->readDetails(input);
35 ✗ out = static_cast<AirflowElement*>(obj);
36
3/3
✓ Branch 1 taken 126 times.
✓ Branch 4 taken 30 times.
✓ Branch 5 taken 96 times.
126 } else if (kind == AirflowElementType::PL_LEAK1) {
37
4/6
✓ Branch 1 taken 30 times.
✓ Branch 4 taken 30 times.
✓ Branch 7 taken 30 times.
✓ Branch 10 taken 30 times.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
30 auto* obj = new PlrLeak1(nr, icon, name, desc);
38
1/1
✓ Branch 1 taken 30 times.
30 obj->readDetails(input);
39 30 out = static_cast<AirflowElement*>(obj);
40
2/3
✓ Branch 1 taken 96 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 96 times.
96 } else if (kind == AirflowElementType::PL_LEAK2) {
41 ✗ auto* obj = new PlrLeak2(nr, icon, name, desc);
42 ✗ obj->readDetails(input);
43 ✗ out = static_cast<AirflowElement*>(obj);
44
3/3
✓ Branch 1 taken 96 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 90 times.
96 } else if (kind == AirflowElementType::PL_LEAK3) {
45
4/6
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✓ Branch 10 taken 6 times.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
6 auto* obj = new PlrLeak3(nr, icon, name, desc);
46
1/1
✓ Branch 1 taken 6 times.
6 obj->readDetails(input);
47 6 out = static_cast<AirflowElement*>(obj);
48
2/3
✓ Branch 1 taken 90 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 90 times.
90 } else if (kind == AirflowElementType::PL_CONN) {
49 ✗ auto* obj = new PlrConn(nr, icon, name, desc);
50 ✗ obj->readDetails(input);
51 ✗ out = static_cast<AirflowElement*>(obj);
52
2/3
✓ Branch 1 taken 90 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 90 times.
90 } else if (kind == AirflowElementType::PL_QCN) {
53 ✗ auto* obj = new PlrQcn(nr, icon, name, desc);
54 ✗ obj->readDetails(input);
55 ✗ out = static_cast<AirflowElement*>(obj);
56
2/3
✓ Branch 1 taken 90 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 90 times.
90 } else if (kind == AirflowElementType::PL_FCN) {
57 ✗ auto* obj = new PlrFcn(nr, icon, name, desc);
58 ✗ obj->readDetails(input);
59 ✗ out = static_cast<AirflowElement*>(obj);
60
3/3
✓ Branch 1 taken 90 times.
✓ Branch 4 taken 72 times.
✓ Branch 5 taken 18 times.
90 } else if (kind == AirflowElementType::PL_TEST1) {
61
4/6
✓ Branch 1 taken 72 times.
✓ Branch 4 taken 72 times.
✓ Branch 7 taken 72 times.
✓ Branch 10 taken 72 times.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
72 auto* obj = new PlrTest1(nr, icon, name, desc);
62
1/1
✓ Branch 1 taken 72 times.
72 obj->readDetails(input);
63 72 out = static_cast<AirflowElement*>(obj);
64
2/3
✓ Branch 1 taken 18 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 18 times.
18 } else if (kind == AirflowElementType::PL_TEST2) {
65 ✗ auto* obj = new PlrTest2(nr, icon, name, desc);
66 ✗ obj->readDetails(input);
67 ✗ out = static_cast<AirflowElement*>(obj);
68
2/3
✓ Branch 1 taken 18 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 18 times.
18 } else if (kind == AirflowElementType::PL_CRACK) {
69 ✗ auto* obj = new PlrCrack(nr, icon, name, desc);
70 ✗ obj->readDetails(input);
71 ✗ out = static_cast<AirflowElement*>(obj);
72
3/3
✓ Branch 1 taken 18 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 12 times.
18 } else if (kind == AirflowElementType::PL_STAIR) {
73
4/6
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✓ Branch 10 taken 6 times.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
6 auto* obj = new PlrStair(nr, icon, name, desc);
74
1/1
✓ Branch 1 taken 6 times.
6 obj->readDetails(input);
75 6 out = static_cast<AirflowElement*>(obj);
76
3/3
✓ Branch 1 taken 12 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 6 times.
12 } else if (kind == AirflowElementType::PL_SHAFT) {
77
4/6
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✓ Branch 10 taken 6 times.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
6 auto* obj = new PlrShaft(nr, icon, name, desc);
78
1/1
✓ Branch 1 taken 6 times.
6 obj->readDetails(input);
79 6 out = static_cast<AirflowElement*>(obj);
80
2/3
✓ Branch 1 taken 6 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
6 } else if (kind == AirflowElementType::PL_BDQ) {
81 ✗ auto* obj = new PlrBdq(nr, icon, name, desc);
82 ✗ obj->readDetails(input);
83 ✗ out = static_cast<AirflowElement*>(obj);
84
2/3
✓ Branch 1 taken 6 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
6 } else if (kind == AirflowElementType::PL_BDF) {
85 ✗ auto* obj = new PlrBdf(nr, icon, name, desc);
86 ✗ obj->readDetails(input);
87 ✗ out = static_cast<AirflowElement*>(obj);
88
2/3
✓ Branch 1 taken 6 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
6 } else if (kind == AirflowElementType::QFR_QAB) {
89 ✗ auto* obj = new QfrQab(nr, icon, name, desc);
90 ✗ obj->readDetails(input);
91 ✗ out = static_cast<AirflowElement*>(obj);
92
2/3
✓ Branch 1 taken 6 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
6 } else if (kind == AirflowElementType::QFR_QAF) {
93 ✗ auto* obj = new QfrFab(nr, icon, name, desc);
94 ✗ obj->readDetails(input);
95 ✗ out = static_cast<AirflowElement*>(obj);
96
2/3
✓ Branch 1 taken 6 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
6 } else if (kind == AirflowElementType::QFR_CRACK) {
97 ✗ auto* obj = new QfrCrack(nr, icon, name, desc);
98 ✗ obj->readDetails(input);
99 ✗ out = static_cast<AirflowElement*>(obj);
100
2/3
✓ Branch 1 taken 6 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
6 } else if (kind == AirflowElementType::QFR_TEST2) {
101 ✗ auto* obj = new QfrTest2(nr, icon, name, desc);
102 ✗ obj->readDetails(input);
103 ✗ out = static_cast<AirflowElement*>(obj);
104
2/3
✓ Branch 1 taken 6 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
6 } else if (kind == AirflowElementType::DR_DOOR) {
105 ✗ auto* obj = new AfeDor(nr, icon, name, desc);
106 ✗ obj->readDetails(input);
107 ✗ out = static_cast<AirflowElement*>(obj);
108
2/3
✓ Branch 1 taken 6 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
6 } else if (kind == AirflowElementType::DR_PL2) {
109 ✗ auto* obj = new DrPl2(nr, icon, name, desc);
110 ✗ obj->readDetails(input);
111 ✗ out = static_cast<AirflowElement*>(obj);
112
2/3
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
6 } else if (kind == AirflowElementType::FN_CMF) {
113
4/6
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✓ Branch 10 taken 6 times.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
6 auto* obj = new AfeCmf(nr, icon, name, desc);
114
1/1
✓ Branch 1 taken 6 times.
6 obj->readDetails(input);
115 6 out = static_cast<AirflowElement*>(obj);
116 ✗ } else if (kind == AirflowElementType::FN_CVF) {
117 ✗ auto* obj = new AfeCvf(nr, icon, name, desc);
118 ✗ obj->readDetails(input);
119 ✗ out = static_cast<AirflowElement*>(obj);
120 ✗ } else if (kind == AirflowElementType::FN_FAN) {
121 ✗ auto* obj = new AfeFan(nr, icon, name, desc);
122 ✗ obj->readDetails(input);
123 ✗ out = static_cast<AirflowElement*>(obj);
124 ✗ } else if (kind == AirflowElementType::CS_FSP) {
125 ✗ auto* obj = new AfeFsp(nr, icon, name, desc);
126 ✗ obj->readDetails(input);
127 ✗ out = static_cast<AirflowElement*>(obj);
128 ✗ } else if (kind == AirflowElementType::CS_QSP) {
129 ✗ auto* obj = new AfeQsp(nr, icon, name, desc);
130 ✗ obj->readDetails(input);
131 ✗ out = static_cast<AirflowElement*>(obj);
132 ✗ } else if (kind == AirflowElementType::CS_PSF) {
133 ✗ auto* obj = new AfePsf(nr, icon, name, desc);
134 ✗ obj->readDetails(input);
135 ✗ out = static_cast<AirflowElement*>(obj);
136 ✗ } else if (kind == AirflowElementType::CS_PSQ) {
137 ✗ auto* obj = new AfePsq(nr, icon, name, desc);
138 ✗ obj->readDetails(input);
139 ✗ out = static_cast<AirflowElement*>(obj);
140 ✗ } else if (kind == AirflowElementType::AF_SUP) {
141 ✗ auto* obj = new AfeSup(nr, icon, name, desc);
142 ✗ obj->readDetails(input);
143 ✗ out = static_cast<AirflowElement*>(obj);
144 }
145 126 return out;
146 126 }
147
148 ✗ PlrOrf::PlrOrf() : m_impl(std::shared_ptr<detail::PlrOrfImpl>(new detail::PlrOrfImpl)) {}
149
150 ✗ PlrOrf::PlrOrf(int nr, int icon, std::string name, std::string desc)
151 ✗ : m_impl(std::shared_ptr<detail::PlrOrfImpl>(new detail::PlrOrfImpl(nr, icon, name, desc))) {}
152
153 ✗ PlrOrf::PlrOrf(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double area, double dia, double coef,
154 ✗ double Re, int u_A, int u_D)
155 ✗ : m_impl(std::shared_ptr<detail::PlrOrfImpl>(new detail::PlrOrfImpl(nr, icon, name, desc, lam, turb, expt, area, dia, coef, Re, u_A, u_D))) {}
156
157 ✗ PlrOrf::PlrOrf(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string area,
158 ✗ std::string dia, std::string coef, std::string Re, int u_A, int u_D)
159 ✗ : m_impl(std::shared_ptr<detail::PlrOrfImpl>(new detail::PlrOrfImpl(nr, icon, name, desc, lam, turb, expt, area, dia, coef, Re, u_A, u_D))) {}
160
161 ✗ PlrOrf::PlrOrf(const PlrOrf& other) : m_impl(other.m_impl) {}
162
163 ✗ PlrOrf& PlrOrf::operator=(const PlrOrf& other) {
164 ✗ m_impl = other.m_impl;
165 ✗ return *this;
166 }
167
168 ✗ bool PlrOrf::operator==(const PlrOrf& other) const {
169 ✗ return m_impl == other.m_impl;
170 }
171
172 ✗ bool PlrOrf::operator!=(const PlrOrf& other) const {
173 ✗ return m_impl != other.m_impl;
174 }
175
176 ✗ std::string PlrOrf::write() {
177 ✗ return m_impl->write();
178 }
179
180 ✗ void PlrOrf::read(Reader& input) {
181 ✗ m_impl->read(input);
182 ✗ }
183
184 ✗ void PlrOrf::readDetails(Reader& input) {
185 ✗ m_impl->readDetails(input);
186 ✗ }
187
188 ✗ int PlrOrf::nr() const {
189 ✗ return m_impl->nr();
190 }
191
192 ✗ void PlrOrf::setNr(const int nr) {
193 ✗ m_impl->setNr(nr);
194 ✗ }
195
196 ✗ int PlrOrf::icon() const {
197 ✗ return m_impl->icon();
198 }
199
200 ✗ void PlrOrf::setIcon(const int icon) {
201 ✗ m_impl->setIcon(icon);
202 ✗ }
203
204 ✗ std::string PlrOrf::name() const {
205 ✗ return m_impl->name();
206 }
207
208 ✗ void PlrOrf::setName(const std::string& name) {
209 ✗ m_impl->setName(name);
210 ✗ }
211
212 ✗ std::string PlrOrf::desc() const {
213 ✗ return m_impl->desc();
214 }
215
216 ✗ void PlrOrf::setDesc(const std::string& desc) {
217 ✗ m_impl->setDesc(desc);
218 ✗ }
219
220 ✗ double PlrOrf::lam() const {
221 ✗ return m_impl->lam();
222 }
223
224 ✗ bool PlrOrf::setLam(const double lam) {
225 ✗ return m_impl->setLam(lam);
226 }
227
228 ✗ bool PlrOrf::setLam(const std::string& lam) {
229 ✗ return m_impl->setLam(lam);
230 }
231
232 ✗ double PlrOrf::turb() const {
233 ✗ return m_impl->turb();
234 }
235
236 ✗ bool PlrOrf::setTurb(const double turb) {
237 ✗ return m_impl->setTurb(turb);
238 }
239
240 ✗ bool PlrOrf::setTurb(const std::string& turb) {
241 ✗ return m_impl->setTurb(turb);
242 }
243
244 ✗ double PlrOrf::expt() const {
245 ✗ return m_impl->expt();
246 }
247
248 ✗ bool PlrOrf::setExpt(const double expt) {
249 ✗ return m_impl->setExpt(expt);
250 }
251
252 ✗ bool PlrOrf::setExpt(const std::string& expt) {
253 ✗ return m_impl->setExpt(expt);
254 }
255
256 ✗ double PlrOrf::area() const {
257 ✗ return m_impl->area();
258 }
259
260 ✗ bool PlrOrf::setArea(const double area) {
261 ✗ return m_impl->setArea(area);
262 }
263
264 ✗ bool PlrOrf::setArea(const std::string& area) {
265 ✗ return m_impl->setArea(area);
266 }
267
268 ✗ double PlrOrf::dia() const {
269 ✗ return m_impl->dia();
270 }
271
272 ✗ bool PlrOrf::setDia(const double dia) {
273 ✗ return m_impl->setDia(dia);
274 }
275
276 ✗ bool PlrOrf::setDia(const std::string& dia) {
277 ✗ return m_impl->setDia(dia);
278 }
279
280 ✗ double PlrOrf::coef() const {
281 ✗ return m_impl->coef();
282 }
283
284 ✗ bool PlrOrf::setCoef(const double coef) {
285 ✗ return m_impl->setCoef(coef);
286 }
287
288 ✗ bool PlrOrf::setCoef(const std::string& coef) {
289 ✗ return m_impl->setCoef(coef);
290 }
291
292 ✗ double PlrOrf::Re() const {
293 ✗ return m_impl->Re();
294 }
295
296 ✗ bool PlrOrf::setRe(const double Re) {
297 ✗ return m_impl->setRe(Re);
298 }
299
300 ✗ bool PlrOrf::setRe(const std::string& Re) {
301 ✗ return m_impl->setRe(Re);
302 }
303
304 ✗ int PlrOrf::u_A() const {
305 ✗ return m_impl->u_A();
306 }
307
308 ✗ void PlrOrf::setU_A(const int u_A) {
309 ✗ m_impl->setU_A(u_A);
310 ✗ }
311
312 ✗ int PlrOrf::u_D() const {
313 ✗ return m_impl->u_D();
314 }
315
316 ✗ void PlrOrf::setU_D(const int u_D) {
317 ✗ m_impl->setU_D(u_D);
318 ✗ }
319
320
3/5
✓ Branch 2 taken 1 time.
✓ Branch 5 taken 1 time.
✓ Branch 8 taken 1 time.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
1 PlrLeak::PlrLeak() : m_impl(std::shared_ptr<detail::PlrLeakImpl>(new detail::PlrLeakImpl())) {}
321
322 36 PlrLeak::PlrLeak(int nr, int icon, std::string name, std::string desc)
323
5/7
✓ Branch 2 taken 36 times.
✓ Branch 5 taken 36 times.
✓ Branch 8 taken 36 times.
✓ Branch 11 taken 36 times.
✓ Branch 14 taken 36 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
36 : m_impl(std::shared_ptr<detail::PlrLeakImpl>(new detail::PlrLeakImpl(nr, icon, name, desc))) {}
324
325 ✗ PlrLeak::PlrLeak(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double coef, double pres, double area1,
326 ✗ double area2, double area3, int u_A1, int u_A2, int u_A3, int u_dP)
327 ✗ : m_impl(std::shared_ptr<detail::PlrLeakImpl>(
328 ✗ new detail::PlrLeakImpl(nr, icon, name, desc, lam, turb, expt, coef, pres, area1, area2, area3, u_A1, u_A2, u_A3, u_dP))) {}
329
330 2 PlrLeak::PlrLeak(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string coef,
331 2 std::string pres, std::string area1, std::string area2, std::string area3, int u_A1, int u_A2, int u_A3, int u_dP)
332
1/3
✓ Branch 1 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
2 : m_impl(std::shared_ptr<detail::PlrLeakImpl>(
333
12/12
✓ Branch 2 taken 2 times.
✓ Branch 5 taken 2 times.
✓ Branch 8 taken 2 times.
✓ Branch 11 taken 2 times.
✓ Branch 14 taken 2 times.
✓ Branch 17 taken 2 times.
✓ Branch 20 taken 2 times.
✓ Branch 23 taken 2 times.
✓ Branch 26 taken 2 times.
✓ Branch 29 taken 2 times.
✓ Branch 32 taken 2 times.
✓ Branch 35 taken 2 times.
4 new detail::PlrLeakImpl(nr, icon, name, desc, lam, turb, expt, coef, pres, area1, area2, area3, u_A1, u_A2, u_A3, u_dP))) {}
334
335 4 PlrLeak::PlrLeak(const PlrLeak& other) : m_impl(other.m_impl) {}
336
337 1 PlrLeak& PlrLeak::operator=(const PlrLeak& other) {
338 1 m_impl = other.m_impl;
339 1 return *this;
340 }
341
342 1 bool PlrLeak::operator==(const PlrLeak& other) const {
343 1 return m_impl == other.m_impl;
344 }
345
346 ✗ bool PlrLeak::operator!=(const PlrLeak& other) const {
347 ✗ return m_impl != other.m_impl;
348 }
349
350 6 std::string PlrLeak::write() {
351
2/2
✓ Branch 2 taken 6 times.
✓ Branch 5 taken 6 times.
12 return m_impl->write(dataType());
352 }
353
354 ✗ void PlrLeak::read(Reader& input) {
355 ✗ m_impl->read(input);
356 ✗ }
357
358 36 void PlrLeak::readDetails(Reader& input) {
359 36 m_impl->readDetails(input);
360 36 }
361
362 1 int PlrLeak::nr() const {
363 1 return m_impl->nr();
364 }
365
366 1 void PlrLeak::setNr(const int nr) {
367 1 m_impl->setNr(nr);
368 1 }
369
370 ✗ int PlrLeak::icon() const {
371 ✗ return m_impl->icon();
372 }
373
374 ✗ void PlrLeak::setIcon(const int icon) {
375 ✗ m_impl->setIcon(icon);
376 ✗ }
377
378 54 std::string PlrLeak::name() const {
379 54 return m_impl->name();
380 }
381
382 ✗ void PlrLeak::setName(const std::string& name) {
383 ✗ m_impl->setName(name);
384 ✗ }
385
386 ✗ std::string PlrLeak::desc() const {
387 ✗ return m_impl->desc();
388 }
389
390 ✗ void PlrLeak::setDesc(const std::string& desc) {
391 ✗ m_impl->setDesc(desc);
392 ✗ }
393
394 ✗ double PlrLeak::lam() const {
395 ✗ return m_impl->lam();
396 }
397
398 ✗ bool PlrLeak::setLam(const double lam) {
399 ✗ return m_impl->setLam(lam);
400 }
401
402 ✗ bool PlrLeak::setLam(const std::string& lam) {
403 ✗ return m_impl->setLam(lam);
404 }
405
406 ✗ double PlrLeak::turb() const {
407 ✗ return m_impl->turb();
408 }
409
410 ✗ bool PlrLeak::setTurb(const double turb) {
411 ✗ return m_impl->setTurb(turb);
412 }
413
414 ✗ bool PlrLeak::setTurb(const std::string& turb) {
415 ✗ return m_impl->setTurb(turb);
416 }
417
418 ✗ double PlrLeak::expt() const {
419 ✗ return m_impl->expt();
420 }
421
422 ✗ bool PlrLeak::setExpt(const double expt) {
423 ✗ return m_impl->setExpt(expt);
424 }
425
426 ✗ bool PlrLeak::setExpt(const std::string& expt) {
427 ✗ return m_impl->setExpt(expt);
428 }
429
430 ✗ double PlrLeak::coef() const {
431 ✗ return m_impl->coef();
432 }
433
434 ✗ bool PlrLeak::setCoef(const double coef) {
435 ✗ return m_impl->setCoef(coef);
436 }
437
438 ✗ bool PlrLeak::setCoef(const std::string& coef) {
439 ✗ return m_impl->setCoef(coef);
440 }
441
442 ✗ double PlrLeak::pres() const {
443 ✗ return m_impl->pres();
444 }
445
446 ✗ bool PlrLeak::setPres(const double pres) {
447 ✗ return m_impl->setPres(pres);
448 }
449
450 ✗ bool PlrLeak::setPres(const std::string& pres) {
451 ✗ return m_impl->setPres(pres);
452 }
453
454 ✗ double PlrLeak::area1() const {
455 ✗ return m_impl->area1();
456 }
457
458 ✗ bool PlrLeak::setArea1(const double area1) {
459 ✗ return m_impl->setArea1(area1);
460 }
461
462 ✗ bool PlrLeak::setArea1(const std::string& area1) {
463 ✗ return m_impl->setArea1(area1);
464 }
465
466 ✗ double PlrLeak::area2() const {
467 ✗ return m_impl->area2();
468 }
469
470 ✗ bool PlrLeak::setArea2(const double area2) {
471 ✗ return m_impl->setArea2(area2);
472 }
473
474 ✗ bool PlrLeak::setArea2(const std::string& area2) {
475 ✗ return m_impl->setArea2(area2);
476 }
477
478 ✗ double PlrLeak::area3() const {
479 ✗ return m_impl->area3();
480 }
481
482 ✗ bool PlrLeak::setArea3(const double area3) {
483 ✗ return m_impl->setArea3(area3);
484 }
485
486 ✗ bool PlrLeak::setArea3(const std::string& area3) {
487 ✗ return m_impl->setArea3(area3);
488 }
489
490 ✗ int PlrLeak::u_A1() const {
491 ✗ return m_impl->u_A1();
492 }
493
494 ✗ void PlrLeak::setU_A1(const int u_A1) {
495 ✗ m_impl->setU_A1(u_A1);
496 ✗ }
497
498 ✗ int PlrLeak::u_A2() const {
499 ✗ return m_impl->u_A2();
500 }
501
502 ✗ void PlrLeak::setU_A2(const int u_A2) {
503 ✗ m_impl->setU_A2(u_A2);
504 ✗ }
505
506 ✗ int PlrLeak::u_A3() const {
507 ✗ return m_impl->u_A3();
508 }
509
510 ✗ void PlrLeak::setU_A3(const int u_A3) {
511 ✗ m_impl->setU_A3(u_A3);
512 ✗ }
513
514 ✗ int PlrLeak::u_dP() const {
515 ✗ return m_impl->u_dP();
516 }
517
518 ✗ void PlrLeak::setU_dP(const int u_dP) {
519 ✗ m_impl->setU_dP(u_dP);
520 ✗ }
521
522 ✗ PlrLeak1::PlrLeak1() : PlrLeak() {}
523
524
3/3
✓ Branch 1 taken 30 times.
✓ Branch 4 taken 30 times.
✓ Branch 7 taken 30 times.
30 PlrLeak1::PlrLeak1(int nr, int icon, std::string name, std::string desc) : PlrLeak(nr, icon, name, desc) {}
525
526 ✗ PlrLeak1::PlrLeak1(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double coef, double pres,
527 ✗ double area1, double area2, double area3, int u_A1, int u_A2, int u_A3, int u_dP)
528 ✗ : PlrLeak(nr, icon, name, desc, lam, turb, expt, coef, pres, area1, area2, area3, u_A1, u_A2, u_A3, u_dP) {}
529
530 ✗ PlrLeak1::PlrLeak1(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string coef,
531 ✗ std::string pres, std::string area1, std::string area2, std::string area3, int u_A1, int u_A2, int u_A3, int u_dP)
532 ✗ : PlrLeak(nr, icon, name, desc, lam, turb, expt, coef, pres, area1, area2, area3, u_A1, u_A2, u_A3, u_dP) {}
533
534 1 PlrLeak2::PlrLeak2() : PlrLeak() {}
535
536 ✗ PlrLeak2::PlrLeak2(int nr, int icon, std::string name, std::string desc) : PlrLeak(nr, icon, name, desc) {}
537
538 ✗ PlrLeak2::PlrLeak2(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double coef, double pres,
539 ✗ double area1, double area2, double area3, int u_A1, int u_A2, int u_A3, int u_dP)
540 ✗ : PlrLeak(nr, icon, name, desc, lam, turb, expt, coef, pres, area1, area2, area3, u_A1, u_A2, u_A3, u_dP) {}
541
542 ✗ PlrLeak2::PlrLeak2(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string coef,
543 ✗ std::string pres, std::string area1, std::string area2, std::string area3, int u_A1, int u_A2, int u_A3, int u_dP)
544 ✗ : PlrLeak(nr, icon, name, desc, lam, turb, expt, coef, pres, area1, area2, area3, u_A1, u_A2, u_A3, u_dP) {}
545
546 ✗ PlrLeak2::PlrLeak2(int icon, std::string name, std::string desc, double lam, double turb, double expt, double coef, double pres, double area2)
547 ✗ : PlrLeak(0, icon, name, desc, lam, turb, expt, coef, pres, 0.0, area2, 0.0, 0, 0, 0, 0) {}
548
549 2 PlrLeak2::PlrLeak2(int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string coef,
550 2 std::string pres, std::string area2)
551
11/11
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 7 taken 2 times.
✓ Branch 10 taken 2 times.
✓ Branch 13 taken 2 times.
✓ Branch 16 taken 2 times.
✓ Branch 19 taken 2 times.
✓ Branch 22 taken 2 times.
✓ Branch 25 taken 2 times.
✓ Branch 28 taken 2 times.
✓ Branch 31 taken 2 times.
10 : PlrLeak(0, icon, name, desc, lam, turb, expt, coef, pres, "0.0", area2, "0.0", 0, 0, 0, 0) {}
552
553 ✗ PlrLeak3::PlrLeak3() : PlrLeak() {}
554
555
3/3
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
6 PlrLeak3::PlrLeak3(int nr, int icon, std::string name, std::string desc) : PlrLeak(nr, icon, name, desc) {}
556
557 ✗ PlrLeak3::PlrLeak3(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double coef, double pres,
558 ✗ double area1, double area2, double area3, int u_A1, int u_A2, int u_A3, int u_dP)
559 ✗ : PlrLeak(nr, icon, name, desc, lam, turb, expt, coef, pres, area1, area2, area3, u_A1, u_A2, u_A3, u_dP) {}
560
561 ✗ PlrLeak3::PlrLeak3(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string coef,
562 ✗ std::string pres, std::string area1, std::string area2, std::string area3, int u_A1, int u_A2, int u_A3, int u_dP)
563 ✗ : PlrLeak(nr, icon, name, desc, lam, turb, expt, coef, pres, area1, area2, area3, u_A1, u_A2, u_A3, u_dP) {}
564
565 ✗ PlrConn::PlrConn() : m_impl(std::shared_ptr<detail::PlrConnImpl>(new detail::PlrConnImpl)) {}
566
567 ✗ PlrConn::PlrConn(int nr, int icon, std::string name, std::string desc)
568 ✗ : m_impl(std::shared_ptr<detail::PlrConnImpl>(new detail::PlrConnImpl(nr, icon, name, desc))) {}
569
570 ✗ PlrConn::PlrConn(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double area, double coef, int u_A)
571 ✗ : m_impl(std::shared_ptr<detail::PlrConnImpl>(new detail::PlrConnImpl(nr, icon, name, desc, lam, turb, expt, area, coef, u_A))) {}
572
573 ✗ PlrConn::PlrConn(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string area,
574 ✗ std::string coef, int u_A)
575 ✗ : m_impl(std::shared_ptr<detail::PlrConnImpl>(new detail::PlrConnImpl(nr, icon, name, desc, lam, turb, expt, area, coef, u_A))) {}
576
577 ✗ PlrConn::PlrConn(const PlrConn& other) : m_impl(other.m_impl) {}
578
579 ✗ PlrConn& PlrConn::operator=(const PlrConn& other) {
580 ✗ m_impl = other.m_impl;
581 ✗ return *this;
582 }
583
584 ✗ bool PlrConn::operator==(const PlrConn& other) const {
585 ✗ return m_impl == other.m_impl;
586 }
587
588 ✗ bool PlrConn::operator!=(const PlrConn& other) const {
589 ✗ return m_impl != other.m_impl;
590 }
591
592 ✗ std::string PlrConn::write() {
593 ✗ return m_impl->write();
594 }
595
596 ✗ void PlrConn::read(Reader& input) {
597 ✗ m_impl->read(input);
598 ✗ }
599
600 ✗ void PlrConn::readDetails(Reader& input) {
601 ✗ m_impl->readDetails(input);
602 ✗ }
603
604 ✗ int PlrConn::nr() const {
605 ✗ return m_impl->nr();
606 }
607
608 ✗ void PlrConn::setNr(const int nr) {
609 ✗ m_impl->setNr(nr);
610 ✗ }
611
612 ✗ int PlrConn::icon() const {
613 ✗ return m_impl->icon();
614 }
615
616 ✗ void PlrConn::setIcon(const int icon) {
617 ✗ m_impl->setIcon(icon);
618 ✗ }
619
620 ✗ std::string PlrConn::name() const {
621 ✗ return m_impl->name();
622 }
623
624 ✗ void PlrConn::setName(const std::string& name) {
625 ✗ m_impl->setName(name);
626 ✗ }
627
628 ✗ std::string PlrConn::desc() const {
629 ✗ return m_impl->desc();
630 }
631
632 ✗ void PlrConn::setDesc(const std::string& desc) {
633 ✗ m_impl->setDesc(desc);
634 ✗ }
635
636 ✗ double PlrConn::lam() const {
637 ✗ return m_impl->lam();
638 }
639
640 ✗ bool PlrConn::setLam(const double lam) {
641 ✗ return m_impl->setLam(lam);
642 }
643
644 ✗ bool PlrConn::setLam(const std::string& lam) {
645 ✗ return m_impl->setLam(lam);
646 }
647
648 ✗ double PlrConn::turb() const {
649 ✗ return m_impl->turb();
650 }
651
652 ✗ bool PlrConn::setTurb(const double turb) {
653 ✗ return m_impl->setTurb(turb);
654 }
655
656 ✗ bool PlrConn::setTurb(const std::string& turb) {
657 ✗ return m_impl->setTurb(turb);
658 }
659
660 ✗ double PlrConn::expt() const {
661 ✗ return m_impl->expt();
662 }
663
664 ✗ bool PlrConn::setExpt(const double expt) {
665 ✗ return m_impl->setExpt(expt);
666 }
667
668 ✗ bool PlrConn::setExpt(const std::string& expt) {
669 ✗ return m_impl->setExpt(expt);
670 }
671
672 ✗ double PlrConn::area() const {
673 ✗ return m_impl->area();
674 }
675
676 ✗ bool PlrConn::setArea(const double area) {
677 ✗ return m_impl->setArea(area);
678 }
679
680 ✗ bool PlrConn::setArea(const std::string& area) {
681 ✗ return m_impl->setArea(area);
682 }
683
684 ✗ double PlrConn::coef() const {
685 ✗ return m_impl->coef();
686 }
687
688 ✗ bool PlrConn::setCoef(const double coef) {
689 ✗ return m_impl->setCoef(coef);
690 }
691
692 ✗ bool PlrConn::setCoef(const std::string& coef) {
693 ✗ return m_impl->setCoef(coef);
694 }
695
696 ✗ int PlrConn::u_A() const {
697 ✗ return m_impl->u_A();
698 }
699
700 ✗ void PlrConn::setU_A(const int u_A) {
701 ✗ m_impl->setU_A(u_A);
702 ✗ }
703
704 ✗ PlrGeneral::PlrGeneral() : m_impl(std::shared_ptr<detail::PlrGeneralImpl>(new detail::PlrGeneralImpl)) {}
705
706 ✗ PlrGeneral::PlrGeneral(int nr, int icon, std::string name, std::string desc)
707 ✗ : m_impl(std::shared_ptr<detail::PlrGeneralImpl>(new detail::PlrGeneralImpl(nr, icon, name, desc))) {}
708
709 ✗ PlrGeneral::PlrGeneral(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt)
710 ✗ : m_impl(std::shared_ptr<detail::PlrGeneralImpl>(new detail::PlrGeneralImpl(nr, icon, name, desc, lam, turb, expt))) {}
711
712 ✗ PlrGeneral::PlrGeneral(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt)
713 ✗ : m_impl(std::shared_ptr<detail::PlrGeneralImpl>(new detail::PlrGeneralImpl(nr, icon, name, desc, lam, turb, expt))) {}
714
715 ✗ PlrGeneral::PlrGeneral(const PlrGeneral& other) : m_impl(other.m_impl) {}
716
717 ✗ PlrGeneral& PlrGeneral::operator=(const PlrGeneral& other) {
718 ✗ m_impl = other.m_impl;
719 ✗ return *this;
720 }
721
722 ✗ bool PlrGeneral::operator==(const PlrGeneral& other) const {
723 ✗ return m_impl == other.m_impl;
724 }
725
726 ✗ bool PlrGeneral::operator!=(const PlrGeneral& other) const {
727 ✗ return m_impl != other.m_impl;
728 }
729
730 ✗ std::string PlrGeneral::write() {
731 ✗ return m_impl->write(dataType());
732 }
733
734 ✗ void PlrGeneral::read(Reader& input) {
735 ✗ m_impl->read(input);
736 ✗ }
737
738 ✗ void PlrGeneral::readDetails(Reader& input) {
739 ✗ m_impl->readDetails(input);
740 ✗ }
741
742 ✗ int PlrGeneral::nr() const {
743 ✗ return m_impl->nr();
744 }
745
746 ✗ void PlrGeneral::setNr(const int nr) {
747 ✗ m_impl->setNr(nr);
748 ✗ }
749
750 ✗ int PlrGeneral::icon() const {
751 ✗ return m_impl->icon();
752 }
753
754 ✗ void PlrGeneral::setIcon(const int icon) {
755 ✗ m_impl->setIcon(icon);
756 ✗ }
757
758 ✗ std::string PlrGeneral::name() const {
759 ✗ return m_impl->name();
760 }
761
762 ✗ void PlrGeneral::setName(const std::string& name) {
763 ✗ m_impl->setName(name);
764 ✗ }
765
766 ✗ std::string PlrGeneral::desc() const {
767 ✗ return m_impl->desc();
768 }
769
770 ✗ void PlrGeneral::setDesc(const std::string& desc) {
771 ✗ m_impl->setDesc(desc);
772 ✗ }
773
774 ✗ double PlrGeneral::lam() const {
775 ✗ return m_impl->lam();
776 }
777
778 ✗ bool PlrGeneral::setLam(const double lam) {
779 ✗ return m_impl->setLam(lam);
780 }
781
782 ✗ bool PlrGeneral::setLam(const std::string& lam) {
783 ✗ return m_impl->setLam(lam);
784 }
785
786 ✗ double PlrGeneral::turb() const {
787 ✗ return m_impl->turb();
788 }
789
790 ✗ bool PlrGeneral::setTurb(const double turb) {
791 ✗ return m_impl->setTurb(turb);
792 }
793
794 ✗ bool PlrGeneral::setTurb(const std::string& turb) {
795 ✗ return m_impl->setTurb(turb);
796 }
797
798 ✗ double PlrGeneral::expt() const {
799 ✗ return m_impl->expt();
800 }
801
802 ✗ bool PlrGeneral::setExpt(const double expt) {
803 ✗ return m_impl->setExpt(expt);
804 }
805
806 ✗ bool PlrGeneral::setExpt(const std::string& expt) {
807 ✗ return m_impl->setExpt(expt);
808 }
809
810 ✗ PlrQcn::PlrQcn() : PlrGeneral() {}
811
812 ✗ PlrQcn::PlrQcn(int nr, int icon, std::string name, std::string desc) : PlrGeneral(nr, icon, name, desc) {}
813
814 ✗ PlrQcn::PlrQcn(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt)
815 ✗ : PlrGeneral(nr, icon, name, desc, lam, turb, expt) {}
816
817 ✗ PlrQcn::PlrQcn(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt)
818 ✗ : PlrGeneral(nr, icon, name, desc, lam, turb, expt) {}
819
820 ✗ PlrFcn::PlrFcn() : PlrGeneral() {}
821
822 ✗ PlrFcn::PlrFcn(int nr, int icon, std::string name, std::string desc) : PlrGeneral(nr, icon, name, desc) {}
823
824 ✗ PlrFcn::PlrFcn(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt)
825 ✗ : PlrGeneral(nr, icon, name, desc, lam, turb, expt) {}
826
827 ✗ PlrFcn::PlrFcn(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt)
828 ✗ : PlrGeneral(nr, icon, name, desc, lam, turb, expt) {}
829
830
3/5
✓ Branch 2 taken 2 times.
✓ Branch 5 taken 2 times.
✓ Branch 8 taken 2 times.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
2 PlrTest1::PlrTest1() : m_impl(std::shared_ptr<detail::PlrTest1Impl>(new detail::PlrTest1Impl)) {}
831
832 72 PlrTest1::PlrTest1(int nr, int icon, std::string name, std::string desc)
833
5/7
✓ Branch 2 taken 72 times.
✓ Branch 5 taken 72 times.
✓ Branch 8 taken 72 times.
✓ Branch 11 taken 72 times.
✓ Branch 14 taken 72 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
72 : m_impl(std::shared_ptr<detail::PlrTest1Impl>(new detail::PlrTest1Impl(nr, icon, name, desc))) {}
834
835 1 PlrTest1::PlrTest1(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double dP, double Flow, int u_P,
836 1 int u_F)
837
5/7
✓ Branch 2 taken 1 time.
✓ Branch 5 taken 1 time.
✓ Branch 8 taken 1 time.
✓ Branch 11 taken 1 time.
✓ Branch 14 taken 1 time.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
1 : m_impl(std::shared_ptr<detail::PlrTest1Impl>(new detail::PlrTest1Impl(nr, icon, name, desc, lam, turb, expt, dP, Flow, u_P, u_F))) {}
838
839 1 PlrTest1::PlrTest1(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string dP,
840 1 std::string Flow, int u_P, int u_F)
841
10/12
✓ Branch 2 taken 1 time.
✓ Branch 5 taken 1 time.
✓ Branch 8 taken 1 time.
✓ Branch 11 taken 1 time.
✓ Branch 14 taken 1 time.
✓ Branch 17 taken 1 time.
✓ Branch 20 taken 1 time.
✓ Branch 23 taken 1 time.
✓ Branch 26 taken 1 time.
✓ Branch 29 taken 1 time.
✗ Branch 45 not taken.
✗ Branch 46 not taken.
1 : m_impl(std::shared_ptr<detail::PlrTest1Impl>(new detail::PlrTest1Impl(nr, icon, name, desc, lam, turb, expt, dP, Flow, u_P, u_F))) {}
842
843 1 PlrTest1::PlrTest1(int icon, std::string name, std::string desc, double lam, double turb, double expt, double dP, double Flow)
844
3/3
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
1 : PlrTest1(0, icon, name, desc, lam, turb, expt, dP, Flow, 0, 0) {}
845
846 1 PlrTest1::PlrTest1(int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string dP,
847 1 std::string Flow)
848
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 : PlrTest1(0, icon, name, desc, lam, turb, expt, dP, Flow, 0, 0) {}
849
850 13 PlrTest1::PlrTest1(const PlrTest1& other) : m_impl(other.m_impl) {}
851
852 2 PlrTest1& PlrTest1::operator=(const PlrTest1& other) {
853 2 m_impl = other.m_impl;
854 2 return *this;
855 }
856
857 2 bool PlrTest1::operator==(const PlrTest1& other) const {
858 2 return m_impl == other.m_impl;
859 }
860
861 ✗ bool PlrTest1::operator!=(const PlrTest1& other) const {
862 ✗ return m_impl != other.m_impl;
863 }
864
865 12 std::string PlrTest1::write() {
866 12 return m_impl->write();
867 }
868
869 ✗ void PlrTest1::read(Reader& input) {
870 ✗ m_impl->read(input);
871 ✗ }
872
873 72 void PlrTest1::readDetails(Reader& input) {
874 72 m_impl->readDetails(input);
875 72 }
876
877 26 int PlrTest1::nr() const {
878 26 return m_impl->nr();
879 }
880
881 2 void PlrTest1::setNr(const int nr) {
882 2 m_impl->setNr(nr);
883 2 }
884
885 ✗ int PlrTest1::icon() const {
886 ✗ return m_impl->icon();
887 }
888
889 ✗ void PlrTest1::setIcon(const int icon) {
890 ✗ m_impl->setIcon(icon);
891 ✗ }
892
893 132 std::string PlrTest1::name() const {
894 132 return m_impl->name();
895 }
896
897 ✗ void PlrTest1::setName(const std::string& name) {
898 ✗ m_impl->setName(name);
899 ✗ }
900
901 ✗ std::string PlrTest1::desc() const {
902 ✗ return m_impl->desc();
903 }
904
905 ✗ void PlrTest1::setDesc(const std::string& desc) {
906 ✗ m_impl->setDesc(desc);
907 ✗ }
908
909 ✗ double PlrTest1::lam() const {
910 ✗ return m_impl->lam();
911 }
912
913 ✗ bool PlrTest1::setLam(const double lam) {
914 ✗ return m_impl->setLam(lam);
915 }
916
917 ✗ bool PlrTest1::setLam(const std::string& lam) {
918 ✗ return m_impl->setLam(lam);
919 }
920
921 ✗ double PlrTest1::turb() const {
922 ✗ return m_impl->turb();
923 }
924
925 ✗ bool PlrTest1::setTurb(const double turb) {
926 ✗ return m_impl->setTurb(turb);
927 }
928
929 ✗ bool PlrTest1::setTurb(const std::string& turb) {
930 ✗ return m_impl->setTurb(turb);
931 }
932
933 ✗ double PlrTest1::expt() const {
934 ✗ return m_impl->expt();
935 }
936
937 ✗ bool PlrTest1::setExpt(const double expt) {
938 ✗ return m_impl->setExpt(expt);
939 }
940
941 ✗ bool PlrTest1::setExpt(const std::string& expt) {
942 ✗ return m_impl->setExpt(expt);
943 }
944
945 ✗ double PlrTest1::dP() const {
946 ✗ return m_impl->dP();
947 }
948
949 ✗ bool PlrTest1::setDP(const double dP) {
950 ✗ return m_impl->setDP(dP);
951 }
952
953 ✗ bool PlrTest1::setDP(const std::string& dP) {
954 ✗ return m_impl->setDP(dP);
955 }
956
957 ✗ double PlrTest1::Flow() const {
958 ✗ return m_impl->Flow();
959 }
960
961 ✗ bool PlrTest1::setFlow(const double Flow) {
962 ✗ return m_impl->setFlow(Flow);
963 }
964
965 ✗ bool PlrTest1::setFlow(const std::string& Flow) {
966 ✗ return m_impl->setFlow(Flow);
967 }
968
969 ✗ int PlrTest1::u_P() const {
970 ✗ return m_impl->u_P();
971 }
972
973 ✗ void PlrTest1::setU_P(const int u_P) {
974 ✗ m_impl->setU_P(u_P);
975 ✗ }
976
977 ✗ int PlrTest1::u_F() const {
978 ✗ return m_impl->u_F();
979 }
980
981 ✗ void PlrTest1::setU_F(const int u_F) {
982 ✗ m_impl->setU_F(u_F);
983 ✗ }
984
985 ✗ PlrTest2::PlrTest2() : m_impl(std::shared_ptr<detail::PlrTest2Impl>(new detail::PlrTest2Impl)) {}
986
987 ✗ PlrTest2::PlrTest2(int nr, int icon, std::string name, std::string desc)
988 ✗ : m_impl(std::shared_ptr<detail::PlrTest2Impl>(new detail::PlrTest2Impl(nr, icon, name, desc))) {}
989
990 ✗ PlrTest2::PlrTest2(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double dP1, double F1, double dP2,
991 ✗ double F2, int u_P1, int u_F1, int u_P2, int u_F2)
992 ✗ : m_impl(std::shared_ptr<detail::PlrTest2Impl>(
993 ✗ new detail::PlrTest2Impl(nr, icon, name, desc, lam, turb, expt, dP1, F1, dP2, F2, u_P1, u_F1, u_P2, u_F2))) {}
994
995 ✗ PlrTest2::PlrTest2(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string dP1,
996 ✗ std::string F1, std::string dP2, std::string F2, int u_P1, int u_F1, int u_P2, int u_F2)
997 ✗ : m_impl(std::shared_ptr<detail::PlrTest2Impl>(
998 ✗ new detail::PlrTest2Impl(nr, icon, name, desc, lam, turb, expt, dP1, F1, dP2, F2, u_P1, u_F1, u_P2, u_F2))) {}
999
1000 ✗ PlrTest2::PlrTest2(const PlrTest2& other) : m_impl(other.m_impl) {}
1001
1002 ✗ PlrTest2& PlrTest2::operator=(const PlrTest2& other) {
1003 ✗ m_impl = other.m_impl;
1004 ✗ return *this;
1005 }
1006
1007 ✗ bool PlrTest2::operator==(const PlrTest2& other) const {
1008 ✗ return m_impl == other.m_impl;
1009 }
1010
1011 ✗ bool PlrTest2::operator!=(const PlrTest2& other) const {
1012 ✗ return m_impl != other.m_impl;
1013 }
1014
1015 ✗ std::string PlrTest2::write() {
1016 ✗ return m_impl->write();
1017 }
1018
1019 ✗ void PlrTest2::read(Reader& input) {
1020 ✗ m_impl->read(input);
1021 ✗ }
1022
1023 ✗ void PlrTest2::readDetails(Reader& input) {
1024 ✗ m_impl->readDetails(input);
1025 ✗ }
1026
1027 ✗ int PlrTest2::nr() const {
1028 ✗ return m_impl->nr();
1029 }
1030
1031 ✗ void PlrTest2::setNr(const int nr) {
1032 ✗ m_impl->setNr(nr);
1033 ✗ }
1034
1035 ✗ int PlrTest2::icon() const {
1036 ✗ return m_impl->icon();
1037 }
1038
1039 ✗ void PlrTest2::setIcon(const int icon) {
1040 ✗ m_impl->setIcon(icon);
1041 ✗ }
1042
1043 ✗ std::string PlrTest2::name() const {
1044 ✗ return m_impl->name();
1045 }
1046
1047 ✗ void PlrTest2::setName(const std::string& name) {
1048 ✗ m_impl->setName(name);
1049 ✗ }
1050
1051 ✗ std::string PlrTest2::desc() const {
1052 ✗ return m_impl->desc();
1053 }
1054
1055 ✗ void PlrTest2::setDesc(const std::string& desc) {
1056 ✗ m_impl->setDesc(desc);
1057 ✗ }
1058
1059 ✗ double PlrTest2::lam() const {
1060 ✗ return m_impl->lam();
1061 }
1062
1063 ✗ bool PlrTest2::setLam(const double lam) {
1064 ✗ return m_impl->setLam(lam);
1065 }
1066
1067 ✗ bool PlrTest2::setLam(const std::string& lam) {
1068 ✗ return m_impl->setLam(lam);
1069 }
1070
1071 ✗ double PlrTest2::turb() const {
1072 ✗ return m_impl->turb();
1073 }
1074
1075 ✗ bool PlrTest2::setTurb(const double turb) {
1076 ✗ return m_impl->setTurb(turb);
1077 }
1078
1079 ✗ bool PlrTest2::setTurb(const std::string& turb) {
1080 ✗ return m_impl->setTurb(turb);
1081 }
1082
1083 ✗ double PlrTest2::expt() const {
1084 ✗ return m_impl->expt();
1085 }
1086
1087 ✗ bool PlrTest2::setExpt(const double expt) {
1088 ✗ return m_impl->setExpt(expt);
1089 }
1090
1091 ✗ bool PlrTest2::setExpt(const std::string& expt) {
1092 ✗ return m_impl->setExpt(expt);
1093 }
1094
1095 ✗ double PlrTest2::dP1() const {
1096 ✗ return m_impl->dP1();
1097 }
1098
1099 ✗ bool PlrTest2::setDP1(const double dP1) {
1100 ✗ return m_impl->setDP1(dP1);
1101 }
1102
1103 ✗ bool PlrTest2::setDP1(const std::string& dP1) {
1104 ✗ return m_impl->setDP1(dP1);
1105 }
1106
1107 ✗ double PlrTest2::F1() const {
1108 ✗ return m_impl->F1();
1109 }
1110
1111 ✗ bool PlrTest2::setF1(const double F1) {
1112 ✗ return m_impl->setF1(F1);
1113 }
1114
1115 ✗ bool PlrTest2::setF1(const std::string& F1) {
1116 ✗ return m_impl->setF1(F1);
1117 }
1118
1119 ✗ double PlrTest2::dP2() const {
1120 ✗ return m_impl->dP2();
1121 }
1122
1123 ✗ bool PlrTest2::setDP2(const double dP2) {
1124 ✗ return m_impl->setDP2(dP2);
1125 }
1126
1127 ✗ bool PlrTest2::setDP2(const std::string& dP2) {
1128 ✗ return m_impl->setDP2(dP2);
1129 }
1130
1131 ✗ double PlrTest2::F2() const {
1132 ✗ return m_impl->F2();
1133 }
1134
1135 ✗ bool PlrTest2::setF2(const double F2) {
1136 ✗ return m_impl->setF2(F2);
1137 }
1138
1139 ✗ bool PlrTest2::setF2(const std::string& F2) {
1140 ✗ return m_impl->setF2(F2);
1141 }
1142
1143 ✗ int PlrTest2::u_P1() const {
1144 ✗ return m_impl->u_P1();
1145 }
1146
1147 ✗ void PlrTest2::setU_P1(const int u_P1) {
1148 ✗ m_impl->setU_P1(u_P1);
1149 ✗ }
1150
1151 ✗ int PlrTest2::u_F1() const {
1152 ✗ return m_impl->u_F1();
1153 }
1154
1155 ✗ void PlrTest2::setU_F1(const int u_F1) {
1156 ✗ m_impl->setU_F1(u_F1);
1157 ✗ }
1158
1159 ✗ int PlrTest2::u_P2() const {
1160 ✗ return m_impl->u_P2();
1161 }
1162
1163 ✗ void PlrTest2::setU_P2(const int u_P2) {
1164 ✗ m_impl->setU_P2(u_P2);
1165 ✗ }
1166
1167 ✗ int PlrTest2::u_F2() const {
1168 ✗ return m_impl->u_F2();
1169 }
1170
1171 ✗ void PlrTest2::setU_F2(const int u_F2) {
1172 ✗ m_impl->setU_F2(u_F2);
1173 ✗ }
1174
1175 ✗ PlrCrack::PlrCrack() : m_impl(std::shared_ptr<detail::PlrCrackImpl>(new detail::PlrCrackImpl)) {}
1176
1177 ✗ PlrCrack::PlrCrack(int nr, int icon, std::string name, std::string desc)
1178 ✗ : m_impl(std::shared_ptr<detail::PlrCrackImpl>(new detail::PlrCrackImpl(nr, icon, name, desc))) {}
1179
1180 ✗ PlrCrack::PlrCrack(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double length, double width, int u_L,
1181 ✗ int u_W)
1182 ✗ : m_impl(std::shared_ptr<detail::PlrCrackImpl>(new detail::PlrCrackImpl(nr, icon, name, desc, lam, turb, expt, length, width, u_L, u_W))) {}
1183
1184 ✗ PlrCrack::PlrCrack(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string length,
1185 ✗ std::string width, int u_L, int u_W)
1186 ✗ : m_impl(std::shared_ptr<detail::PlrCrackImpl>(new detail::PlrCrackImpl(nr, icon, name, desc, lam, turb, expt, length, width, u_L, u_W))) {}
1187
1188 ✗ PlrCrack::PlrCrack(const PlrCrack& other) : m_impl(other.m_impl) {}
1189
1190 ✗ PlrCrack& PlrCrack::operator=(const PlrCrack& other) {
1191 ✗ m_impl = other.m_impl;
1192 ✗ return *this;
1193 }
1194
1195 ✗ bool PlrCrack::operator==(const PlrCrack& other) const {
1196 ✗ return m_impl == other.m_impl;
1197 }
1198
1199 ✗ bool PlrCrack::operator!=(const PlrCrack& other) const {
1200 ✗ return m_impl != other.m_impl;
1201 }
1202
1203 ✗ std::string PlrCrack::write() {
1204 ✗ return m_impl->write();
1205 }
1206
1207 ✗ void PlrCrack::read(Reader& input) {
1208 ✗ m_impl->read(input);
1209 ✗ }
1210
1211 ✗ void PlrCrack::readDetails(Reader& input) {
1212 ✗ m_impl->readDetails(input);
1213 ✗ }
1214
1215 ✗ int PlrCrack::nr() const {
1216 ✗ return m_impl->nr();
1217 }
1218
1219 ✗ void PlrCrack::setNr(const int nr) {
1220 ✗ m_impl->setNr(nr);
1221 ✗ }
1222
1223 ✗ int PlrCrack::icon() const {
1224 ✗ return m_impl->icon();
1225 }
1226
1227 ✗ void PlrCrack::setIcon(const int icon) {
1228 ✗ m_impl->setIcon(icon);
1229 ✗ }
1230
1231 ✗ std::string PlrCrack::name() const {
1232 ✗ return m_impl->name();
1233 }
1234
1235 ✗ void PlrCrack::setName(const std::string& name) {
1236 ✗ m_impl->setName(name);
1237 ✗ }
1238
1239 ✗ std::string PlrCrack::desc() const {
1240 ✗ return m_impl->desc();
1241 }
1242
1243 ✗ void PlrCrack::setDesc(const std::string& desc) {
1244 ✗ m_impl->setDesc(desc);
1245 ✗ }
1246
1247 ✗ double PlrCrack::lam() const {
1248 ✗ return m_impl->lam();
1249 }
1250
1251 ✗ bool PlrCrack::setLam(const double lam) {
1252 ✗ return m_impl->setLam(lam);
1253 }
1254
1255 ✗ bool PlrCrack::setLam(const std::string& lam) {
1256 ✗ return m_impl->setLam(lam);
1257 }
1258
1259 ✗ double PlrCrack::turb() const {
1260 ✗ return m_impl->turb();
1261 }
1262
1263 ✗ bool PlrCrack::setTurb(const double turb) {
1264 ✗ return m_impl->setTurb(turb);
1265 }
1266
1267 ✗ bool PlrCrack::setTurb(const std::string& turb) {
1268 ✗ return m_impl->setTurb(turb);
1269 }
1270
1271 ✗ double PlrCrack::expt() const {
1272 ✗ return m_impl->expt();
1273 }
1274
1275 ✗ bool PlrCrack::setExpt(const double expt) {
1276 ✗ return m_impl->setExpt(expt);
1277 }
1278
1279 ✗ bool PlrCrack::setExpt(const std::string& expt) {
1280 ✗ return m_impl->setExpt(expt);
1281 }
1282
1283 ✗ double PlrCrack::length() const {
1284 ✗ return m_impl->length();
1285 }
1286
1287 ✗ bool PlrCrack::setLength(const double length) {
1288 ✗ return m_impl->setLength(length);
1289 }
1290
1291 ✗ bool PlrCrack::setLength(const std::string& length) {
1292 ✗ return m_impl->setLength(length);
1293 }
1294
1295 ✗ double PlrCrack::width() const {
1296 ✗ return m_impl->width();
1297 }
1298
1299 ✗ bool PlrCrack::setWidth(const double width) {
1300 ✗ return m_impl->setWidth(width);
1301 }
1302
1303 ✗ bool PlrCrack::setWidth(const std::string& width) {
1304 ✗ return m_impl->setWidth(width);
1305 }
1306
1307 ✗ int PlrCrack::u_L() const {
1308 ✗ return m_impl->u_L();
1309 }
1310
1311 ✗ void PlrCrack::setU_L(const int u_L) {
1312 ✗ m_impl->setU_L(u_L);
1313 ✗ }
1314
1315 ✗ int PlrCrack::u_W() const {
1316 ✗ return m_impl->u_W();
1317 }
1318
1319 ✗ void PlrCrack::setU_W(const int u_W) {
1320 ✗ m_impl->setU_W(u_W);
1321 ✗ }
1322
1323 ✗ PlrStair::PlrStair() : m_impl(std::shared_ptr<detail::PlrStairImpl>(new detail::PlrStairImpl)) {}
1324
1325 6 PlrStair::PlrStair(int nr, int icon, std::string name, std::string desc)
1326
5/7
✓ Branch 2 taken 6 times.
✓ Branch 5 taken 6 times.
✓ Branch 8 taken 6 times.
✓ Branch 11 taken 6 times.
✓ Branch 14 taken 6 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
6 : m_impl(std::shared_ptr<detail::PlrStairImpl>(new detail::PlrStairImpl(nr, icon, name, desc))) {}
1327
1328 ✗ PlrStair::PlrStair(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double Ht, double Area, double peo,
1329 ✗ int tread, int u_A, int u_D)
1330 ✗ : m_impl(std::shared_ptr<detail::PlrStairImpl>(new detail::PlrStairImpl(nr, icon, name, desc, lam, turb, expt, Ht, Area, peo, tread, u_A, u_D))) {
1331 ✗ }
1332
1333 ✗ PlrStair::PlrStair(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string Ht,
1334 ✗ std::string Area, std::string peo, int tread, int u_A, int u_D)
1335 ✗ : m_impl(std::shared_ptr<detail::PlrStairImpl>(new detail::PlrStairImpl(nr, icon, name, desc, lam, turb, expt, Ht, Area, peo, tread, u_A, u_D))) {
1336 ✗ }
1337
1338 ✗ PlrStair::PlrStair(const PlrStair& other) : m_impl(other.m_impl) {}
1339
1340 ✗ PlrStair& PlrStair::operator=(const PlrStair& other) {
1341 ✗ m_impl = other.m_impl;
1342 ✗ return *this;
1343 }
1344
1345 ✗ bool PlrStair::operator==(const PlrStair& other) const {
1346 ✗ return m_impl == other.m_impl;
1347 }
1348
1349 ✗ bool PlrStair::operator!=(const PlrStair& other) const {
1350 ✗ return m_impl != other.m_impl;
1351 }
1352
1353 1 std::string PlrStair::write() {
1354 1 return m_impl->write();
1355 }
1356
1357 ✗ void PlrStair::read(Reader& input) {
1358 ✗ m_impl->read(input);
1359 ✗ }
1360
1361 6 void PlrStair::readDetails(Reader& input) {
1362 6 m_impl->readDetails(input);
1363 6 }
1364
1365 ✗ int PlrStair::nr() const {
1366 ✗ return m_impl->nr();
1367 }
1368
1369 ✗ void PlrStair::setNr(const int nr) {
1370 ✗ m_impl->setNr(nr);
1371 ✗ }
1372
1373 ✗ int PlrStair::icon() const {
1374 ✗ return m_impl->icon();
1375 }
1376
1377 ✗ void PlrStair::setIcon(const int icon) {
1378 ✗ m_impl->setIcon(icon);
1379 ✗ }
1380
1381 ✗ std::string PlrStair::name() const {
1382 ✗ return m_impl->name();
1383 }
1384
1385 ✗ void PlrStair::setName(const std::string& name) {
1386 ✗ m_impl->setName(name);
1387 ✗ }
1388
1389 ✗ std::string PlrStair::desc() const {
1390 ✗ return m_impl->desc();
1391 }
1392
1393 ✗ void PlrStair::setDesc(const std::string& desc) {
1394 ✗ m_impl->setDesc(desc);
1395 ✗ }
1396
1397 ✗ double PlrStair::lam() const {
1398 ✗ return m_impl->lam();
1399 }
1400
1401 ✗ bool PlrStair::setLam(const double lam) {
1402 ✗ return m_impl->setLam(lam);
1403 }
1404
1405 ✗ bool PlrStair::setLam(const std::string& lam) {
1406 ✗ return m_impl->setLam(lam);
1407 }
1408
1409 ✗ double PlrStair::turb() const {
1410 ✗ return m_impl->turb();
1411 }
1412
1413 ✗ bool PlrStair::setTurb(const double turb) {
1414 ✗ return m_impl->setTurb(turb);
1415 }
1416
1417 ✗ bool PlrStair::setTurb(const std::string& turb) {
1418 ✗ return m_impl->setTurb(turb);
1419 }
1420
1421 ✗ double PlrStair::expt() const {
1422 ✗ return m_impl->expt();
1423 }
1424
1425 ✗ bool PlrStair::setExpt(const double expt) {
1426 ✗ return m_impl->setExpt(expt);
1427 }
1428
1429 ✗ bool PlrStair::setExpt(const std::string& expt) {
1430 ✗ return m_impl->setExpt(expt);
1431 }
1432
1433 ✗ double PlrStair::Ht() const {
1434 ✗ return m_impl->Ht();
1435 }
1436
1437 ✗ bool PlrStair::setHt(const double Ht) {
1438 ✗ return m_impl->setHt(Ht);
1439 }
1440
1441 ✗ bool PlrStair::setHt(const std::string& Ht) {
1442 ✗ return m_impl->setHt(Ht);
1443 }
1444
1445 ✗ double PlrStair::area() const {
1446 ✗ return m_impl->area();
1447 }
1448
1449 ✗ bool PlrStair::setArea(const double Area) {
1450 ✗ return m_impl->setArea(Area);
1451 }
1452
1453 ✗ bool PlrStair::setArea(const std::string& Area) {
1454 ✗ return m_impl->setArea(Area);
1455 }
1456
1457 ✗ double PlrStair::people() const {
1458 ✗ return m_impl->people();
1459 }
1460
1461 ✗ bool PlrStair::setPeople(const double peo) {
1462 ✗ return m_impl->setPeople(peo);
1463 }
1464
1465 ✗ bool PlrStair::setPeople(const std::string& peo) {
1466 ✗ return m_impl->setPeople(peo);
1467 }
1468
1469 ✗ int PlrStair::tread() const {
1470 ✗ return m_impl->tread();
1471 }
1472
1473 ✗ void PlrStair::setTread(const int tread) {
1474 ✗ m_impl->setTread(tread);
1475 ✗ }
1476
1477 ✗ int PlrStair::u_A() const {
1478 ✗ return m_impl->u_A();
1479 }
1480
1481 ✗ void PlrStair::setU_A(const int u_A) {
1482 ✗ m_impl->setU_A(u_A);
1483 ✗ }
1484
1485 ✗ int PlrStair::u_D() const {
1486 ✗ return m_impl->u_D();
1487 }
1488
1489 ✗ void PlrStair::setU_D(const int u_D) {
1490 ✗ m_impl->setU_D(u_D);
1491 ✗ }
1492
1493 ✗ PlrShaft::PlrShaft() : m_impl(std::shared_ptr<detail::PlrShaftImpl>(new detail::PlrShaftImpl)) {}
1494
1495 6 PlrShaft::PlrShaft(int nr, int icon, std::string name, std::string desc)
1496
5/7
✓ Branch 2 taken 6 times.
✓ Branch 5 taken 6 times.
✓ Branch 8 taken 6 times.
✓ Branch 11 taken 6 times.
✓ Branch 14 taken 6 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
6 : m_impl(std::shared_ptr<detail::PlrShaftImpl>(new detail::PlrShaftImpl(nr, icon, name, desc))) {}
1497
1498 ✗ PlrShaft::PlrShaft(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double Ht, double area, double perim,
1499 ✗ double rough, int u_A, int u_D, int u_P, int u_R)
1500 ✗ : m_impl(std::shared_ptr<detail::PlrShaftImpl>(
1501 ✗ new detail::PlrShaftImpl(nr, icon, name, desc, lam, turb, expt, Ht, area, perim, rough, u_A, u_D, u_P, u_R))) {}
1502
1503 ✗ PlrShaft::PlrShaft(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string Ht,
1504 ✗ std::string area, std::string perim, std::string rough, int u_A, int u_D, int u_P, int u_R)
1505 ✗ : m_impl(std::shared_ptr<detail::PlrShaftImpl>(
1506 ✗ new detail::PlrShaftImpl(nr, icon, name, desc, lam, turb, expt, Ht, area, perim, rough, u_A, u_D, u_P, u_R))) {}
1507
1508 ✗ PlrShaft::PlrShaft(const PlrShaft& other) : m_impl(other.m_impl) {}
1509
1510 ✗ PlrShaft& PlrShaft::operator=(const PlrShaft& other) {
1511 ✗ m_impl = other.m_impl;
1512 ✗ return *this;
1513 }
1514
1515 ✗ bool PlrShaft::operator==(const PlrShaft& other) const {
1516 ✗ return m_impl == other.m_impl;
1517 }
1518
1519 ✗ bool PlrShaft::operator!=(const PlrShaft& other) const {
1520 ✗ return m_impl != other.m_impl;
1521 }
1522
1523 1 std::string PlrShaft::write() {
1524 1 return m_impl->write();
1525 }
1526
1527 ✗ void PlrShaft::read(Reader& input) {
1528 ✗ m_impl->read(input);
1529 ✗ }
1530
1531 6 void PlrShaft::readDetails(Reader& input) {
1532 6 m_impl->readDetails(input);
1533 6 }
1534
1535 ✗ int PlrShaft::nr() const {
1536 ✗ return m_impl->nr();
1537 }
1538
1539 ✗ void PlrShaft::setNr(const int nr) {
1540 ✗ m_impl->setNr(nr);
1541 ✗ }
1542
1543 ✗ int PlrShaft::icon() const {
1544 ✗ return m_impl->icon();
1545 }
1546
1547 ✗ void PlrShaft::setIcon(const int icon) {
1548 ✗ m_impl->setIcon(icon);
1549 ✗ }
1550
1551 24 std::string PlrShaft::name() const {
1552 24 return m_impl->name();
1553 }
1554
1555 ✗ void PlrShaft::setName(const std::string& name) {
1556 ✗ m_impl->setName(name);
1557 ✗ }
1558
1559 ✗ std::string PlrShaft::desc() const {
1560 ✗ return m_impl->desc();
1561 }
1562
1563 ✗ void PlrShaft::setDesc(const std::string& desc) {
1564 ✗ m_impl->setDesc(desc);
1565 ✗ }
1566
1567 ✗ double PlrShaft::lam() const {
1568 ✗ return m_impl->lam();
1569 }
1570
1571 ✗ bool PlrShaft::setLam(const double lam) {
1572 ✗ return m_impl->setLam(lam);
1573 }
1574
1575 ✗ bool PlrShaft::setLam(const std::string& lam) {
1576 ✗ return m_impl->setLam(lam);
1577 }
1578
1579 ✗ double PlrShaft::turb() const {
1580 ✗ return m_impl->turb();
1581 }
1582
1583 ✗ bool PlrShaft::setTurb(const double turb) {
1584 ✗ return m_impl->setTurb(turb);
1585 }
1586
1587 ✗ bool PlrShaft::setTurb(const std::string& turb) {
1588 ✗ return m_impl->setTurb(turb);
1589 }
1590
1591 ✗ double PlrShaft::expt() const {
1592 ✗ return m_impl->expt();
1593 }
1594
1595 ✗ bool PlrShaft::setExpt(const double expt) {
1596 ✗ return m_impl->setExpt(expt);
1597 }
1598
1599 ✗ bool PlrShaft::setExpt(const std::string& expt) {
1600 ✗ return m_impl->setExpt(expt);
1601 }
1602
1603 ✗ double PlrShaft::Ht() const {
1604 ✗ return m_impl->Ht();
1605 }
1606
1607 ✗ bool PlrShaft::setHt(const double Ht) {
1608 ✗ return m_impl->setHt(Ht);
1609 }
1610
1611 ✗ bool PlrShaft::setHt(const std::string& Ht) {
1612 ✗ return m_impl->setHt(Ht);
1613 }
1614
1615 ✗ double PlrShaft::area() const {
1616 ✗ return m_impl->area();
1617 }
1618
1619 ✗ bool PlrShaft::setArea(const double area) {
1620 ✗ return m_impl->setArea(area);
1621 }
1622
1623 ✗ bool PlrShaft::setArea(const std::string& area) {
1624 ✗ return m_impl->setArea(area);
1625 }
1626
1627 ✗ double PlrShaft::perim() const {
1628 ✗ return m_impl->perim();
1629 }
1630
1631 ✗ bool PlrShaft::setPerim(const double perim) {
1632 ✗ return m_impl->setPerim(perim);
1633 }
1634
1635 ✗ bool PlrShaft::setPerim(const std::string& perim) {
1636 ✗ return m_impl->setPerim(perim);
1637 }
1638
1639 ✗ double PlrShaft::rough() const {
1640 ✗ return m_impl->rough();
1641 }
1642
1643 ✗ bool PlrShaft::setRough(const double rough) {
1644 ✗ return m_impl->setRough(rough);
1645 }
1646
1647 ✗ bool PlrShaft::setRough(const std::string& rough) {
1648 ✗ return m_impl->setRough(rough);
1649 }
1650
1651 ✗ int PlrShaft::u_A() const {
1652 ✗ return m_impl->u_A();
1653 }
1654
1655 ✗ void PlrShaft::setU_A(const int u_A) {
1656 ✗ m_impl->setU_A(u_A);
1657 ✗ }
1658
1659 ✗ int PlrShaft::u_D() const {
1660 ✗ return m_impl->u_D();
1661 }
1662
1663 ✗ void PlrShaft::setU_D(const int u_D) {
1664 ✗ m_impl->setU_D(u_D);
1665 ✗ }
1666
1667 ✗ int PlrShaft::u_P() const {
1668 ✗ return m_impl->u_P();
1669 }
1670
1671 ✗ void PlrShaft::setU_P(const int u_P) {
1672 ✗ m_impl->setU_P(u_P);
1673 ✗ }
1674
1675 ✗ int PlrShaft::u_R() const {
1676 ✗ return m_impl->u_R();
1677 }
1678
1679 ✗ void PlrShaft::setU_R(const int u_R) {
1680 ✗ m_impl->setU_R(u_R);
1681 ✗ }
1682
1683 ✗ PlrBackDamper::PlrBackDamper() : m_impl(std::shared_ptr<detail::PlrBackDamperImpl>(new detail::PlrBackDamperImpl)) {}
1684
1685 ✗ PlrBackDamper::PlrBackDamper(int nr, int icon, std::string name, std::string desc)
1686 ✗ : m_impl(std::shared_ptr<detail::PlrBackDamperImpl>(new detail::PlrBackDamperImpl(nr, icon, name, desc))) {}
1687
1688 ✗ PlrBackDamper::PlrBackDamper(int nr, int icon, std::string name, std::string desc, double lam, double Cp, double xp, double Cn, double xn)
1689 ✗ : m_impl(std::shared_ptr<detail::PlrBackDamperImpl>(new detail::PlrBackDamperImpl(nr, icon, name, desc, lam, Cp, xp, Cn, xn))) {}
1690
1691 ✗ PlrBackDamper::PlrBackDamper(int nr, int icon, std::string name, std::string desc, std::string lam, std::string Cp, std::string xp, std::string Cn,
1692 ✗ std::string xn)
1693 ✗ : m_impl(std::shared_ptr<detail::PlrBackDamperImpl>(new detail::PlrBackDamperImpl(nr, icon, name, desc, lam, Cp, xp, Cn, xn))) {}
1694
1695 ✗ PlrBackDamper::PlrBackDamper(const PlrBackDamper& other) : m_impl(other.m_impl) {}
1696
1697 ✗ PlrBackDamper& PlrBackDamper::operator=(const PlrBackDamper& other) {
1698 ✗ m_impl = other.m_impl;
1699 ✗ return *this;
1700 }
1701
1702 ✗ bool PlrBackDamper::operator==(const PlrBackDamper& other) const {
1703 ✗ return m_impl == other.m_impl;
1704 }
1705
1706 ✗ bool PlrBackDamper::operator!=(const PlrBackDamper& other) const {
1707 ✗ return m_impl != other.m_impl;
1708 }
1709
1710 ✗ std::string PlrBackDamper::write() {
1711 ✗ return m_impl->write("plr_bdq");
1712 }
1713
1714 ✗ void PlrBackDamper::read(Reader& input) {
1715 ✗ m_impl->read(input);
1716 ✗ }
1717
1718 ✗ void PlrBackDamper::readDetails(Reader& input) {
1719 ✗ m_impl->readDetails(input);
1720 ✗ }
1721
1722 ✗ int PlrBackDamper::nr() const {
1723 ✗ return m_impl->nr();
1724 }
1725
1726 ✗ void PlrBackDamper::setNr(const int nr) {
1727 ✗ m_impl->setNr(nr);
1728 ✗ }
1729
1730 ✗ int PlrBackDamper::icon() const {
1731 ✗ return m_impl->icon();
1732 }
1733
1734 ✗ void PlrBackDamper::setIcon(const int icon) {
1735 ✗ m_impl->setIcon(icon);
1736 ✗ }
1737
1738 ✗ std::string PlrBackDamper::name() const {
1739 ✗ return m_impl->name();
1740 }
1741
1742 ✗ void PlrBackDamper::setName(const std::string& name) {
1743 ✗ m_impl->setName(name);
1744 ✗ }
1745
1746 ✗ std::string PlrBackDamper::desc() const {
1747 ✗ return m_impl->desc();
1748 }
1749
1750 ✗ void PlrBackDamper::setDesc(const std::string& desc) {
1751 ✗ m_impl->setDesc(desc);
1752 ✗ }
1753
1754 ✗ double PlrBackDamper::lam() const {
1755 ✗ return m_impl->lam();
1756 }
1757
1758 ✗ bool PlrBackDamper::setLam(const double lam) {
1759 ✗ return m_impl->setLam(lam);
1760 }
1761
1762 ✗ bool PlrBackDamper::setLam(const std::string& lam) {
1763 ✗ return m_impl->setLam(lam);
1764 }
1765
1766 ✗ double PlrBackDamper::Cp() const {
1767 ✗ return m_impl->Cp();
1768 }
1769
1770 ✗ bool PlrBackDamper::setCp(const double Cp) {
1771 ✗ return m_impl->setCp(Cp);
1772 }
1773
1774 ✗ bool PlrBackDamper::setCp(const std::string& Cp) {
1775 ✗ return m_impl->setCp(Cp);
1776 }
1777
1778 ✗ double PlrBackDamper::xp() const {
1779 ✗ return m_impl->xp();
1780 }
1781
1782 ✗ bool PlrBackDamper::setXp(const double xp) {
1783 ✗ return m_impl->setXp(xp);
1784 }
1785
1786 ✗ bool PlrBackDamper::setXp(const std::string& xp) {
1787 ✗ return m_impl->setXp(xp);
1788 }
1789
1790 ✗ double PlrBackDamper::Cn() const {
1791 ✗ return m_impl->Cn();
1792 }
1793
1794 ✗ bool PlrBackDamper::setCn(const double Cn) {
1795 ✗ return m_impl->setCn(Cn);
1796 }
1797
1798 ✗ bool PlrBackDamper::setCn(const std::string& Cn) {
1799 ✗ return m_impl->setCn(Cn);
1800 }
1801
1802 ✗ double PlrBackDamper::xn() const {
1803 ✗ return m_impl->xn();
1804 }
1805
1806 ✗ bool PlrBackDamper::setXn(const double xn) {
1807 ✗ return m_impl->setXn(xn);
1808 }
1809
1810 ✗ bool PlrBackDamper::setXn(const std::string& xn) {
1811 ✗ return m_impl->setXn(xn);
1812 }
1813
1814 ✗ PlrBdq::PlrBdq() : PlrBackDamper() {}
1815
1816 ✗ PlrBdq::PlrBdq(int nr, int icon, std::string name, std::string desc) : PlrBackDamper(nr, icon, name, desc) {}
1817
1818 ✗ PlrBdq::PlrBdq(int nr, int icon, std::string name, std::string desc, double lam, double Cp, double xp, double Cn, double xn)
1819 ✗ : PlrBackDamper(nr, icon, name, desc, lam, Cp, xp, Cn, xn) {}
1820
1821 ✗ PlrBdq::PlrBdq(int nr, int icon, std::string name, std::string desc, std::string lam, std::string Cp, std::string xp, std::string Cn,
1822 ✗ std::string xn)
1823 ✗ : PlrBackDamper(nr, icon, name, desc, lam, Cp, xp, Cn, xn) {}
1824
1825 ✗ PlrBdf::PlrBdf() : PlrBackDamper() {}
1826
1827 ✗ PlrBdf::PlrBdf(int nr, int icon, std::string name, std::string desc) : PlrBackDamper(nr, icon, name, desc) {}
1828
1829 ✗ PlrBdf::PlrBdf(int nr, int icon, std::string name, std::string desc, double lam, double Cp, double xp, double Cn, double xn)
1830 ✗ : PlrBackDamper(nr, icon, name, desc, lam, Cp, xp, Cn, xn) {}
1831
1832 ✗ PlrBdf::PlrBdf(int nr, int icon, std::string name, std::string desc, std::string lam, std::string Cp, std::string xp, std::string Cn,
1833 ✗ std::string xn)
1834 ✗ : PlrBackDamper(nr, icon, name, desc, lam, Cp, xp, Cn, xn) {}
1835
1836 ✗ QfrGeneral::QfrGeneral() : m_impl(std::shared_ptr<detail::QfrQuadraticImpl>(new detail::QfrQuadraticImpl)) {}
1837
1838 ✗ QfrGeneral::QfrGeneral(int nr, int icon, std::string name, std::string desc)
1839 ✗ : m_impl(std::shared_ptr<detail::QfrQuadraticImpl>(new detail::QfrQuadraticImpl(nr, icon, name, desc))) {}
1840
1841 ✗ QfrGeneral::QfrGeneral(int nr, int icon, std::string name, std::string desc, double a, double b)
1842 ✗ : m_impl(std::shared_ptr<detail::QfrQuadraticImpl>(new detail::QfrQuadraticImpl(nr, icon, name, desc, a, b))) {}
1843
1844 ✗ QfrGeneral::QfrGeneral(int nr, int icon, std::string name, std::string desc, std::string a, std::string b)
1845 ✗ : m_impl(std::shared_ptr<detail::QfrQuadraticImpl>(new detail::QfrQuadraticImpl(nr, icon, name, desc, a, b))) {}
1846
1847 ✗ QfrGeneral::QfrGeneral(const QfrGeneral& other) : m_impl(other.m_impl) {}
1848
1849 ✗ QfrGeneral& QfrGeneral::operator=(const QfrGeneral& other) {
1850 ✗ m_impl = other.m_impl;
1851 ✗ return *this;
1852 }
1853
1854 ✗ bool QfrGeneral::operator==(const QfrGeneral& other) const {
1855 ✗ return m_impl == other.m_impl;
1856 }
1857
1858 ✗ bool QfrGeneral::operator!=(const QfrGeneral& other) const {
1859 ✗ return m_impl != other.m_impl;
1860 }
1861
1862 ✗ std::string QfrGeneral::write() {
1863 ✗ return m_impl->write(dataType());
1864 }
1865
1866 ✗ void QfrGeneral::read(Reader& input) {
1867 ✗ m_impl->read(input);
1868 ✗ }
1869
1870 ✗ void QfrGeneral::readDetails(Reader& input) {
1871 ✗ m_impl->readDetails(input);
1872 ✗ }
1873
1874 ✗ int QfrGeneral::nr() const {
1875 ✗ return m_impl->nr();
1876 }
1877
1878 ✗ void QfrGeneral::setNr(const int nr) {
1879 ✗ m_impl->setNr(nr);
1880 ✗ }
1881
1882 ✗ int QfrGeneral::icon() const {
1883 ✗ return m_impl->icon();
1884 }
1885
1886 ✗ void QfrGeneral::setIcon(const int icon) {
1887 ✗ m_impl->setIcon(icon);
1888 ✗ }
1889
1890 ✗ std::string QfrGeneral::name() const {
1891 ✗ return m_impl->name();
1892 }
1893
1894 ✗ void QfrGeneral::setName(const std::string& name) {
1895 ✗ m_impl->setName(name);
1896 ✗ }
1897
1898 ✗ std::string QfrGeneral::desc() const {
1899 ✗ return m_impl->desc();
1900 }
1901
1902 ✗ void QfrGeneral::setDesc(const std::string& desc) {
1903 ✗ m_impl->setDesc(desc);
1904 ✗ }
1905
1906 ✗ double QfrGeneral::a() const {
1907 ✗ return m_impl->a();
1908 }
1909
1910 ✗ bool QfrGeneral::setA(const double a) {
1911 ✗ return m_impl->setA(a);
1912 }
1913
1914 ✗ bool QfrGeneral::setA(const std::string& a) {
1915 ✗ return m_impl->setA(a);
1916 }
1917
1918 ✗ double QfrGeneral::b() const {
1919 ✗ return m_impl->b();
1920 }
1921
1922 ✗ bool QfrGeneral::setB(const double b) {
1923 ✗ return m_impl->setB(b);
1924 }
1925
1926 ✗ bool QfrGeneral::setB(const std::string& b) {
1927 ✗ return m_impl->setB(b);
1928 }
1929
1930 ✗ QfrQab::QfrQab() : QfrGeneral() {}
1931
1932 ✗ QfrQab::QfrQab(int nr, int icon, std::string name, std::string desc) : QfrGeneral(nr, icon, name, desc) {}
1933
1934 ✗ QfrQab::QfrQab(int nr, int icon, std::string name, std::string desc, double a, double b) : QfrGeneral(nr, icon, name, desc, a, b) {}
1935
1936 ✗ QfrQab::QfrQab(int nr, int icon, std::string name, std::string desc, std::string a, std::string b) : QfrGeneral(nr, icon, name, desc, a, b) {}
1937
1938 ✗ QfrFab::QfrFab() : QfrGeneral() {}
1939
1940 ✗ QfrFab::QfrFab(int nr, int icon, std::string name, std::string desc) : QfrGeneral(nr, icon, name, desc) {}
1941
1942 ✗ QfrFab::QfrFab(int nr, int icon, std::string name, std::string desc, double a, double b) : QfrGeneral(nr, icon, name, desc, a, b) {}
1943
1944 ✗ QfrFab::QfrFab(int nr, int icon, std::string name, std::string desc, std::string a, std::string b) : QfrGeneral(nr, icon, name, desc, a, b) {}
1945
1946 ✗ QfrCrack::QfrCrack() : m_impl(std::shared_ptr<detail::QfrCrackImpl>(new detail::QfrCrackImpl)) {}
1947
1948 ✗ QfrCrack::QfrCrack(int nr, int icon, std::string name, std::string desc)
1949 ✗ : m_impl(std::shared_ptr<detail::QfrCrackImpl>(new detail::QfrCrackImpl(nr, icon, name, desc))) {}
1950
1951 ✗ QfrCrack::QfrCrack(int nr, int icon, std::string name, std::string desc, double a, double b, double length, double width, double depth, int nB,
1952 ✗ int u_L, int u_W, int u_D)
1953 ✗ : m_impl(std::shared_ptr<detail::QfrCrackImpl>(new detail::QfrCrackImpl(nr, icon, name, desc, a, b, length, width, depth, nB, u_L, u_W, u_D))) {}
1954
1955 ✗ QfrCrack::QfrCrack(int nr, int icon, std::string name, std::string desc, std::string a, std::string b, std::string length, std::string width,
1956 ✗ std::string depth, int nB, int u_L, int u_W, int u_D)
1957 ✗ : m_impl(std::shared_ptr<detail::QfrCrackImpl>(new detail::QfrCrackImpl(nr, icon, name, desc, a, b, length, width, depth, nB, u_L, u_W, u_D))) {}
1958
1959 ✗ QfrCrack::QfrCrack(const QfrCrack& other) : m_impl(other.m_impl) {}
1960
1961 ✗ QfrCrack& QfrCrack::operator=(const QfrCrack& other) {
1962 ✗ m_impl = other.m_impl;
1963 ✗ return *this;
1964 }
1965
1966 ✗ bool QfrCrack::operator==(const QfrCrack& other) const {
1967 ✗ return m_impl == other.m_impl;
1968 }
1969
1970 ✗ bool QfrCrack::operator!=(const QfrCrack& other) const {
1971 ✗ return m_impl != other.m_impl;
1972 }
1973
1974 ✗ std::string QfrCrack::write() {
1975 ✗ return m_impl->write();
1976 }
1977
1978 ✗ void QfrCrack::read(Reader& input) {
1979 ✗ m_impl->read(input);
1980 ✗ }
1981
1982 ✗ void QfrCrack::readDetails(Reader& input) {
1983 ✗ m_impl->readDetails(input);
1984 ✗ }
1985
1986 ✗ int QfrCrack::nr() const {
1987 ✗ return m_impl->nr();
1988 }
1989
1990 ✗ void QfrCrack::setNr(const int nr) {
1991 ✗ m_impl->setNr(nr);
1992 ✗ }
1993
1994 ✗ int QfrCrack::icon() const {
1995 ✗ return m_impl->icon();
1996 }
1997
1998 ✗ void QfrCrack::setIcon(const int icon) {
1999 ✗ m_impl->setIcon(icon);
2000 ✗ }
2001
2002 ✗ std::string QfrCrack::name() const {
2003 ✗ return m_impl->name();
2004 }
2005
2006 ✗ void QfrCrack::setName(const std::string& name) {
2007 ✗ m_impl->setName(name);
2008 ✗ }
2009
2010 ✗ std::string QfrCrack::desc() const {
2011 ✗ return m_impl->desc();
2012 }
2013
2014 ✗ void QfrCrack::setDesc(const std::string& desc) {
2015 ✗ m_impl->setDesc(desc);
2016 ✗ }
2017
2018 ✗ double QfrCrack::a() const {
2019 ✗ return m_impl->a();
2020 }
2021
2022 ✗ bool QfrCrack::setA(const double a) {
2023 ✗ return m_impl->setA(a);
2024 }
2025
2026 ✗ bool QfrCrack::setA(const std::string& a) {
2027 ✗ return m_impl->setA(a);
2028 }
2029
2030 ✗ double QfrCrack::b() const {
2031 ✗ return m_impl->b();
2032 }
2033
2034 ✗ bool QfrCrack::setB(const double b) {
2035 ✗ return m_impl->setB(b);
2036 }
2037
2038 ✗ bool QfrCrack::setB(const std::string& b) {
2039 ✗ return m_impl->setB(b);
2040 }
2041
2042 ✗ double QfrCrack::length() const {
2043 ✗ return m_impl->length();
2044 }
2045
2046 ✗ bool QfrCrack::setLength(const double length) {
2047 ✗ return m_impl->setLength(length);
2048 }
2049
2050 ✗ bool QfrCrack::setLength(const std::string& length) {
2051 ✗ return m_impl->setLength(length);
2052 }
2053
2054 ✗ double QfrCrack::width() const {
2055 ✗ return m_impl->width();
2056 }
2057
2058 ✗ bool QfrCrack::setWidth(const double width) {
2059 ✗ return m_impl->setWidth(width);
2060 }
2061
2062 ✗ bool QfrCrack::setWidth(const std::string& width) {
2063 ✗ return m_impl->setWidth(width);
2064 }
2065
2066 ✗ double QfrCrack::depth() const {
2067 ✗ return m_impl->depth();
2068 }
2069
2070 ✗ bool QfrCrack::setDepth(const double depth) {
2071 ✗ return m_impl->setDepth(depth);
2072 }
2073
2074 ✗ bool QfrCrack::setDepth(const std::string& depth) {
2075 ✗ return m_impl->setDepth(depth);
2076 }
2077
2078 ✗ int QfrCrack::nB() const {
2079 ✗ return m_impl->nB();
2080 }
2081
2082 ✗ void QfrCrack::setNB(const int nB) {
2083 ✗ m_impl->setNB(nB);
2084 ✗ }
2085
2086 ✗ int QfrCrack::u_L() const {
2087 ✗ return m_impl->u_L();
2088 }
2089
2090 ✗ void QfrCrack::setU_L(const int u_L) {
2091 ✗ m_impl->setU_L(u_L);
2092 ✗ }
2093
2094 ✗ int QfrCrack::u_W() const {
2095 ✗ return m_impl->u_W();
2096 }
2097
2098 ✗ void QfrCrack::setU_W(const int u_W) {
2099 ✗ m_impl->setU_W(u_W);
2100 ✗ }
2101
2102 ✗ int QfrCrack::u_D() const {
2103 ✗ return m_impl->u_D();
2104 }
2105
2106 ✗ void QfrCrack::setU_D(const int u_D) {
2107 ✗ m_impl->setU_D(u_D);
2108 ✗ }
2109
2110 ✗ QfrTest2::QfrTest2() : m_impl(std::shared_ptr<detail::QfrTest2Impl>(new detail::QfrTest2Impl)) {}
2111
2112 ✗ QfrTest2::QfrTest2(int nr, int icon, std::string name, std::string desc)
2113 ✗ : m_impl(std::shared_ptr<detail::QfrTest2Impl>(new detail::QfrTest2Impl(nr, icon, name, desc))) {}
2114
2115 ✗ QfrTest2::QfrTest2(int nr, int icon, std::string name, std::string desc, double a, double b, double dP1, double F1, double dP2, double F2, int u_P1,
2116 ✗ int u_F1, int u_P2, int u_F2)
2117 ✗ : m_impl(std::shared_ptr<detail::QfrTest2Impl>(new detail::QfrTest2Impl(nr, icon, name, desc, a, b, dP1, F1, dP2, F2, u_P1, u_F1, u_P2, u_F2))) {}
2118
2119 ✗ QfrTest2::QfrTest2(int nr, int icon, std::string name, std::string desc, std::string a, std::string b, std::string dP1, std::string F1,
2120 ✗ std::string dP2, std::string F2, int u_P1, int u_F1, int u_P2, int u_F2)
2121 ✗ : m_impl(std::shared_ptr<detail::QfrTest2Impl>(new detail::QfrTest2Impl(nr, icon, name, desc, a, b, dP1, F1, dP2, F2, u_P1, u_F1, u_P2, u_F2))) {}
2122
2123 ✗ QfrTest2::QfrTest2(const QfrTest2& other) : m_impl(other.m_impl) {}
2124
2125 ✗ QfrTest2& QfrTest2::operator=(const QfrTest2& other) {
2126 ✗ m_impl = other.m_impl;
2127 ✗ return *this;
2128 }
2129
2130 ✗ bool QfrTest2::operator==(const QfrTest2& other) const {
2131 ✗ return m_impl == other.m_impl;
2132 }
2133
2134 ✗ bool QfrTest2::operator!=(const QfrTest2& other) const {
2135 ✗ return m_impl != other.m_impl;
2136 }
2137
2138 ✗ std::string QfrTest2::write() {
2139 ✗ return m_impl->write();
2140 }
2141
2142 ✗ void QfrTest2::read(Reader& input) {
2143 ✗ m_impl->read(input);
2144 ✗ }
2145
2146 ✗ void QfrTest2::readDetails(Reader& input) {
2147 ✗ m_impl->readDetails(input);
2148 ✗ }
2149
2150 ✗ int QfrTest2::nr() const {
2151 ✗ return m_impl->nr();
2152 }
2153
2154 ✗ void QfrTest2::setNr(const int nr) {
2155 ✗ m_impl->setNr(nr);
2156 ✗ }
2157
2158 ✗ int QfrTest2::icon() const {
2159 ✗ return m_impl->icon();
2160 }
2161
2162 ✗ void QfrTest2::setIcon(const int icon) {
2163 ✗ m_impl->setIcon(icon);
2164 ✗ }
2165
2166 ✗ std::string QfrTest2::name() const {
2167 ✗ return m_impl->name();
2168 }
2169
2170 ✗ void QfrTest2::setName(const std::string& name) {
2171 ✗ m_impl->setName(name);
2172 ✗ }
2173
2174 ✗ std::string QfrTest2::desc() const {
2175 ✗ return m_impl->desc();
2176 }
2177
2178 ✗ void QfrTest2::setDesc(const std::string& desc) {
2179 ✗ m_impl->setDesc(desc);
2180 ✗ }
2181
2182 ✗ double QfrTest2::a() const {
2183 ✗ return m_impl->a();
2184 }
2185
2186 ✗ bool QfrTest2::setA(const double a) {
2187 ✗ return m_impl->setA(a);
2188 }
2189
2190 ✗ bool QfrTest2::setA(const std::string& a) {
2191 ✗ return m_impl->setA(a);
2192 }
2193
2194 ✗ double QfrTest2::b() const {
2195 ✗ return m_impl->b();
2196 }
2197
2198 ✗ bool QfrTest2::setB(const double b) {
2199 ✗ return m_impl->setB(b);
2200 }
2201
2202 ✗ bool QfrTest2::setB(const std::string& b) {
2203 ✗ return m_impl->setB(b);
2204 }
2205
2206 ✗ double QfrTest2::dP1() const {
2207 ✗ return m_impl->dP1();
2208 }
2209
2210 ✗ bool QfrTest2::setDP1(const double dP1) {
2211 ✗ return m_impl->setDP1(dP1);
2212 }
2213
2214 ✗ bool QfrTest2::setDP1(const std::string& dP1) {
2215 ✗ return m_impl->setDP1(dP1);
2216 }
2217
2218 ✗ double QfrTest2::F1() const {
2219 ✗ return m_impl->F1();
2220 }
2221
2222 ✗ bool QfrTest2::setF1(const double F1) {
2223 ✗ return m_impl->setF1(F1);
2224 }
2225
2226 ✗ bool QfrTest2::setF1(const std::string& F1) {
2227 ✗ return m_impl->setF1(F1);
2228 }
2229
2230 ✗ double QfrTest2::dP2() const {
2231 ✗ return m_impl->dP2();
2232 }
2233
2234 ✗ bool QfrTest2::setDP2(const double dP2) {
2235 ✗ return m_impl->setDP2(dP2);
2236 }
2237
2238 ✗ bool QfrTest2::setDP2(const std::string& dP2) {
2239 ✗ return m_impl->setDP2(dP2);
2240 }
2241
2242 ✗ double QfrTest2::F2() const {
2243 ✗ return m_impl->F2();
2244 }
2245
2246 ✗ bool QfrTest2::setF2(const double F2) {
2247 ✗ return m_impl->setF2(F2);
2248 }
2249
2250 ✗ bool QfrTest2::setF2(const std::string& F2) {
2251 ✗ return m_impl->setF2(F2);
2252 }
2253
2254 ✗ int QfrTest2::u_P1() const {
2255 ✗ return m_impl->u_P1();
2256 }
2257
2258 ✗ void QfrTest2::setU_P1(const int u_P1) {
2259 ✗ m_impl->setU_P1(u_P1);
2260 ✗ }
2261
2262 ✗ int QfrTest2::u_F1() const {
2263 ✗ return m_impl->u_F1();
2264 }
2265
2266 ✗ void QfrTest2::setU_F1(const int u_F1) {
2267 ✗ m_impl->setU_F1(u_F1);
2268 ✗ }
2269
2270 ✗ int QfrTest2::u_P2() const {
2271 ✗ return m_impl->u_P2();
2272 }
2273
2274 ✗ void QfrTest2::setU_P2(const int u_P2) {
2275 ✗ m_impl->setU_P2(u_P2);
2276 ✗ }
2277
2278 ✗ int QfrTest2::u_F2() const {
2279 ✗ return m_impl->u_F2();
2280 }
2281
2282 ✗ void QfrTest2::setU_F2(const int u_F2) {
2283 ✗ m_impl->setU_F2(u_F2);
2284 ✗ }
2285
2286 ✗ AfeDor::AfeDor() : m_impl(std::shared_ptr<detail::AfeDorImpl>(new detail::AfeDorImpl)) {}
2287
2288 ✗ AfeDor::AfeDor(int nr, int icon, std::string name, std::string desc)
2289 ✗ : m_impl(std::shared_ptr<detail::AfeDorImpl>(new detail::AfeDorImpl(nr, icon, name, desc))) {}
2290
2291 ✗ AfeDor::AfeDor(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double dTmin, double ht, double wd,
2292 ✗ double cd, int u_T, int u_H, int u_W)
2293 ✗ : m_impl(std::shared_ptr<detail::AfeDorImpl>(new detail::AfeDorImpl(nr, icon, name, desc, lam, turb, expt, dTmin, ht, wd, cd, u_T, u_H, u_W))) {}
2294
2295 ✗ AfeDor::AfeDor(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string dTmin,
2296 ✗ std::string ht, std::string wd, std::string cd, int u_T, int u_H, int u_W)
2297 ✗ : m_impl(std::shared_ptr<detail::AfeDorImpl>(new detail::AfeDorImpl(nr, icon, name, desc, lam, turb, expt, dTmin, ht, wd, cd, u_T, u_H, u_W))) {}
2298
2299 ✗ AfeDor::AfeDor(const AfeDor& other) : m_impl(other.m_impl) {}
2300
2301 ✗ AfeDor& AfeDor::operator=(const AfeDor& other) {
2302 ✗ m_impl = other.m_impl;
2303 ✗ return *this;
2304 }
2305
2306 ✗ bool AfeDor::operator==(const AfeDor& other) const {
2307 ✗ return m_impl == other.m_impl;
2308 }
2309
2310 ✗ bool AfeDor::operator!=(const AfeDor& other) const {
2311 ✗ return m_impl != other.m_impl;
2312 }
2313
2314 ✗ std::string AfeDor::write() {
2315 ✗ return m_impl->write();
2316 }
2317
2318 ✗ void AfeDor::read(Reader& input) {
2319 ✗ m_impl->read(input);
2320 ✗ }
2321
2322 ✗ void AfeDor::readDetails(Reader& input) {
2323 ✗ m_impl->readDetails(input);
2324 ✗ }
2325
2326 ✗ int AfeDor::nr() const {
2327 ✗ return m_impl->nr();
2328 }
2329
2330 ✗ void AfeDor::setNr(const int nr) {
2331 ✗ m_impl->setNr(nr);
2332 ✗ }
2333
2334 ✗ int AfeDor::icon() const {
2335 ✗ return m_impl->icon();
2336 }
2337
2338 ✗ void AfeDor::setIcon(const int icon) {
2339 ✗ m_impl->setIcon(icon);
2340 ✗ }
2341
2342 ✗ std::string AfeDor::name() const {
2343 ✗ return m_impl->name();
2344 }
2345
2346 ✗ void AfeDor::setName(const std::string& name) {
2347 ✗ m_impl->setName(name);
2348 ✗ }
2349
2350 ✗ std::string AfeDor::desc() const {
2351 ✗ return m_impl->desc();
2352 }
2353
2354 ✗ void AfeDor::setDesc(const std::string& desc) {
2355 ✗ m_impl->setDesc(desc);
2356 ✗ }
2357
2358 ✗ double AfeDor::lam() const {
2359 ✗ return m_impl->lam();
2360 }
2361
2362 ✗ bool AfeDor::setLam(const double lam) {
2363 ✗ return m_impl->setLam(lam);
2364 }
2365
2366 ✗ bool AfeDor::setLam(const std::string& lam) {
2367 ✗ return m_impl->setLam(lam);
2368 }
2369
2370 ✗ double AfeDor::turb() const {
2371 ✗ return m_impl->turb();
2372 }
2373
2374 ✗ bool AfeDor::setTurb(const double turb) {
2375 ✗ return m_impl->setTurb(turb);
2376 }
2377
2378 ✗ bool AfeDor::setTurb(const std::string& turb) {
2379 ✗ return m_impl->setTurb(turb);
2380 }
2381
2382 ✗ double AfeDor::expt() const {
2383 ✗ return m_impl->expt();
2384 }
2385
2386 ✗ bool AfeDor::setExpt(const double expt) {
2387 ✗ return m_impl->setExpt(expt);
2388 }
2389
2390 ✗ bool AfeDor::setExpt(const std::string& expt) {
2391 ✗ return m_impl->setExpt(expt);
2392 }
2393
2394 ✗ double AfeDor::dTmin() const {
2395 ✗ return m_impl->dTmin();
2396 }
2397
2398 ✗ bool AfeDor::setDTmin(const double dTmin) {
2399 ✗ return m_impl->setDTmin(dTmin);
2400 }
2401
2402 ✗ bool AfeDor::setDTmin(const std::string& dTmin) {
2403 ✗ return m_impl->setDTmin(dTmin);
2404 }
2405
2406 ✗ double AfeDor::height() const {
2407 ✗ return m_impl->height();
2408 }
2409
2410 ✗ bool AfeDor::setHeight(const double ht) {
2411 ✗ return m_impl->setHeight(ht);
2412 }
2413
2414 ✗ bool AfeDor::setHeight(const std::string& ht) {
2415 ✗ return m_impl->setHeight(ht);
2416 }
2417
2418 ✗ double AfeDor::width() const {
2419 ✗ return m_impl->width();
2420 }
2421
2422 ✗ bool AfeDor::setWidth(const double wd) {
2423 ✗ return m_impl->setWidth(wd);
2424 }
2425
2426 ✗ bool AfeDor::setWidth(const std::string& wd) {
2427 ✗ return m_impl->setWidth(wd);
2428 }
2429
2430 ✗ double AfeDor::cd() const {
2431 ✗ return m_impl->cd();
2432 }
2433
2434 ✗ bool AfeDor::setCd(const double cd) {
2435 ✗ return m_impl->setCd(cd);
2436 }
2437
2438 ✗ bool AfeDor::setCd(const std::string& cd) {
2439 ✗ return m_impl->setCd(cd);
2440 }
2441
2442 ✗ int AfeDor::u_T() const {
2443 ✗ return m_impl->u_T();
2444 }
2445
2446 ✗ void AfeDor::setU_T(const int u_T) {
2447 ✗ m_impl->setU_T(u_T);
2448 ✗ }
2449
2450 ✗ int AfeDor::u_H() const {
2451 ✗ return m_impl->u_H();
2452 }
2453
2454 ✗ void AfeDor::setU_H(const int u_H) {
2455 ✗ m_impl->setU_H(u_H);
2456 ✗ }
2457
2458 ✗ int AfeDor::u_W() const {
2459 ✗ return m_impl->u_W();
2460 }
2461
2462 ✗ void AfeDor::setU_W(const int u_W) {
2463 ✗ m_impl->setU_W(u_W);
2464 ✗ }
2465
2466 ✗ DrPl2::DrPl2() : m_impl(std::shared_ptr<detail::DrPl2Impl>(new detail::DrPl2Impl)) {}
2467
2468 ✗ DrPl2::DrPl2(int nr, int icon, std::string name, std::string desc)
2469 ✗ : m_impl(std::shared_ptr<detail::DrPl2Impl>(new detail::DrPl2Impl(nr, icon, name, desc))) {}
2470
2471 ✗ DrPl2::DrPl2(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double dH, double ht, double wd, double cd,
2472 ✗ int u_H, int u_W)
2473 ✗ : m_impl(std::shared_ptr<detail::DrPl2Impl>(new detail::DrPl2Impl(nr, icon, name, desc, lam, turb, expt, dH, ht, wd, cd, u_H, u_W))) {}
2474
2475 ✗ DrPl2::DrPl2(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string dH,
2476 ✗ std::string ht, std::string wd, std::string cd, int u_H, int u_W)
2477 ✗ : m_impl(std::shared_ptr<detail::DrPl2Impl>(new detail::DrPl2Impl(nr, icon, name, desc, lam, turb, expt, dH, ht, wd, cd, u_H, u_W))) {}
2478
2479 ✗ DrPl2::DrPl2(const DrPl2& other) : m_impl(other.m_impl) {}
2480
2481 ✗ DrPl2& DrPl2::operator=(const DrPl2& other) {
2482 ✗ m_impl = other.m_impl;
2483 ✗ return *this;
2484 }
2485
2486 ✗ bool DrPl2::operator==(const DrPl2& other) const {
2487 ✗ return m_impl == other.m_impl;
2488 }
2489
2490 ✗ bool DrPl2::operator!=(const DrPl2& other) const {
2491 ✗ return m_impl != other.m_impl;
2492 }
2493
2494 ✗ std::string DrPl2::write() {
2495 ✗ return m_impl->write();
2496 }
2497
2498 ✗ void DrPl2::read(Reader& input) {
2499 ✗ m_impl->read(input);
2500 ✗ }
2501
2502 ✗ void DrPl2::readDetails(Reader& input) {
2503 ✗ m_impl->readDetails(input);
2504 ✗ }
2505
2506 ✗ int DrPl2::nr() const {
2507 ✗ return m_impl->nr();
2508 }
2509
2510 ✗ void DrPl2::setNr(const int nr) {
2511 ✗ m_impl->setNr(nr);
2512 ✗ }
2513
2514 ✗ int DrPl2::icon() const {
2515 ✗ return m_impl->icon();
2516 }
2517
2518 ✗ void DrPl2::setIcon(const int icon) {
2519 ✗ m_impl->setIcon(icon);
2520 ✗ }
2521
2522 ✗ std::string DrPl2::name() const {
2523 ✗ return m_impl->name();
2524 }
2525
2526 ✗ void DrPl2::setName(const std::string& name) {
2527 ✗ m_impl->setName(name);
2528 ✗ }
2529
2530 ✗ std::string DrPl2::desc() const {
2531 ✗ return m_impl->desc();
2532 }
2533
2534 ✗ void DrPl2::setDesc(const std::string& desc) {
2535 ✗ m_impl->setDesc(desc);
2536 ✗ }
2537
2538 ✗ double DrPl2::lam() const {
2539 ✗ return m_impl->lam();
2540 }
2541
2542 ✗ bool DrPl2::setLam(const double lam) {
2543 ✗ return m_impl->setLam(lam);
2544 }
2545
2546 ✗ bool DrPl2::setLam(const std::string& lam) {
2547 ✗ return m_impl->setLam(lam);
2548 }
2549
2550 ✗ double DrPl2::turb() const {
2551 ✗ return m_impl->turb();
2552 }
2553
2554 ✗ bool DrPl2::setTurb(const double turb) {
2555 ✗ return m_impl->setTurb(turb);
2556 }
2557
2558 ✗ bool DrPl2::setTurb(const std::string& turb) {
2559 ✗ return m_impl->setTurb(turb);
2560 }
2561
2562 ✗ double DrPl2::expt() const {
2563 ✗ return m_impl->expt();
2564 }
2565
2566 ✗ bool DrPl2::setExpt(const double expt) {
2567 ✗ return m_impl->setExpt(expt);
2568 }
2569
2570 ✗ bool DrPl2::setExpt(const std::string& expt) {
2571 ✗ return m_impl->setExpt(expt);
2572 }
2573
2574 ✗ double DrPl2::dH() const {
2575 ✗ return m_impl->dH();
2576 }
2577
2578 ✗ bool DrPl2::setDH(const double dH) {
2579 ✗ return m_impl->setDH(dH);
2580 }
2581
2582 ✗ bool DrPl2::setDH(const std::string& dH) {
2583 ✗ return m_impl->setDH(dH);
2584 }
2585
2586 ✗ double DrPl2::height() const {
2587 ✗ return m_impl->height();
2588 }
2589
2590 ✗ bool DrPl2::setHeight(const double ht) {
2591 ✗ return m_impl->setHeight(ht);
2592 }
2593
2594 ✗ bool DrPl2::setHeight(const std::string& ht) {
2595 ✗ return m_impl->setHeight(ht);
2596 }
2597
2598 ✗ double DrPl2::width() const {
2599 ✗ return m_impl->width();
2600 }
2601
2602 ✗ bool DrPl2::setWidth(const double wd) {
2603 ✗ return m_impl->setWidth(wd);
2604 }
2605
2606 ✗ bool DrPl2::setWidth(const std::string& wd) {
2607 ✗ return m_impl->setWidth(wd);
2608 }
2609
2610 ✗ double DrPl2::cd() const {
2611 ✗ return m_impl->cd();
2612 }
2613
2614 ✗ bool DrPl2::setCd(const double cd) {
2615 ✗ return m_impl->setCd(cd);
2616 }
2617
2618 ✗ bool DrPl2::setCd(const std::string& cd) {
2619 ✗ return m_impl->setCd(cd);
2620 }
2621
2622 ✗ int DrPl2::u_H() const {
2623 ✗ return m_impl->u_H();
2624 }
2625
2626 ✗ void DrPl2::setU_H(const int u_H) {
2627 ✗ m_impl->setU_H(u_H);
2628 ✗ }
2629
2630 ✗ int DrPl2::u_W() const {
2631 ✗ return m_impl->u_W();
2632 }
2633
2634 ✗ void DrPl2::setU_W(const int u_W) {
2635 ✗ m_impl->setU_W(u_W);
2636 ✗ }
2637
2638 ✗ AfeFlow::AfeFlow() : m_impl(std::shared_ptr<detail::AfeFlowImpl>(new detail::AfeFlowImpl)) {}
2639
2640 6 AfeFlow::AfeFlow(int nr, int icon, std::string name, std::string desc)
2641
5/7
✓ Branch 2 taken 6 times.
✓ Branch 5 taken 6 times.
✓ Branch 8 taken 6 times.
✓ Branch 11 taken 6 times.
✓ Branch 14 taken 6 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
6 : m_impl(std::shared_ptr<detail::AfeFlowImpl>(new detail::AfeFlowImpl(nr, icon, name, desc))) {}
2642
2643 ✗ AfeFlow::AfeFlow(int nr, int icon, std::string name, std::string desc, double Flow, int u_F)
2644 ✗ : m_impl(std::shared_ptr<detail::AfeFlowImpl>(new detail::AfeFlowImpl(nr, icon, name, desc, Flow, u_F))) {}
2645
2646 ✗ AfeFlow::AfeFlow(int nr, int icon, std::string name, std::string desc, std::string Flow, int u_F)
2647 ✗ : m_impl(std::shared_ptr<detail::AfeFlowImpl>(new detail::AfeFlowImpl(nr, icon, name, desc, Flow, u_F))) {}
2648
2649 ✗ AfeFlow::AfeFlow(const AfeFlow& other) : m_impl(other.m_impl) {}
2650
2651 ✗ AfeFlow& AfeFlow::operator=(const AfeFlow& other) {
2652 ✗ m_impl = other.m_impl;
2653 ✗ return *this;
2654 }
2655
2656 ✗ bool AfeFlow::operator==(const AfeFlow& other) const {
2657 ✗ return m_impl == other.m_impl;
2658 }
2659
2660 ✗ bool AfeFlow::operator!=(const AfeFlow& other) const {
2661 ✗ return m_impl != other.m_impl;
2662 }
2663
2664 1 std::string AfeFlow::write() {
2665
2/2
✓ Branch 2 taken 1 time.
✓ Branch 5 taken 1 time.
2 return m_impl->write(dataType());
2666 }
2667
2668 ✗ void AfeFlow::read(Reader& input) {
2669 ✗ m_impl->read(input);
2670 ✗ }
2671
2672 6 void AfeFlow::readDetails(Reader& input) {
2673 6 m_impl->readDetails(input);
2674 6 }
2675
2676 ✗ int AfeFlow::nr() const {
2677 ✗ return m_impl->nr();
2678 }
2679
2680 ✗ void AfeFlow::setNr(const int nr) {
2681 ✗ m_impl->setNr(nr);
2682 ✗ }
2683
2684 ✗ int AfeFlow::icon() const {
2685 ✗ return m_impl->icon();
2686 }
2687
2688 ✗ void AfeFlow::setIcon(const int icon) {
2689 ✗ m_impl->setIcon(icon);
2690 ✗ }
2691
2692 24 std::string AfeFlow::name() const {
2693 24 return m_impl->name();
2694 }
2695
2696 ✗ void AfeFlow::setName(const std::string& name) {
2697 ✗ m_impl->setName(name);
2698 ✗ }
2699
2700 ✗ std::string AfeFlow::desc() const {
2701 ✗ return m_impl->desc();
2702 }
2703
2704 ✗ void AfeFlow::setDesc(const std::string& desc) {
2705 ✗ m_impl->setDesc(desc);
2706 ✗ }
2707
2708 ✗ double AfeFlow::Flow() const {
2709 ✗ return m_impl->Flow();
2710 }
2711
2712 ✗ bool AfeFlow::setFlow(const double Flow) {
2713 ✗ return m_impl->setFlow(Flow);
2714 }
2715
2716 ✗ bool AfeFlow::setFlow(const std::string& Flow) {
2717 ✗ return m_impl->setFlow(Flow);
2718 }
2719
2720 ✗ int AfeFlow::u_F() const {
2721 ✗ return m_impl->u_F();
2722 }
2723
2724 ✗ void AfeFlow::setU_F(const int u_F) {
2725 ✗ m_impl->setU_F(u_F);
2726 ✗ }
2727
2728 ✗ AfeCmf::AfeCmf() : AfeFlow() {}
2729
2730
3/3
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
6 AfeCmf::AfeCmf(int nr, int icon, std::string name, std::string desc) : AfeFlow(nr, icon, name, desc) {}
2731
2732 ✗ AfeCmf::AfeCmf(int nr, int icon, std::string name, std::string desc, double Flow, int u_F) : AfeFlow(nr, icon, name, desc, Flow, u_F) {}
2733
2734 ✗ AfeCmf::AfeCmf(int nr, int icon, std::string name, std::string desc, std::string Flow, int u_F) : AfeFlow(nr, icon, name, desc, Flow, u_F) {}
2735
2736 ✗ AfeCvf::AfeCvf() : AfeFlow() {}
2737
2738 ✗ AfeCvf::AfeCvf(int nr, int icon, std::string name, std::string desc) : AfeFlow(nr, icon, name, desc) {}
2739
2740 ✗ AfeCvf::AfeCvf(int nr, int icon, std::string name, std::string desc, double Flow, int u_F) : AfeFlow(nr, icon, name, desc, Flow, u_F) {}
2741
2742 ✗ AfeCvf::AfeCvf(int nr, int icon, std::string name, std::string desc, std::string Flow, int u_F) : AfeFlow(nr, icon, name, desc, Flow, u_F) {}
2743
2744 ✗ AfeFan::AfeFan() : m_impl(std::shared_ptr<detail::AfeFanImpl>(new detail::AfeFanImpl)) {}
2745
2746 ✗ AfeFan::AfeFan(int nr, int icon, std::string name, std::string desc)
2747 ✗ : m_impl(std::shared_ptr<detail::AfeFanImpl>(new detail::AfeFanImpl(nr, icon, name, desc))) {}
2748
2749 ✗ AfeFan::AfeFan(int nr, int icon, std::string name, std::string desc, double lam, double turb, double expt, double rdens, double fdf, double sop,
2750 ✗ double off, std::vector<double> fpc, double Sarea, int u_Sa, std::vector<FanDataPoint> data)
2751 ✗ : m_impl(std::shared_ptr<detail::AfeFanImpl>(
2752 ✗ new detail::AfeFanImpl(nr, icon, name, desc, lam, turb, expt, rdens, fdf, sop, off, fpc, Sarea, u_Sa, data))) {}
2753
2754 ✗ AfeFan::AfeFan(int nr, int icon, std::string name, std::string desc, std::string lam, std::string turb, std::string expt, std::string rdens,
2755 std::string fdf, std::string sop, std::string off, std::vector<std::string> fpc, std::string Sarea, int u_Sa,
2756 ✗ std::vector<FanDataPoint> data)
2757 ✗ : m_impl(std::shared_ptr<detail::AfeFanImpl>(
2758 ✗ new detail::AfeFanImpl(nr, icon, name, desc, lam, turb, expt, rdens, fdf, sop, off, fpc, Sarea, u_Sa, data))) {}
2759
2760 ✗ AfeFan::AfeFan(const AfeFan& other) : m_impl(other.m_impl) {}
2761
2762 ✗ AfeFan& AfeFan::operator=(const AfeFan& other) {
2763 ✗ m_impl = other.m_impl;
2764 ✗ return *this;
2765 }
2766
2767 ✗ bool AfeFan::operator==(const AfeFan& other) const {
2768 ✗ return m_impl == other.m_impl;
2769 }
2770
2771 ✗ bool AfeFan::operator!=(const AfeFan& other) const {
2772 ✗ return m_impl != other.m_impl;
2773 }
2774
2775 ✗ std::string AfeFan::write() {
2776 ✗ return m_impl->write();
2777 }
2778
2779 ✗ void AfeFan::read(Reader& input) {
2780 ✗ m_impl->read(input);
2781 ✗ }
2782
2783 ✗ void AfeFan::readDetails(Reader& input) {
2784 ✗ m_impl->readDetails(input);
2785 ✗ }
2786
2787 ✗ int AfeFan::nr() const {
2788 ✗ return m_impl->nr();
2789 }
2790
2791 ✗ void AfeFan::setNr(const int nr) {
2792 ✗ m_impl->setNr(nr);
2793 ✗ }
2794
2795 ✗ int AfeFan::icon() const {
2796 ✗ return m_impl->icon();
2797 }
2798
2799 ✗ void AfeFan::setIcon(const int icon) {
2800 ✗ m_impl->setIcon(icon);
2801 ✗ }
2802
2803 ✗ std::string AfeFan::name() const {
2804 ✗ return m_impl->name();
2805 }
2806
2807 ✗ void AfeFan::setName(const std::string& name) {
2808 ✗ m_impl->setName(name);
2809 ✗ }
2810
2811 ✗ std::string AfeFan::desc() const {
2812 ✗ return m_impl->desc();
2813 }
2814
2815 ✗ void AfeFan::setDesc(const std::string& desc) {
2816 ✗ m_impl->setDesc(desc);
2817 ✗ }
2818
2819 ✗ double AfeFan::lam() const {
2820 ✗ return m_impl->lam();
2821 }
2822
2823 ✗ bool AfeFan::setLam(const double lam) {
2824 ✗ return m_impl->setLam(lam);
2825 }
2826
2827 ✗ bool AfeFan::setLam(const std::string& lam) {
2828 ✗ return m_impl->setLam(lam);
2829 }
2830
2831 ✗ double AfeFan::turb() const {
2832 ✗ return m_impl->turb();
2833 }
2834
2835 ✗ bool AfeFan::setTurb(const double turb) {
2836 ✗ return m_impl->setTurb(turb);
2837 }
2838
2839 ✗ bool AfeFan::setTurb(const std::string& turb) {
2840 ✗ return m_impl->setTurb(turb);
2841 }
2842
2843 ✗ double AfeFan::expt() const {
2844 ✗ return m_impl->expt();
2845 }
2846
2847 ✗ bool AfeFan::setExpt(const double expt) {
2848 ✗ return m_impl->setExpt(expt);
2849 }
2850
2851 ✗ bool AfeFan::setExpt(const std::string& expt) {
2852 ✗ return m_impl->setExpt(expt);
2853 }
2854
2855 ✗ double AfeFan::rdens() const {
2856 ✗ return m_impl->rdens();
2857 }
2858
2859 ✗ bool AfeFan::setRdens(const double rdens) {
2860 ✗ return m_impl->setRdens(rdens);
2861 }
2862
2863 ✗ bool AfeFan::setRdens(const std::string& rdens) {
2864 ✗ return m_impl->setRdens(rdens);
2865 }
2866
2867 ✗ double AfeFan::fdf() const {
2868 ✗ return m_impl->fdf();
2869 }
2870
2871 ✗ bool AfeFan::setFdf(const double fdf) {
2872 ✗ return m_impl->setFdf(fdf);
2873 }
2874
2875 ✗ bool AfeFan::setFdf(const std::string& fdf) {
2876 ✗ return m_impl->setFdf(fdf);
2877 }
2878
2879 ✗ double AfeFan::sop() const {
2880 ✗ return m_impl->sop();
2881 }
2882
2883 ✗ bool AfeFan::setSop(const double sop) {
2884 ✗ return m_impl->setSop(sop);
2885 }
2886
2887 ✗ bool AfeFan::setSop(const std::string& sop) {
2888 ✗ return m_impl->setSop(sop);
2889 }
2890
2891 ✗ double AfeFan::off() const {
2892 ✗ return m_impl->off();
2893 }
2894
2895 ✗ bool AfeFan::setOff(const double off) {
2896 ✗ return m_impl->setOff(off);
2897 }
2898
2899 ✗ bool AfeFan::setOff(const std::string& off) {
2900 ✗ return m_impl->setOff(off);
2901 }
2902
2903 ✗ std::vector<double> AfeFan::fpc() const {
2904 ✗ return m_impl->fpc();
2905 }
2906
2907 ✗ bool AfeFan::setFpc(const std::vector<double>& fpc) {
2908 ✗ return m_impl->setFpc(fpc);
2909 }
2910
2911 ✗ bool AfeFan::setFpc(const std::vector<std::string>& fpc) {
2912 ✗ return m_impl->setFpc(fpc);
2913 }
2914
2915 ✗ double AfeFan::Sarea() const {
2916 ✗ return m_impl->Sarea();
2917 }
2918
2919 ✗ bool AfeFan::setSarea(const double Sarea) {
2920 ✗ return m_impl->setSarea(Sarea);
2921 }
2922
2923 ✗ bool AfeFan::setSarea(const std::string& Sarea) {
2924 ✗ return m_impl->setSarea(Sarea);
2925 }
2926
2927 ✗ int AfeFan::u_Sa() const {
2928 ✗ return m_impl->u_Sa();
2929 }
2930
2931 ✗ void AfeFan::setU_Sa(const int u_Sa) {
2932 ✗ m_impl->setU_Sa(u_Sa);
2933 ✗ }
2934
2935 ✗ std::vector<FanDataPoint> AfeFan::data() const {
2936 ✗ return m_impl->data();
2937 }
2938
2939 ✗ void AfeFan::setData(const std::vector<FanDataPoint>& data) {
2940 ✗ m_impl->setData(data);
2941 ✗ }
2942
2943 ✗ AfeCsf::AfeCsf() : m_impl(std::shared_ptr<detail::AfeCsfImpl>(new detail::AfeCsfImpl())) {}
2944
2945 ✗ AfeCsf::AfeCsf(int nr, int icon, std::string name, std::string desc)
2946 ✗ : m_impl(std::shared_ptr<detail::AfeCsfImpl>(new detail::AfeCsfImpl(nr, icon, name, desc))) {}
2947
2948 ✗ AfeCsf::AfeCsf(int nr, int icon, std::string name, std::string desc, int u_x, int u_y, std::vector<XyDataPoint> data)
2949 ✗ : m_impl(std::shared_ptr<detail::AfeCsfImpl>(new detail::AfeCsfImpl(nr, icon, name, desc, u_x, u_y, data))) {}
2950
2951 ✗ AfeCsf::AfeCsf(const AfeCsf& other) : m_impl(other.m_impl) {}
2952
2953 ✗ AfeCsf& AfeCsf::operator=(const AfeCsf& other) {
2954 ✗ m_impl = other.m_impl;
2955 ✗ return *this;
2956 }
2957
2958 ✗ bool AfeCsf::operator==(const AfeCsf& other) const {
2959 ✗ return m_impl == other.m_impl;
2960 }
2961
2962 ✗ bool AfeCsf::operator!=(const AfeCsf& other) const {
2963 ✗ return m_impl != other.m_impl;
2964 }
2965
2966 ✗ std::string AfeCsf::write() {
2967 ✗ return m_impl->write(dataType());
2968 }
2969
2970 ✗ void AfeCsf::read(Reader& input) {
2971 ✗ m_impl->read(input);
2972 ✗ }
2973
2974 ✗ void AfeCsf::readDetails(Reader& input) {
2975 ✗ m_impl->readDetails(input);
2976 ✗ }
2977
2978 ✗ int AfeCsf::nr() const {
2979 ✗ return m_impl->nr();
2980 }
2981
2982 ✗ void AfeCsf::setNr(const int nr) {
2983 ✗ m_impl->setNr(nr);
2984 ✗ }
2985
2986 ✗ int AfeCsf::icon() const {
2987 ✗ return m_impl->icon();
2988 }
2989
2990 ✗ void AfeCsf::setIcon(const int icon) {
2991 ✗ m_impl->setIcon(icon);
2992 ✗ }
2993
2994 ✗ std::string AfeCsf::name() const {
2995 ✗ return m_impl->name();
2996 }
2997
2998 ✗ void AfeCsf::setName(const std::string& name) {
2999 ✗ m_impl->setName(name);
3000 ✗ }
3001
3002 ✗ std::string AfeCsf::desc() const {
3003 ✗ return m_impl->desc();
3004 }
3005
3006 ✗ void AfeCsf::setDesc(const std::string& desc) {
3007 ✗ m_impl->setDesc(desc);
3008 ✗ }
3009
3010 ✗ int AfeCsf::u_x() const {
3011 ✗ return m_impl->u_x();
3012 }
3013
3014 ✗ void AfeCsf::setU_x(const int u_x) {
3015 ✗ m_impl->setU_x(u_x);
3016 ✗ }
3017
3018 ✗ int AfeCsf::u_y() const {
3019 ✗ return m_impl->u_y();
3020 }
3021
3022 ✗ void AfeCsf::setU_y(const int u_y) {
3023 ✗ m_impl->setU_y(u_y);
3024 ✗ }
3025
3026 ✗ std::vector<XyDataPoint> AfeCsf::data() const {
3027 ✗ return m_impl->data();
3028 }
3029
3030 ✗ void AfeCsf::setData(const std::vector<XyDataPoint>& data) {
3031 ✗ m_impl->setData(data);
3032 ✗ }
3033
3034 ✗ AfeFsp::AfeFsp() : AfeCsf() {}
3035
3036 ✗ AfeFsp::AfeFsp(int nr, int icon, std::string name, std::string desc) : AfeCsf(nr, icon, name, desc) {}
3037
3038 ✗ AfeFsp::AfeFsp(int nr, int icon, std::string name, std::string desc, int u_x, int u_y, std::vector<XyDataPoint> data)
3039 ✗ : AfeCsf(nr, icon, name, desc, u_x, u_y, data) {}
3040
3041 ✗ AfeQsp::AfeQsp() : AfeCsf() {}
3042
3043 ✗ AfeQsp::AfeQsp(int nr, int icon, std::string name, std::string desc) : AfeCsf(nr, icon, name, desc) {}
3044
3045 ✗ AfeQsp::AfeQsp(int nr, int icon, std::string name, std::string desc, int u_x, int u_y, std::vector<XyDataPoint> data)
3046 ✗ : AfeCsf(nr, icon, name, desc, u_x, u_y, data) {}
3047
3048 ✗ AfePsf::AfePsf() : AfeCsf() {}
3049
3050 ✗ AfePsf::AfePsf(int nr, int icon, std::string name, std::string desc) : AfeCsf(nr, icon, name, desc) {}
3051
3052 ✗ AfePsf::AfePsf(int nr, int icon, std::string name, std::string desc, int u_x, int u_y, std::vector<XyDataPoint> data)
3053 ✗ : AfeCsf(nr, icon, name, desc, u_x, u_y, data) {}
3054
3055 ✗ AfePsq::AfePsq() : AfeCsf() {}
3056
3057 ✗ AfePsq::AfePsq(int nr, int icon, std::string name, std::string desc) : AfeCsf(nr, icon, name, desc) {}
3058
3059 ✗ AfePsq::AfePsq(int nr, int icon, std::string name, std::string desc, int u_x, int u_y, std::vector<XyDataPoint> data)
3060 ✗ : AfeCsf(nr, icon, name, desc, u_x, u_y, data) {}
3061
3062 ✗ AfeSup::AfeSup() : m_impl(std::shared_ptr<detail::AfeSupImpl>(new detail::AfeSupImpl)) {}
3063
3064 ✗ AfeSup::AfeSup(int nr, int icon, std::string name, std::string desc)
3065 ✗ : m_impl(std::shared_ptr<detail::AfeSupImpl>(new detail::AfeSupImpl(nr, icon, name, desc))) {}
3066
3067 ✗ AfeSup::AfeSup(int nr, int icon, std::string name, std::string desc, int sched, int u_H, std::vector<AirflowSubelementData> subelements)
3068 ✗ : m_impl(std::shared_ptr<detail::AfeSupImpl>(new detail::AfeSupImpl(nr, icon, name, desc, sched, u_H, subelements))) {}
3069
3070 ✗ AfeSup::AfeSup(const AfeSup& other) : m_impl(other.m_impl) {}
3071
3072 ✗ AfeSup& AfeSup::operator=(const AfeSup& other) {
3073 ✗ m_impl = other.m_impl;
3074 ✗ return *this;
3075 }
3076
3077 ✗ bool AfeSup::operator==(const AfeSup& other) const {
3078 ✗ return m_impl == other.m_impl;
3079 }
3080
3081 ✗ bool AfeSup::operator!=(const AfeSup& other) const {
3082 ✗ return m_impl != other.m_impl;
3083 }
3084
3085 ✗ std::string AfeSup::write() {
3086 ✗ return m_impl->write();
3087 }
3088
3089 ✗ void AfeSup::read(Reader& input) {
3090 ✗ m_impl->read(input);
3091 ✗ }
3092
3093 ✗ void AfeSup::readDetails(Reader& input) {
3094 ✗ m_impl->readDetails(input);
3095 ✗ }
3096
3097 ✗ int AfeSup::nr() const {
3098 ✗ return m_impl->nr();
3099 }
3100
3101 ✗ void AfeSup::setNr(const int nr) {
3102 ✗ m_impl->setNr(nr);
3103 ✗ }
3104
3105 ✗ int AfeSup::icon() const {
3106 ✗ return m_impl->icon();
3107 }
3108
3109 ✗ void AfeSup::setIcon(const int icon) {
3110 ✗ m_impl->setIcon(icon);
3111 ✗ }
3112
3113 ✗ std::string AfeSup::name() const {
3114 ✗ return m_impl->name();
3115 }
3116
3117 ✗ void AfeSup::setName(const std::string& name) {
3118 ✗ m_impl->setName(name);
3119 ✗ }
3120
3121 ✗ std::string AfeSup::desc() const {
3122 ✗ return m_impl->desc();
3123 }
3124
3125 ✗ void AfeSup::setDesc(const std::string& desc) {
3126 ✗ m_impl->setDesc(desc);
3127 ✗ }
3128
3129 ✗ int AfeSup::sched() const {
3130 ✗ return m_impl->sched();
3131 }
3132
3133 ✗ void AfeSup::setSched(const int sched) {
3134 ✗ m_impl->setSched(sched);
3135 ✗ }
3136
3137 ✗ int AfeSup::u_H() const {
3138 ✗ return m_impl->u_H();
3139 }
3140
3141 ✗ void AfeSup::setU_H(const int u_H) {
3142 ✗ m_impl->setU_H(u_H);
3143 ✗ }
3144
3145 ✗ std::vector<AirflowSubelementData> AfeSup::subelements() const {
3146 ✗ return m_impl->subelements();
3147 }
3148
3149 ✗ void AfeSup::setSubelements(const std::vector<AirflowSubelementData>& subelements) {
3150 ✗ m_impl->setSubelements(subelements);
3151 ✗ }
3152
3153 } // namespace contam
3154 } // namespace openstudio
3155