ChkptPointFileReader Class Reference

Class to read particle and simulation data from a '.xml' file. More...

#include <ChkptPointFileReader.h>

Collaboration diagram for ChkptPointFileReader:

Public Member Functions
std::tuple< std::vector< Particle >, int >	readFile (const std::filesystem::path &filepath) const
	Reads particle data from a '.xml' file and returns a vector of particles. More...

Static Public Member Functions
static size_t	calculateHash (const std::filesystem::path &filepath)
	Calculates the hash for the given input file. More...
static bool	detectSourceFileChanges (const std::string &filepath)
	Checks if the given file contains a valid hash generated from the original input file. More...

Detailed Description

Class to read particle and simulation data from a '.xml' file.

Definition at line 10 of file ChkptPointFileReader.h.

Member Function Documentation

calculateHash()

size_t ChkptPointFileReader::calculateHash ( const std::filesystem::path &  filepath )

static

Calculates the hash for the given input file.

Parameters

filepath

Path to the input file to calculate the hash for

Each CheckPoint saves the hash of the original it was created from. This function calculates the hash of the given file.

Definition at line 43 of file ChkptPointFileReader.cpp.

                                                                            {
    if (!std::filesystem::exists(filepath)) {
        Logger::logger->warn("File '{}' does not exist. Using hash 0.", filepath.string());
        return 0;
    }
 
    std::ifstream input_file(filepath);
 
    if (!input_file.is_open()) {
        Logger::logger->error("Error: could not open file '{}'.", filepath.string());
        throw FileReader::FileFormatException("Could not open file");
    }
 
    auto buffer = std::stringstream();
    buffer << input_file.rdbuf();
 
    std::hash<std::string> hasher;
    auto hash = hasher(buffer.str());
    return hash;
}

detectSourceFileChanges()

bool ChkptPointFileReader::detectSourceFileChanges ( const std::string &  filepath )

static

Checks if the given file contains a valid hash generated from the original input file.

Parameters

filepath

Path of the checkpoint file to check

Each CheckPoint saves the hash of the original it was created from. This function checks if the original file still hashes to the same value. If not, the CheckPoint is invalid because it refers to a input file which has been changed since the CheckPoint was created.

Definition at line 64 of file ChkptPointFileReader.cpp.

                                                                            {
    auto checkpoint = CheckPoint(filepath, xml_schema::flags::dont_validate);
    auto meta_data = checkpoint->MetaData();
 
    std::ifstream input_file(meta_data.input_file());
 
    auto buffer = std::stringstream();
    buffer << input_file.rdbuf();
 
    std::hash<std::string> hasher;
    auto curr_hash = hasher(buffer.str());
 
    bool hash_valid = curr_hash == meta_data.input_file_hash();
 
    if (!hash_valid) {
        Logger::logger->warn("Source file '{}' has changed since last checkpoint. Original hash: {}, current hash: {}",
                             meta_data.input_file(), meta_data.input_file_hash(), curr_hash);
    }
 
    return hash_valid;
}

readFile()

std::tuple< std::vector< Particle >, int > ChkptPointFileReader::readFile

(

const std::filesystem::path &

filepath

)

const

Reads particle data from a '.xml' file and returns a vector of particles.

Parameters

filepath

Path to the file to read

Returns

A tuple containing a vector of particles and the iteration number

Definition at line 19 of file ChkptPointFileReader.cpp.

                                                                                                         {
    try {
        auto checkpoint = CheckPoint(filepath, xml_schema::flags::dont_validate);
 
        auto particle_data = checkpoint->ParticleData();
        auto meta_data = checkpoint->MetaData();
 
        summarizeMetadata(meta_data);
 
        std::vector<Particle> particles;
 
        for (auto xsd_particle : particle_data.particle()) {
            auto particle = XSDToInternalTypeAdapter::convertToParticle(xsd_particle);
            particles.push_back(std::move(particle));
        }
 
        return std::make_tuple(particles, meta_data.current_iteration());
    } catch (const xml_schema::exception& e) {
        std::stringstream error_message;
        error_message << "Error: could not parse file '" << filepath << "'.\n";
        error_message << e << std::endl;
        throw FileReader::FileFormatException(error_message.str());
    }
}

---

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

• ChkptPointFileReader.h
• ChkptPointFileReader.cpp