Option.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <iterator>
#include <map>
#include <set>
#include <string>
#include <type_traits>
#include <vector>
 
#include "autopas/utils/StringUtils.h"
 
namespace autopas {
inline namespace options {
template <typename actualOption_T>
class Option {
 public:
  explicit operator bool() = delete;
 
  static std::set<actualOption_T> getAllOptions() {
    const auto mapOptionNames = actualOption_T::getOptionNames();
    std::set<actualOption_T> retSet;
    std::for_each(mapOptionNames.begin(), mapOptionNames.end(),
                  [&](auto pairOpStr) { retSet.insert(pairOpStr.first); });
    return retSet;
  };
 
  static std::set<actualOption_T> getMostOptions() {
    const auto allOptions = getAllOptions();
    const auto discouragedOptions = actualOption_T::getDiscouragedOptions();
    std::set<actualOption_T> retSet;
    std::set_difference(allOptions.begin(), allOptions.end(), discouragedOptions.begin(), discouragedOptions.end(),
                        std::inserter(retSet, retSet.begin()));
    return retSet;
  }
 
  [[nodiscard]] std::string to_string(bool fixedLength = false) const {
    const auto &actualThis = *static_cast<const actualOption_T *>(this);
    const auto mapOptNames = actualOption_T::getOptionNames();  // <- not copying the map destroys the strings
    const auto match = mapOptNames.find(actualThis);
    if (match == mapOptNames.end()) {
      return "Unknown Option (" + std::to_string(actualThis) + ")";
    } else {
      std::string result = match->second;
      if (fixedLength) {
        result.resize(maxStringLength(), ' ');
      }
      return result;
    }
  }
 
  [[nodiscard]] static size_t maxStringLength() {
    static size_t maxLength = 0;
    if (maxLength == 0) {
      for (const auto &[_, name] : actualOption_T::getOptionNames()) {
        maxLength = std::max(maxLength, name.size());
      }
    }
    return maxLength;
  }
 
  template <class OutputContainer = std::set<actualOption_T>>
  static OutputContainer parseOptions(const std::string &optionsString) {
    const auto needles = autopas::utils::StringUtils::tokenize(optionsString, autopas::utils::StringUtils::delimiters);
 
    // Shorthand to get everything
    if (needles.size() == 1 and needles.front() == "all") {
      if constexpr (std::is_same_v<OutputContainer, std::set<actualOption_T>>) {
        return actualOption_T::getAllOptions();
      } else {
        const auto allOptionsSet = actualOption_T::getAllOptions();
        OutputContainer allOptionsOut;
        std::copy(allOptionsSet.begin(), allOptionsSet.end(),
                  std::insert_iterator(allOptionsOut, allOptionsOut.begin()));
        return allOptionsOut;
      }
    }
 
    // create a map of enum -> string with lowercase enums as a lookup and fill strings in the haystack
    std::map<std::string, actualOption_T> allOptionNamesLower;
    std::vector<std::string> haystack;
    for (auto &[optionEnum, optionString] : actualOption_T::getOptionNames()) {
      std::transform(optionString.begin(), optionString.end(), optionString.begin(), ::tolower);
      allOptionNamesLower.emplace(optionString, optionEnum);
      haystack.push_back(optionString);
    }
 
    // convert all needles to options.
    OutputContainer foundOptions;
    std::transform(needles.begin(), needles.end(), std::insert_iterator(foundOptions, foundOptions.begin()),
                   [&](const auto &needle) {
                     // first find the best matching string
                     const auto matchingString = autopas::utils::StringUtils::matchStrings(haystack, needle);
                     // then find the corresponding enum and add it to the return set
                     return allOptionNamesLower[matchingString];
                   });
 
    return foundOptions;
  }
 
  template <bool lowercase = false>
  static actualOption_T parseOptionExact(const std::string &optionString) {
    for (auto [optionEnum, optionName] : actualOption_T::getOptionNames()) {
      if constexpr (lowercase) {
        std::transform(std::begin(optionName), std::end(optionName), std::begin(optionName), ::tolower);
      }
      if (optionString == optionName) {
        return optionEnum;
      }
    }
 
    // the end of the function should not be reached
    utils::ExceptionHandler::exception("Option::parseOptionExact() no match found for: {}", optionString);
    return actualOption_T();
  }
 
  friend std::ostream &operator<<(std::ostream &os, const Option &option) {
    os << option.to_string();
    return os;
  }
 
  friend std::istream &operator>>(std::istream &in, actualOption_T &option) {
    // Buffer for the current char.
    char c = ' ';
    // Skip any leading whitespace
    while (std::iswspace(c)) {
      in.get(c);
    }
    // String that is parsed.
    std::string str{c};
    // Concat c to str until an unexpected char is encountered
    do {
      in.get(c);
      str.push_back(c);
    } while (std::isalnum(c) or c == '_' or c == '-');  // This assumes that an option only contains alphanum, _, or -.
    // Pop the last char which is an undesired one.
    str.pop_back();
 
    // Actual parsing.
    option = parseOptionExact(str);
    return in;
  }
};
 
template <typename actualOption_T>
inline std::string format_as(const Option<actualOption_T> &opt) {
  return opt.to_string();
}
 
}  // namespace options
}  // namespace autopas