Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines helpers for the Parser<T> class
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <algorithm>
      10             : #include <array>
      11             : #include <iomanip>
      12             : #include <list>
      13             : #include <map>
      14             : #include <memory>
      15             : #include <sstream>
      16             : #include <string>
      17             : #include <type_traits>
      18             : #include <unordered_set>
      19             : #include <utility>
      20             : #include <variant>
      21             : #include <vector>
      22             : 
      23             : #include "Options/Options.hpp"
      24             : #include "Utilities/CallWithDynamicType.hpp"
      25             : #include "Utilities/MakeString.hpp"
      26             : #include "Utilities/PrettyType.hpp"
      27             : #include "Utilities/Requires.hpp"
      28             : #include "Utilities/TMPL.hpp"
      29             : #include "Utilities/TypeTraits.hpp"
      30             : #include "Utilities/TypeTraits/IsA.hpp"
      31             : #include "Utilities/TypeTraits/IsInteger.hpp"
      32             : #include "Utilities/WrapText.hpp"
      33             : 
      34             : namespace Options::Options_detail {
      35             : 
      36             : template <typename Tag>
      37             : struct flatten_alternatives {
      38             :   using type = Tag;
      39             : };
      40             : 
      41             : template <typename... Tags>
      42             : struct flatten_alternatives<tmpl::list<Tags...>> {
      43             :   using type =
      44             :       tmpl::flatten<tmpl::list<typename flatten_alternatives<Tags>::type...>>;
      45             : };
      46             : 
      47             : template <typename... Tags>
      48             : struct flatten_alternatives<Options::Alternatives<Tags...>> {
      49             :   using type = tmpl::list<typename flatten_alternatives<Tags>::type...>;
      50             : };
      51             : 
      52             : // Traverses the group hierarchy of `Tag`, returning the topmost group that is
      53             : // a subgroup of `Root`. Directly returns `Tag` if it has no group.
      54             : // This means that the returned type is always the direct child node of `Root`
      55             : // that contains `Tag` in its hierarchy.
      56             : // If `Root` is not in the group hierarchy of `Tag`, this function returns the
      57             : // topmost group of `Tag` (meaning that `Root` is treated as the root of its
      58             : // group hierarchy).
      59             : template <typename Tag, typename Root, typename = std::void_t<>>
      60             : struct find_subgroup {
      61             :   using type = Tag;
      62             : };
      63             : 
      64             : template <typename Tag>
      65             : struct find_subgroup<Tag, typename Tag::group,
      66             :                      std::void_t<typename Tag::group>> {
      67             :   using type = Tag;
      68             : };
      69             : 
      70             : template <typename Tag, typename Root>
      71             : struct find_subgroup<Tag, Root, std::void_t<typename Tag::group>> {
      72             :   using type = typename find_subgroup<typename Tag::group, Root>::type;
      73             : };
      74             : 
      75             : /// Checks if `Tag` is within the group hierarchy of `Group`.
      76             : template <typename Tag, typename Group, typename = std::void_t<>>
      77             : struct is_in_group : std::false_type {};
      78             : 
      79             : template <typename Tag>
      80             : struct is_in_group<Tag, typename Tag::group, std::void_t<typename Tag::group>>
      81             :     : std::true_type {};
      82             : 
      83             : template <typename Tag, typename Group>
      84             : struct is_in_group<Tag, Group, std::void_t<typename Tag::group>>
      85             :     : is_in_group<typename Tag::group, Group> {};
      86             : 
      87             : /// The subset of tags in `OptionList` that are in the hierarchy of `Group`
      88             : template <typename OptionList, typename Group>
      89             : using options_in_group =
      90             :     tmpl::filter<OptionList, is_in_group<tmpl::_1, tmpl::pin<Group>>>;
      91             : 
      92             : // Display a type in a pseudo-YAML form, leaving out likely irrelevant
      93             : // information.
      94             : template <typename T>
      95             : struct yaml_type {
      96             :   static std::string value() { return pretty_type::name<T>(); }
      97             : };
      98             : 
      99             : template <typename T>
     100             : struct yaml_type<std::unique_ptr<T>> {
     101             :   static std::string value() { return yaml_type<T>::value(); }
     102             : };
     103             : 
     104             : template <typename T>
     105             : struct yaml_type<std::vector<T>> {
     106             :   static std::string value() { return "[" + yaml_type<T>::value() + ", ...]"; }
     107             : };
     108             : 
     109             : template <typename T>
     110             : struct yaml_type<std::list<T>> {
     111             :   static std::string value() { return "[" + yaml_type<T>::value() + ", ...]"; }
     112             : };
     113             : 
     114             : template <typename T, size_t N>
     115             : struct yaml_type<std::array<T, N>> {
     116             :   static std::string value() {
     117             :     return "[" + yaml_type<T>::value() + " x" + std::to_string(N) + "]";
     118             :   }
     119             : };
     120             : 
     121             : template <typename K, typename V, typename C>
     122             : struct yaml_type<std::map<K, V, C>> {
     123             :   static std::string value() {
     124             :     return "{" + yaml_type<K>::value() + ": " + yaml_type<V>::value() + "}";
     125             :   }
     126             : };
     127             : 
     128             : template <typename K, typename V, typename H, typename E>
     129             : struct yaml_type<std::unordered_map<K, V, H, E>> {
     130             :   static std::string value() {
     131             :     return "{" + yaml_type<K>::value() + ": " + yaml_type<V>::value() + "}";
     132             :   }
     133             : };
     134             : 
     135             : template <typename T, typename U>
     136             : struct yaml_type<std::pair<T, U>> {
     137             :   static std::string value() {
     138             :     return "[" + yaml_type<T>::value() + ", " + yaml_type<U>::value() + "]";
     139             :   }
     140             : };
     141             : 
     142             : template <typename... T>
     143             : struct yaml_type<std::variant<T...>> {
     144             :   static std::string value() {
     145             :     bool first = true;
     146             :     std::string result;
     147             :     const auto add_type = [&first, &result](auto alternative) {
     148             :       if (not first) {
     149             :         result += " or ";
     150             :       }
     151             :       first = false;
     152             :       result += yaml_type<tmpl::type_from<decltype(alternative)>>::value();
     153             :     };
     154             :     EXPAND_PACK_LEFT_TO_RIGHT(add_type(tmpl::type_<T>{}));
     155             :     return result;
     156             :   }
     157             : };
     158             : 
     159             : template <typename S, typename = std::void_t<>>
     160             : struct has_suggested : std::false_type {};
     161             : template <typename S>
     162             : struct has_suggested<
     163             :     S, std::void_t<decltype(std::declval<S>().suggested_value())>>
     164             :     : std::true_type {};
     165             : 
     166             : template <typename S, typename = std::void_t<>>
     167             : struct has_lower_bound : std::false_type {};
     168             : template <typename S>
     169             : struct has_lower_bound<S,
     170             :                        std::void_t<decltype(std::declval<S>().lower_bound())>>
     171             :     : std::true_type {};
     172             : 
     173             : template <typename S, typename = std::void_t<>>
     174             : struct has_upper_bound : std::false_type {};
     175             : template <typename S>
     176             : struct has_upper_bound<S,
     177             :                        std::void_t<decltype(std::declval<S>().upper_bound())>>
     178             :     : std::true_type {};
     179             : 
     180             : template <typename S, typename = std::void_t<>>
     181             : struct has_lower_bound_on_size : std::false_type {};
     182             : template <typename S>
     183             : struct has_lower_bound_on_size<
     184             :     S, std::void_t<decltype(std::declval<S>().lower_bound_on_size())>>
     185             :     : std::true_type {};
     186             : 
     187             : template <typename S, typename = std::void_t<>>
     188             : struct has_upper_bound_on_size : std::false_type {};
     189             : template <typename S>
     190             : struct has_upper_bound_on_size<
     191             :     S, std::void_t<decltype(std::declval<S>().upper_bound_on_size())>>
     192             :     : std::true_type {};
     193             : 
     194             : template <typename Tag>
     195             : std::string print_tag(const std::string& indent) {
     196             :   const std::string new_line = "\n" + indent + "  ";
     197             :   std::ostringstream ss;
     198             :   ss << indent << pretty_type::name<Tag>() << ":" << new_line
     199             :      << "type=" << yaml_type<typename Tag::type>::value();
     200             :   if constexpr (has_suggested<Tag>::value) {
     201             :     if constexpr (tt::is_a_v<std::unique_ptr, typename Tag::type>) {
     202             :       call_with_dynamic_type<
     203             :           void, typename Tag::type::element_type::creatable_classes>(
     204             :           Tag::suggested_value().get(), [&new_line, &ss](const auto* derived) {
     205             :             ss << new_line << "suggested=" << std::boolalpha
     206             :                << pretty_type::short_name<decltype(*derived)>();
     207             :           });
     208             :     } else {
     209             :       ss << new_line << "suggested="
     210             :          << (MakeString{} << std::boolalpha << Tag::suggested_value());
     211             :     }
     212             :   }
     213             :   if constexpr (has_lower_bound<Tag>::value) {
     214             :     ss << new_line << "min=" << (MakeString{} << Tag::lower_bound());
     215             :   }
     216             :   if constexpr (has_upper_bound<Tag>::value) {
     217             :     ss << new_line << "max=" << (MakeString{} << Tag::upper_bound());
     218             :   }
     219             :   if constexpr (has_lower_bound_on_size<Tag>::value) {
     220             :     ss << new_line << "min size=" << Tag::lower_bound_on_size();
     221             :   }
     222             :   if constexpr (has_upper_bound_on_size<Tag>::value) {
     223             :     ss << new_line << "max size=" << Tag::upper_bound_on_size();
     224             :   }
     225             :   ss << "\n" << wrap_text(Tag::help, 77, indent + "  ") << "\n\n";
     226             :   return ss.str();
     227             : }
     228             : 
     229             : template <typename OptionList, typename TagsAndSubgroups>
     230             : struct print;
     231             : 
     232             : template <typename Tag, typename OptionList>
     233             : struct print_impl {
     234             :   static std::string apply(const std::string& indent) {
     235             :     if constexpr (tmpl::list_contains_v<OptionList, Tag>) {
     236             :       return print_tag<Tag>(indent);
     237             :     } else {
     238             :       // A group
     239             :       std::ostringstream ss;
     240             :       ss << indent << pretty_type::name<Tag>() << ":\n"
     241             :          << wrap_text(Tag::help, 77, indent + "  ") << "\n\n";
     242             :       return ss.str();
     243             :     }
     244             :   }
     245             : };
     246             : 
     247             : template <typename... Alternatives>
     248             : std::string print_alternatives(const std::string& header,
     249             :                                const std::string& indent) {
     250             :   return (
     251             :       indent + header + "\n" + ... +
     252             :       (print<tmpl::list<Alternatives...>, Alternatives>::apply(indent + "  ")));
     253             : }
     254             : 
     255             : template <typename FirstAlternative, typename... OtherAlternatives,
     256             :           typename OptionList>
     257             : struct print_impl<Alternatives<FirstAlternative, OtherAlternatives...>,
     258             :                   OptionList> {
     259             :   static std::string apply(const std::string& indent) {
     260             :     return print_alternatives<FirstAlternative>("EITHER", indent) +
     261             :            print_alternatives<OtherAlternatives...>("OR", indent);
     262             :   }
     263             : };
     264             : 
     265             : template <typename OptionList, typename... TagsAndSubgroups>
     266             : struct print<OptionList, tmpl::list<TagsAndSubgroups...>> {
     267             :   static std::string apply(const std::string& indent) {
     268             :     return ("" + ... +
     269             :             (print_impl<TagsAndSubgroups, OptionList>::apply(indent)));
     270             :   }
     271             : };
     272             : 
     273             : template <typename T, typename Metavariables>
     274             : struct CreateWrapper {
     275             :   using metavariables = Metavariables;
     276             :   T data{};
     277             : };
     278           0 : #define CREATE_WRAPPER_FORWARD_OP(op)                          \
     279             :   template <typename T, typename Metavariables>                \
     280             :   bool operator op(const CreateWrapper<T, Metavariables>& a,   \
     281             :                    const CreateWrapper<T, Metavariables>& b) { \
     282             :     return a.data op b.data;                                   \
     283             :   }
     284             : CREATE_WRAPPER_FORWARD_OP(==)
     285             : CREATE_WRAPPER_FORWARD_OP(!=)
     286             : CREATE_WRAPPER_FORWARD_OP(<)
     287             : CREATE_WRAPPER_FORWARD_OP(>)
     288             : CREATE_WRAPPER_FORWARD_OP(<=)
     289             : CREATE_WRAPPER_FORWARD_OP(>=)
     290             : #undef CREATE_WRAPPER_FORWARD_OP
     291             : 
     292             : template <typename T, typename = std::nullptr_t>
     293             : struct wrap_create_types_impl;
     294             : 
     295             : template <typename T, typename Metavariables>
     296             : using wrap_create_types =
     297             :     typename wrap_create_types_impl<T>::template wrapped_type<Metavariables>;
     298             : 
     299             : template <typename T>
     300             : auto unwrap_create_types(T wrapped) {
     301             :   return wrap_create_types_impl<T>::unwrap(std::move(wrapped));
     302             : }
     303             : 
     304             : template <typename T, typename>
     305             : struct wrap_create_types_impl {
     306             :   template <typename Metavariables>
     307             :   using wrapped_type = CreateWrapper<T, Metavariables>;
     308             : };
     309             : 
     310             : template <typename T, typename Metavariables>
     311             : struct wrap_create_types_impl<CreateWrapper<T, Metavariables>> {
     312             :   // Never actually used, but instantiated during unwrapping
     313             :   template <typename /*Metavars*/>
     314             :   using wrapped_type = void;
     315             : 
     316             :   static T unwrap(CreateWrapper<T, Metavariables> wrapped) {
     317             :     return std::move(wrapped.data);
     318             :   }
     319             : };
     320             : 
     321             : template <typename T>
     322             : struct wrap_create_types_impl<
     323             :     T, Requires<std::is_fundamental_v<T> and not tt::is_integer_v<T>>> {
     324             :   template <typename Metavariables>
     325             :   using wrapped_type = T;
     326             : 
     327             :   static T unwrap(T wrapped) { return wrapped; }
     328             : };
     329             : 
     330             : // Classes convertible by yaml-cpp
     331             : template <>
     332             : struct wrap_create_types_impl<std::string> {
     333             :   template <typename Metavariables>
     334             :   using wrapped_type = std::string;
     335             : 
     336             :   static std::string unwrap(std::string wrapped) { return wrapped; }
     337             : };
     338             : 
     339             : template <typename K, typename V>
     340             : struct wrap_create_types_impl<std::map<K, V>> {
     341             :   template <typename Metavariables>
     342             :   using wrapped_type = std::map<wrap_create_types<K, Metavariables>,
     343             :                                 wrap_create_types<V, Metavariables>>;
     344             : 
     345             :   static auto unwrap(std::map<K, V> wrapped) {
     346             :     using UnwrappedK = decltype(unwrap_create_types<K>(std::declval<K>()));
     347             :     using UnwrappedV = decltype(unwrap_create_types<V>(std::declval<V>()));
     348             :     std::map<UnwrappedK, UnwrappedV> result;
     349             :     for (auto it = wrapped.begin(); it != wrapped.end();) {
     350             :       auto node = wrapped.extract(it++);
     351             :       result.emplace(unwrap_create_types<K>(std::move(node.key())),
     352             :                      unwrap_create_types<V>(std::move(node.mapped())));
     353             :     }
     354             :     return result;
     355             :   }
     356             : };
     357             : 
     358             : template <typename T>
     359             : struct wrap_create_types_impl<std::vector<T>> {
     360             :   template <typename Metavariables>
     361             :   using wrapped_type = std::vector<wrap_create_types<T, Metavariables>>;
     362             : 
     363             :   static auto unwrap(std::vector<T> wrapped) {
     364             :     using UnwrappedT = decltype(unwrap_create_types<T>(std::declval<T>()));
     365             :     std::vector<UnwrappedT> result;
     366             :     result.reserve(wrapped.size());
     367             :     for (auto& w : wrapped) {
     368             :       result.push_back(unwrap_create_types<T>(std::move(w)));
     369             :     }
     370             :     return result;
     371             :   }
     372             : };
     373             : 
     374             : template <typename T>
     375             : struct wrap_create_types_impl<std::list<T>> {
     376             :   template <typename Metavariables>
     377             :   using wrapped_type = std::list<wrap_create_types<T, Metavariables>>;
     378             : 
     379             :   static auto unwrap(std::list<T> wrapped) {
     380             :     using UnwrappedT = decltype(unwrap_create_types<T>(std::declval<T>()));
     381             :     std::list<UnwrappedT> result;
     382             :     for (auto& w : wrapped) {
     383             :       result.push_back(unwrap_create_types<T>(std::move(w)));
     384             :     }
     385             :     return result;
     386             :   }
     387             : };
     388             : 
     389             : template <typename T, size_t N>
     390             : struct wrap_create_types_impl<std::array<T, N>> {
     391             :   template <typename Metavariables>
     392             :   using wrapped_type = std::array<wrap_create_types<T, Metavariables>, N>;
     393             : 
     394             :   static auto unwrap(std::array<T, N> wrapped) {
     395             :     return unwrap_helper(std::move(wrapped), std::make_index_sequence<N>{});
     396             :   }
     397             : 
     398             :   template <size_t... Is>
     399             :   static auto unwrap_helper(std::array<T, N> wrapped,
     400             :                             std::integer_sequence<size_t, Is...> /*meta*/) {
     401             :     using UnwrappedT = decltype(unwrap_create_types<T>(std::declval<T>()));
     402             :     static_cast<void>(wrapped);  // Work around broken GCC warning
     403             :     return std::array<UnwrappedT, N>{
     404             :         {unwrap_create_types<T>(std::move(wrapped[Is]))...}};
     405             :   }
     406             : };
     407             : 
     408             : template <typename T, typename U>
     409             : struct wrap_create_types_impl<std::pair<T, U>> {
     410             :   template <typename Metavariables>
     411             :   using wrapped_type = std::pair<wrap_create_types<T, Metavariables>,
     412             :                                  wrap_create_types<U, Metavariables>>;
     413             : 
     414             :   static auto unwrap(std::pair<T, U> wrapped) {
     415             :     using UnwrappedT = decltype(unwrap_create_types<T>(std::declval<T>()));
     416             :     using UnwrappedU = decltype(unwrap_create_types<U>(std::declval<U>()));
     417             :     return std::pair<UnwrappedT, UnwrappedU>(
     418             :         unwrap_create_types<T>(std::move(wrapped.first)),
     419             :         unwrap_create_types<U>(std::move(wrapped.second)));
     420             :   }
     421             : };
     422             : }  // namespace Options::Options_detail