CommandLine.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "MooseError.h"
#include "Conversion.h"
#include "MooseEnum.h"
#include "InputParameters.h"
#include "MooseUtils.h"
 
#include <list>
#include <string>
#include <map>
#include <memory>
#include <set>
#include <optional>
#include <regex>
 
class CommandLine
{
public:
  using ArgumentType = InputParameters::CommandLineMetadata::ArgumentType;
  struct Entry
  {
    std::string name;
    std::optional<std::string> subapp_name;
    std::optional<std::string> value;
    std::optional<std::string> value_separator;
    std::vector<std::string> raw_args;
    bool used = false;
    bool global = false;
    bool hit_param = false;
  };
 
  struct CommandLineParam
  {
    std::string description;
    InputParameters::CommandLineMetadata metadata;
  };
 
  CommandLine();
  CommandLine(int argc, char * argv[]);
  CommandLine(const std::vector<std::string> & args);
  virtual ~CommandLine();
 
  void addArguments(int argc, char * argv[]);
  void addArgument(const std::string & arg);
  void addArguments(const std::vector<std::string> & args);
 
  bool hasArgument(const std::string & arg) const;
 
  void removeArgument(const std::string & arg);
 
  void parse();
 
  bool hasParsed() const { return _has_parsed; }
 
  std::unique_ptr<CommandLine>
  initSubAppCommandLine(const std::string & multiapp_name,
                        const std::string & subapp_name,
                        const std::vector<std::string> & input_cli_args,
                        const std::set<std::string> & exclude_params = {});
 
  std::vector<std::string> buildHitParams();
 
  const std::vector<std::string> & getArguments() { return _argv; }
 
  void populateCommandLineParams(InputParameters & params);
 
  auto begin() const { return _entries.begin(); }
  auto end() const { return _entries.end(); }
 
  const std::list<Entry> & getEntries() const;
 
  std::string getExecutableName() const;
 
  std::string getExecutableNameBase() const;
 
  void printUsage() const;
 
  std::vector<std::string> unusedHitParams(const Parallel::Communicator & comm) const;
 
  std::list<Entry>::const_iterator findCommandLineParam(const std::string & name) const;
 
  std::string formatEntry(const Entry & entry) const;
 
private:
  std::list<Entry> & getEntries();
 
  template <typename T>
  void setCommandLineParam(std::list<Entry>::iterator entry_it,
                           const CommandLineParam & param,
                           const std::string & cli_switch,
                           T & value);
 
  std::list<Entry>::iterator findCommandLineParam(const std::string & name);
 
  std::vector<std::string> _argv;
 
  std::list<Entry> _entries;
 
  std::map<std::string, CommandLineParam> _command_line_params;
 
  bool _has_parsed = false;
  bool _command_line_params_populated = false;
  bool _hit_params_built = false;
};
 
template <typename T>
void
CommandLine::setCommandLineParam(std::list<CommandLine::Entry>::iterator entry_it,
                                 const CommandLineParam & param,
                                 const std::string & cli_switch,
                                 T & value)
{
  auto & entry = *entry_it;
  const auto required = param.metadata.argument_type == ArgumentType::REQUIRED;
 
  // Mark this entry as used
  entry.used = true;
 
  // Option doesn't have any arguments (boolean)
  if constexpr (std::is_same_v<bool, T>)
  {
    mooseAssert(param.metadata.argument_type == ArgumentType::NONE, "Incorrect argument type");
 
    if (entry.value)
      mooseError("The command line option '",
                 cli_switch,
                 "' is a boolean and does not support a value but the value '",
                 *entry.value,
                 "' was provided.\nDoc string: ",
                 param.description);
    value = true;
  }
  // Option has arguments
  else
  {
    mooseAssert(param.metadata.argument_type != ArgumentType::NONE, "Incorrect argument type");
 
    // Helper for setting a value depending on its type and also throwing a useful
    // error when the conversion fails
    const auto set_value = [&cli_switch](const std::string & from, auto & value)
    {
      using type = typename std::remove_reference<decltype(value)>::type;
 
      // Keep track of and change the throw on error characteristics so that
      // we can catch parsing errors for the argument
      const auto throw_on_error_orig = Moose::_throw_on_error;
      Moose::_throw_on_error = true;
 
      try
      {
        if constexpr (std::is_same_v<type, std::string> || std::is_same_v<type, MooseEnum>)
          value = from;
        else
          value = MooseUtils::convert<type>(from, true);
      }
      catch (std::exception & e)
      {
        Moose::_throw_on_error = throw_on_error_orig;
        mooseError("While parsing command line option '",
                   cli_switch,
                   "' with value '",
                   from,
                   "':\n\n",
                   e.what());
      }
 
      Moose::_throw_on_error = throw_on_error_orig;
    };
 
    // If a value doesn't exist, check the next argument to see if it
    // would work. This is needed for when we have argument values that
    // have = signs that get split. For example:
    // "--required-capabilities 'petsc>=3.11'" would get split into:
    //   - "--required-capabilities" with no value
    //   - "petsc>" with value "3.11"
    // which we want to re-combine into
    //   - "--required-capabilities" with value "petsc>=3.11"
    if (!entry.value)
    {
      auto next_entry_it = std::next(entry_it);
      if (next_entry_it != _entries.end())
      {
        const auto & next_entry = *next_entry_it;
        if (!next_entry.used &&                    // isn't already used
            (required || !next_entry.hit_param) && // if required, get the last value. if not, get
                                                   // it if it's not a hit param
            !MooseUtils::beginsWith(next_entry.name, "-") && // doesn't start with a -
            next_entry.value_separator &&                    // has a separator
            *next_entry.value_separator == "=" &&            // that separator is =
            next_entry.value)                                // and has a value after the =
        {
          const auto & next_entry = *next_entry_it;
          // Merge with the next Entry object and remove said next object
          entry.value = next_entry.name + *next_entry.value_separator + *next_entry.value;
          entry.value_separator = " ";
          entry.raw_args.insert(
              entry.raw_args.end(), next_entry.raw_args.begin(), next_entry.raw_args.end());
          _entries.erase(next_entry_it);
        }
      }
    }
 
    // If we have a value, set the parameter to it
    if (entry.value)
    {
      // For vector<string>, we need to unpack the values
      if constexpr (std::is_same_v<T, std::vector<std::string>>)
      {
        std::vector<std::string> split_values;
        MooseUtils::tokenize(*entry.value, split_values, 1, " ");
        value.resize(split_values.size());
        for (const auto i : index_range(split_values))
          set_value(split_values[i], value[i]);
      }
      // For everything else, we can set them directly
      else
        set_value(*entry.value, value);
    }
    // No value, but one is required
    else if (param.metadata.argument_type == ArgumentType::REQUIRED)
      mooseError("The command line option '",
                 cli_switch,
                 "' requires a value and one was not provided.\nDoc string: ",
                 param.description);
  }
}