TranslationTable.cpp

Go to the documentation of this file.

#include <TranslationTable.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/optional/optional.hpp>
#include <boost/filesystem.hpp>
#include <algorithm>
#include <iterator>
 
TranslationTable::TranslationTable(std::optional<std::stringstream> file) {
  if (file.has_value()) {
    boost::property_tree::read_json(file.value(), contents);
    styleProperties = parseStyles();
  } else {
    contents = {};
    styleProperties = {};
  }
}
 
TranslationTable::TranslationTable(const std::optional<boost::filesystem::path> &path) {
  if (path.has_value()) {
    if (!boost::filesystem::exists(path.value())) {
      throw std::invalid_argument(
          "No such file. [translationTablePath=" + path.value().string() + "]"
      );
    } else if (!boost::filesystem::is_regular_file(path.value())) {
      throw std::invalid_argument(
          "Translation-Table is not a file. [translationTablePath=" + path.value().string() + "]"
      );
    } else {
      boost::property_tree::read_json(path.value().string(), contents);
      styleProperties = parseStyles();
    }
  } else {
    contents = {};
    styleProperties = {};
  }
}
 
auto TranslationTable::printAll(std::ostream &out) const -> void {
  boost::property_tree::json_parser::write_json(out, contents);
}
 
auto TranslationTable::parseStyle(
    const boost::property_tree::ptree &style
) noexcept -> StyleProperties {
  const auto parseConstraintNode = [](const boost::property_tree::ptree &node) {
    std::unordered_set<std::string> fields;
    std::for_each(std::cbegin(node),
                  std::cend(node),
                  [&fields](const boost::property_tree::ptree::value_type &field) {
                    const std::string title = field.second.data();
                    if (!title.empty()) {
                      fields.insert(title);
                    }
                  });
    return fields;
  };
 
  const boost::optional<const boost::property_tree::ptree &> name =
      style.get_child_optional("name");
  const boost::optional<const boost::property_tree::ptree &> requiredFieldsNode =
      style.get_child_optional("requiredFields");
  const boost::optional<const boost::property_tree::ptree &> optionalFieldsNode =
      style.get_child_optional("optionalFields");
 
  return {name ? std::string{name.value().data()} : "",
          requiredFieldsNode ? parseConstraintNode(requiredFieldsNode.value())
                             : std::unordered_set<std::string>{},
          optionalFieldsNode ? parseConstraintNode(optionalFieldsNode.value())
                             : std::unordered_set<std::string>{}};
}
 
auto TranslationTable::parseStyles() const -> std::vector<StyleProperties> {
  std::vector<StyleProperties> props;
  const boost::optional<const boost::property_tree::ptree &> styles =
      contents.get_child_optional("styles");
  if (styles) {
    std::transform(std::cbegin(styles.value()),
                   std::cend(styles.value()),
                   std::back_inserter(props),
                   [this](const boost::property_tree::ptree::value_type &style) {
                     return this->parseStyle(style.second);
                   });
  } else {
    throw std::logic_error("Property \"styles\" not found in provided Translation-Table.");
  }
  return props;
}
 
auto TranslationTable::getStyleProperties() const noexcept -> const std::vector<StyleProperties> & {
  return styleProperties;
}
 
auto TranslationTable::stylePropertiesOf(
    const std::string &name
) const noexcept -> std::optional<StyleProperties> {
  const auto propItr = std::find_if(std::cbegin(styleProperties), std::cend(styleProperties),
                                    [&name](const StyleProperties &prop) { return prop.name == name; });
  return (propItr != std::cend(styleProperties)) ? std::optional(*propItr) : std::nullopt;
}
 
auto TranslationTable::stylePropertiesOf(
    const std::vector<std::string> &names
) const noexcept -> std::vector<StyleProperties> {
  if (names.empty()) return getStyleProperties();
  std::vector<StyleProperties> result;
  for (const auto &style : names) {
    const auto props = stylePropertiesOf(style);
    if (props) result.push_back(props.value());
  }
  return result;
}