GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 13.9% 182 / 0 / 1307
Functions: 16.3% 50 / 0 / 306
Branches: 9.7% 67 / 0 / 689

src/utilities/sql/SqlFile.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 "SqlFile.hpp"
7 #include "SqlFile_Impl.hpp"
8 #include "SqlFileTimeSeriesQuery.hpp"
9
10 #include <sqlite3.h>
11
12 namespace openstudio {
13
14 2163 SqlFile::SqlFile() = default;
15
16 68 SqlFile::SqlFile(const openstudio::path& path, const bool createIndexes) {
17 try {
18
3/5
✓ Branch 1 taken 68 times.
✓ Branch 4 taken 68 times.
✓ Branch 7 taken 68 times.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
68 m_impl = std::shared_ptr<detail::SqlFile_Impl>(new detail::SqlFile_Impl(path, createIndexes));
19 ✗ } catch (const std::exception& e) {
20 ✗ LOG(Error, "Could not create SqlFile for path '" << openstudio::toString(path) << "' error:" << e.what());
21 ✗ }
22 68 }
23
24 ✗ SqlFile::SqlFile(const openstudio::path& t_path, const openstudio::EpwFile& t_epwFile, const openstudio::DateTime& t_simulationTime,
25 ✗ const openstudio::Calendar& t_calendar, const bool createIndexes) {
26 try {
27 ✗ m_impl = std::shared_ptr<detail::SqlFile_Impl>(new detail::SqlFile_Impl(t_path, t_epwFile, t_simulationTime, t_calendar, createIndexes));
28 ✗ } catch (const std::exception& e) {
29 ✗ LOG(Error, "Could not create SqlFile for path '" << openstudio::toString(t_path) << "' error:" << e.what());
30 ✗ }
31 ✗ }
32
33 ✗ void SqlFile::createIndexes() {
34 ✗ if (m_impl) {
35 ✗ m_impl->createIndexes();
36 }
37 ✗ }
38
39 ✗ void SqlFile::removeIndexes() {
40 ✗ if (m_impl) {
41 ✗ m_impl->removeIndexes();
42 }
43 ✗ }
44
45 55 bool SqlFile::connectionOpen() const {
46 55 bool result = false;
47
1/2
✓ Branch 1 taken 55 times.
✗ Branch 2 not taken.
55 if (m_impl) {
48 55 result = m_impl->connectionOpen();
49 }
50 55 return result;
51 }
52
53 ✗ openstudio::path SqlFile::path() const {
54 ✗ openstudio::path result;
55 ✗ if (m_impl) {
56 ✗ result = m_impl->path();
57 }
58 ✗ return result;
59 ✗ }
60
61 25 bool SqlFile::close() {
62 25 bool result = false;
63
1/2
✓ Branch 1 taken 25 times.
✗ Branch 2 not taken.
25 if (m_impl) {
64 25 result = m_impl->close();
65 }
66 25 return result;
67 }
68
69 2 bool SqlFile::reopen() {
70 2 bool result = false;
71
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
2 if (m_impl) {
72 2 result = m_impl->reopen();
73 }
74 2 return result;
75 }
76
77 2 boost::optional<double> SqlFile::hoursSimulated() const {
78 2 boost::optional<double> result;
79
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
2 if (m_impl) {
80
1/1
✓ Branch 2 taken 2 times.
2 result = m_impl->hoursSimulated();
81 }
82 2 return result;
83 }
84
85 9 boost::optional<double> SqlFile::netSiteEnergy() const {
86 9 boost::optional<double> result;
87
1/2
✓ Branch 1 taken 9 times.
✗ Branch 2 not taken.
9 if (m_impl) {
88
1/1
✓ Branch 2 taken 9 times.
9 result = m_impl->netSiteEnergy();
89 }
90 9 return result;
91 }
92
93 ✗ boost::optional<double> SqlFile::netSourceEnergy() const {
94 ✗ boost::optional<double> result;
95 ✗ if (m_impl) {
96 ✗ result = m_impl->netSourceEnergy();
97 }
98 ✗ return result;
99 }
100
101 ✗ boost::optional<double> SqlFile::totalSiteEnergy() const {
102 ✗ boost::optional<double> result;
103 ✗ if (m_impl) {
104 ✗ result = m_impl->totalSiteEnergy();
105 }
106 ✗ return result;
107 }
108
109 ✗ boost::optional<double> SqlFile::totalSourceEnergy() const {
110 ✗ boost::optional<double> result;
111 ✗ if (m_impl) {
112 ✗ result = m_impl->totalSourceEnergy();
113 }
114 ✗ return result;
115 }
116
117 ✗ boost::optional<double> SqlFile::annualTotalCost(const FuelType& fuel) const {
118 ✗ boost::optional<double> result;
119 ✗ if (m_impl) {
120 ✗ result = m_impl->annualTotalCost(fuel);
121 }
122 ✗ return result;
123 }
124
125 ✗ boost::optional<double> SqlFile::annualTotalCostPerBldgArea(const FuelType& fuel) const {
126 ✗ boost::optional<double> result;
127 ✗ if (m_impl) {
128 ✗ result = m_impl->annualTotalCostPerBldgArea(fuel);
129 }
130 ✗ return result;
131 }
132
133 ✗ boost::optional<double> SqlFile::annualTotalCostPerNetConditionedBldgArea(const FuelType& fuel) const {
134 ✗ boost::optional<double> result;
135 ✗ if (m_impl) {
136 ✗ result = m_impl->annualTotalCostPerNetConditionedBldgArea(fuel);
137 }
138 ✗ return result;
139 }
140
141 ✗ boost::optional<double> SqlFile::annualTotalUtilityCost() const {
142 ✗ boost::optional<double> result;
143 ✗ if (m_impl) {
144 ✗ result = m_impl->annualTotalUtilityCost();
145 }
146 ✗ return result;
147 }
148
149 ✗ boost::optional<double> SqlFile::economicsEnergyCost() const {
150 ✗ if (m_impl) {
151 ✗ return m_impl->economicsEnergyCost();
152 } else {
153 ✗ return {};
154 }
155 }
156
157 ✗ boost::optional<EndUses> SqlFile::endUses() const {
158 ✗ if (m_impl) {
159 ✗ return m_impl->endUses();
160 } else {
161 ✗ return {};
162 }
163 }
164
165 ✗ boost::optional<double> SqlFile::getElecOrGasCost(bool t_getGas) const {
166 ✗ if (m_impl) {
167 ✗ return m_impl->getElecOrGasCost(t_getGas);
168 } else {
169 ✗ return {};
170 }
171 }
172
173 ✗ boost::optional<double> SqlFile::getElecOrGasUse(bool t_getGas) const {
174 ✗ if (m_impl) {
175 ✗ return m_impl->getElecOrGasUse(t_getGas);
176 } else {
177 ✗ return {};
178 }
179 }
180
181 17136 boost::optional<double> SqlFile::energyConsumptionByMonth(const openstudio::EndUseFuelType& t_fuelType,
182 const openstudio::EndUseCategoryType& t_categoryType,
183 const openstudio::MonthOfYear& t_monthOfYear) const {
184
1/2
✓ Branch 1 taken 17136 times.
✗ Branch 2 not taken.
17136 if (m_impl) {
185 17136 return m_impl->energyConsumptionByMonth(t_fuelType, t_categoryType, t_monthOfYear);
186 } else {
187 ✗ return {};
188 }
189 }
190
191 ✗ boost::optional<double> SqlFile::peakEnergyDemandByMonth(const openstudio::EndUseFuelType& t_fuelType,
192 const openstudio::EndUseCategoryType& t_categoryType,
193 const openstudio::MonthOfYear& t_monthOfYear) const {
194 ✗ if (m_impl) {
195 ✗ return m_impl->peakEnergyDemandByMonth(t_fuelType, t_categoryType, t_monthOfYear);
196 } else {
197 ✗ return {};
198 }
199 }
200
201 ✗ boost::optional<double> SqlFile::electricityHeating() const {
202 ✗ if (m_impl) {
203 ✗ return m_impl->electricityHeating();
204 } else {
205 ✗ return {};
206 }
207 }
208
209 ✗ boost::optional<double> SqlFile::electricityCooling() const {
210 ✗ if (m_impl) {
211 ✗ return m_impl->electricityCooling();
212 } else {
213 ✗ return {};
214 }
215 }
216
217 ✗ boost::optional<double> SqlFile::electricityInteriorLighting() const {
218 ✗ if (m_impl) {
219 ✗ return m_impl->electricityInteriorLighting();
220 } else {
221 ✗ return {};
222 }
223 }
224
225 ✗ boost::optional<double> SqlFile::electricityExteriorLighting() const {
226 ✗ if (m_impl) {
227 ✗ return m_impl->electricityExteriorLighting();
228 } else {
229 ✗ return {};
230 }
231 }
232
233 ✗ boost::optional<double> SqlFile::electricityInteriorEquipment() const {
234 ✗ if (m_impl) {
235 ✗ return m_impl->electricityInteriorEquipment();
236 } else {
237 ✗ return {};
238 }
239 }
240
241 1 boost::optional<double> SqlFile::electricityExteriorEquipment() const {
242
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
243 1 return m_impl->electricityExteriorEquipment();
244 } else {
245 ✗ return {};
246 }
247 }
248
249 ✗ boost::optional<double> SqlFile::electricityFans() const {
250 ✗ if (m_impl) {
251 ✗ return m_impl->electricityFans();
252 } else {
253 ✗ return {};
254 }
255 }
256
257 ✗ boost::optional<double> SqlFile::electricityPumps() const {
258 ✗ if (m_impl) {
259 ✗ return m_impl->electricityPumps();
260 } else {
261 ✗ return {};
262 }
263 }
264
265 ✗ boost::optional<double> SqlFile::electricityHeatRejection() const {
266 ✗ if (m_impl) {
267 ✗ return m_impl->electricityHeatRejection();
268 } else {
269 ✗ return {};
270 }
271 }
272
273 ✗ boost::optional<double> SqlFile::electricityHumidification() const {
274 ✗ if (m_impl) {
275 ✗ return m_impl->electricityHumidification();
276 } else {
277 ✗ return {};
278 }
279 }
280
281 ✗ boost::optional<double> SqlFile::electricityHeatRecovery() const {
282 ✗ if (m_impl) {
283 ✗ return m_impl->electricityHeatRecovery();
284 } else {
285 ✗ return {};
286 }
287 }
288
289 ✗ boost::optional<double> SqlFile::electricityWaterSystems() const {
290 ✗ if (m_impl) {
291 ✗ return m_impl->electricityWaterSystems();
292 } else {
293 ✗ return {};
294 }
295 }
296
297 ✗ boost::optional<double> SqlFile::electricityRefrigeration() const {
298 ✗ if (m_impl) {
299 ✗ return m_impl->electricityRefrigeration();
300 } else {
301 ✗ return {};
302 }
303 }
304
305 ✗ boost::optional<double> SqlFile::electricityGenerators() const {
306 ✗ if (m_impl) {
307 ✗ return m_impl->electricityGenerators();
308 } else {
309 ✗ return {};
310 }
311 }
312
313 1 boost::optional<double> SqlFile::electricityTotalEndUses() const {
314
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
315 1 return m_impl->electricityTotalEndUses();
316 } else {
317 ✗ return {};
318 }
319 }
320
321 ✗ boost::optional<double> SqlFile::naturalGasHeating() const {
322 ✗ if (m_impl) {
323 ✗ return m_impl->naturalGasHeating();
324 } else {
325 ✗ return {};
326 }
327 }
328
329 ✗ boost::optional<double> SqlFile::naturalGasCooling() const {
330 ✗ if (m_impl) {
331 ✗ return m_impl->naturalGasCooling();
332 } else {
333 ✗ return {};
334 }
335 }
336
337 ✗ boost::optional<double> SqlFile::naturalGasInteriorLighting() const {
338 ✗ if (m_impl) {
339 ✗ return m_impl->naturalGasInteriorLighting();
340 } else {
341 ✗ return {};
342 }
343 }
344
345 ✗ boost::optional<double> SqlFile::naturalGasExteriorLighting() const {
346 ✗ if (m_impl) {
347 ✗ return m_impl->naturalGasExteriorLighting();
348 } else {
349 ✗ return {};
350 }
351 }
352
353 ✗ boost::optional<double> SqlFile::naturalGasInteriorEquipment() const {
354 ✗ if (m_impl) {
355 ✗ return m_impl->naturalGasInteriorEquipment();
356 } else {
357 ✗ return {};
358 }
359 }
360
361 1 boost::optional<double> SqlFile::naturalGasExteriorEquipment() const {
362
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
363 1 return m_impl->naturalGasExteriorEquipment();
364 } else {
365 ✗ return {};
366 }
367 }
368
369 ✗ boost::optional<double> SqlFile::naturalGasFans() const {
370 ✗ if (m_impl) {
371 ✗ return m_impl->naturalGasFans();
372 } else {
373 ✗ return {};
374 }
375 }
376
377 ✗ boost::optional<double> SqlFile::naturalGasPumps() const {
378 ✗ if (m_impl) {
379 ✗ return m_impl->naturalGasPumps();
380 } else {
381 ✗ return {};
382 }
383 }
384
385 ✗ boost::optional<double> SqlFile::naturalGasHeatRejection() const {
386 ✗ if (m_impl) {
387 ✗ return m_impl->naturalGasHeatRejection();
388 } else {
389 ✗ return {};
390 }
391 }
392
393 ✗ boost::optional<double> SqlFile::naturalGasHumidification() const {
394 ✗ if (m_impl) {
395 ✗ return m_impl->naturalGasHumidification();
396 } else {
397 ✗ return {};
398 }
399 }
400
401 ✗ boost::optional<double> SqlFile::naturalGasHeatRecovery() const {
402 ✗ if (m_impl) {
403 ✗ return m_impl->naturalGasHeatRecovery();
404 } else {
405 ✗ return {};
406 }
407 }
408
409 ✗ boost::optional<double> SqlFile::naturalGasWaterSystems() const {
410 ✗ if (m_impl) {
411 ✗ return m_impl->naturalGasWaterSystems();
412 } else {
413 ✗ return {};
414 }
415 }
416
417 ✗ boost::optional<double> SqlFile::naturalGasRefrigeration() const {
418 ✗ if (m_impl) {
419 ✗ return m_impl->naturalGasRefrigeration();
420 } else {
421 ✗ return {};
422 }
423 }
424
425 ✗ boost::optional<double> SqlFile::naturalGasGenerators() const {
426 ✗ if (m_impl) {
427 ✗ return m_impl->naturalGasGenerators();
428 } else {
429 ✗ return {};
430 }
431 }
432
433 1 boost::optional<double> SqlFile::naturalGasTotalEndUses() const {
434
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
435 1 return m_impl->naturalGasTotalEndUses();
436 } else {
437 ✗ return {};
438 }
439 }
440
441 // Gasoline
442 ✗ boost::optional<double> SqlFile::gasolineHeating() const {
443 ✗ if (m_impl) {
444 ✗ return m_impl->gasolineHeating();
445 } else {
446 ✗ return {};
447 }
448 }
449
450 ✗ boost::optional<double> SqlFile::gasolineCooling() const {
451 ✗ if (m_impl) {
452 ✗ return m_impl->gasolineCooling();
453 } else {
454 ✗ return {};
455 }
456 }
457
458 ✗ boost::optional<double> SqlFile::gasolineInteriorLighting() const {
459 ✗ if (m_impl) {
460 ✗ return m_impl->gasolineInteriorLighting();
461 } else {
462 ✗ return {};
463 }
464 }
465
466 ✗ boost::optional<double> SqlFile::gasolineExteriorLighting() const {
467 ✗ if (m_impl) {
468 ✗ return m_impl->gasolineExteriorLighting();
469 } else {
470 ✗ return {};
471 }
472 }
473
474 ✗ boost::optional<double> SqlFile::gasolineInteriorEquipment() const {
475 ✗ if (m_impl) {
476 ✗ return m_impl->gasolineInteriorEquipment();
477 } else {
478 ✗ return {};
479 }
480 }
481
482 1 boost::optional<double> SqlFile::gasolineExteriorEquipment() const {
483
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
484 1 return m_impl->gasolineExteriorEquipment();
485 } else {
486 ✗ return {};
487 }
488 }
489
490 ✗ boost::optional<double> SqlFile::gasolineFans() const {
491 ✗ if (m_impl) {
492 ✗ return m_impl->gasolineFans();
493 } else {
494 ✗ return {};
495 }
496 }
497
498 ✗ boost::optional<double> SqlFile::gasolinePumps() const {
499 ✗ if (m_impl) {
500 ✗ return m_impl->gasolinePumps();
501 } else {
502 ✗ return {};
503 }
504 }
505
506 ✗ boost::optional<double> SqlFile::gasolineHeatRejection() const {
507 ✗ if (m_impl) {
508 ✗ return m_impl->gasolineHeatRejection();
509 } else {
510 ✗ return {};
511 }
512 }
513
514 ✗ boost::optional<double> SqlFile::gasolineHumidification() const {
515 ✗ if (m_impl) {
516 ✗ return m_impl->gasolineHumidification();
517 } else {
518 ✗ return {};
519 }
520 }
521
522 ✗ boost::optional<double> SqlFile::gasolineHeatRecovery() const {
523 ✗ if (m_impl) {
524 ✗ return m_impl->gasolineHeatRecovery();
525 } else {
526 ✗ return {};
527 }
528 }
529
530 ✗ boost::optional<double> SqlFile::gasolineWaterSystems() const {
531 ✗ if (m_impl) {
532 ✗ return m_impl->gasolineWaterSystems();
533 } else {
534 ✗ return {};
535 }
536 }
537
538 ✗ boost::optional<double> SqlFile::gasolineRefrigeration() const {
539 ✗ if (m_impl) {
540 ✗ return m_impl->gasolineRefrigeration();
541 } else {
542 ✗ return {};
543 }
544 }
545
546 ✗ boost::optional<double> SqlFile::gasolineGenerators() const {
547 ✗ if (m_impl) {
548 ✗ return m_impl->gasolineGenerators();
549 } else {
550 ✗ return {};
551 }
552 }
553
554 1 boost::optional<double> SqlFile::gasolineTotalEndUses() const {
555
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
556 1 return m_impl->gasolineTotalEndUses();
557 } else {
558 ✗ return boost::optional<double>();
559 }
560 }
561
562 // Diesel
563 ✗ boost::optional<double> SqlFile::dieselHeating() const {
564 ✗ if (m_impl) {
565 ✗ return m_impl->dieselHeating();
566 } else {
567 ✗ return boost::optional<double>();
568 }
569 }
570
571 ✗ boost::optional<double> SqlFile::dieselCooling() const {
572 ✗ if (m_impl) {
573 ✗ return m_impl->dieselCooling();
574 } else {
575 ✗ return boost::optional<double>();
576 }
577 }
578
579 ✗ boost::optional<double> SqlFile::dieselInteriorLighting() const {
580 ✗ if (m_impl) {
581 ✗ return m_impl->dieselInteriorLighting();
582 } else {
583 ✗ return boost::optional<double>();
584 }
585 }
586
587 ✗ boost::optional<double> SqlFile::dieselExteriorLighting() const {
588 ✗ if (m_impl) {
589 ✗ return m_impl->dieselExteriorLighting();
590 } else {
591 ✗ return boost::optional<double>();
592 }
593 }
594
595 ✗ boost::optional<double> SqlFile::dieselInteriorEquipment() const {
596 ✗ if (m_impl) {
597 ✗ return m_impl->dieselInteriorEquipment();
598 } else {
599 ✗ return boost::optional<double>();
600 }
601 }
602
603 1 boost::optional<double> SqlFile::dieselExteriorEquipment() const {
604
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
605 1 return m_impl->dieselExteriorEquipment();
606 } else {
607 ✗ return boost::optional<double>();
608 }
609 }
610
611 ✗ boost::optional<double> SqlFile::dieselFans() const {
612 ✗ if (m_impl) {
613 ✗ return m_impl->dieselFans();
614 } else {
615 ✗ return boost::optional<double>();
616 }
617 }
618
619 ✗ boost::optional<double> SqlFile::dieselPumps() const {
620 ✗ if (m_impl) {
621 ✗ return m_impl->dieselPumps();
622 } else {
623 ✗ return boost::optional<double>();
624 }
625 }
626
627 ✗ boost::optional<double> SqlFile::dieselHeatRejection() const {
628 ✗ if (m_impl) {
629 ✗ return m_impl->dieselHeatRejection();
630 } else {
631 ✗ return boost::optional<double>();
632 }
633 }
634
635 ✗ boost::optional<double> SqlFile::dieselHumidification() const {
636 ✗ if (m_impl) {
637 ✗ return m_impl->dieselHumidification();
638 } else {
639 ✗ return boost::optional<double>();
640 }
641 }
642
643 ✗ boost::optional<double> SqlFile::dieselHeatRecovery() const {
644 ✗ if (m_impl) {
645 ✗ return m_impl->dieselHeatRecovery();
646 } else {
647 ✗ return boost::optional<double>();
648 }
649 }
650
651 ✗ boost::optional<double> SqlFile::dieselWaterSystems() const {
652 ✗ if (m_impl) {
653 ✗ return m_impl->dieselWaterSystems();
654 } else {
655 ✗ return boost::optional<double>();
656 }
657 }
658
659 ✗ boost::optional<double> SqlFile::dieselRefrigeration() const {
660 ✗ if (m_impl) {
661 ✗ return m_impl->dieselRefrigeration();
662 } else {
663 ✗ return boost::optional<double>();
664 }
665 }
666
667 ✗ boost::optional<double> SqlFile::dieselGenerators() const {
668 ✗ if (m_impl) {
669 ✗ return m_impl->dieselGenerators();
670 } else {
671 ✗ return boost::optional<double>();
672 }
673 }
674
675 1 boost::optional<double> SqlFile::dieselTotalEndUses() const {
676
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
677 1 return m_impl->dieselTotalEndUses();
678 } else {
679 ✗ return boost::optional<double>();
680 }
681 }
682
683 // Coal
684 ✗ boost::optional<double> SqlFile::coalHeating() const {
685 ✗ if (m_impl) {
686 ✗ return m_impl->coalHeating();
687 } else {
688 ✗ return boost::optional<double>();
689 }
690 }
691
692 ✗ boost::optional<double> SqlFile::coalCooling() const {
693 ✗ if (m_impl) {
694 ✗ return m_impl->coalCooling();
695 } else {
696 ✗ return boost::optional<double>();
697 }
698 }
699
700 ✗ boost::optional<double> SqlFile::coalInteriorLighting() const {
701 ✗ if (m_impl) {
702 ✗ return m_impl->coalInteriorLighting();
703 } else {
704 ✗ return boost::optional<double>();
705 }
706 }
707
708 ✗ boost::optional<double> SqlFile::coalExteriorLighting() const {
709 ✗ if (m_impl) {
710 ✗ return m_impl->coalExteriorLighting();
711 } else {
712 ✗ return boost::optional<double>();
713 }
714 }
715
716 ✗ boost::optional<double> SqlFile::coalInteriorEquipment() const {
717 ✗ if (m_impl) {
718 ✗ return m_impl->coalInteriorEquipment();
719 } else {
720 ✗ return boost::optional<double>();
721 }
722 }
723
724 1 boost::optional<double> SqlFile::coalExteriorEquipment() const {
725
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
726 1 return m_impl->coalExteriorEquipment();
727 } else {
728 ✗ return boost::optional<double>();
729 }
730 }
731
732 ✗ boost::optional<double> SqlFile::coalFans() const {
733 ✗ if (m_impl) {
734 ✗ return m_impl->coalFans();
735 } else {
736 ✗ return boost::optional<double>();
737 }
738 }
739
740 ✗ boost::optional<double> SqlFile::coalPumps() const {
741 ✗ if (m_impl) {
742 ✗ return m_impl->coalPumps();
743 } else {
744 ✗ return boost::optional<double>();
745 }
746 }
747
748 ✗ boost::optional<double> SqlFile::coalHeatRejection() const {
749 ✗ if (m_impl) {
750 ✗ return m_impl->coalHeatRejection();
751 } else {
752 ✗ return boost::optional<double>();
753 }
754 }
755
756 ✗ boost::optional<double> SqlFile::coalHumidification() const {
757 ✗ if (m_impl) {
758 ✗ return m_impl->coalHumidification();
759 } else {
760 ✗ return boost::optional<double>();
761 }
762 }
763
764 ✗ boost::optional<double> SqlFile::coalHeatRecovery() const {
765 ✗ if (m_impl) {
766 ✗ return m_impl->coalHeatRecovery();
767 } else {
768 ✗ return boost::optional<double>();
769 }
770 }
771
772 ✗ boost::optional<double> SqlFile::coalWaterSystems() const {
773 ✗ if (m_impl) {
774 ✗ return m_impl->coalWaterSystems();
775 } else {
776 ✗ return boost::optional<double>();
777 }
778 }
779
780 ✗ boost::optional<double> SqlFile::coalRefrigeration() const {
781 ✗ if (m_impl) {
782 ✗ return m_impl->coalRefrigeration();
783 } else {
784 ✗ return boost::optional<double>();
785 }
786 }
787
788 ✗ boost::optional<double> SqlFile::coalGenerators() const {
789 ✗ if (m_impl) {
790 ✗ return m_impl->coalGenerators();
791 } else {
792 ✗ return boost::optional<double>();
793 }
794 }
795
796 1 boost::optional<double> SqlFile::coalTotalEndUses() const {
797
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
798 1 return m_impl->coalTotalEndUses();
799 } else {
800 ✗ return boost::optional<double>();
801 }
802 }
803
804 // Fuel Oil No 1
805 ✗ boost::optional<double> SqlFile::fuelOilNo1Heating() const {
806 ✗ if (m_impl) {
807 ✗ return m_impl->fuelOilNo1Heating();
808 } else {
809 ✗ return boost::optional<double>();
810 }
811 }
812
813 ✗ boost::optional<double> SqlFile::fuelOilNo1Cooling() const {
814 ✗ if (m_impl) {
815 ✗ return m_impl->fuelOilNo1Cooling();
816 } else {
817 ✗ return boost::optional<double>();
818 }
819 }
820
821 ✗ boost::optional<double> SqlFile::fuelOilNo1InteriorLighting() const {
822 ✗ if (m_impl) {
823 ✗ return m_impl->fuelOilNo1InteriorLighting();
824 } else {
825 ✗ return boost::optional<double>();
826 }
827 }
828
829 ✗ boost::optional<double> SqlFile::fuelOilNo1ExteriorLighting() const {
830 ✗ if (m_impl) {
831 ✗ return m_impl->fuelOilNo1ExteriorLighting();
832 } else {
833 ✗ return boost::optional<double>();
834 }
835 }
836
837 ✗ boost::optional<double> SqlFile::fuelOilNo1InteriorEquipment() const {
838 ✗ if (m_impl) {
839 ✗ return m_impl->fuelOilNo1InteriorEquipment();
840 } else {
841 ✗ return boost::optional<double>();
842 }
843 }
844
845 1 boost::optional<double> SqlFile::fuelOilNo1ExteriorEquipment() const {
846
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
847 1 return m_impl->fuelOilNo1ExteriorEquipment();
848 } else {
849 ✗ return boost::optional<double>();
850 }
851 }
852
853 ✗ boost::optional<double> SqlFile::fuelOilNo1Fans() const {
854 ✗ if (m_impl) {
855 ✗ return m_impl->fuelOilNo1Fans();
856 } else {
857 ✗ return boost::optional<double>();
858 }
859 }
860
861 ✗ boost::optional<double> SqlFile::fuelOilNo1Pumps() const {
862 ✗ if (m_impl) {
863 ✗ return m_impl->fuelOilNo1Pumps();
864 } else {
865 ✗ return boost::optional<double>();
866 }
867 }
868
869 ✗ boost::optional<double> SqlFile::fuelOilNo1HeatRejection() const {
870 ✗ if (m_impl) {
871 ✗ return m_impl->fuelOilNo1HeatRejection();
872 } else {
873 ✗ return boost::optional<double>();
874 }
875 }
876
877 ✗ boost::optional<double> SqlFile::fuelOilNo1Humidification() const {
878 ✗ if (m_impl) {
879 ✗ return m_impl->fuelOilNo1Humidification();
880 } else {
881 ✗ return boost::optional<double>();
882 }
883 }
884
885 ✗ boost::optional<double> SqlFile::fuelOilNo1HeatRecovery() const {
886 ✗ if (m_impl) {
887 ✗ return m_impl->fuelOilNo1HeatRecovery();
888 } else {
889 ✗ return boost::optional<double>();
890 }
891 }
892
893 ✗ boost::optional<double> SqlFile::fuelOilNo1WaterSystems() const {
894 ✗ if (m_impl) {
895 ✗ return m_impl->fuelOilNo1WaterSystems();
896 } else {
897 ✗ return boost::optional<double>();
898 }
899 }
900
901 ✗ boost::optional<double> SqlFile::fuelOilNo1Refrigeration() const {
902 ✗ if (m_impl) {
903 ✗ return m_impl->fuelOilNo1Refrigeration();
904 } else {
905 ✗ return boost::optional<double>();
906 }
907 }
908
909 ✗ boost::optional<double> SqlFile::fuelOilNo1Generators() const {
910 ✗ if (m_impl) {
911 ✗ return m_impl->fuelOilNo1Generators();
912 } else {
913 ✗ return boost::optional<double>();
914 }
915 }
916
917 1 boost::optional<double> SqlFile::fuelOilNo1TotalEndUses() const {
918
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
919 1 return m_impl->fuelOilNo1TotalEndUses();
920 } else {
921 ✗ return boost::optional<double>();
922 }
923 }
924
925 // Fuel Oil No 2
926 ✗ boost::optional<double> SqlFile::fuelOilNo2Heating() const {
927 ✗ if (m_impl) {
928 ✗ return m_impl->fuelOilNo2Heating();
929 } else {
930 ✗ return boost::optional<double>();
931 }
932 }
933
934 ✗ boost::optional<double> SqlFile::fuelOilNo2Cooling() const {
935 ✗ if (m_impl) {
936 ✗ return m_impl->fuelOilNo2Cooling();
937 } else {
938 ✗ return boost::optional<double>();
939 }
940 }
941
942 ✗ boost::optional<double> SqlFile::fuelOilNo2InteriorLighting() const {
943 ✗ if (m_impl) {
944 ✗ return m_impl->fuelOilNo2InteriorLighting();
945 } else {
946 ✗ return boost::optional<double>();
947 }
948 }
949
950 ✗ boost::optional<double> SqlFile::fuelOilNo2ExteriorLighting() const {
951 ✗ if (m_impl) {
952 ✗ return m_impl->fuelOilNo2ExteriorLighting();
953 } else {
954 ✗ return boost::optional<double>();
955 }
956 }
957
958 ✗ boost::optional<double> SqlFile::fuelOilNo2InteriorEquipment() const {
959 ✗ if (m_impl) {
960 ✗ return m_impl->fuelOilNo2InteriorEquipment();
961 } else {
962 ✗ return boost::optional<double>();
963 }
964 }
965
966 1 boost::optional<double> SqlFile::fuelOilNo2ExteriorEquipment() const {
967
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
968 1 return m_impl->fuelOilNo2ExteriorEquipment();
969 } else {
970 ✗ return boost::optional<double>();
971 }
972 }
973
974 ✗ boost::optional<double> SqlFile::fuelOilNo2Fans() const {
975 ✗ if (m_impl) {
976 ✗ return m_impl->fuelOilNo2Fans();
977 } else {
978 ✗ return boost::optional<double>();
979 }
980 }
981
982 ✗ boost::optional<double> SqlFile::fuelOilNo2Pumps() const {
983 ✗ if (m_impl) {
984 ✗ return m_impl->fuelOilNo2Pumps();
985 } else {
986 ✗ return boost::optional<double>();
987 }
988 }
989
990 ✗ boost::optional<double> SqlFile::fuelOilNo2HeatRejection() const {
991 ✗ if (m_impl) {
992 ✗ return m_impl->fuelOilNo2HeatRejection();
993 } else {
994 ✗ return boost::optional<double>();
995 }
996 }
997
998 ✗ boost::optional<double> SqlFile::fuelOilNo2Humidification() const {
999 ✗ if (m_impl) {
1000 ✗ return m_impl->fuelOilNo2Humidification();
1001 } else {
1002 ✗ return boost::optional<double>();
1003 }
1004 }
1005
1006 ✗ boost::optional<double> SqlFile::fuelOilNo2HeatRecovery() const {
1007 ✗ if (m_impl) {
1008 ✗ return m_impl->fuelOilNo2HeatRecovery();
1009 } else {
1010 ✗ return boost::optional<double>();
1011 }
1012 }
1013
1014 ✗ boost::optional<double> SqlFile::fuelOilNo2WaterSystems() const {
1015 ✗ if (m_impl) {
1016 ✗ return m_impl->fuelOilNo2WaterSystems();
1017 } else {
1018 ✗ return boost::optional<double>();
1019 }
1020 }
1021
1022 ✗ boost::optional<double> SqlFile::fuelOilNo2Refrigeration() const {
1023 ✗ if (m_impl) {
1024 ✗ return m_impl->fuelOilNo2Refrigeration();
1025 } else {
1026 ✗ return boost::optional<double>();
1027 }
1028 }
1029
1030 ✗ boost::optional<double> SqlFile::fuelOilNo2Generators() const {
1031 ✗ if (m_impl) {
1032 ✗ return m_impl->fuelOilNo2Generators();
1033 } else {
1034 ✗ return boost::optional<double>();
1035 }
1036 }
1037
1038 1 boost::optional<double> SqlFile::fuelOilNo2TotalEndUses() const {
1039
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1040 1 return m_impl->fuelOilNo2TotalEndUses();
1041 } else {
1042 ✗ return boost::optional<double>();
1043 }
1044 }
1045
1046 // Propane
1047 ✗ boost::optional<double> SqlFile::propaneHeating() const {
1048 ✗ if (m_impl) {
1049 ✗ return m_impl->propaneHeating();
1050 } else {
1051 ✗ return boost::optional<double>();
1052 }
1053 }
1054
1055 ✗ boost::optional<double> SqlFile::propaneCooling() const {
1056 ✗ if (m_impl) {
1057 ✗ return m_impl->propaneCooling();
1058 } else {
1059 ✗ return boost::optional<double>();
1060 }
1061 }
1062
1063 ✗ boost::optional<double> SqlFile::propaneInteriorLighting() const {
1064 ✗ if (m_impl) {
1065 ✗ return m_impl->propaneInteriorLighting();
1066 } else {
1067 ✗ return boost::optional<double>();
1068 }
1069 }
1070
1071 ✗ boost::optional<double> SqlFile::propaneExteriorLighting() const {
1072 ✗ if (m_impl) {
1073 ✗ return m_impl->propaneExteriorLighting();
1074 } else {
1075 ✗ return boost::optional<double>();
1076 }
1077 }
1078
1079 ✗ boost::optional<double> SqlFile::propaneInteriorEquipment() const {
1080 ✗ if (m_impl) {
1081 ✗ return m_impl->propaneInteriorEquipment();
1082 } else {
1083 ✗ return boost::optional<double>();
1084 }
1085 }
1086
1087 1 boost::optional<double> SqlFile::propaneExteriorEquipment() const {
1088
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1089 1 return m_impl->propaneExteriorEquipment();
1090 } else {
1091 ✗ return boost::optional<double>();
1092 }
1093 }
1094
1095 ✗ boost::optional<double> SqlFile::propaneFans() const {
1096 ✗ if (m_impl) {
1097 ✗ return m_impl->propaneFans();
1098 } else {
1099 ✗ return boost::optional<double>();
1100 }
1101 }
1102
1103 ✗ boost::optional<double> SqlFile::propanePumps() const {
1104 ✗ if (m_impl) {
1105 ✗ return m_impl->propanePumps();
1106 } else {
1107 ✗ return boost::optional<double>();
1108 }
1109 }
1110
1111 ✗ boost::optional<double> SqlFile::propaneHeatRejection() const {
1112 ✗ if (m_impl) {
1113 ✗ return m_impl->propaneHeatRejection();
1114 } else {
1115 ✗ return boost::optional<double>();
1116 }
1117 }
1118
1119 ✗ boost::optional<double> SqlFile::propaneHumidification() const {
1120 ✗ if (m_impl) {
1121 ✗ return m_impl->propaneHumidification();
1122 } else {
1123 ✗ return boost::optional<double>();
1124 }
1125 }
1126
1127 ✗ boost::optional<double> SqlFile::propaneHeatRecovery() const {
1128 ✗ if (m_impl) {
1129 ✗ return m_impl->propaneHeatRecovery();
1130 } else {
1131 ✗ return boost::optional<double>();
1132 }
1133 }
1134
1135 ✗ boost::optional<double> SqlFile::propaneWaterSystems() const {
1136 ✗ if (m_impl) {
1137 ✗ return m_impl->propaneWaterSystems();
1138 } else {
1139 ✗ return boost::optional<double>();
1140 }
1141 }
1142
1143 ✗ boost::optional<double> SqlFile::propaneRefrigeration() const {
1144 ✗ if (m_impl) {
1145 ✗ return m_impl->propaneRefrigeration();
1146 } else {
1147 ✗ return boost::optional<double>();
1148 }
1149 }
1150
1151 ✗ boost::optional<double> SqlFile::propaneGenerators() const {
1152 ✗ if (m_impl) {
1153 ✗ return m_impl->propaneGenerators();
1154 } else {
1155 ✗ return boost::optional<double>();
1156 }
1157 }
1158
1159 1 boost::optional<double> SqlFile::propaneTotalEndUses() const {
1160
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1161 1 return m_impl->propaneTotalEndUses();
1162 } else {
1163 ✗ return boost::optional<double>();
1164 }
1165 }
1166
1167 // Other Fuel 1
1168 ✗ boost::optional<double> SqlFile::otherFuel1Heating() const {
1169 ✗ if (m_impl) {
1170 ✗ return m_impl->otherFuel1Heating();
1171 } else {
1172 ✗ return boost::optional<double>();
1173 }
1174 }
1175
1176 ✗ boost::optional<double> SqlFile::otherFuel1Cooling() const {
1177 ✗ if (m_impl) {
1178 ✗ return m_impl->otherFuel1Cooling();
1179 } else {
1180 ✗ return boost::optional<double>();
1181 }
1182 }
1183
1184 ✗ boost::optional<double> SqlFile::otherFuel1InteriorLighting() const {
1185 ✗ if (m_impl) {
1186 ✗ return m_impl->otherFuel1InteriorLighting();
1187 } else {
1188 ✗ return boost::optional<double>();
1189 }
1190 }
1191
1192 ✗ boost::optional<double> SqlFile::otherFuel1ExteriorLighting() const {
1193 ✗ if (m_impl) {
1194 ✗ return m_impl->otherFuel1ExteriorLighting();
1195 } else {
1196 ✗ return boost::optional<double>();
1197 }
1198 }
1199
1200 ✗ boost::optional<double> SqlFile::otherFuel1InteriorEquipment() const {
1201 ✗ if (m_impl) {
1202 ✗ return m_impl->otherFuel1InteriorEquipment();
1203 } else {
1204 ✗ return boost::optional<double>();
1205 }
1206 }
1207
1208 1 boost::optional<double> SqlFile::otherFuel1ExteriorEquipment() const {
1209
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1210 1 return m_impl->otherFuel1ExteriorEquipment();
1211 } else {
1212 ✗ return boost::optional<double>();
1213 }
1214 }
1215
1216 ✗ boost::optional<double> SqlFile::otherFuel1Fans() const {
1217 ✗ if (m_impl) {
1218 ✗ return m_impl->otherFuel1Fans();
1219 } else {
1220 ✗ return boost::optional<double>();
1221 }
1222 }
1223
1224 ✗ boost::optional<double> SqlFile::otherFuel1Pumps() const {
1225 ✗ if (m_impl) {
1226 ✗ return m_impl->otherFuel1Pumps();
1227 } else {
1228 ✗ return boost::optional<double>();
1229 }
1230 }
1231
1232 ✗ boost::optional<double> SqlFile::otherFuel1HeatRejection() const {
1233 ✗ if (m_impl) {
1234 ✗ return m_impl->otherFuel1HeatRejection();
1235 } else {
1236 ✗ return boost::optional<double>();
1237 }
1238 }
1239
1240 ✗ boost::optional<double> SqlFile::otherFuel1Humidification() const {
1241 ✗ if (m_impl) {
1242 ✗ return m_impl->otherFuel1Humidification();
1243 } else {
1244 ✗ return boost::optional<double>();
1245 }
1246 }
1247
1248 ✗ boost::optional<double> SqlFile::otherFuel1HeatRecovery() const {
1249 ✗ if (m_impl) {
1250 ✗ return m_impl->otherFuel1HeatRecovery();
1251 } else {
1252 ✗ return boost::optional<double>();
1253 }
1254 }
1255
1256 ✗ boost::optional<double> SqlFile::otherFuel1WaterSystems() const {
1257 ✗ if (m_impl) {
1258 ✗ return m_impl->otherFuel1WaterSystems();
1259 } else {
1260 ✗ return boost::optional<double>();
1261 }
1262 }
1263
1264 ✗ boost::optional<double> SqlFile::otherFuel1Refrigeration() const {
1265 ✗ if (m_impl) {
1266 ✗ return m_impl->otherFuel1Refrigeration();
1267 } else {
1268 ✗ return boost::optional<double>();
1269 }
1270 }
1271
1272 ✗ boost::optional<double> SqlFile::otherFuel1Generators() const {
1273 ✗ if (m_impl) {
1274 ✗ return m_impl->otherFuel1Generators();
1275 } else {
1276 ✗ return boost::optional<double>();
1277 }
1278 }
1279
1280 1 boost::optional<double> SqlFile::otherFuel1TotalEndUses() const {
1281
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1282 1 return m_impl->otherFuel1TotalEndUses();
1283 } else {
1284 ✗ return boost::optional<double>();
1285 }
1286 }
1287
1288 // Other Fuel 2
1289 ✗ boost::optional<double> SqlFile::otherFuel2Heating() const {
1290 ✗ if (m_impl) {
1291 ✗ return m_impl->otherFuel2Heating();
1292 } else {
1293 ✗ return boost::optional<double>();
1294 }
1295 }
1296
1297 ✗ boost::optional<double> SqlFile::otherFuel2Cooling() const {
1298 ✗ if (m_impl) {
1299 ✗ return m_impl->otherFuel2Cooling();
1300 } else {
1301 ✗ return boost::optional<double>();
1302 }
1303 }
1304
1305 ✗ boost::optional<double> SqlFile::otherFuel2InteriorLighting() const {
1306 ✗ if (m_impl) {
1307 ✗ return m_impl->otherFuel2InteriorLighting();
1308 } else {
1309 ✗ return boost::optional<double>();
1310 }
1311 }
1312
1313 ✗ boost::optional<double> SqlFile::otherFuel2ExteriorLighting() const {
1314 ✗ if (m_impl) {
1315 ✗ return m_impl->otherFuel2ExteriorLighting();
1316 } else {
1317 ✗ return boost::optional<double>();
1318 }
1319 }
1320
1321 ✗ boost::optional<double> SqlFile::otherFuel2InteriorEquipment() const {
1322 ✗ if (m_impl) {
1323 ✗ return m_impl->otherFuel2InteriorEquipment();
1324 } else {
1325 ✗ return boost::optional<double>();
1326 }
1327 }
1328
1329 1 boost::optional<double> SqlFile::otherFuel2ExteriorEquipment() const {
1330
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1331 1 return m_impl->otherFuel2ExteriorEquipment();
1332 } else {
1333 ✗ return boost::optional<double>();
1334 }
1335 }
1336
1337 ✗ boost::optional<double> SqlFile::otherFuel2Fans() const {
1338 ✗ if (m_impl) {
1339 ✗ return m_impl->otherFuel2Fans();
1340 } else {
1341 ✗ return boost::optional<double>();
1342 }
1343 }
1344
1345 ✗ boost::optional<double> SqlFile::otherFuel2Pumps() const {
1346 ✗ if (m_impl) {
1347 ✗ return m_impl->otherFuel2Pumps();
1348 } else {
1349 ✗ return boost::optional<double>();
1350 }
1351 }
1352
1353 ✗ boost::optional<double> SqlFile::otherFuel2HeatRejection() const {
1354 ✗ if (m_impl) {
1355 ✗ return m_impl->otherFuel2HeatRejection();
1356 } else {
1357 ✗ return boost::optional<double>();
1358 }
1359 }
1360
1361 ✗ boost::optional<double> SqlFile::otherFuel2Humidification() const {
1362 ✗ if (m_impl) {
1363 ✗ return m_impl->otherFuel2Humidification();
1364 } else {
1365 ✗ return boost::optional<double>();
1366 }
1367 }
1368
1369 ✗ boost::optional<double> SqlFile::otherFuel2HeatRecovery() const {
1370 ✗ if (m_impl) {
1371 ✗ return m_impl->otherFuel2HeatRecovery();
1372 } else {
1373 ✗ return boost::optional<double>();
1374 }
1375 }
1376
1377 ✗ boost::optional<double> SqlFile::otherFuel2WaterSystems() const {
1378 ✗ if (m_impl) {
1379 ✗ return m_impl->otherFuel2WaterSystems();
1380 } else {
1381 ✗ return boost::optional<double>();
1382 }
1383 }
1384
1385 ✗ boost::optional<double> SqlFile::otherFuel2Refrigeration() const {
1386 ✗ if (m_impl) {
1387 ✗ return m_impl->otherFuel2Refrigeration();
1388 } else {
1389 ✗ return boost::optional<double>();
1390 }
1391 }
1392
1393 ✗ boost::optional<double> SqlFile::otherFuel2Generators() const {
1394 ✗ if (m_impl) {
1395 ✗ return m_impl->otherFuel2Generators();
1396 } else {
1397 ✗ return boost::optional<double>();
1398 }
1399 }
1400
1401 1 boost::optional<double> SqlFile::otherFuel2TotalEndUses() const {
1402
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1403 1 return m_impl->otherFuel2TotalEndUses();
1404 } else {
1405 ✗ return {};
1406 }
1407 }
1408
1409 ✗ boost::optional<double> SqlFile::districtCoolingHeating() const {
1410 ✗ if (m_impl) {
1411 ✗ return m_impl->districtCoolingHeating();
1412 } else {
1413 ✗ return {};
1414 }
1415 }
1416
1417 ✗ boost::optional<double> SqlFile::districtCoolingCooling() const {
1418 ✗ if (m_impl) {
1419 ✗ return m_impl->districtCoolingCooling();
1420 } else {
1421 ✗ return {};
1422 }
1423 }
1424
1425 ✗ boost::optional<double> SqlFile::districtCoolingInteriorLighting() const {
1426 ✗ if (m_impl) {
1427 ✗ return m_impl->districtCoolingInteriorLighting();
1428 } else {
1429 ✗ return {};
1430 }
1431 }
1432
1433 ✗ boost::optional<double> SqlFile::districtCoolingExteriorLighting() const {
1434 ✗ if (m_impl) {
1435 ✗ return m_impl->districtCoolingExteriorLighting();
1436 } else {
1437 ✗ return {};
1438 }
1439 }
1440
1441 ✗ boost::optional<double> SqlFile::districtCoolingInteriorEquipment() const {
1442 ✗ if (m_impl) {
1443 ✗ return m_impl->districtCoolingInteriorEquipment();
1444 } else {
1445 ✗ return {};
1446 }
1447 }
1448
1449 1 boost::optional<double> SqlFile::districtCoolingExteriorEquipment() const {
1450
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1451 1 return m_impl->districtCoolingExteriorEquipment();
1452 } else {
1453 ✗ return {};
1454 }
1455 }
1456
1457 ✗ boost::optional<double> SqlFile::districtCoolingFans() const {
1458 ✗ if (m_impl) {
1459 ✗ return m_impl->districtCoolingFans();
1460 } else {
1461 ✗ return {};
1462 }
1463 }
1464
1465 ✗ boost::optional<double> SqlFile::districtCoolingPumps() const {
1466 ✗ if (m_impl) {
1467 ✗ return m_impl->districtCoolingPumps();
1468 } else {
1469 ✗ return {};
1470 }
1471 }
1472
1473 ✗ boost::optional<double> SqlFile::districtCoolingHeatRejection() const {
1474 ✗ if (m_impl) {
1475 ✗ return m_impl->districtCoolingHeatRejection();
1476 } else {
1477 ✗ return {};
1478 }
1479 }
1480
1481 ✗ boost::optional<double> SqlFile::districtCoolingHumidification() const {
1482 ✗ if (m_impl) {
1483 ✗ return m_impl->districtCoolingHumidification();
1484 } else {
1485 ✗ return {};
1486 }
1487 }
1488
1489 ✗ boost::optional<double> SqlFile::districtCoolingHeatRecovery() const {
1490 ✗ if (m_impl) {
1491 ✗ return m_impl->districtCoolingHeatRecovery();
1492 } else {
1493 ✗ return {};
1494 }
1495 }
1496
1497 ✗ boost::optional<double> SqlFile::districtCoolingWaterSystems() const {
1498 ✗ if (m_impl) {
1499 ✗ return m_impl->districtCoolingWaterSystems();
1500 } else {
1501 ✗ return {};
1502 }
1503 }
1504
1505 ✗ boost::optional<double> SqlFile::districtCoolingRefrigeration() const {
1506 ✗ if (m_impl) {
1507 ✗ return m_impl->districtCoolingRefrigeration();
1508 } else {
1509 ✗ return {};
1510 }
1511 }
1512
1513 ✗ boost::optional<double> SqlFile::districtCoolingGenerators() const {
1514 ✗ if (m_impl) {
1515 ✗ return m_impl->districtCoolingGenerators();
1516 } else {
1517 ✗ return {};
1518 }
1519 }
1520
1521 1 boost::optional<double> SqlFile::districtCoolingTotalEndUses() const {
1522
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1523 1 return m_impl->districtCoolingTotalEndUses();
1524 } else {
1525 ✗ return {};
1526 }
1527 }
1528
1529 ✗ boost::optional<double> SqlFile::districtHeatingWaterHeating() const {
1530 ✗ if (m_impl) {
1531 ✗ return m_impl->districtHeatingWaterHeating();
1532 } else {
1533 ✗ return {};
1534 }
1535 }
1536
1537 ✗ boost::optional<double> SqlFile::districtHeatingWaterCooling() const {
1538 ✗ if (m_impl) {
1539 ✗ return m_impl->districtHeatingWaterCooling();
1540 } else {
1541 ✗ return {};
1542 }
1543 }
1544
1545 ✗ boost::optional<double> SqlFile::districtHeatingWaterInteriorLighting() const {
1546 ✗ if (m_impl) {
1547 ✗ return m_impl->districtHeatingWaterInteriorLighting();
1548 } else {
1549 ✗ return {};
1550 }
1551 }
1552
1553 ✗ boost::optional<double> SqlFile::districtHeatingWaterExteriorLighting() const {
1554 ✗ if (m_impl) {
1555 ✗ return m_impl->districtHeatingWaterExteriorLighting();
1556 } else {
1557 ✗ return {};
1558 }
1559 }
1560
1561 ✗ boost::optional<double> SqlFile::districtHeatingWaterInteriorEquipment() const {
1562 ✗ if (m_impl) {
1563 ✗ return m_impl->districtHeatingWaterInteriorEquipment();
1564 } else {
1565 ✗ return {};
1566 }
1567 }
1568
1569 1 boost::optional<double> SqlFile::districtHeatingWaterExteriorEquipment() const {
1570
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1571 1 return m_impl->districtHeatingWaterExteriorEquipment();
1572 } else {
1573 ✗ return {};
1574 }
1575 }
1576
1577 ✗ boost::optional<double> SqlFile::districtHeatingWaterFans() const {
1578 ✗ if (m_impl) {
1579 ✗ return m_impl->districtHeatingWaterFans();
1580 } else {
1581 ✗ return {};
1582 }
1583 }
1584
1585 ✗ boost::optional<double> SqlFile::districtHeatingWaterPumps() const {
1586 ✗ if (m_impl) {
1587 ✗ return m_impl->districtHeatingWaterPumps();
1588 } else {
1589 ✗ return {};
1590 }
1591 }
1592
1593 ✗ boost::optional<double> SqlFile::districtHeatingWaterHeatRejection() const {
1594 ✗ if (m_impl) {
1595 ✗ return m_impl->districtHeatingWaterHeatRejection();
1596 } else {
1597 ✗ return {};
1598 }
1599 }
1600
1601 ✗ boost::optional<double> SqlFile::districtHeatingWaterHumidification() const {
1602 ✗ if (m_impl) {
1603 ✗ return m_impl->districtHeatingWaterHumidification();
1604 } else {
1605 ✗ return {};
1606 }
1607 }
1608
1609 ✗ boost::optional<double> SqlFile::districtHeatingWaterHeatRecovery() const {
1610 ✗ if (m_impl) {
1611 ✗ return m_impl->districtHeatingWaterHeatRecovery();
1612 } else {
1613 ✗ return {};
1614 }
1615 }
1616
1617 ✗ boost::optional<double> SqlFile::districtHeatingWaterWaterSystems() const {
1618 ✗ if (m_impl) {
1619 ✗ return m_impl->districtHeatingWaterWaterSystems();
1620 } else {
1621 ✗ return {};
1622 }
1623 }
1624
1625 ✗ boost::optional<double> SqlFile::districtHeatingWaterRefrigeration() const {
1626 ✗ if (m_impl) {
1627 ✗ return m_impl->districtHeatingWaterRefrigeration();
1628 } else {
1629 ✗ return {};
1630 }
1631 }
1632
1633 ✗ boost::optional<double> SqlFile::districtHeatingWaterGenerators() const {
1634 ✗ if (m_impl) {
1635 ✗ return m_impl->districtHeatingWaterGenerators();
1636 } else {
1637 ✗ return {};
1638 }
1639 }
1640
1641 1 boost::optional<double> SqlFile::districtHeatingWaterTotalEndUses() const {
1642
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1643 1 return m_impl->districtHeatingWaterTotalEndUses();
1644 } else {
1645 ✗ return {};
1646 }
1647 }
1648
1649 ✗ boost::optional<double> SqlFile::districtHeatingSteamHeating() const {
1650 ✗ if (m_impl) {
1651 ✗ return m_impl->districtHeatingSteamHeating();
1652 } else {
1653 ✗ return {};
1654 }
1655 }
1656
1657 ✗ boost::optional<double> SqlFile::districtHeatingSteamCooling() const {
1658 ✗ if (m_impl) {
1659 ✗ return m_impl->districtHeatingSteamCooling();
1660 } else {
1661 ✗ return {};
1662 }
1663 }
1664
1665 ✗ boost::optional<double> SqlFile::districtHeatingSteamInteriorLighting() const {
1666 ✗ if (m_impl) {
1667 ✗ return m_impl->districtHeatingSteamInteriorLighting();
1668 } else {
1669 ✗ return {};
1670 }
1671 }
1672
1673 ✗ boost::optional<double> SqlFile::districtHeatingSteamExteriorLighting() const {
1674 ✗ if (m_impl) {
1675 ✗ return m_impl->districtHeatingSteamExteriorLighting();
1676 } else {
1677 ✗ return {};
1678 }
1679 }
1680
1681 ✗ boost::optional<double> SqlFile::districtHeatingSteamInteriorEquipment() const {
1682 ✗ if (m_impl) {
1683 ✗ return m_impl->districtHeatingSteamInteriorEquipment();
1684 } else {
1685 ✗ return {};
1686 }
1687 }
1688
1689 1 boost::optional<double> SqlFile::districtHeatingSteamExteriorEquipment() const {
1690
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1691 1 return m_impl->districtHeatingSteamExteriorEquipment();
1692 } else {
1693 ✗ return {};
1694 }
1695 }
1696
1697 ✗ boost::optional<double> SqlFile::districtHeatingSteamFans() const {
1698 ✗ if (m_impl) {
1699 ✗ return m_impl->districtHeatingSteamFans();
1700 } else {
1701 ✗ return {};
1702 }
1703 }
1704
1705 ✗ boost::optional<double> SqlFile::districtHeatingSteamPumps() const {
1706 ✗ if (m_impl) {
1707 ✗ return m_impl->districtHeatingSteamPumps();
1708 } else {
1709 ✗ return {};
1710 }
1711 }
1712
1713 ✗ boost::optional<double> SqlFile::districtHeatingSteamHeatRejection() const {
1714 ✗ if (m_impl) {
1715 ✗ return m_impl->districtHeatingSteamHeatRejection();
1716 } else {
1717 ✗ return {};
1718 }
1719 }
1720
1721 ✗ boost::optional<double> SqlFile::districtHeatingSteamHumidification() const {
1722 ✗ if (m_impl) {
1723 ✗ return m_impl->districtHeatingSteamHumidification();
1724 } else {
1725 ✗ return {};
1726 }
1727 }
1728
1729 ✗ boost::optional<double> SqlFile::districtHeatingSteamHeatRecovery() const {
1730 ✗ if (m_impl) {
1731 ✗ return m_impl->districtHeatingSteamHeatRecovery();
1732 } else {
1733 ✗ return {};
1734 }
1735 }
1736
1737 ✗ boost::optional<double> SqlFile::districtHeatingSteamWaterSystems() const {
1738 ✗ if (m_impl) {
1739 ✗ return m_impl->districtHeatingSteamWaterSystems();
1740 } else {
1741 ✗ return {};
1742 }
1743 }
1744
1745 ✗ boost::optional<double> SqlFile::districtHeatingSteamRefrigeration() const {
1746 ✗ if (m_impl) {
1747 ✗ return m_impl->districtHeatingSteamRefrigeration();
1748 } else {
1749 ✗ return {};
1750 }
1751 }
1752
1753 ✗ boost::optional<double> SqlFile::districtHeatingSteamGenerators() const {
1754 ✗ if (m_impl) {
1755 ✗ return m_impl->districtHeatingSteamGenerators();
1756 } else {
1757 ✗ return {};
1758 }
1759 }
1760
1761 1 boost::optional<double> SqlFile::districtHeatingSteamTotalEndUses() const {
1762
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1763 1 return m_impl->districtHeatingSteamTotalEndUses();
1764 } else {
1765 ✗ return {};
1766 }
1767 }
1768
1769 ✗ boost::optional<double> SqlFile::districtHeatingHeating() const {
1770 ✗ if (m_impl) {
1771 ✗ return m_impl->districtHeatingHeating();
1772 } else {
1773 ✗ return {};
1774 }
1775 }
1776
1777 ✗ boost::optional<double> SqlFile::districtHeatingCooling() const {
1778 ✗ if (m_impl) {
1779 ✗ return m_impl->districtHeatingCooling();
1780 } else {
1781 ✗ return {};
1782 }
1783 }
1784
1785 ✗ boost::optional<double> SqlFile::districtHeatingInteriorLighting() const {
1786 ✗ if (m_impl) {
1787 ✗ return m_impl->districtHeatingInteriorLighting();
1788 } else {
1789 ✗ return {};
1790 }
1791 }
1792
1793 ✗ boost::optional<double> SqlFile::districtHeatingExteriorLighting() const {
1794 ✗ if (m_impl) {
1795 ✗ return m_impl->districtHeatingExteriorLighting();
1796 } else {
1797 ✗ return {};
1798 }
1799 }
1800
1801 ✗ boost::optional<double> SqlFile::districtHeatingInteriorEquipment() const {
1802 ✗ if (m_impl) {
1803 ✗ return m_impl->districtHeatingInteriorEquipment();
1804 } else {
1805 ✗ return {};
1806 }
1807 }
1808
1809 1 boost::optional<double> SqlFile::districtHeatingExteriorEquipment() const {
1810
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1811 1 return m_impl->districtHeatingExteriorEquipment();
1812 } else {
1813 ✗ return {};
1814 }
1815 }
1816
1817 ✗ boost::optional<double> SqlFile::districtHeatingFans() const {
1818 ✗ if (m_impl) {
1819 ✗ return m_impl->districtHeatingFans();
1820 } else {
1821 ✗ return {};
1822 }
1823 }
1824
1825 ✗ boost::optional<double> SqlFile::districtHeatingPumps() const {
1826 ✗ if (m_impl) {
1827 ✗ return m_impl->districtHeatingPumps();
1828 } else {
1829 ✗ return {};
1830 }
1831 }
1832
1833 ✗ boost::optional<double> SqlFile::districtHeatingHeatRejection() const {
1834 ✗ if (m_impl) {
1835 ✗ return m_impl->districtHeatingHeatRejection();
1836 } else {
1837 ✗ return {};
1838 }
1839 }
1840
1841 ✗ boost::optional<double> SqlFile::districtHeatingHumidification() const {
1842 ✗ if (m_impl) {
1843 ✗ return m_impl->districtHeatingHumidification();
1844 } else {
1845 ✗ return {};
1846 }
1847 }
1848
1849 ✗ boost::optional<double> SqlFile::districtHeatingHeatRecovery() const {
1850 ✗ if (m_impl) {
1851 ✗ return m_impl->districtHeatingHeatRecovery();
1852 } else {
1853 ✗ return {};
1854 }
1855 }
1856
1857 ✗ boost::optional<double> SqlFile::districtHeatingWaterSystems() const {
1858 ✗ if (m_impl) {
1859 ✗ return m_impl->districtHeatingWaterSystems();
1860 } else {
1861 ✗ return {};
1862 }
1863 }
1864
1865 ✗ boost::optional<double> SqlFile::districtHeatingRefrigeration() const {
1866 ✗ if (m_impl) {
1867 ✗ return m_impl->districtHeatingRefrigeration();
1868 } else {
1869 ✗ return {};
1870 }
1871 }
1872
1873 ✗ boost::optional<double> SqlFile::districtHeatingGenerators() const {
1874 ✗ if (m_impl) {
1875 ✗ return m_impl->districtHeatingGenerators();
1876 } else {
1877 ✗ return {};
1878 }
1879 }
1880
1881 1 boost::optional<double> SqlFile::districtHeatingTotalEndUses() const {
1882
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
1883 1 return m_impl->districtHeatingTotalEndUses();
1884 } else {
1885 ✗ return {};
1886 }
1887 }
1888
1889 ✗ boost::optional<double> SqlFile::waterHeating() const {
1890 ✗ if (m_impl) {
1891 ✗ return m_impl->waterHeating();
1892 } else {
1893 ✗ return {};
1894 }
1895 }
1896
1897 ✗ boost::optional<double> SqlFile::waterCooling() const {
1898 ✗ if (m_impl) {
1899 ✗ return m_impl->waterCooling();
1900 } else {
1901 ✗ return {};
1902 }
1903 }
1904
1905 ✗ boost::optional<double> SqlFile::waterInteriorLighting() const {
1906 ✗ if (m_impl) {
1907 ✗ return m_impl->waterInteriorLighting();
1908 } else {
1909 ✗ return {};
1910 }
1911 }
1912
1913 ✗ boost::optional<double> SqlFile::waterExteriorLighting() const {
1914 ✗ if (m_impl) {
1915 ✗ return m_impl->waterExteriorLighting();
1916 } else {
1917 ✗ return {};
1918 }
1919 }
1920
1921 ✗ boost::optional<double> SqlFile::waterInteriorEquipment() const {
1922 ✗ if (m_impl) {
1923 ✗ return m_impl->waterInteriorEquipment();
1924 } else {
1925 ✗ return {};
1926 }
1927 }
1928
1929 ✗ boost::optional<double> SqlFile::waterExteriorEquipment() const {
1930 ✗ if (m_impl) {
1931 ✗ return m_impl->waterExteriorEquipment();
1932 } else {
1933 ✗ return {};
1934 }
1935 }
1936
1937 ✗ boost::optional<double> SqlFile::waterFans() const {
1938 ✗ if (m_impl) {
1939 ✗ return m_impl->waterFans();
1940 } else {
1941 ✗ return {};
1942 }
1943 }
1944
1945 ✗ boost::optional<double> SqlFile::waterPumps() const {
1946 ✗ if (m_impl) {
1947 ✗ return m_impl->waterPumps();
1948 } else {
1949 ✗ return {};
1950 }
1951 }
1952
1953 ✗ boost::optional<double> SqlFile::waterHeatRejection() const {
1954 ✗ if (m_impl) {
1955 ✗ return m_impl->waterHeatRejection();
1956 } else {
1957 ✗ return {};
1958 }
1959 }
1960
1961 ✗ boost::optional<double> SqlFile::waterHumidification() const {
1962 ✗ if (m_impl) {
1963 ✗ return m_impl->waterHumidification();
1964 } else {
1965 ✗ return {};
1966 }
1967 }
1968
1969 ✗ boost::optional<double> SqlFile::waterHeatRecovery() const {
1970 ✗ if (m_impl) {
1971 ✗ return m_impl->waterHeatRecovery();
1972 } else {
1973 ✗ return {};
1974 }
1975 }
1976
1977 ✗ boost::optional<double> SqlFile::waterWaterSystems() const {
1978 ✗ if (m_impl) {
1979 ✗ return m_impl->waterWaterSystems();
1980 } else {
1981 ✗ return {};
1982 }
1983 }
1984
1985 ✗ boost::optional<double> SqlFile::waterRefrigeration() const {
1986 ✗ if (m_impl) {
1987 ✗ return m_impl->waterRefrigeration();
1988 } else {
1989 ✗ return {};
1990 }
1991 }
1992
1993 ✗ boost::optional<double> SqlFile::waterGenerators() const {
1994 ✗ if (m_impl) {
1995 ✗ return m_impl->waterGenerators();
1996 } else {
1997 ✗ return {};
1998 }
1999 }
2000
2001 ✗ boost::optional<double> SqlFile::waterTotalEndUses() const {
2002 ✗ if (m_impl) {
2003 ✗ return m_impl->waterTotalEndUses();
2004 } else {
2005 ✗ return {};
2006 }
2007 }
2008
2009 ✗ boost::optional<double> SqlFile::hoursHeatingSetpointNotMet() const {
2010 ✗ if (m_impl) {
2011 ✗ return m_impl->hoursHeatingSetpointNotMet();
2012 } else {
2013 ✗ return {};
2014 }
2015 }
2016
2017 ✗ boost::optional<double> SqlFile::hoursCoolingSetpointNotMet() const {
2018 ✗ if (m_impl) {
2019 ✗ return m_impl->hoursCoolingSetpointNotMet();
2020 } else {
2021 ✗ return {};
2022 }
2023 }
2024
2025 ✗ std::vector<std::string> SqlFile::availableTimeSeries() {
2026 ✗ std::vector<std::string> result;
2027 ✗ if (m_impl) {
2028 ✗ result = m_impl->availableTimeSeries();
2029 }
2030 ✗ return result;
2031 ✗ }
2032
2033 ✗ std::vector<std::string> SqlFile::availableVariableNames(const std::string& envPeriod, const std::string& reportingFrequency) const {
2034 ✗ std::vector<std::string> result;
2035 ✗ if (m_impl) {
2036 ✗ result = m_impl->availableVariableNames(envPeriod, reportingFrequency);
2037 }
2038 ✗ return result;
2039 ✗ }
2040
2041 ✗ int SqlFile::insertZone(const std::string& t_name, double t_relNorth, double t_originX, double t_originY, double t_originZ, double t_centroidX,
2042 double t_centroidY, double t_centroidZ, int t_ofType, double t_multiplier, double t_listMultiplier, double t_minimumX,
2043 double t_maximumX, double t_minimumY, double t_maximumY, double t_minimumZ, double t_maximumZ, double t_ceilingHeight,
2044 double t_volume, int t_insideConvectionAlgo, int t_outsideConvectionAlgo, double t_floorArea, double t_extGrossWallArea,
2045 double t_extNetWallArea, double t_extWindowArea, bool t_isPartOfTotalArea) {
2046 ✗ return m_impl->insertZone(t_name, t_relNorth, t_originX, t_originY, t_originZ, t_centroidX, t_centroidY, t_centroidZ, t_ofType, t_multiplier,
2047 t_listMultiplier, t_minimumX, t_maximumX, t_minimumY, t_maximumY, t_minimumZ, t_maximumZ, t_ceilingHeight, t_volume,
2048 t_insideConvectionAlgo, t_outsideConvectionAlgo, t_floorArea, t_extGrossWallArea, t_extNetWallArea, t_extWindowArea,
2049 ✗ t_isPartOfTotalArea);
2050 }
2051
2052 ✗ void SqlFile::insertIlluminanceMap(const std::string& t_zoneName, const std::string& t_name, const std::string& t_environmentName,
2053 const std::vector<DateTime>& t_times, const std::vector<double>& t_xs, const std::vector<double>& t_ys, double t_z,
2054 const std::vector<Matrix>& t_maps) {
2055 ✗ m_impl->insertIlluminanceMap(t_zoneName, t_name, t_environmentName, t_times, t_xs, t_ys, t_z, t_maps);
2056 ✗ }
2057
2058 ✗ void SqlFile::insertTimeSeriesData(const std::string& t_variableType, const std::string& t_indexGroup, const std::string& t_timestepType,
2059 const std::string& t_keyValue, const std::string& t_variableName,
2060 const openstudio::ReportingFrequency& t_reportingFrequency, const boost::optional<std::string>& t_scheduleName,
2061 const std::string& t_variableUnits, const openstudio::TimeSeries& t_timeSeries) {
2062 ✗ m_impl->insertTimeSeriesData(t_variableType, t_indexGroup, t_timestepType, t_keyValue, t_variableName, t_reportingFrequency, t_scheduleName,
2063 t_variableUnits, t_timeSeries);
2064 ✗ }
2065
2066 ✗ std::vector<std::string> SqlFile::availableReportingFrequencies(const std::string& envPeriod) {
2067 ✗ std::vector<std::string> result;
2068 ✗ if (m_impl) {
2069 ✗ result = m_impl->availableReportingFrequencies(envPeriod);
2070 }
2071 ✗ return result;
2072 ✗ }
2073
2074 ✗ boost::optional<openstudio::ReportingFrequency> SqlFile::reportingFrequencyFromDB(const std::string& dbReportingFrequency) {
2075 ✗ boost::optional<openstudio::ReportingFrequency> result;
2076 ✗ if (m_impl) {
2077 ✗ result = m_impl->reportingFrequencyFromDB(dbReportingFrequency);
2078 }
2079 ✗ return result;
2080 ✗ }
2081
2082 2 boost::optional<EnvironmentType> SqlFile::environmentType(const std::string& envPeriod) const {
2083 2 boost::optional<EnvironmentType> result;
2084
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
2 if (m_impl) {
2085
1/1
✓ Branch 2 taken 2 times.
2 result = m_impl->environmentType(envPeriod);
2086 }
2087 2 return result;
2088 ✗ }
2089
2090 3 std::vector<std::string> SqlFile::availableEnvPeriods() const {
2091 3 std::vector<std::string> result;
2092
1/2
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
3 if (m_impl) {
2093
1/1
✓ Branch 2 taken 3 times.
3 result = m_impl->availableEnvPeriods();
2094 }
2095 3 return result;
2096 ✗ }
2097
2098 ✗ std::vector<std::string> SqlFile::availableKeyValues(const std::string& envPeriod, const std::string& reportingFrequency,
2099 const std::string& timeSeriesName) {
2100 ✗ std::vector<std::string> result;
2101 ✗ if (m_impl) {
2102 ✗ result = m_impl->availableKeyValues(envPeriod, reportingFrequency, timeSeriesName);
2103 }
2104 ✗ return result;
2105 ✗ }
2106
2107 ✗ openstudio::TimeSeriesVector SqlFile::timeSeries(const std::string& envPeriod, const std::string& reportingFrequency,
2108 const std::string& timeSeriesName) {
2109
2110 ✗ openstudio::TimeSeriesVector result;
2111 ✗ if (m_impl) {
2112 ✗ result = m_impl->timeSeries(envPeriod, reportingFrequency, timeSeriesName);
2113 }
2114 ✗ return result;
2115 ✗ }
2116
2117 ✗ boost::optional<double> SqlFile::runPeriodValue(const std::string& envPeriod, const std::string& timeSeriesName, const std::string& keyValue) {
2118 ✗ boost::optional<double> result;
2119 ✗ if (m_impl) {
2120 ✗ result = m_impl->runPeriodValue(envPeriod, timeSeriesName, keyValue);
2121 }
2122 ✗ return result;
2123 }
2124
2125 1 openstudio::OptionalTimeSeries SqlFile::timeSeries(const std::string& envPeriod, const std::string& reportingFrequency,
2126 const std::string& timeSeriesName, const std::string& keyValue) {
2127 1 openstudio::OptionalTimeSeries result;
2128
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
2129
1/1
✓ Branch 2 taken 1 time.
1 result = m_impl->timeSeries(envPeriod, reportingFrequency, timeSeriesName, keyValue);
2130 }
2131 1 return result;
2132 ✗ }
2133
2134 ✗ SqlFileTimeSeriesQueryVector SqlFile::expandQuery(const SqlFileTimeSeriesQuery& query) {
2135 ✗ SqlFileTimeSeriesQueryVector result;
2136 ✗ if (m_impl) {
2137 ✗ result = m_impl->expandQuery(query);
2138 }
2139 ✗ return result;
2140 ✗ }
2141
2142 ✗ TimeSeriesVector SqlFile::timeSeries(const SqlFileTimeSeriesQuery& query) {
2143 ✗ TimeSeriesVector result;
2144 ✗ if (m_impl) {
2145 ✗ result = m_impl->timeSeries(query);
2146 }
2147 ✗ return result;
2148 ✗ }
2149
2150 ✗ boost::optional<std::pair<DateTime, DateTime>> SqlFile::daylightSavingsPeriod() const {
2151 ✗ boost::optional<std::pair<DateTime, DateTime>> result;
2152 ✗ if (m_impl) {
2153 ✗ result = m_impl->daylightSavingsPeriod();
2154 }
2155 ✗ return result;
2156 ✗ }
2157
2158 /// returns datadictionary of available timeseries
2159 /*
2160 DataDictionaryTable SqlFile::dataDictionary() const
2161 {
2162 DataDictionaryTable result;
2163 if (m_impl){
2164 result = m_impl->dataDictionary();
2165 }
2166 return result;
2167 }
2168 */
2169
2170 /// Energy plus version number
2171 ✗ std::string SqlFile::energyPlusVersion() const {
2172 ✗ std::string result;
2173 ✗ if (m_impl) {
2174 ✗ result = m_impl->energyPlusVersion();
2175 }
2176 ✗ return result;
2177 ✗ }
2178
2179 /// Energy Plus eplusout.sql file name
2180 ✗ std::string SqlFile::energyPlusSqliteFile() const {
2181 ✗ std::string result;
2182 ✗ if (m_impl) {
2183 ✗ result = m_impl->energyPlusSqliteFile();
2184 }
2185 ✗ return result;
2186 ✗ }
2187
2188 ✗ boost::optional<int> SqlFile::illuminanceMapHourlyReportIndex(int mapIndex, const DateTime& dateTime) const {
2189 ✗ if (m_impl) {
2190 ✗ return m_impl->illuminanceMapHourlyReportIndex(mapIndex, dateTime);
2191 } else {
2192 ✗ return {};
2193 }
2194 }
2195
2196 /// get zone names of for specified illuminance map
2197 ✗ std::vector<std::string> SqlFile::illuminanceMapZoneNames(const std::string& name) const {
2198 ✗ std::vector<std::string> result;
2199 ✗ if (m_impl) {
2200 ✗ result = m_impl->illuminanceMapZoneNames(name);
2201 }
2202 ✗ return result;
2203 ✗ }
2204
2205 ✗ std::vector<std::string> SqlFile::illuminanceMapZoneNames(int mapIndex) const {
2206 ✗ std::vector<std::string> result;
2207 ✗ if (m_impl) {
2208 ✗ result = m_impl->illuminanceMapZoneNames(mapIndex);
2209 }
2210 ✗ return result;
2211 ✗ }
2212
2213 /// get names of all available illuminance maps
2214 1 std::vector<std::string> SqlFile::illuminanceMapNames() const {
2215 1 std::vector<std::string> result;
2216
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
2217
1/1
✓ Branch 2 taken 1 time.
1 result = m_impl->illuminanceMapNames();
2218 }
2219 1 return result;
2220 ✗ }
2221
2222 /// get names of all available illuminance maps
2223 ✗ std::vector<std::string> SqlFile::illuminanceMapNames(const std::string& envPeriod) const {
2224 ✗ std::vector<std::string> result;
2225 ✗ if (m_impl) {
2226 ✗ result = m_impl->illuminanceMapNames(envPeriod);
2227 }
2228 ✗ return result;
2229 ✗ }
2230
2231 /// x position (m) of the illuminance map
2232 1 Vector SqlFile::illuminanceMapX(const std::string& name, const DateTime& dateTime) const {
2233 1 Vector result;
2234
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
2235
2/2
✓ Branch 2 taken 1 time.
✓ Branch 5 taken 1 time.
1 result = m_impl->illuminanceMapX(name, dateTime);
2236 }
2237 1 return result;
2238 ✗ }
2239
2240 /// y position (m) of the illuminance map
2241 1 Vector SqlFile::illuminanceMapY(const std::string& name, const DateTime& dateTime) const {
2242 1 Vector result;
2243
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
2244
2/2
✓ Branch 2 taken 1 time.
✓ Branch 5 taken 1 time.
1 result = m_impl->illuminanceMapY(name, dateTime);
2245 }
2246 1 return result;
2247 ✗ }
2248
2249 /// x position (m) of the illuminance map
2250 ✗ Vector SqlFile::illuminanceMapX(int hourlyReportIndex) const {
2251 ✗ Vector result;
2252 ✗ if (m_impl) {
2253 ✗ result = m_impl->illuminanceMapX(hourlyReportIndex);
2254 }
2255 ✗ return result;
2256 ✗ }
2257
2258 /// y position (m) of the illuminance map
2259 ✗ Vector SqlFile::illuminanceMapY(int hourlyReportIndex) const {
2260 ✗ Vector result;
2261 ✗ if (m_impl) {
2262 ✗ result = m_impl->illuminanceMapY(hourlyReportIndex);
2263 }
2264 ✗ return result;
2265 ✗ }
2266
2267 /// hourly report indices of the illuminance map
2268 ✗ std::vector<int> SqlFile::illuminanceMapHourlyReportIndices(const std::string& name) const {
2269 ✗ std::vector<int> result;
2270 ✗ if (m_impl) {
2271 ✗ result = m_impl->illuminanceMapHourlyReportIndices(name);
2272 }
2273 ✗ return result;
2274 ✗ }
2275
2276 // find the illuminance map index by name
2277 ✗ boost::optional<int> SqlFile::illuminanceMapIndex(const std::string& name) const {
2278 ✗ boost::optional<int> result;
2279 ✗ if (m_impl) {
2280 ✗ result = m_impl->illuminanceMapIndex(name);
2281 }
2282 ✗ return result;
2283 }
2284
2285 /// reference point for map - form RefPtn=(x:y:illuminance)
2286 2 boost::optional<std::string> SqlFile::illuminanceMapRefPt(const std::string& name, int ptNum) const {
2287 2 boost::optional<std::string> result;
2288
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
2 if (m_impl) {
2289
1/1
✓ Branch 2 taken 2 times.
2 result = m_impl->illuminanceMapRefPt(name, ptNum);
2290 }
2291 2 return result;
2292 ✗ }
2293
2294 ✗ boost::optional<std::string> SqlFile::illuminanceMapRefPt(int mapIndex, int ptNum) const {
2295 ✗ boost::optional<std::string> result;
2296 ✗ if (m_impl) {
2297 ✗ result = m_impl->illuminanceMapRefPt(mapIndex, ptNum);
2298 }
2299 ✗ return result;
2300 ✗ }
2301
2302 /// min value for map
2303 1 boost::optional<double> SqlFile::illuminanceMapMinValue(const std::string& name) const {
2304 1 boost::optional<double> result;
2305
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
2306
1/1
✓ Branch 2 taken 1 time.
1 result = m_impl->illuminanceMapMinValue(name);
2307 }
2308 1 return result;
2309 }
2310
2311 /// min value for map
2312 ✗ boost::optional<double> SqlFile::illuminanceMapMinValue(int mapIndex) const {
2313 ✗ boost::optional<double> result;
2314 ✗ if (m_impl) {
2315 ✗ result = m_impl->illuminanceMapMinValue(mapIndex);
2316 }
2317 ✗ return result;
2318 }
2319
2320 /// max value for map
2321 1 boost::optional<double> SqlFile::illuminanceMapMaxValue(const std::string& name) const {
2322 1 boost::optional<double> result;
2323
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
2324
1/1
✓ Branch 2 taken 1 time.
1 result = m_impl->illuminanceMapMaxValue(name);
2325 }
2326 1 return result;
2327 }
2328
2329 /// max value for map
2330 ✗ boost::optional<double> SqlFile::illuminanceMapMaxValue(int mapIndex) const {
2331 ✗ boost::optional<double> result;
2332 ✗ if (m_impl) {
2333 ✗ result = m_impl->illuminanceMapMaxValue(mapIndex);
2334 }
2335 ✗ return result;
2336 }
2337
2338 /// min and max values for map
2339 1 void SqlFile::illuminanceMapMaxValue(const std::string& name, double& minValue, double& maxValue) const {
2340
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
2341 1 m_impl->illuminanceMapMaxValue(name, minValue, maxValue);
2342 }
2343 1 }
2344
2345 /// min and max values for map
2346 ✗ void SqlFile::illuminanceMapMaxValue(int mapIndex, double& minValue, double& maxValue) const {
2347 ✗ if (m_impl) {
2348 ✗ m_impl->illuminanceMapMaxValue(mapIndex, minValue, maxValue);
2349 }
2350 ✗ }
2351
2352 /// hourly report indices of the illuminance map
2353 ✗ std::vector<int> SqlFile::illuminanceMapHourlyReportIndices(int mapIndex) const {
2354 ✗ std::vector<int> result;
2355 ✗ if (m_impl) {
2356 ✗ result = m_impl->illuminanceMapHourlyReportIndices(mapIndex);
2357 }
2358 ✗ return result;
2359 ✗ }
2360
2361 /// hourly report indices and dates of the illuminance map
2362 4 std::vector<std::pair<int, DateTime>> SqlFile::illuminanceMapHourlyReportIndicesDates(const std::string& name) const {
2363 4 std::vector<std::pair<int, DateTime>> result;
2364
1/2
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
4 if (m_impl) {
2365
1/1
✓ Branch 2 taken 4 times.
4 result = m_impl->illuminanceMapHourlyReportIndicesDates(name);
2366 }
2367 4 return result;
2368 ✗ }
2369
2370 /// hourly report indices and dates of the illuminance map
2371 ✗ std::vector<std::pair<int, DateTime>> SqlFile::illuminanceMapHourlyReportIndicesDates(int mapIndex) const {
2372 ✗ std::vector<std::pair<int, DateTime>> result;
2373 ✗ if (m_impl) {
2374 ✗ result = m_impl->illuminanceMapHourlyReportIndicesDates(mapIndex);
2375 }
2376 ✗ return result;
2377 ✗ }
2378
2379 /// date and time for hourly report index
2380 ✗ boost::optional<DateTime> SqlFile::illuminanceMapDate(int hourlyReportIndex) const {
2381 ✗ boost::optional<DateTime> result;
2382 ✗ if (m_impl) {
2383 ✗ result = m_impl->illuminanceMapDate(hourlyReportIndex);
2384 }
2385 ✗ return result;
2386 ✗ }
2387
2388 /// value (lux) of the illuminance map at date and time
2389 /// value(i,j) is the illuminance at x(i), y(j)
2390 1 Matrix SqlFile::illuminanceMap(const std::string& name, const DateTime& dateTime) const {
2391 1 Matrix result;
2392
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
2393
2/2
✓ Branch 2 taken 1 time.
✓ Branch 5 taken 1 time.
1 result = m_impl->illuminanceMap(name, dateTime);
2394 }
2395 1 return result;
2396 ✗ }
2397
2398 /// value (lux) of the illuminance map at hourly report index
2399 /// value(i,j) is the illuminance at x(i), y(j)
2400 ✗ Matrix SqlFile::illuminanceMap(int hourlyReportIndex) const {
2401 ✗ Matrix result;
2402 ✗ if (m_impl) {
2403 ✗ result = m_impl->illuminanceMap(hourlyReportIndex);
2404 }
2405 ✗ return result;
2406 ✗ }
2407
2408 ✗ std::vector<SummaryData> SqlFile::getSummaryData() const {
2409 ✗ if (m_impl) {
2410 ✗ return m_impl->getSummaryData();
2411 }
2412 ✗ return {};
2413 }
2414
2415 /** value (lux) of the illuminance map at hourlyReportIndex
2416 * value(i,j) is the illuminance at x(i), y(j) fills in x,y, illuminance*/
2417 1 void SqlFile::illuminanceMap(int hourlyReportIndex, std::vector<double>& x, std::vector<double>& y, std::vector<double>& illuminance) const {
2418
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
2419 1 m_impl->illuminanceMap(hourlyReportIndex, x, y, illuminance);
2420 }
2421 1 }
2422
2423 // equality test
2424 ✗ bool SqlFile::operator==(const SqlFile& other) const {
2425 ✗ return (m_impl == other.m_impl);
2426 }
2427
2428 // inequality test
2429 ✗ bool SqlFile::operator<(const SqlFile& other) const {
2430 ✗ return (m_impl < other.m_impl);
2431 }
2432
2433 /// returns datadictionary of available timeseries
2434 ✗ detail::DataDictionaryTable SqlFile::dataDictionary() const {
2435 ✗ detail::DataDictionaryTable result;
2436 ✗ if (m_impl) {
2437 ✗ result = m_impl->dataDictionary();
2438 }
2439 ✗ return result;
2440 ✗ }
2441
2442 ✗ bool SqlFile::supportedVersion() const {
2443 ✗ if (m_impl) {
2444 ✗ return m_impl->isSupportedVersion();
2445 }
2446
2447 ✗ return false;
2448 }
2449
2450 ✗ bool SqlFile::hasYear() const {
2451 ✗ if (m_impl) {
2452 ✗ return m_impl->hasYear();
2453 }
2454
2455 ✗ return true;
2456 }
2457
2458 1 bool SqlFile::hasIlluminanceMapYear() const {
2459
1/2
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
1 if (m_impl) {
2460 1 return m_impl->hasIlluminanceMapYear();
2461 }
2462
2463 ✗ return true;
2464 }
2465
2466 ✗ boost::optional<double> SqlFile::getExteriorFenestrationValue(const std::string& subSurfaceName, const std::string& columnName) const {
2467 ✗ boost::optional<double> result;
2468 ✗ if (m_impl) {
2469 ✗ result = m_impl->getExteriorFenestrationValue(subSurfaceName, columnName);
2470 }
2471 ✗ return result;
2472 }
2473
2474 ✗ boost::optional<double> SqlFile::assemblyUFactor(const std::string& subSurfaceName) const {
2475 ✗ boost::optional<double> result;
2476 ✗ if (m_impl) {
2477 ✗ result = m_impl->assemblyUFactor(subSurfaceName);
2478 }
2479 ✗ return result;
2480 }
2481
2482 ✗ boost::optional<double> SqlFile::assemblySHGC(const std::string& subSurfaceName) const {
2483 ✗ boost::optional<double> result;
2484 ✗ if (m_impl) {
2485 ✗ result = m_impl->assemblySHGC(subSurfaceName);
2486 }
2487 ✗ return result;
2488 }
2489
2490 ✗ boost::optional<double> SqlFile::assemblyVisibleTransmittance(const std::string& subSurfaceName) const {
2491 ✗ boost::optional<double> result;
2492 ✗ if (m_impl) {
2493 ✗ result = m_impl->assemblyVisibleTransmittance(subSurfaceName);
2494 }
2495 ✗ return result;
2496 }
2497
2498 } // namespace openstudio
2499