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 2154 : InputFile::InputFile(fs::path FilePath) : filePath(std::move(FilePath))
137 : {
138 2154 : }
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) --g1;
204 5412 : while (g1 > g0) {
205 5412 : is->seekg(--g1, std::ios::beg); // Backup by 1
206 5412 : if (is->peek() == '\n') { // Found end of previous record
207 31 : is->seekg(++g1, std::ios::beg);
208 31 : break;
209 : }
210 : }
211 : }
212 31 : }
213 :
214 7147 : InputOutputFile &InputOutputFile::ensure_open(EnergyPlusData &state, const std::string &caller, bool output_to_file)
215 : {
216 7147 : if (!good()) {
217 362 : open(false, output_to_file);
218 : }
219 7147 : if (!good()) {
220 0 : ShowFatalError(state, fmt::format("{}: Could not open file {} for output (write).", caller, filePath));
221 : }
222 7147 : return *this;
223 : }
224 :
225 62359 : bool InputOutputFile::good() const
226 : {
227 62359 : if (os && print_to_dev_null && os->bad()) { // badbit is set
228 0 : return true;
229 62359 : } else if (os) {
230 61997 : return os->good();
231 : } else {
232 362 : return false;
233 : }
234 : }
235 :
236 17249 : void InputOutputFile::close()
237 : {
238 17249 : os.reset();
239 17249 : }
240 :
241 21107 : void InputOutputFile::del()
242 : {
243 21107 : if (os) {
244 18805 : os.reset();
245 18805 : FileSystem::removeFile(filePath);
246 : }
247 21107 : }
248 :
249 23561 : void InputOutputFile::open_as_stringstream()
250 : {
251 23561 : os = std::make_unique<std::stringstream>();
252 23561 : }
253 :
254 357 : void InputOutputFile::flush()
255 : {
256 357 : if (os) {
257 69 : os->flush();
258 : }
259 357 : }
260 :
261 467 : std::string InputOutputFile::get_output()
262 : {
263 467 : auto *ss = dynamic_cast<std::stringstream *>(os.get());
264 467 : if (ss) {
265 466 : return ss->str();
266 : } else {
267 2 : return "";
268 : }
269 : }
270 :
271 38373 : InputOutputFile::InputOutputFile(fs::path FilePath, const bool DefaultToStdout) : filePath{std::move(FilePath)}, defaultToStdOut{DefaultToStdout}
272 : {
273 38373 : }
274 :
275 26 : std::ostream::pos_type InputOutputFile::position() const noexcept
276 : {
277 26 : return os->tellg();
278 : }
279 :
280 388 : void InputOutputFile::open(const bool forAppend, bool output_to_file)
281 : {
282 1164 : auto appendMode = [=]() {
283 388 : if (forAppend) {
284 0 : return std::ios_base::app;
285 : } else {
286 388 : return std::ios_base::trunc;
287 : }
288 388 : }();
289 388 : if (!output_to_file) {
290 0 : os = std::make_unique<std::iostream>(nullptr);
291 : // os->imbue(std::locale("C"));
292 0 : print_to_dev_null = true;
293 : } else {
294 388 : os = std::make_unique<std::fstream>(filePath.c_str(), std::ios_base::in | std::ios_base::out | appendMode);
295 : // os->imbue(std::locale("C"));
296 388 : print_to_dev_null = false;
297 : }
298 388 : }
299 :
300 39 : std::vector<std::string> InputOutputFile::getLines()
301 : {
302 39 : if (os) {
303 : // avoid saving and reloading the file by simply reading the current input stream
304 39 : os->flush();
305 39 : const size_t last_pos = os->tellg();
306 39 : std::string line;
307 39 : std::vector<std::string> lines;
308 39 : os->seekg(0);
309 :
310 4443 : while (std::getline(*os, line)) {
311 4404 : lines.push_back(line);
312 : }
313 :
314 : // after getline is done, we're at eof/fail bit
315 39 : os->clear();
316 39 : os->seekg(last_pos);
317 39 : return lines;
318 39 : }
319 0 : return std::vector<std::string>();
320 : }
321 :
322 324 : bool IOFiles::OutputControl::writeTabular(EnergyPlusData &state)
323 : {
324 324 : bool const htmlTabular = state.files.outputControl.tabular;
325 324 : bool const jsonTabular = state.files.outputControl.json && state.dataResultsFramework->resultsFramework->timeSeriesAndTabularEnabled();
326 324 : bool const sqliteTabular = state.files.outputControl.sqlite; // && @JasonGlazer thinks something else maybe?
327 324 : return (htmlTabular || jsonTabular || sqliteTabular);
328 : }
329 :
330 107 : void IOFiles::OutputControl::getInput(EnergyPlusData &state)
331 : {
332 107 : auto &ip = state.dataInputProcessing->inputProcessor;
333 214 : auto const instances = ip->epJSON.find("OutputControl:Files");
334 107 : if (instances != ip->epJSON.end()) {
335 :
336 1024 : auto find_input = [=, &state](nlohmann::json const &fields, std::string const &field_name) -> std::string {
337 1024 : std::string input;
338 1024 : auto found = fields.find(field_name);
339 1024 : if (found != fields.end()) {
340 1023 : input = found.value().get<std::string>();
341 1023 : input = Util::makeUPPER(input);
342 : } else {
343 3 : state.dataInputProcessing->inputProcessor->getDefaultValue(state, "OutputControl:Files", field_name, input);
344 : }
345 2048 : return input;
346 0 : };
347 :
348 1024 : auto boolean_choice = [=, &state](std::string const &input) -> bool {
349 1024 : if (input == "YES") {
350 52 : return true;
351 972 : } else if (input == "NO") {
352 972 : return false;
353 : }
354 0 : ShowFatalError(state, "Invalid boolean Yes/No choice input");
355 0 : return true;
356 32 : };
357 :
358 32 : auto &instancesValue = instances.value();
359 64 : for (auto instance = instancesValue.begin(); instance != instancesValue.end(); ++instance) {
360 32 : auto const &fields = instance.value();
361 :
362 96 : ip->markObjectAsUsed("OutputControl:Files", instance.key());
363 :
364 : { // "output_csv"
365 64 : csv = boolean_choice(find_input(fields, "output_csv"));
366 : }
367 : { // "output_mtr"
368 64 : mtr = boolean_choice(find_input(fields, "output_mtr"));
369 : }
370 : { // "output_eso"
371 64 : eso = boolean_choice(find_input(fields, "output_eso"));
372 : }
373 : { // "output_eio"
374 64 : eio = boolean_choice(find_input(fields, "output_eio"));
375 : }
376 : { // "output_audit"
377 64 : audit = boolean_choice(find_input(fields, "output_audit"));
378 : }
379 : { // "output_space_sizing"
380 64 : spsz = boolean_choice(find_input(fields, "output_space_sizing"));
381 : }
382 : { // "output_zone_sizing"
383 64 : zsz = boolean_choice(find_input(fields, "output_zone_sizing"));
384 : }
385 : { // "output_system_sizing"
386 64 : ssz = boolean_choice(find_input(fields, "output_system_sizing"));
387 : }
388 : { // "output_dxf"
389 64 : dxf = boolean_choice(find_input(fields, "output_dxf"));
390 : }
391 : { // "output_bnd"
392 64 : bnd = boolean_choice(find_input(fields, "output_bnd"));
393 : }
394 : { // "output_rdd"
395 64 : rdd = boolean_choice(find_input(fields, "output_rdd"));
396 : }
397 : { // "output_mdd"
398 64 : mdd = boolean_choice(find_input(fields, "output_mdd"));
399 : }
400 : { // "output_mtd"
401 64 : mtd = boolean_choice(find_input(fields, "output_mtd"));
402 : }
403 : { // "output_end"
404 64 : end = boolean_choice(find_input(fields, "output_end"));
405 : }
406 : { // "output_shd"
407 64 : shd = boolean_choice(find_input(fields, "output_shd"));
408 : }
409 : { // "output_dfs"
410 64 : dfs = boolean_choice(find_input(fields, "output_dfs"));
411 : }
412 : { // "output_glhe"
413 64 : glhe = boolean_choice(find_input(fields, "output_glhe"));
414 : }
415 : { // "output_delightin"
416 64 : delightin = boolean_choice(find_input(fields, "output_delightin"));
417 : }
418 : { // "output_delighteldmp"
419 64 : delighteldmp = boolean_choice(find_input(fields, "output_delighteldmp"));
420 : }
421 : { // "output_delightdfdmp"
422 64 : delightdfdmp = boolean_choice(find_input(fields, "output_delightdfdmp"));
423 : }
424 : { // "output_edd"
425 64 : edd = boolean_choice(find_input(fields, "output_edd"));
426 : }
427 : { // "output_dbg"
428 64 : dbg = boolean_choice(find_input(fields, "output_dbg"));
429 : }
430 : { // "output_perflog"
431 64 : perflog = boolean_choice(find_input(fields, "output_perflog"));
432 : }
433 : { // "output_sln"
434 64 : sln = boolean_choice(find_input(fields, "output_sln"));
435 : }
436 : { // "output_sci"
437 64 : sci = boolean_choice(find_input(fields, "output_sci"));
438 : }
439 : { // "output_wrl"
440 64 : wrl = boolean_choice(find_input(fields, "output_wrl"));
441 : }
442 : { // "output_screen"
443 64 : screen = boolean_choice(find_input(fields, "output_screen"));
444 : }
445 : { // "output_tarcog"
446 64 : tarcog = boolean_choice(find_input(fields, "output_tarcog"));
447 : }
448 : { // "output_extshd"
449 64 : extshd = boolean_choice(find_input(fields, "output_extshd"));
450 : }
451 : { // "json"
452 64 : json = boolean_choice(find_input(fields, "output_json"));
453 : }
454 : { // "tabular"
455 64 : tabular = boolean_choice(find_input(fields, "output_tabular"));
456 : }
457 : { // "sqlite"
458 64 : sqlite = boolean_choice(find_input(fields, "output_sqlite"));
459 : }
460 : }
461 : }
462 :
463 214 : auto const timestamp_instances = ip->epJSON.find("OutputControl:Timestamp");
464 107 : if (timestamp_instances != ip->epJSON.end()) {
465 0 : auto const &instancesValue = timestamp_instances.value();
466 0 : for (auto instance = instancesValue.begin(); instance != instancesValue.end(); ++instance) {
467 0 : auto const &fields = instance.value();
468 0 : ip->markObjectAsUsed("OutputControl:Timestamp", instance.key());
469 :
470 0 : auto item = fields.find("iso_8601_format");
471 0 : if (item != fields.end()) {
472 0 : state.dataResultsFramework->resultsFramework->setISO8601(item->get<std::string>() == "Yes");
473 : }
474 :
475 0 : item = fields.find("timestamp_at_beginning_of_interval");
476 0 : if (item != fields.end()) {
477 0 : state.dataResultsFramework->resultsFramework->setBeginningOfInterval(item->get<std::string>() == "Yes");
478 : }
479 : }
480 : }
481 107 : }
482 :
483 21 : void IOFiles::flushAll()
484 : {
485 :
486 21 : audit.flush();
487 21 : eio.flush();
488 21 : eso.flush();
489 21 : zsz.flush();
490 21 : spsz.flush();
491 21 : ssz.flush();
492 21 : map.flush();
493 21 : mtr.flush();
494 21 : bnd.flush();
495 21 : rdd.flush();
496 21 : mdd.flush();
497 21 : debug.flush();
498 21 : dfs.flush();
499 21 : mtd.flush();
500 21 : edd.flush();
501 21 : shade.flush();
502 21 : csv.flush();
503 :
504 21 : if (err_stream) {
505 21 : err_stream->flush();
506 : }
507 21 : }
508 :
509 : } // namespace EnergyPlus
510 :
511 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int>(std::string_view, int &&);
512 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, const char *const &>(std::string_view, const char *const &);
513 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &, std::string &>(std::string_view, int &, std::string &);
514 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, std::string &, std::string &, double &>(
515 : std::string_view, std::string &, std::string &, std::string &, double &);
516 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, const std::string_view &>(std::string_view, const std::string_view &);
517 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, const std::string_view &, std::string &>(std::string_view,
518 : const std::string_view &,
519 : std::string &);
520 : template std::string
521 : EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, double &, double &>(std::string_view, std::string &, double &, double &);
522 : template std::string
523 : EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, std::string &, int &>(std::string_view, std::string &, std::string &, int &);
524 : template std::string
525 : EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, double &, double &, double &>(std::string_view, double &, double &, double &);
526 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, double &, std::string &>(std::string_view, double &, std::string &);
527 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &>(std::string_view, std::string &);
528 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, const int &, int &>(std::string_view, const int &, int &);
529 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, double>(std::string_view, double &&);
530 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &, int &>(std::string_view, int &, int &);
531 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, const double &>(std::string_view, const double &);
532 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, int &>(std::string_view, std::string &, int &);
533 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, std::string &, double &>(std::string_view,
534 : std::string &,
535 : std::string &,
536 : double &);
537 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, double &, std::string &, double &>(
538 : std::string_view, std::string &, double &, std::string &, double &);
539 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, const int &>(std::string_view, const int &);
540 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &, const std::string &, std::string &>(std::string_view,
541 : int &,
542 : const std::string &,
543 : std::string &);
544 : template std::string
545 : EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &, int &, const std::string &>(std::string_view, int &, int &, const std::string &);
546 : template std::string
547 : EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &, int &, std::string_view &>(std::string_view, int &, int &, std::string_view &);
548 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &, std::string_view &, std::string &>(std::string_view,
549 : int &,
550 : std::string_view &,
551 : std::string &);
552 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, double &, double &>(std::string_view, double &, double &);
553 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, int &>(std::string_view, int &);
554 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, std::string &, double &>(std::string_view, std::string &, double &);
555 : template std::string EnergyPlus::format<EnergyPlus::FormatSyntax::Fortran, double &>(std::string_view, double &);
|
