Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <optional>
       7             : #include <ostream>
       8             : #include <pup.h>
       9             : #include <pup_stl.h>
      10             : #include <string>
      11             : #include <utility>
      12             : #include <variant>
      13             : 
      14             : #include "Options/Options.hpp"
      15             : #include "Options/ParseError.hpp"
      16             : #include "Utilities/GetOutput.hpp"
      17             : #include "Utilities/PrettyType.hpp"
      18             : #include "Utilities/StdHelpers.hpp"
      19             : 
      20             : namespace Options {
      21             : /// The label representing the absence of a value for `Options::Auto`
      22           1 : namespace AutoLabel {
      23             : /// 'Auto' label
      24           1 : struct Auto {};
      25             : /// 'None' label
      26           1 : struct None {};
      27             : /// 'All' label
      28           1 : struct All {};
      29             : }  // namespace AutoLabel
      30             : 
      31             : /// \ingroup OptionParsingGroup
      32             : /// \brief A class indicating that a parsed value can be automatically
      33             : /// computed instead of specified.
      34             : ///
      35             : /// When an `Auto<T>` is parsed from an input file, the value may be specified
      36             : /// either as the `AutoLabel` (defaults to "Auto") or as a value of type `T`.
      37             : /// When this class is passed to the constructor of the class taking it as an
      38             : /// option, it can be implicitly converted to a `std::optional<U>`, for any
      39             : /// type `U` implicitly creatable from a `T`.
      40             : ///
      41             : /// \snippet Test_Auto.cpp example_class
      42             : /// \snippet Test_Auto.cpp example_create
      43             : template <typename T, typename Label = AutoLabel::Auto>
      44           1 : class Auto {
      45             :  public:
      46           0 :   using value_type = std::optional<T>;
      47             : 
      48           0 :   Auto() = default;
      49           0 :   explicit Auto(T value) : value_(std::move(value)) {}
      50             : 
      51             :   // NOLINTNEXTLINE(google-explicit-constructor)
      52             :   template <typename U>
      53             :   operator std::optional<U>() && {
      54             :     return std::move(value_);
      55             :   }
      56             : 
      57           0 :   void pup(PUP::er& p) { p | value_; }
      58             : 
      59             :   // NOLINTNEXTLINE(google-explicit-constructor)
      60           0 :   operator const value_type&() const { return value_; }
      61             : 
      62             :  private:
      63           0 :   value_type value_{};
      64             : };
      65             : 
      66             : template <typename T, typename Label>
      67           0 : bool operator==(const Auto<T, Label>& a, const Auto<T, Label>& b) {
      68             :   return static_cast<const std::optional<T>&>(a) ==
      69             :          static_cast<const std::optional<T>&>(b);
      70             : }
      71             : 
      72             : template <typename T, typename Label>
      73           0 : bool operator!=(const Auto<T, Label>& a, const Auto<T, Label>& b) {
      74             :   return not(a == b);
      75             : }
      76             : 
      77             : template <typename T, typename Label>
      78           0 : std::ostream& operator<<(std::ostream& os, const Auto<T, Label>& x) {
      79             :   const std::optional<T>& value = x;
      80             :   if (value) {
      81             :     return os << get_output(*value);
      82             :   } else {
      83             :     return os << pretty_type::name<Label>();
      84             :   }
      85             : }
      86             : 
      87             : namespace Auto_detail {
      88             : template <typename Label>
      89             : struct AutoLabel {};
      90             : }  // namespace Auto_detail
      91             : 
      92             : template <typename Label>
      93             : struct create_from_yaml<Auto_detail::AutoLabel<Label>> {
      94             :   template <typename Metavariables>
      95             :   static Auto_detail::AutoLabel<Label> create(const Option& options) {
      96             :     const auto label_string = pretty_type::name<Label>();
      97             :     try {
      98             :       if (options.parse_as<std::string>() == label_string) {
      99             :         return {};
     100             :       }
     101             :     } catch (...) {
     102             :       // The node failed to parse as a string.  It is not the Label.
     103             :     }
     104             :     // The error if the std::variant parse fails will print the value
     105             :     // from the input file (and the T parse probably will too), so we
     106             :     // don't need to print it again.
     107             :     PARSE_ERROR(options.context(),
     108             :                 "Failed to parse as Auto label \"" << label_string << "\"");
     109             :   }
     110             : };
     111             : 
     112             : template <typename T, typename Label>
     113           0 : struct create_from_yaml<Auto<T, Label>> {
     114             :   template <typename Metavariables>
     115           0 :   static Auto<T, Label> create(const Option& options) {
     116             :     auto parsed_variant =
     117             :         options.parse_as<std::variant<Auto_detail::AutoLabel<Label>, T>,
     118             :                          Metavariables>();
     119             :     if (std::holds_alternative<T>(parsed_variant)) {
     120             :       return Auto<T, Label>{std::move(std::get<T>(parsed_variant))};
     121             :     } else {
     122             :       return Auto<T, Label>{};
     123             :     }
     124             :   }
     125             : };
     126             : }  // namespace Options