cxxopts::ParseResult Class Reference

#include <cxxopts.h>

Public Member Functions
const std::vector< KeyValue > &	arguments () const
size_t	count (const std::string &o) const
const OptionValue &	operator[] (const std::string &option) const
	ParseResult (const std::shared_ptr< std::unordered_map< std::string, std::shared_ptr< OptionDetails >>>, std::vector< std::string >, bool allow_unrecognised, int &, char **&)

Private Member Functions
void	add_to_option (const std::string &option, const std::string &arg)
void	checked_parse_arg (int argc, char *argv[], int &current, std::shared_ptr< OptionDetails > value, const std::string &name)
bool	consume_positional (std::string a)
void	parse (int &argc, char **&argv)
void	parse_default (std::shared_ptr< OptionDetails > details)
void	parse_option (std::shared_ptr< OptionDetails > value, const std::string &name, const std::string &arg="")

Private Attributes
bool	m_allow_unrecognised
std::vector< std::string >::iterator	m_next_positional
const std::shared_ptr< std::unordered_map< std::string, std::shared_ptr< OptionDetails > > >	m_options
std::vector< std::string >	m_positional
std::unordered_set< std::string >	m_positional_set
std::unordered_map< std::shared_ptr< OptionDetails >, OptionValue >	m_results
std::vector< KeyValue >	m_sequential

Detailed Description

Definition at line 695 of file cxxopts.h.

Constructor & Destructor Documentation

ParseResult()

cxxopts::ParseResult::ParseResult ( const std::shared_ptr< std::unordered_map< std::string, std::shared_ptr< OptionDetails >>>  options, std::vector< std::string >  positional, bool  allow_unrecognised, int &  argc, char **&  argv  )

inline

Definition at line 943 of file cxxopts.h.

References dir2webdir::argc, GCPpyPlots::argv, and parse().

      : m_options(options),
        m_positional(std::move(positional)),
        m_next_positional(m_positional.begin()),
        m_allow_unrecognised(allow_unrecognised) {
    parse(argc, argv);
  }

Member Function Documentation

add_to_option()

void cxxopts::ParseResult::add_to_option ( const std::string &  option, const std::string &  arg  )

inlineprivate

Definition at line 1023 of file cxxopts.h.

References m_options, fileinputsource_cfi::option, and parse_option().

Referenced by consume_positional().

                                                                                      {
    auto iter = m_options->find(option);

    if (iter == m_options->end()) {
      throw Option_not_exists_exception(option);
    }

    parse_option(iter->second, option, arg);
  }

arguments()

const std::vector<KeyValue>& cxxopts::ParseResult::arguments ( ) const

inline

Definition at line 726 of file cxxopts.h.

References m_sequential.

{ return m_sequential; }

checked_parse_arg()

void cxxopts::ParseResult::checked_parse_arg ( int  argc, char *  argv[], int &  current, std::shared_ptr< OptionDetails >  value, const std::string &  name  )

inlineprivate

Definition at line 1005 of file cxxopts.h.

References dir2webdir::argc, GCPpyPlots::argv, mergeVDriftHistosByStation::name, and parse_option().

Referenced by parse().

                                                                                                       {
    if (current + 1 >= argc) {
      if (value->value().has_implicit()) {
        parse_option(value, name, value->value().get_implicit_value());
      } else {
        throw Missing_argument_exception(name);
      }
    } else {
      if (value->value().has_implicit()) {
        parse_option(value, name, value->value().get_implicit_value());
      } else {
        parse_option(value, name, argv[current + 1]);
        ++current;
      }
    }
  }

consume_positional()

bool cxxopts::ParseResult::consume_positional ( std::string  a )

inlineprivate

Definition at line 1033 of file cxxopts.h.

References a, add_to_option(), m_next_positional, m_options, m_positional, m_results, and mps_fire::result.

Referenced by parse().

                                                         {
    while (m_next_positional != m_positional.end()) {
      auto iter = m_options->find(*m_next_positional);
      if (iter != m_options->end()) {
        auto& result = m_results[iter->second];
        if (!iter->second->value().is_container()) {
          if (result.count() == 0) {
            add_to_option(*m_next_positional, a);
            ++m_next_positional;
            return true;
          } else {
            ++m_next_positional;
            continue;
          }
        } else {
          add_to_option(*m_next_positional, a);
          return true;
        }
      }
      ++m_next_positional;
    }

    return false;
  }

count()

size_t cxxopts::ParseResult::count ( const std::string &  o ) const

inline

Definition at line 703 of file cxxopts.h.

References m_options, m_results, and EcalTangentSkim_cfg::o.

                                           {
      auto iter = m_options->find(o);
      if (iter == m_options->end()) {
        return 0;
      }

      auto riter = m_results.find(iter->second);

      return riter->second.count();
    }

operator[]()

const OptionValue& cxxopts::ParseResult::operator[] ( const std::string &  option ) const

inline

Definition at line 714 of file cxxopts.h.

References m_options, m_results, and fileinputsource_cfi::option.

                                                                 {
      auto iter = m_options->find(option);

      if (iter == m_options->end()) {
        throw Option_not_present_exception(option);
      }

      auto riter = m_results.find(iter->second);

      return riter->second;
    }

parse()

void cxxopts::ParseResult::parse ( int &  argc, char **&  argv  )

inlineprivate

Definition at line 1078 of file cxxopts.h.

