toml_file_importer.h

[詳解]

 
 
// Copyright(c) 2023-2025 Design Engineering Laboratory, Saitama University
// Released under the MIT license
// https://opensource.org/licenses/mit-license.php
 
#ifndef DESIGNLAB_TOML_FILE_IMPORTER_H_
#define DESIGNLAB_TOML_FILE_IMPORTER_H_
 
#include <concepts>
#include <filesystem>
#include <fstream>
#include <memory>
#include <optional>
#include <string>
#include <utility>
 
#include "cmdio_util.h"
#include "implicit_metafunction_for_toml11.h"
#include "interface_toml_data_validator.h"
#include "my_expected.h"
#include "toml_data_validator_always_true.h"
#include "toml_file_exporter.h"
 
namespace designlab {
 
template <typename T>
concept HasFromToml =
    std::is_default_constructible_v<T> && impl::has_from_toml<T>::value;
 
template <HasFromToml T>
class TomlFileImporter final {
 public:
  TomlFileImporter()
      : validator_(std::make_unique<TomlDataValidatorAlwaysTrue<T>>()) {}
 
  explicit TomlFileImporter(std::unique_ptr<ITomlDataValidator<T>>&& validator)
      : validator_(std::move(validator)) {}
 
  std::optional<T> Import(const std::string& file_path) const {
    if (do_output_message_) {
      cmdio::OutputNewLine(1, OutputDetail::kSystem);
      cmdio::SystemOutput("Loads a file. file_path : " + file_path);
    }
 
    if (!FileIsExist(file_path)) {
      return std::nullopt;
    }
 
    toml::value toml_value;
 
    if (!ParseTomlFile(file_path, &toml_value)) {
      return std::nullopt;
    }
 
    T data;
 
    if (!SerializeTomlData(&toml_value, &data)) {
      return std::nullopt;
    }
 
    if (!ValidateData(data)) {
      return std::nullopt;
    }
 
    if (do_output_message_) {
      cmdio::SystemOutput("Loading completed successfully.");
      cmdio::OutputNewLine(1, OutputDetail::kSystem);
    }
 
    return data;
  }
 
  T ImportOrUseDefault(const std::string& file_path) const {
    const auto data = Import(file_path);
 
    if (data.has_value()) {
      return data.value();
    }
 
    if (cmdio::InputYesNo("Do you want to output a default file?")) {
      TomlFileExporter<T> exporter;
      exporter.Export(file_path, T());
    }
 
    cmdio::SystemOutput("Use default data.");
    cmdio::OutputNewLine(1, OutputDetail::kSystem);
 
    return T();
  }
 
 private:
  bool FileIsExist(const std::string& file_path) const {
    if (do_output_message_) {
      cmdio::InfoOutput("Check if the file exists. ");
    }
 
    if (!std::filesystem::exists(file_path)) {
      if (do_output_message_) {
        cmdio::ErrorOutput("The file does not exist.");
        cmdio::OutputNewLine(1, OutputDetail::kError);
      }
 
      return false;
    }
 
    if (do_output_message_) {
      cmdio::InfoOutput("The file found.");
    }
 
    return true;
  }
 
  bool ParseTomlFile(const std::string& file_path,
                     toml::value* toml_value) const {
    if (do_output_message_) {
      cmdio::InfoOutput("Start parsing.");
    }
 
    try {
      // バイナリモードで読み込む.
      std::ifstream ifs(file_path, std::ios::binary);
 
      *toml_value = toml::parse(ifs, file_path);
    } catch (toml::syntax_error err) {
      if (do_output_message_) {
        cmdio::ErrorOutput("File parsing failed.");
        cmdio::OutputNewLine(1, OutputDetail::kError);
        cmdio::ErrorOutput("< Rows that failed to parse >");
        cmdio::ErrorOutput(err.what());
        cmdio::OutputNewLine(1, OutputDetail::kError);
      }
 
      return false;
    }
 
    if (do_output_message_) {
      cmdio::InfoOutput("File parsing succeeded.");
    }
 
    return true;
  }
 
  bool SerializeTomlData(toml::value* toml_value, T* data) const {
    if (do_output_message_) {
      cmdio::InfoOutput("Serialize data.");
    }
 
    try {
      *data = toml::from<T>::from_toml(*toml_value);
    } catch (...) {
      if (do_output_message_) {
        cmdio::ErrorOutput("Data serialization failed.");
        cmdio::OutputNewLine(1, OutputDetail::kError);
      }
 
      return false;
    }
 
    if (do_output_message_) {
      cmdio::InfoOutput("Data serialization succeeded.");
    }
 
    return true;
  }
 
  bool ValidateData(const T& data) const {
    if (do_output_message_) {
      cmdio::InfoOutput("Start data validation.");
    }
 
    const auto [is_valid, error_message] = validator_->Validate(data);
 
    if (!is_valid) {
      if (do_output_message_) {
        cmdio::ErrorOutput("Data validation failed.");
        cmdio::OutputNewLine(1, OutputDetail::kError);
        cmdio::ErrorOutput("<Reasons for Failure to Verify>");
        cmdio::ErrorOutput(error_message);
        cmdio::OutputNewLine(1, OutputDetail::kError);
      }
 
      return false;
    }
 
    if (do_output_message_) {
      cmdio::InfoOutput("Data validation succeeded.");
    }
 
    return true;
  }
 
  bool do_output_message_{true};
 
  const std::unique_ptr<ITomlDataValidator<T>> validator_;
};
 
}  // namespace designlab
 
#endif  // DESIGNLAB_TOML_FILE_IMPORTER_H_