Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines classes and functions for making classes creatable from
       6             : /// input files.
       7             : 
       8             : #pragma once
       9             : 
      10             : #include <memory>
      11             : #include <string>
      12             : #include <type_traits>
      13             : 
      14             : #include "Options/Context.hpp"
      15             : #include "Utilities/NoSuchType.hpp"
      16             : #include "Utilities/TMPL.hpp"
      17             : #include "Utilities/TypeTraits/IsA.hpp"
      18             : 
      19             : /// \cond
      20             : namespace YAML {
      21             : class Node;
      22             : }  // namespace YAML
      23             : /// \endcond
      24             : 
      25             : /// Utilities for parsing input files.
      26             : namespace Options {
      27             : /// \ingroup OptionParsingGroup
      28             : /// The type that options are passed around as.  Contains YAML node
      29             : /// data and an Context.
      30             : ///
      31             : /// \note To use any methods on this class in a concrete function you
      32             : /// must include ParseOptions.hpp, but you do *not* need to include
      33             : /// that header to use this in an uninstantiated
      34             : /// `create_from_yaml::create` function.
      35           1 : class Option {
      36             :  public:
      37           0 :   const Context& context() const;
      38             : 
      39             :   /// Append a line to the contained context.
      40           1 :   void append_context(const std::string& context);
      41             : 
      42             :   /// Convert to an object of type `T`.
      43             :   template <typename T, typename Metavariables = NoSuchType>
      44           1 :   T parse_as() const;
      45             : 
      46             :   /// \note This constructor overwrites the mark data in the supplied
      47             :   /// context with the one from the node.
      48             :   ///
      49             :   /// \warning This method is for internal use of the option parser.
      50           1 :   explicit Option(YAML::Node node, Context context = {});
      51             : 
      52             :   /// \warning This method is for internal use of the option parser.
      53           1 :   explicit Option(Context context);
      54             : 
      55             :   /// \warning This method is for internal use of the option parser.
      56           1 :   const YAML::Node& node() const;
      57             : 
      58             :   /// Sets the node and updates the context's mark to correspond to it.
      59             :   ///
      60             :   /// \warning This method is for internal use of the option parser.
      61           1 :   void set_node(YAML::Node node);
      62             : 
      63             :  private:
      64           0 :   std::unique_ptr<YAML::Node> node_;
      65           0 :   Context context_;
      66             : };
      67             : 
      68             : /// \ingroup OptionParsingGroup
      69             : /// Used by the parser to create an object.  The default action is to
      70             : /// parse options using `T::options`.  This struct may be specialized
      71             : /// to change that behavior for specific types.
      72             : ///
      73             : /// Do not call create directly.  Use Option::parse_as instead.
      74             : template <typename T>
      75           1 : struct create_from_yaml {
      76             :   template <typename Metavariables>
      77           0 :   static T create(const Option& options);
      78             : };
      79             : 
      80             : /// Provide multiple ways to construct a class.
      81             : ///
      82             : /// This type may be included in an option list along with option
      83             : /// tags.  When creating the class, the parser will choose one of the
      84             : /// lists of options to use, depending on the user input.
      85             : ///
      86             : /// The class must be prepared to accept any of the possible
      87             : /// alternatives as arguments to its constructor.  To disambiguate
      88             : /// multiple alternatives with the same types, a constructor may take
      89             : /// the full list of option tags expected as its first argument.
      90             : ///
      91             : /// \snippet Test_Options.cpp alternatives
      92             : template <typename... AlternativeLists>
      93           1 : struct Alternatives {
      94             :   static_assert(sizeof...(AlternativeLists) >= 1,
      95             :                 "Option alternatives must provide at least one alternative.");
      96             :   static_assert(
      97             :       tmpl::all<tmpl::list<tt::is_a<tmpl::list, AlternativeLists>...>>::value,
      98             :       "Option alternatives must be given as tmpl::lists.");
      99             :   static_assert(
     100             :       tmpl::none<
     101             :           tmpl::list<std::is_same<tmpl::list<>, AlternativeLists>...>>::value,
     102             :       "All option alternatives must have at least one option.");
     103             : };
     104             : }  // namespace Options