Parser.cpp

Go to the documentation of this file.

#include <boost/filesystem/path.hpp>
#include <GlobalParserState.hpp>
#include <ParserException.hpp>
#include <Parser.hpp>
#include <algorithm>
#include <numeric>
 
using namespace std::literals::string_literals;
 
Parser::Parser(
    const std::optional<boost::filesystem::path> &ruleFilePath,
    std::vector<std::string> targetStyles,
    const bool allowAll
) : targetStyles(std::move(targetStyles)),
    translationTable(TranslationTable(ruleFilePath)),
    allowAll{allowAll} {}
 
Parser::Parser(
    std::optional<std::stringstream> ruleFileContents,
    std::vector<std::string> targetStyles,
    const bool allowAll
) : targetStyles(std::move(targetStyles)),
    translationTable(TranslationTable(std::move(ruleFileContents))),
    allowAll{allowAll} {}
 
auto Parser::generate(
    const boost::filesystem::path &inputPath,
    const std::optional<std::string> &sorting
) const -> std::vector<BibElement> {
  if (!boost::filesystem::exists(inputPath)) {
    throw std::invalid_argument("No such file or directory. [path=" + inputPath.string() + "]");
  } else if (boost::filesystem::is_directory(inputPath)) {
    std::vector<BibElement> collector{};
    for (const auto &file : boost::filesystem::directory_iterator(inputPath)) {
      std::ifstream inFile{file.path().string()};
      inFile >> std::noskipws;
      std::string inContent{std::istream_iterator<char>{inFile}, std::istream_iterator<char>{}};
      for (const auto &element : generate(std::string_view(inContent), sorting, inputPath.string())) {
        collector.push_back(element);
      }
    }
    if (sorting) sortElements(collector, sorting.value());
    return collector;
  } else if (boost::filesystem::is_regular_file(inputPath)) {
    std::ifstream inFile{inputPath.string()};
    inFile >> std::noskipws;
    std::string inContent{std::istream_iterator<char>{inFile}, std::istream_iterator<char>{}};
    auto elements = generate(std::string_view(inContent), sorting, inputPath.string());
    if (sorting) sortElements(elements, sorting.value());
    return elements;
  } else {
    throw std::invalid_argument("Unexpected file-descriptor. [path=" + inputPath.string() + "]");
  }
}
 
auto Parser::generate(
    std::string_view inputFileContent,
    const std::optional<std::string> &sorting,
    const std::string &filename
) const -> std::vector<BibElement> {
  const std::vector<StyleProperties> targetStructures = translationTable.stylePropertiesOf(targetStyles);
  std::vector<BibElement> parsedElements = Parser::elementsOf(inputFileContent, filename);
  if (allowAll) {
    if (sorting) sortElements(parsedElements, sorting.value());
    return parsedElements;
  } else if (targetStructures.empty()) {
    return {};
  } else {
    auto filteredElements = filterElements(parsedElements, targetStructures);
    if (sorting) sortElements(filteredElements, sorting.value());
    return filteredElements;
  }
}
 
auto Parser::elementsOf(
    std::string_view input,
    const std::string &filename
) -> std::vector<BibElement> {
  ParserContext context(filename);
  std::vector<BibElement> result;
  try {
    delete std::accumulate<std::string_view::iterator, ParserState *>(
        std::cbegin(input),
        std::cend(input),
        new GlobalParserState{context, result},
        [&context](ParserState *const acc, const char it) -> ParserState * {
          ++context.column;
          if (it == '\n') {
            ++context.line;
            context.column = 0;
            return acc;
          }
          return acc->handleCharacter(it);
        });
    return result;
  } catch (ParserException &e) {
    delete e.state;
    throw std::runtime_error(e.what());
  }
}
 
auto Parser::sortElements(std::vector<BibElement> &elements, const std::string &sorting) noexcept -> void {
  std::sort(
      std::begin(elements),
      std::end(elements),
      [&sorting](const BibElement &l, const BibElement &r) {
        return l.findAttribute(sorting).value_or<Field>({""s, ""s}).value
            < r.findAttribute(sorting).value_or<Field>({""s, ""s}).value;
      }
  );
}
 
auto Parser::generate(
    const std::vector<boost::filesystem::path> &inputPaths,
    const std::optional<std::string> &sorting
) const -> std::vector<BibElement> {
  std::vector<BibElement> parsedElements;
  std::for_each(
      std::cbegin(inputPaths),
      std::cend(inputPaths),
      [this, &parsedElements, &sorting](const boost::filesystem::path &p) {
        const auto elements = generate(p, sorting);
        parsedElements.insert(std::end(parsedElements), std::cbegin(elements), std::cend(elements));
      }
  );
  if (sorting) sortElements(parsedElements, sorting.value());
  return parsedElements;
}
 
auto Parser::filterElements(
    const std::vector<BibElement> &elements,
    const std::vector<StyleProperties> &props
) noexcept -> std::vector<BibElement> {
  std::vector<BibElement> filteredElements{};
  std::copy_if(
      std::cbegin(elements),
      std::cend(elements),
      std::back_inserter(filteredElements),
      [&props](const BibElement &element) {
        return std::find_if(
            std::cbegin(props),
            std::cend(props),
            [&](const StyleProperties &prop) {
              return element.isCompliantTo(prop);
            }
        ) != std::cend(props);
      }
  );
  return filteredElements;
}