Options::Auto< T, Label > Class Template Reference

A class indicating that a parsed value can be automatically computed instead of specified. More...

#include <Auto.hpp>

Public Types
using	value_type = std::optional<T>

Public Member Functions
	Auto (T value)
void	pup (PUP::er &p)
	operator const value_type & () const

Detailed Description

template<typename T, typename Label = AutoLabel::Auto>
class Options::Auto< T, Label >

A class indicating that a parsed value can be automatically computed instead of specified.

When an Auto<T> is parsed from an input file, the value may be specified either as the AutoLabel (defaults to "Auto") or as a value of type T. When this class is passed to the constructor of the class taking it as an option, it can be implicitly converted to a std::optional<U>, for any type U implicitly creatable from a T.

class ExampleClass {
 public:
  ExampleClass() = default;
 
  struct AutoArg {
    using type = Options::Auto<int>;
    static type suggested_value() { return {}; }
    static constexpr Options::String help =
        "Integer that can be automatically chosen";
  };
  struct OptionalArg {
    using type = Options::Auto<double, Options::AutoLabel::None>;
    static constexpr Options::String help = "Optional parameter";
  };
  struct AllArg {
    using type = Options::Auto<std::vector<int>, Options::AutoLabel::All>;
    static constexpr Options::String help = "Optional parameter all";
  };
 
  static constexpr Options::String help =
      "A class that can automatically choose an argument";
  using options = tmpl::list<AutoArg, OptionalArg, AllArg>;
 
  explicit ExampleClass(std::optional<int> auto_arg,
                        std::optional<double> opt_arg,
                        std::optional<std::vector<int>> all_arg)
      : value(auto_arg ? *auto_arg : -12),
        optional_value(opt_arg),
        all_value(all_arg) {}
 
  int value{};
  std::optional<double> optional_value{};
  std::optional<std::vector<int>> all_value{};
};

  const auto example1 = TestHelpers::test_creation<ExampleClass>(
      "AutoArg: 7\n"
      "OptionalArg: 10.\n"
      "AllArg: [0, 1, 2]");
  CHECK(example1.value == 7);
  CHECK(example1.optional_value == 10.);
  CHECK(example1.all_value == std::vector<int>{{0, 1, 2}});
  const auto example2 = TestHelpers::test_creation<ExampleClass>(
      "AutoArg: Auto\n"
      "OptionalArg: None\n"
      "AllArg: [0, 1, 2]");
  CHECK(example2.value == -12);
  CHECK(example2.optional_value == std::nullopt);
  CHECK(example2.all_value == std::vector<int>{{0, 1, 2}});
  const auto example3 = TestHelpers::test_creation<ExampleClass>(
      "AutoArg: 7\n"
      "OptionalArg: 10.\n"
      "AllArg: All");
  CHECK(example3.value == 7);
  CHECK(example3.optional_value == 10.);
  CHECK(example3.all_value == std::nullopt);

---

The documentation for this class was generated from the following file:

• src/Options/Auto.hpp