Line data Source code
1 : // EnergyPlus, Copyright (c) 1996-2025, The Board of Trustees of the University of Illinois,
2 : // The Regents of the University of California, through Lawrence Berkeley National Laboratory
3 : // (subject to receipt of any required approvals from the U.S. Dept. of Energy), Oak Ridge
4 : // National Laboratory, managed by UT-Battelle, Alliance for Sustainable Energy, LLC, and other
5 : // contributors. All rights reserved.
6 : //
7 : // NOTICE: This Software was developed under funding from the U.S. Department of Energy and the
8 : // U.S. Government consequently retains certain rights. As such, the U.S. Government has been
9 : // granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable,
10 : // worldwide license in the Software to reproduce, distribute copies to the public, prepare
11 : // derivative works, and perform publicly and display publicly, and to permit others to do so.
12 : //
13 : // Redistribution and use in source and binary forms, with or without modification, are permitted
14 : // provided that the following conditions are met:
15 : //
16 : // (1) Redistributions of source code must retain the above copyright notice, this list of
17 : // conditions and the following disclaimer.
18 : //
19 : // (2) Redistributions in binary form must reproduce the above copyright notice, this list of
20 : // conditions and the following disclaimer in the documentation and/or other materials
21 : // provided with the distribution.
22 : //
23 : // (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory,
24 : // the University of Illinois, U.S. Dept. of Energy nor the names of its contributors may be
25 : // used to endorse or promote products derived from this software without specific prior
26 : // written permission.
27 : //
28 : // (4) Use of EnergyPlus(TM) Name. If Licensee (i) distributes the software in stand-alone form
29 : // without changes from the version obtained under this License, or (ii) Licensee makes a
30 : // reference solely to the software portion of its product, Licensee must refer to the
31 : // software as "EnergyPlus version X" software, where "X" is the version number Licensee
32 : // obtained under this License and may not use a different name for the software. Except as
33 : // specifically required in this Section (4), Licensee shall not use in a company name, a
34 : // product name, in advertising, publicity, or other promotional activities any name, trade
35 : // name, trademark, logo, or other designation of "EnergyPlus", "E+", "e+" or confusingly
36 : // similar designation, without the U.S. Department of Energy's prior written consent.
37 : //
38 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
39 : // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
40 : // AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
41 : // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
42 : // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
43 : // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
44 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
45 : // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
46 : // POSSIBILITY OF SUCH DAMAGE.
47 :
48 : #include <EnergyPlus/IOFiles.hh>
49 :
50 : #include "Data/EnergyPlusData.hh"
51 : #include "DataStringGlobals.hh"
52 : #include "FileSystem.hh"
53 : #include "InputProcessing/InputProcessor.hh"
54 : #include "ResultsFramework.hh"
55 : #include "UtilityRoutines.hh"
56 : #include <embedded/EmbeddedEpJSONSchema.hh>
57 :
58 : #include <algorithm>
59 : #include <fmt/format.h>
60 : #include <memory>
61 : #include <stdexcept>
62 :
63 : namespace EnergyPlus {
64 :
65 22 : InputFile &InputFile::ensure_open(EnergyPlusData &state, const std::string &caller, bool output_to_file)
66 : {
67 22 : if (!good()) {
68 22 : open(false, output_to_file);
69 : }
70 22 : if (!good()) {
71 0 : ShowFatalError(state, fmt::format("{}: Could not open file {} for input (read).", caller, filePath));
72 : }
73 22 : return *this;
74 : }
75 :
76 10539 : bool InputFile::good() const noexcept
77 : {
78 10539 : if (is) {
79 10517 : return is->good();
80 : } else {
81 22 : return false;
82 : }
83 : }
84 :
85 1034 : void InputFile::close()
86 : {
87 1034 : is.reset();
88 1034 : }
89 :
90 72461 : InputFile::ReadResult<std::string> InputFile::readLine() noexcept
91 : {
92 72461 : if (!is) {
93 0 : return {"", true, false};
94 : }
95 :
96 72461 : std::string line;
97 72461 : if (std::getline(*is, line)) {
98 72440 : if (!line.empty() && line.back() == '\r') {
99 9629 : line.pop_back();
100 : }
101 : // Use operator bool, see ReadResult::good() docstring
102 72440 : return {std::move(line), is->eof(), bool(is)};
103 : } else {
104 42 : return {"", is->eof(), false};
105 : }
106 72461 : }
107 :
108 0 : std::string InputFile::readFile()
109 : {
110 0 : std::string result(file_size, '\0');
111 0 : is->read(result.data(), file_size);
112 0 : return result;
113 0 : }
114 :
115 0 : nlohmann::json InputFile::readJSON()
116 : {
117 0 : FileSystem::FileTypes const ext = FileSystem::getFileType(filePath);
118 0 : switch (ext) {
119 0 : case FileSystem::FileTypes::EpJSON:
120 : case FileSystem::FileTypes::JSON:
121 : case FileSystem::FileTypes::GLHE:
122 0 : return nlohmann::json::parse(*is, nullptr, true, true);
123 0 : case FileSystem::FileTypes::CBOR:
124 0 : return nlohmann::json::from_cbor(*is);
125 0 : case FileSystem::FileTypes::MsgPack:
126 0 : return nlohmann::json::from_msgpack(*is);
127 0 : case FileSystem::FileTypes::UBJSON:
128 0 : return nlohmann::json::from_ubjson(*is);
129 0 : case FileSystem::FileTypes::BSON:
130 0 : return nlohmann::json::from_bson(*is);
131 0 : default:
132 0 : throw FatalError("Invalid file extension. Must be epJSON, JSON, or other experimental extensions");
133 : }
134 : }
135 :
136 2156 : InputFile::InputFile(fs::path FilePath) : filePath(std::move(FilePath))
137 : {
138 2156 : }
139 :
140 0 : std::ostream::pos_type InputFile::position() const noexcept
141 : {
142 0 : return is->tellg();
143 : }
144 :
145 98 : void InputFile::open(bool, bool)
146 : {
147 98 : file_size = fs::file_size(filePath);
148 : // basic_fstream is a template, it has no problem with wchar_t (which filePath.c_str() returns on Windows)
149 98 : is = std::make_unique<std::fstream>(filePath.c_str(), std::ios_base::in | std::ios_base::binary);
150 : // is->imbue(std::locale("C"));
151 98 : }
152 :
153 0 : std::string InputFile::error_state_to_string() const
154 : {
155 0 : const std::istream::iostate state = rdstate();
156 :
157 0 : if (!is_open()) {
158 0 : return "file not opened'";
159 : }
160 :
161 0 : if (state == std::ios_base::failbit) {
162 0 : return "io operation failed";
163 0 : } else if (state == std::ios_base::badbit) {
164 0 : return "irrecoverable stream error";
165 0 : } else if (state == std::ios_base::eofbit) {
166 0 : return "end of file reached";
167 : } else {
168 0 : return "no error";
169 : }
170 : }
171 :
172 0 : std::istream::iostate InputFile::rdstate() const noexcept
173 : {
174 0 : if (is) {
175 0 : return is->rdstate();
176 : } else {
177 0 : return std::ios_base::badbit;
178 : }
179 : }
180 :
181 0 : bool InputFile::is_open() const noexcept
182 : {
183 0 : if (is) {
184 0 : auto *ss = dynamic_cast<std::ifstream *>(is.get());
185 0 : if (ss) {
186 0 : return ss->is_open();
187 : } else {
188 0 : return true;
189 : }
190 : } else {
191 0 : return false;
192 : }
193 : }
194 :
195 31 : void InputFile::backspace() noexcept
196 : {
197 31 : if (is) {
198 31 : is->clear();
199 31 : std::streamoff g1(is->tellg()); // Current position
200 31 : is->seekg(0, std::ios::beg); // Beginning of file
201 31 : std::streampos const g0(is->tellg());
202 31 : is->seekg(g1, std::ios::beg); // Restore position
203 31 : if (g1 > g0) {
204 31 : --g1;
205 : }
206 5412 : while (g1 > g0) {
207 5412 : is->seekg(--g1, std::ios::beg); // Backup by 1
208 5412 : if (is->peek() == '\n') { // Found end of previous record
209 31 : is->seekg(++g1, std::ios::beg);
210 31 : break;
211 : }
212 : }
213 : }
214 31 : }
215 :
216 7152 : InputOutputFile &InputOutputFile::ensure_open(EnergyPlusData &state, const std::string &caller, bool output_to_file)
217 : {
218 7152 : if (!good()) {
219 362 : open(false, output_to_file);
220 : }
221 7152 : if (!good()) {
222 0 : ShowFatalError(state, fmt::format("{}: Could not open file {} for output (write).", caller, filePath));
223 : }
224 7152 : return *this;
225 : }
226 :
227 62369 : bool InputOutputFile::good() const
228 : {
229 62369 : if (os && print_to_dev_null && os->bad()) { // badbit is set
230 0 : return true;
231 62369 : } else if (os) {
232 62007 : return os->good();
233 : } else {
234 362 : return false;
235 : }
236 : }
237 :
238 17265 : void InputOutputFile::close()
239 : {
240 17265 : os.reset();
241 17265 : }
242 :
243 21127 : void InputOutputFile::del()
244 : {
245 21127 : if (os) {
246 18823 : os.reset();
247 18823 : FileSystem::removeFile(filePath);
248 : }
249 21127 : }
250 :
251 23583 : void InputOutputFile::open_as_stringstream()
252 : {
253 23583 : os = std::make_unique<std::stringstream>();
254 23583 : }
255 :
256 357 : void InputOutputFile::flush()
257 : {
258 357 : if (os) {
259 69 : os->flush();
260 : }
261 357 : }
262 :
263 467 : std::string InputOutputFile::get_output()
264 : {
265 467 : auto *ss = dynamic_cast<std::stringstream *>(os.get());
266 467 : if (ss) {
267 466 : return ss->str();
268 : } else {
269 2 : return "";
270 : }
271 : }
272 :
273 38409 : InputOutputFile::InputOutputFile(fs::path FilePath, const bool DefaultToStdout) : filePath{std::move(FilePath)}, defaultToStdOut{DefaultToStdout}
274 : {
275 38409 : }
276 :
277 26 : std::ostream::pos_type InputOutputFile::position() const noexcept
278 : {
279 26 : return os->tellg();
280 : }
281 :
282 388 : void InputOutputFile::open(const bool forAppend, bool output_to_file)
283 : {
284 1164 : auto appendMode = [=]() {
285 388 : if (forAppend) {
286 0 : return std::ios_base::app;
287 : } else {
288 388 : return std::ios_base::trunc;
289 : }
290 388 : }();
291 388 : if (!output_to_file) {
292 0 : os = std::make_unique<std::iostream>(nullptr);
293 : // os->imbue(std::locale("C"));
294 0 : print_to_dev_null = true;
295 : } else {
296 388 : os = std::make_unique<std::fstream>(filePath.c_str(), std::ios_base::in | std::ios_base::out | appendMode);
297 : // os->imbue(std::locale("C"));
298 388 : print_to_dev_null = false;
299 : }
300 388 : }
301 :
302 39 : std::vector<std::string> InputOutputFile::getLines()
303 : {
304 39 : if (os) {
305 : // avoid saving and reloading the file by simply reading the current input stream
306 39 : os->flush();
307 39 : const size_t last_pos = os->tellg();
308 39 : std::string line;
309 39 : std::vector<std::string> lines;
310 39 : os->seekg(0);
311 :
312 4443 : while (std::getline(*os, line)) {
313 4404 : lines.push_back(line);
314 : }
315 :
316 : // after getline is done, we're at eof/fail bit
317 39 : os->clear();
318 39 : os->seekg(last_pos);
319 39 : return lines;
320 39 : }
321 0 : return std::vector<std::string>();
322 : }
323 :
324 324 : bool IOFiles::OutputControl::writeTabular(EnergyPlusData &state)
325 : {
326 324 : bool const htmlTabular = state.files.outputControl.tabular;
327 324 : bool const jsonTabular = state.files.outputControl.json && state.dataResultsFramework->resultsFramework->timeSeriesAndTabularEnabled();
328 324 : bool const sqliteTabular = state.files.outputControl.sqlite; // && @JasonGlazer thinks something else maybe?
329 324 : return (htmlTabular || jsonTabular || sqliteTabular);
330 : }
331 :
332 107 : void IOFiles::OutputControl::getInput(EnergyPlusData &state)
333 : {
334 107 : auto &ip = state.dataInputProcessing->inputProcessor;
335 214 : auto const instances = ip->epJSON.find("OutputControl:Files");
336 107 : if (instances != ip->epJSON.end()) {
337 :
338 1024 : auto find_input = [=, &state](nlohmann::json const &fields, std::string const &field_name) -> std::string {
339 1024 : std::string input;
340 1024 : auto found = fields.find(field_name);
341 1024 : if (found != fields.end()) {
342 1023 : input = found.value().get<std::string>();
343 1023 : input = Util::makeUPPER(input);
344 : } else {
345 3 : state.dataInputProcessing->inputProcessor->getDefaultValue(state, "OutputControl:Files", field_name, input);
346 : }
347 2048 : return input;
348 1024 : };
349 :
350 1024 : auto boolean_choice = [=, &state](std::string const &input) -> bool {
351 1024 : if (input == "YES") {
352 52 : return true;
353 972 : } else if (input == "NO") {
354 972 : return false;
355 : }
356 0 : ShowFatalError(state, "Invalid boolean Yes/No choice input");
357 0 : return true;
358 32 : };
359 :
360 32 : auto &instancesValue = instances.value();
361 64 : for (auto instance = instancesValue.begin(); instance != instancesValue.end(); ++instance) {
362 32 : auto const &fields = instance.value();
363 :
364 96 : ip->markObjectAsUsed("OutputControl:Files", instance.key());
365 :
366 : { // "output_csv"
367 64 : csv = boolean_choice(find_input(fields, "output_csv"));
368 : }
369 : { // "output_mtr"
370 64 : mtr = boolean_choice(find_input(fields, "output_mtr"));
371 : }
372 : { // "output_eso"
373 64 : eso = boolean_choice(find_input(fields, "output_eso"));
374 : }
375 : { // "output_eio"
376 64 : eio = boolean_choice(find_input(fields, "output_eio"));
377 : }
378 : { // "output_audit"
379 64 : audit = boolean_choice(find_input(fields, "output_audit"));
380 : }
381 : { // "output_space_sizing"
382 64 : spsz = boolean_choice(find_input(fields, "output_space_sizing"));
383 : }
384 : { // "output_zone_sizing"
385 64 : zsz = boolean_choice(find_input(fields, "output_zone_sizing"));
386 : }
387 : { // "output_system_sizing"
388 64 : ssz = boolean_choice(find_input(fields, "output_system_sizing"));
389 : }
390 : { // "output_dxf"
391 64 : dxf = boolean_choice(find_input(fields, "output_dxf"));
392 : }
393 : { // "output_bnd"
394 64 : bnd = boolean_choice(find_input(fields, "output_bnd"));
395 : }
396 : { // "output_rdd"
397 64 : rdd = boolean_choice(find_input(fields, "output_rdd"));
398 : }
399 : { // "output_mdd"
400 64 : mdd = boolean_choice(find_input(fields, "output_mdd"));
401 : }
402 : { // "output_mtd"
403 64 : mtd = boolean_choice(find_input(fields, "output_mtd"));
404 : }
405 : { // "output_end"
406 64 : end = boolean_choice(find_input(fields, "output_end"));
407 : }
408 : { // "output_shd"
409 64 : shd = boolean_choice(find_input(fields, "output_shd"));
410 : }
411 : { // "output_dfs"
412 64 : dfs = boolean_choice(find_input(fields, "output_dfs"));
413 : }
414 : { // "output_glhe"
415 64 : glhe = boolean_choice(find_input(fields, "output_glhe"));
416 : }
417 : { // "output_delightin"
418 64 : delightin = boolean_choice(find_input(fields, "output_delightin"));
419 : }
420 : { // "output_delighteldmp"
421 64 : delighteldmp = boolean_choice(find_input(fields, "output_delighteldmp"));
422 : }
423 : { // "output_delightdfdmp"
424 64 : delightdfdmp = boolean_choice(find_input(fields, "output_delightdfdmp"));
425 : }
426 : { // "output_edd"
427 64 : edd = boolean_choice(find_input(fields, "output_edd"));
428 : }
429 : { // "output_dbg"
430 64 : dbg = boolean_choice(find_input(fields, "output_dbg"));
431 : }
432 : { // "output_perflog"
433 64 : perflog = boolean_choice(find_input(fields, "output_perflog"));
434 : }
435 : { // "output_sln"
436 64 : sln = boolean_choice(find_input(fields, "output_sln"));
437 : }
438 : { // "output_sci"
439 64 : sci = boolean_choice(find_input(fields, "output_sci"));
440 : }
441 : { // "output_wrl"
442 64 : wrl = boolean_choice(find_input(fields, "output_wrl"));
443 : }
444 : { // "output_screen"
445 64 : screen = boolean_choice(find_input(fields, "output_screen"));
446 : }
447 : { // "output_tarcog"
448 64 : tarcog = boolean_choice(find_input(fields, "output_tarcog"));
449 : }
450 : { // "output_extshd"
451 64 : extshd = boolean_choice(find_input(fields, "output_extshd"));
452 : }
453 : { // "json"
454 64 : json = boolean_choice(find_input(fields, "output_json"));
455 : }
456 : { // "tabular"
457 64 : tabular = boolean_choice(find_input(fields, "output_tabular"));
458 : }
459 : { // "sqlite"
460 64 : sqlite = boolean_choice(find_input(fields, "output_sqlite"));
461 : }
462 32 : }
463 : }
464 :
465 214 : auto const timestamp_instances = ip->epJSON.find("OutputControl:Timestamp");
466 107 : if (timestamp_instances != ip->epJSON.end()) {
467 0 : auto const &instancesValue = timestamp_instances.value();
468 0 : for (auto instance = instancesValue.begin(); instance != instancesValue.end(); ++instance) {
469 0 : auto const &fields = instance.value();
470 0 : ip->markObjectAsUsed("OutputControl:Timestamp", instance.key());
471 :
472 0 : auto item = fields.find("iso_8601_format");
473 0 : if (item != fields.end()) {
474 0 : state.dataResultsFramework->resultsFramework->setISO8601(item->get<std::string>() == "Yes");
475 : }
476 :
477 0 : item = fields.find("timestamp_at_beginning_of_interval");
478 0 : if (item != fields.end()) {
479 0 : state.dataResultsFramework->resultsFramework->setBeginningOfInterval(item->get<std::string>() == "Yes");
480 : }
481 0 : }
482 : }
483 107 : }
484 :
485 21 : void IOFiles::flushAll()
486 : {
487 :
488 21 : audit.flush();
489 21 : eio.flush();
490 21 : eso.flush();
491 21 : zsz.flush();
492 21 : spsz.flush();
493 21 : ssz.flush();
494 21 : map.flush();
495 21 : mtr.flush();
496 21 : bnd.flush();
497 21 : rdd.flush();
498 21 : mdd.flush();
499 21 : debug.flush();
500 21 : dfs.flush();
501 21 : mtd.flush();
502 21 : edd.flush();
503 21 : shade.flush();
504 21 : csv.flush();
505 :
506 21 : if (err_stream) {
507 21 : err_stream->flush();
508 : }
509 21 : }
510 :
511 : } // namespace EnergyPlus
512 :
513 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int>(std::string_view, int &&);
514 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, const char *const &>(std::string_view, const char *const &);
515 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &, std::string &>(std::string_view, int &, std::string &);
516 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, std::string &, std::string &, double &>(
517 : std::string_view, std::string &, std::string &, std::string &, double &);
518 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, const std::string_view &>(std::string_view, const std::string_view &);
519 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, const std::string_view &, std::string &>(std::string_view,
520 : const std::string_view &,
521 : std::string &);
522 : template std::string
523 : EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, double &, double &>(std::string_view, std::string &, double &, double &);
524 : template std::string
525 : EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, std::string &, int &>(std::string_view, std::string &, std::string &, int &);
526 : template std::string
527 : EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, double &, double &, double &>(std::string_view, double &, double &, double &);
528 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, double &, std::string &>(std::string_view, double &, std::string &);
529 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &>(std::string_view, std::string &);
530 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, const int &, int &>(std::string_view, const int &, int &);
531 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, double>(std::string_view, double &&);
532 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &, int &>(std::string_view, int &, int &);
533 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, const double &>(std::string_view, const double &);
534 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, int &>(std::string_view, std::string &, int &);
535 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, std::string &, double &>(std::string_view,
536 : std::string &,
537 : std::string &,
538 : double &);
539 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, double &, std::string &, double &>(
540 : std::string_view, std::string &, double &, std::string &, double &);
541 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, const int &>(std::string_view, const int &);
542 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &, const std::string &, std::string &>(std::string_view,
543 : int &,
544 : const std::string &,
545 : std::string &);
546 : template std::string
547 : EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &, int &, const std::string &>(std::string_view, int &, int &, const std::string &);
548 : template std::string
549 : EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &, int &, std::string_view &>(std::string_view, int &, int &, std::string_view &);
550 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &, std::string_view &, std::string &>(std::string_view,
551 : int &,
552 : std::string_view &,
553 : std::string &);
554 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, double &, double &>(std::string_view, double &, double &);
555 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &>(std::string_view, int &);
556 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, double &>(std::string_view, std::string &, double &);
557 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, double &>(std::string_view, double &);
|
