fortran_io.hpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#pragma once
 
#include "shambase/aliases_float.hpp"
#include "shambase/aliases_int.hpp"
#include "shambase/bytestream.hpp"
#include "shambase/exception.hpp"
#include <array>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace shambase {
 
    class FortranIOFile {
 
        inline void check_fortran_4byte(std::basic_stringstream<byte> &buffer, i32 fortran_byte) {
            i32 new_check = 0;
 
            shambase::stream_read(buffer, new_check);
 
            if (new_check != fortran_byte) {
                throw shambase::make_except_with_loc<std::runtime_error>("fortran 4 bytes invalid");
            }
 
            fortran_byte = new_check;
        }
 
        inline i32 read_fortran_4byte(std::basic_stringstream<byte> &buffer) {
            i32 check;
            shambase::stream_read(buffer, check);
            return check;
        }
 
        std::basic_stringstream<byte> data;
 
        u64 length;
 
        template<class T>
        inline void _write(T arg) {
            stream_write(data, arg);
        }
 
        template<class T>
        inline void _read(T &arg) {
            stream_read(data, arg);
        }
 
        template<class T, int N>
        inline void _read(std::array<T, N> &vec) {
            for (u32 i = 0; i < N; i++) {
                stream_read(data, vec[i]);
            }
        }
 
        template<class T, int N>
        inline void _write(std::array<T, N> &vec) {
            for (u32 i = 0; i < N; i++) {
                stream_write(data, vec[i]);
            }
        }
 
        public:
        using fort_real = f64;
 
        using fort_int = int;
 
        explicit FortranIOFile(std::basic_stringstream<byte> &&data_in, u64 length)
            : data(std::forward<std::basic_stringstream<byte>>(data_in)), length(length) {
 
            // Set the internal buffer to the beginning of the buffer
            data.seekg(0);
        }
 
        FortranIOFile() = default;
 
        inline std::basic_stringstream<byte> &get_internal_buf() {
            // Return a reference to the internal buffer
            return data;
        }
 
        template<class... Args>
        inline void write(Args &...args) {
            i32 linebytecount = ((sizeof(args)) + ...);
            stream_write(data, linebytecount);
            ((_write(args)), ...);
            stream_write(data, linebytecount);
        }
 
        template<class... Args>
        inline void read(Args &...args) {
            u64 linebytecount = ((sizeof(args)) + ...);
            i32 check         = read_fortran_4byte(data);
            if (check != linebytecount) {
                throw_with_loc<std::runtime_error>("the byte count is not correct");
            }
            ((_read(args)), ...);
            check_fortran_4byte(data, check);
        }
 
        inline void read_fixed_string(std::string &s, u32 len) {
            s.resize(len);
            i32 check = read_fortran_4byte(data);
            if (check != len) {
                throw_with_loc<std::runtime_error>("the byte count is not correct");
            }
            data.read(reinterpret_cast<byte *>(s.data()), len * sizeof(char));
            check_fortran_4byte(data, check);
        }
 
        inline void write_fixed_string(std::string &s, u32 len) {
            stream_write(data, len);
            data.write(reinterpret_cast<byte *>(s.data()), len * sizeof(char));
            stream_write(data, len);
        }
 
        inline void read_string_array(std::vector<std::string> &svec, u32 strlen, u32 str_count) {
 
            u64 totlen = strlen * str_count;
            i32 check  = read_fortran_4byte(data);
            if (check != totlen) {
                throw_with_loc<std::runtime_error>("the byte count is not correct");
            }
 
            svec.resize(str_count);
 
            for (u32 i = 0; i < str_count; i++) {
                svec[i].resize(strlen); // Resize the string to the correct size
                data.read(reinterpret_cast<byte *>(svec[i].data()), strlen * sizeof(char));
            }
 
            check_fortran_4byte(data, check);
        }
 
        inline void write_string_array(std::vector<std::string> &svec, u32 strlen, u32 str_count) {
 
            i32 totlen = strlen * str_count; // Total length of the array
 
            stream_write(data, totlen); // Write the total length as a 4-byte integer
 
            for (u32 i = 0; i < str_count; i++) {
                // Write each string to the buffer
                data.write(reinterpret_cast<byte *>(svec[i].data()), strlen * sizeof(char));
            }
 
            stream_write(data, totlen); // Write the total length again as a 4-byte integer
        }
 
        template<class T>
        inline void read_val_array(std::vector<T> &vec, u32 val_count) {
 
            u64 totlen = sizeof(T) * val_count;    // Total length of the array
            i32 check  = read_fortran_4byte(data); // Read the total length
 
            if (check != totlen) {                  // Make sure the byte count matches
                throw_with_loc<std::runtime_error>( // Throw an exception if not
                    "the byte count is not correct");
            }
 
            vec.resize(val_count); // Resize the output array to the correct size
 
            for (u32 i = 0; i < val_count; i++) { // Read each value from the buffer
                stream_read(data, vec[i]);
            }
 
            check_fortran_4byte(data, check); // Check the byte count again
        }
 
        template<class T>
        inline void write_val_array(std::vector<T> &vec, u32 val_count) {
            if (val_count > vec.size()) {
                throw make_except_with_loc<std::invalid_argument>(
                    "val count is higher than vec size");
            }
            i32 totlen = sizeof(T) * val_count;
            stream_write(data, totlen); // Write the total length of the array
 
            for (u32 i = 0; i < val_count; i++) { // Write each value in the array
                stream_write(data, vec[i]);
            }
 
            stream_write(data, totlen); // Write the total length again
        }
 
        inline bool finished_read() { return length == data.tellg(); }
 
        inline void write_to_file(std::string fname) {
            std::ofstream out_f(fname, std::ios::binary);
 
            if (out_f) {
                // Copy the contents of the internal streambuf to the file
                out_f << data.rdbuf();
 
                // Close the file
                out_f.close();
            } else {
                // Throw an exception if the file could not be opened for writing
                throw_unimplemented(
                    "unimplemented case : could not open file " + fname + " for writing");
            }
        }
    };
 
    inline FortranIOFile load_fortran_file(const std::string &fname) {
        std::ifstream in_f(fname, std::ios::binary);
 
        std::basic_stringstream<byte> buffer;
        if (in_f) {
            buffer << in_f.rdbuf();
            in_f.close();
        } else {
            throw_unimplemented("unimplemented case : file not found");
        }
 
        return FortranIOFile(std::move(buffer), buffer.tellp());
    }
 
} // namespace shambase