References dir2webdir::argc, GCPpyPlots::argv, checked_parse_arg(), consume_positional(), createIOVlist::detail, mps_fire::i, m_allow_unrecognised, m_options, m_results, mergeVDriftHistosByStation::name, das-up-to-nevents::opt, parse_default(), parse_option(), mps_fire::result, alignCSCRings::s, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by ParseResult().

                                                        {
    int current = 1;

    int nextKeep = 1;

    bool consume_remaining = false;

    while (current != argc) {
      if (strcmp(argv[current], "--") == 0) {
        consume_remaining = true;
        ++current;
        break;
      }

      std::match_results<const char*> result;
      std::regex_match(argv[current], result, option_matcher);

      if (result.empty()) {
        //not a flag

        // but if it starts with a `-`, then it's an error
        if (argv[current][0] == '-' && argv[current][1] != '\0') {
          throw Option_syntax_exception(argv[current]);
        }

        //if true is returned here then it was consumed, otherwise it is
        //ignored
        if (consume_positional(argv[current])) {
        } else {
          argv[nextKeep] = argv[current];
          ++nextKeep;
        }
        //if we return from here then it was parsed successfully, so continue
      } else {
        //short or long option?
        if (result[4].length() != 0) {
          const std::string& s = result[4];

          for (std::size_t i = 0; i != s.size(); ++i) {
            std::string name(1, s[i]);
            auto iter = m_options->find(name);

            if (iter == m_options->end()) {
              if (m_allow_unrecognised) {
                continue;
              } else {
                //error
                throw Option_not_exists_exception(name);
              }
            }

            auto value = iter->second;

            if (i + 1 == s.size()) {
              //it must be the last argument
              checked_parse_arg(argc, argv, current, value, name);
            } else if (value->value().has_implicit()) {
              parse_option(value, name, value->value().get_implicit_value());
            } else {
              //error
              throw Option_requires_argument_exception(name);
            }
          }
        } else if (result[1].length() != 0) {
          const std::string& name = result[1];

          auto iter = m_options->find(name);

          if (iter == m_options->end()) {
            if (m_allow_unrecognised) {
              // keep unrecognised options in argument list, skip to next argument
              argv[nextKeep] = argv[current];
              ++nextKeep;
              ++current;
              continue;
            } else {
              //error
              throw Option_not_exists_exception(name);
            }
          }

          auto opt = iter->second;

          //equals provided for long option?
          if (result[2].length() != 0) {
            //parse the option given

            parse_option(opt, name, result[3]);
          } else {
            //parse the next argument
            checked_parse_arg(argc, argv, current, opt, name);
          }
        }
      }

      ++current;
    }

    for (auto& opt : *m_options) {
      auto& detail = opt.second;
      auto& value = detail->value();

      auto& store = m_results[detail];

      if (!store.count() && value.has_default()) {
        parse_default(detail);
      }
    }

    if (consume_remaining) {
      while (current < argc) {
        if (!consume_positional(argv[current])) {
          break;
        }
        ++current;
      }

      //adjust argv for any that couldn't be swallowed
      while (current != argc) {
        argv[nextKeep] = argv[current];
        ++nextKeep;
        ++current;
      }
    }

    argc = nextKeep;
  }

parse_default()

void cxxopts::ParseResult::parse_default ( std::shared_ptr< OptionDetails >  details )

inlineprivate

Definition at line 992 of file cxxopts.h.

References m_results.

Referenced by parse().

                                                                             {
    m_results[details].parse_default(details);
  }

parse_option()

void cxxopts::ParseResult::parse_option ( std::shared_ptr< OptionDetails >  value, const std::string &  name, const std::string &  arg = ""  )

inlineprivate

Definition at line 996 of file cxxopts.h.

References m_results, m_sequential, mps_fire::result, and cxxopts::value().

Referenced by add_to_option(), checked_parse_arg(), and parse().

                                                              {
    auto& result = m_results[value];
    result.parse(value, arg);

    m_sequential.emplace_back(value->long_name(), arg);
  }

Member Data Documentation

m_allow_unrecognised

bool cxxopts::ParseResult::m_allow_unrecognised

private

Definition at line 748 of file cxxopts.h.

Referenced by parse().

m_next_positional

std::vector<std::string>::iterator cxxopts::ParseResult::m_next_positional

private

Definition at line 744 of file cxxopts.h.

Referenced by consume_positional().

m_options

const std::shared_ptr<std::unordered_map<std::string, std::shared_ptr<OptionDetails> > > cxxopts::ParseResult::m_options

private

Definition at line 742 of file cxxopts.h.

Referenced by add_to_option(), consume_positional(), count(), operator[](), and parse().

m_positional

std::vector<std::string> cxxopts::ParseResult::m_positional

private

Definition at line 743 of file cxxopts.h.

Referenced by consume_positional().

m_positional_set

std::unordered_set<std::string> cxxopts::ParseResult::m_positional_set

private

Definition at line 745 of file cxxopts.h.

m_results

std::unordered_map<std::shared_ptr<OptionDetails>, OptionValue> cxxopts::ParseResult::m_results

private

Definition at line 746 of file cxxopts.h.

Referenced by consume_positional(), count(), operator[](), parse(), parse_default(), and parse_option().

m_sequential

std::vector<KeyValue> cxxopts::ParseResult::m_sequential

private

Definition at line 750 of file cxxopts.h.

Referenced by arguments(), and parse_option().