FileInputHandler Class Reference

Wrapper class to abstract the reading of input files. More...

#include <FileInputHandler.h>

Collaboration diagram for FileInputHandler:

Static Public Member Functions
static std::tuple< std::vector< Particle >, std::optional< SimulationParams > >	readFile (const std::filesystem::path &input_file_path, bool fresh=false, bool allow_recursion=true)
	Reads the input file and stores the particles in the given ParticleContainer. Other simulation parameters are returned as SimulationParams object. More...

Detailed Description

Wrapper class to abstract the reading of input files.

This class abstracts the reading and writing of files, so that the Simulation class does not have to know about the concrete implementations. Automatically determines correct file format using the file extension.

Definition at line 17 of file FileInputHandler.h.

Member Function Documentation

readFile()

std::tuple< std::vector< Particle >, std::optional< SimulationParams > > FileInputHandler::readFile ( const std::filesystem::path &  input_file_path, bool  fresh = false, bool  allow_recursion = true  )

static

Reads the input file and stores the particles in the given ParticleContainer. Other simulation parameters are returned as SimulationParams object.

Parameters

input_file_path	The path to the input file
fresh	Whether to start a fresh simulation or reuse cached data
allow_recursion	Whether to allow subsimulations to be started

Returns

std::tuple<std::vector<Particle>, std::optional<SimulationParams>> Tuple containing the particles and the parameters of the file

Reads the input file, generates particles and returns them in a vector. Parameters are stored in a SimulationParams object and returned. For more information about the output file formats, see Input File Formats

Definition at line 8 of file FileInputHandler.cpp.

                                                                                                                                {
    if (!std::filesystem::exists(input_file_path)) {
        Logger::logger->error("Error: file '{}' does not exist.", input_file_path.string());
        throw FileReader::FileFormatException("File does not exist");
    }
 
    std::string file_extension = input_file_path.extension().string();
 
    if (get_supported_input_file_extensions().find(file_extension) == get_supported_input_file_extensions().end()) {
        Logger::logger->error("Error: file extension '{}' is not supported.", file_extension);
        throw FileReader::FileFormatException("File extension is not supported");
    }
 
    std::unique_ptr<FileReader> file_reader;
 
    if (file_extension == ".xml") {
        file_reader = std::make_unique<XMLFileReader>(fresh, allow_recursion);
    } else {
        Logger::logger->error("Error: file extension '{}' is not supported.", file_extension);
        throw FileReader::FileFormatException("File extension is not supported");
    }
 
    try {
        auto [particles, config] = file_reader->readFile(input_file_path);
        Logger::logger->info("Loaded {} particles from file {}", particles.size(), input_file_path.string());
        return std::make_tuple(particles, config);
    } catch (const FileReader::FileFormatException& e) {
        Logger::logger->error("Error: file '{}' is not a valid {} file.", input_file_path.string(), file_extension);
        Logger::logger->error("FileFormatException:\n{}", std::string(e.what()));
        throw;
    }
}

---

The documentation for this class was generated from the following files:

• FileInputHandler.h
• FileInputHandler.cpp