GetPot - A class for parsing command line arguments and configuration files. More...

#include <getpot.h>

Classes
struct	ltstr
	Transparent comparator object used for making std::sets that contain unique_ptrs. More...

struct	variable
	Variable to be specified on the command line or in input files. More...

Public Member Functions
	GetPot ()
	constructors, destructor, assignment operator

	GetPot (const GetPot &)

	GetPot (const int argc_, const char const argv_, const char *FieldSeparator=0x0)

	GetPot (const char FileName, const char CommentStart=0x0, const char CommentEnd=0x0, const char FieldSeparator=0x0)

	GetPot (const std::string &FileName, const std::string &CommentStart=std::string("#"), const std::string &CommentEnd=std::string("\n"), const std::string &FieldSeparator=std::string(" \t\n"))

	GetPot (std::istream &FileStream, const std::string &CommentStart=std::string("#"), const std::string &CommentEnd=std::string("\n"), const std::string &FieldSeparator=std::string(" \t\n"))
	This constructor is mainly for testing.

	~GetPot ()

GetPot &	operator= (const GetPot &)

void	parse_command_line (const int argc_, const char const argv_, const char *FieldSeparator=0x0)
	Re-initialization methods.

void	parse_input_file (const std::string &FileName, const std::string &CommentStart=std::string("#"), const std::string &CommentEnd=std::string("\n"), const std::string &FieldSeparator=std::string(" \t\n"))

void	parse_input_stream (std::istream &FileStream, const std::string &FileName=std::string("ParsedFromStream"), const std::string &CommentStart=std::string("#"), const std::string &CommentEnd=std::string("\n"), const std::string &FieldSeparator=std::string(" \t\n"))

void	absorb (const GetPot &Other)
	absorbing contents of another GetPot object

void	clear_requests ()
	for ufo detection: recording requested arguments, options etc.

void	disable_request_recording ()

void	enable_request_recording ()

const char *	operator[] (unsigned Idx) const
	direct access to command line arguments

template<typename T >
T	get (unsigned Idx, const T &Default) const

const char *	get (unsigned Idx, const char *Default) const

unsigned	size () const

bool	options_contain (const char *FlagList) const
	flags

bool	argument_contains (unsigned Idx, const char *FlagList) const

bool	have_variable (const char *VarName) const
	variables

bool	have_variable (const std::string &VarName) const

bool	have_section (const char *section_name) const
	Check for a section name.

bool	have_section (const std::string &section_name) const
	Check for a section name.

template<typename T >
T	operator() (const char *VarName, const T &Default) const
	scalar values

template<typename T >
T	operator() (const std::string &VarName, const T &Default) const

const char *	operator() (const char VarName, const char Default) const

const char *	operator() (const std::string &VarName, const char *Default) const

template<typename T >
T	operator() (const char *VarName, const T &Default, unsigned Idx) const
	vectors

template<typename T >
T	operator() (const std::string &VarName, const T &Default, unsigned Idx) const

const char *	operator() (const char VarName, const char Default, unsigned Idx) const

const char *	operator() (const std::string &VarName, const char *Default, unsigned Idx) const

template<typename T >
T	get_value_no_default (const char *VarName, const T &Default) const
	access variables, but error out if not present scalar values

template<typename T >
T	get_value_no_default (const std::string &VarName, const T &Default) const

const char *	get_value_no_default (const char VarName, const char Default) const

const char *	get_value_no_default (const std::string &VarName, const char *Default) const

template<typename T >
T	get_value_no_default (const char *VarName, const T &Default, unsigned Idx) const
	vectors

template<typename T >
T	get_value_no_default (const std::string &VarName, const T &Default, unsigned Idx) const

const char *	get_value_no_default (const char VarName, const char Default, unsigned Idx) const

const char *	get_value_no_default (const std::string &VarName, const char *Default, unsigned Idx) const

template<typename T >
void	set (const char *VarName, const T &Value, const bool Requested=true)
	setting variables i) from outside of GetPot (considering prefix etc.) ii) from inside, use '_set_variable()' below

template<typename T >
void	set (const std::string &VarName, const T &Value, const bool Requested=true)

void	set (const char VarName, const char Value, const bool Requested=true)

void	set (const std::string &VarName, const char *Value, const bool Requested=true)

unsigned	vector_variable_size (const char *VarName) const

unsigned	vector_variable_size (const std::string &VarName) const

STRING_VECTOR	get_variable_names () const

STRING_VECTOR	get_section_names () const

STRING_VECTOR	get_subsection_names (const std::string &section_name) const

std::set< std::string >	get_overridden_variables () const

void	set_prefix (const char *Prefix)
	cursor oriented functions

bool	search_failed () const

void	disable_loop ()
	enable/disable search for an option in loop

void	enable_loop ()

void	reset_cursor ()
	reset cursor to position '1'

void	init_multiple_occurrence ()

bool	search (const char *option)
	search for a certain option and set cursor to position

bool	search (const std::string &option)

bool	search (unsigned No, const char *P,...)

template<typename T >
T	next (const T &Default)
	get argument at cursor++

const char *	next (const char *Default)

template<typename T >
T	follow (const T &Default, const char *Option)
	search for option and get argument at cursor++

const char *	follow (const char Default, const char Option)

template<typename T >
T	follow (const T &Default, unsigned No, const char *Option,...)
	search for one of the given options and get argument that follows it

const char *	follow (const char Default, unsigned No, const char Option,...)

template<typename T >
T	direct_follow (const T &Default, const char *Option)
	directly followed arguments

const char *	direct_follow (const char Default, const char Option)

void	reset_nominus_cursor ()
	nominus arguments

STRING_VECTOR	nominus_vector () const

unsigned	nominus_size () const

const char *	next_nominus ()

std::string	next_nominus_string ()

STRING_VECTOR	unidentified_arguments (unsigned Number, const char *Known,...) const
	unidentified flying objects

STRING_VECTOR	unidentified_arguments (const std::set< std::string > &Knowns) const

STRING_VECTOR	unidentified_arguments (const std::vector< std::string > &Knowns) const

STRING_VECTOR	unidentified_arguments () const

STRING_VECTOR	unidentified_options (unsigned Number, const char *Known,...) const

STRING_VECTOR	unidentified_options (const std::set< std::string > &Knowns) const

STRING_VECTOR	unidentified_options (const std::vector< std::string > &Knowns) const

STRING_VECTOR	unidentified_options () const

std::string	unidentified_flags (const char *Known, int ArgumentNumber) const

STRING_VECTOR	unidentified_variables (unsigned Number, const char *Known,...) const

STRING_VECTOR	unidentified_variables (const std::set< std::string > &Knowns) const

STRING_VECTOR	unidentified_variables (const std::vector< std::string > &Knowns) const

STRING_VECTOR	unidentified_variables () const

STRING_VECTOR	unidentified_sections (unsigned Number, const char *Known,...) const

STRING_VECTOR	unidentified_sections (const std::set< std::string > &Knowns) const

STRING_VECTOR	unidentified_sections (const std::vector< std::string > &Knowns) const

STRING_VECTOR	unidentified_sections () const

STRING_VECTOR	unidentified_nominuses (unsigned Number, const char *Known,...) const

STRING_VECTOR	unidentified_nominuses (const std::set< std::string > &Knowns) const

STRING_VECTOR	unidentified_nominuses (const std::vector< std::string > &Knowns) const

STRING_VECTOR	unidentified_nominuses () const

std::set< std::string >	get_requested_arguments () const
	Accessors for requested variables.

std::set< std::string >	get_requested_variables () const

std::set< std::string >	get_requested_sections () const

int	print (std::ostream &out_stream=std::cout) const
	output

int	print (const char *custom_prefix, std::ostream &out_stream=std::cout, unsigned int skip_count=1) const
	Print everything after skipping skip_count arguments, with a custom prefix.

template<>
std::string	_convert_to_type (const std::string &String, const std::string &) const

template<>
std::string	_convert_to_type_no_default (const char *, const std::string &String, const std::string &) const

template<typename T >
T	get (unsigned int Idx, const T &Default) const

template<typename T >
T	follow (const T &Default, unsigned int No, const char *P,...)

template<typename T >
T	operator() (const char *VarName, const T &Default, unsigned int Idx) const

template<typename T >
T	operator() (const std::string &VarName, const T &Default, unsigned int Idx) const

template<typename T >
T	get_value_no_default (const char *VarName, const T &Default, unsigned int Idx) const

template<typename T >
T	get_value_no_default (const std::string &VarName, const T &Default, unsigned int Idx) const

Private Member Functions
void	_basic_initialization ()

const char *	_internal_managed_copy (const std::string &Arg) const
	some functions return a char pointer to a temporarily existing string this function adds them to our container

void	_record_argument_request (const std::string &Arg) const
	if an argument is requested record it and the 'tag' the section branch to which it belongs.

void	_record_variable_request (const std::string &Arg) const

void	_set_variable (const std::string &VarName, const std::string &Value, const bool Requested)
	helper functions

void	_parse_argument_vector (const STRING_VECTOR &ARGV)
	produce three basic data vectors:

const variable *	_find_variable (const char *) const
	helpers for argument list processing

const variable *	_request_variable (const char *) const
	search (and record request) for a variable in 'variables' array

const char *	_match_starting_string (const char *StartString)
	support finding directly followed arguments

bool	_check_flags (const std::string &Str, const char *FlagList) const
	support search for flags in a specific argument

template<typename T >
T	_convert_to_type (const std::string &String, const T &Default) const
	type conversion if possible

std::string	_convert_to_type (const std::string &String, const char *Default) const

template<typename T >
T	_convert_to_type_no_default (const char *VarName, const std::string &String, const T &Default) const

std::string	_convert_to_type_no_default (const char VarName, const std::string &String, const char Default) const

const std::string	_get_remaining_string (const std::string &String, const std::string &Start) const
	prefix extraction

bool	_search_string_vector (const STRING_VECTOR &Vec, const std::string &Str) const
	search for a specific string

void	_skip_whitespace (std::istream &istr)
	helpers to parse input file create an argument vector based on data found in an input file, i.e.: 1) delete comments (in between '_comment_start' '_comment_end') 2) contract assignment expressions, such as my-variable = '007 J.

const std::string	_get_next_token (std::istream &istr)

const std::string	_get_string (std::istream &istr)

const std::string	_get_until_closing_bracket (std::istream &istr)

const std::string	_get_until_closing_square_bracket (std::istream &istr)

STRING_VECTOR	_read_in_stream (std::istream &istr)

std::string	_process_section_label (const std::string &Section, STRING_VECTOR &section_stack)

std::string	_DBE_expand_string (const std::string &str)
	dollar bracket expressions

std::string	_DBE_expand (const std::string &str)

const GetPot::variable *	_DBE_get_variable (const std::string &str)

STRING_VECTOR	_DBE_get_expr_list (const std::string &str, const unsigned ExpectedNumber)

template<>
bool	_convert_to_type (const std::string &String, const bool &Default) const

template<>
bool	_convert_to_type_no_default (const char *VarName, const std::string &String, const bool &) const

Static Private Member Functions
template<typename T >
static std::string	_convert_from_type (const T &Value)

static STRING_VECTOR	_get_section_tree (const std::string &FullPath)
	cuts a variable name into a tree of sub-sections.

Private Attributes
std::string	prefix
	member variables

std::string	section

STRING_VECTOR	section_list

STRING_VECTOR	argv
	argument vector

unsigned	cursor

bool	search_loop_f

bool	search_failed_f

std::set< std::string >	overridden_vars

int	nominus_cursor
	nominus vector

std::vector< unsigned >	idx_nominus

std::vector< variable >	variables
	variables (arguments of the form "variable=value")

std::string	_comment_start
	comment delimiters

std::string	_comment_end

std::string	_field_separator
	field separator (separating elements of a vector)

	GETPOT_MUTEX_DECLARE
	we have some mutable non-thread-safe members, but we want to be able to call const member functions from multiple threads at once, so we'll wrap access to mutable objects in a mutex.

std::set< std::unique_ptr< const char[]>, ltstr >	_internal_string_container
	some functions return a char pointer to a string created on the fly.

std::set< std::string >	_requested_arguments
	keeping track about arguments that are requested, so that the UFO detection can be simplified

std::set< std::string >	_requested_variables

std::set< std::string >	_requested_sections

bool	request_recording_f

Detailed Description

GetPot - A class for parsing command line arguments and configuration files.

Author: Frank R. Schaefer

Date: (C) 2001-2002

Definition at line 155 of file getpot.h.

Constructor & Destructor Documentation

◆ GetPot() [1/6]

GETPOT_NAMESPACE::GetPot::GetPot ( )

inline

constructors, destructor, assignment operator

Definition at line 764 of file getpot.h.

               :
  prefix(),
  section(),
  section_list(),
  argv(),
  cursor(),
  search_loop_f(),
  search_failed_f(),
  nominus_cursor(),
  idx_nominus(),
  variables(),
  _comment_start(),
  _comment_end(),
  _field_separator(),
#if !defined(GETPOT_DISABLE_MUTEX)
  _getpot_mtx(),
#endif
  _internal_string_container(),
  _requested_arguments(),
  _requested_variables(),
  _requested_sections(),
  request_recording_f()
{
  _basic_initialization();
}

References _basic_initialization().

◆ GetPot() [2/6]

GETPOT_NAMESPACE::GetPot::GetPot ( const GetPot & Other )

inline

Definition at line 997 of file getpot.h.

                                  :
  prefix(Other.prefix),
  section(Other.section),
  section_list(Other.section_list),
  argv(Other.argv),
  cursor(Other.cursor),
  search_loop_f(Other.search_loop_f),
  search_failed_f(Other.search_failed_f),
  overridden_vars(),
  nominus_cursor(Other.nominus_cursor),
  idx_nominus(Other.idx_nominus),
  variables(Other.variables),
  _comment_start(Other._comment_start),
  _comment_end(Other._comment_end),
  _field_separator(Other._field_separator),
  // #if !defined(GETPOT_DISABLE_MUTEX)
  //   _getpot_mtx(Other._getpot_mtx),
  // #endif
  _internal_string_container(),
  _requested_arguments(Other._requested_arguments),
  _requested_variables(Other._requested_variables),
  _requested_sections(Other._requested_sections),
  request_recording_f(Other.request_recording_f)
{
  for (const auto & otherstr : Other._internal_string_container)
    {
      auto newlen = strlen(otherstr.get()) + 1;
      auto newcopy = std::make_unique<char[]>(newlen);
      strncpy(newcopy.get(), otherstr.get(), newlen);
      this->_internal_string_container.insert(std::move(newcopy));
    }
}

References _internal_string_container.

◆ GetPot() [3/6]

GETPOT_NAMESPACE::GetPot::GetPot	(	const int	argc_,
		const char const	argv_,
		const char *	FieldSeparator = `0x0`
	)

inline

Definition at line 793 of file getpot.h.

                                             :
  // leave 'char**' non-const to honor less capable compilers ...
  prefix(),
  section(),
  section_list(),
  argv(),
  cursor(),
  search_loop_f(),
  search_failed_f(),
  nominus_cursor(),
  idx_nominus(),
  variables(),
  _comment_start(),
  _comment_end(),
  _field_separator(),
#if !defined(GETPOT_DISABLE_MUTEX)
  _getpot_mtx(),
#endif
  _internal_string_container(),
  _requested_arguments(),
  _requested_variables(),
  _requested_sections(),
  request_recording_f()
{
  this->parse_command_line(argc_, argv_, FieldSeparator);
}

References parse_command_line().

◆ GetPot() [4/6]

GETPOT_NAMESPACE::GetPot::GetPot	(	const char *	FileName,
		const char *	CommentStart = `0x0`,
		const char *	CommentEnd = `0x0`,
		const char *	FieldSeparator = `0x0`
	)

inline

Definition at line 854 of file getpot.h.

                                            :
  prefix(),
  section(),
  section_list(),
  argv(),
  cursor(),
  search_loop_f(),
  search_failed_f(),
  nominus_cursor(),
  idx_nominus(),
  variables(),
  _comment_start(),
  _comment_end(),
  _field_separator(),
#if !defined(GETPOT_DISABLE_MUTEX)
  _getpot_mtx(),
#endif
  _internal_string_container(),
  _requested_arguments(),
  _requested_variables(),
  _requested_sections(),
  request_recording_f()
{
  const std::string& StrCommentStart   = CommentStart   ? CommentStart   : std::string("#");
  const std::string& StrCommentEnd     = CommentEnd     ? CommentEnd     : std::string("\n");
  const std::string& StrFieldSeparator = FieldSeparator ? FieldSeparator : std::string(" \t\n");
  this->parse_input_file(FileName, StrCommentStart, StrCommentEnd, StrFieldSeparator);
}

References parse_input_file().

◆ GetPot() [5/6]

GETPOT_NAMESPACE::GetPot::GetPot	(	const std::string &	FileName,
		const std::string &	CommentStart = `std::string("#")`,
		const std::string &	CommentEnd = `std::string("\n")`,
		const std::string &	FieldSeparator = `std::string(" \t\n")`
	)

inline

Definition at line 888 of file getpot.h.

                                                :
  prefix(),
  section(),
  section_list(),
  argv(),
  cursor(),
  search_loop_f(),
  search_failed_f(),
  nominus_cursor(),
  idx_nominus(),
  variables(),
  _comment_start(),
  _comment_end(),
  _field_separator(),
#if !defined(GETPOT_DISABLE_MUTEX)
  _getpot_mtx(),
#endif
  _internal_string_container(),
  _requested_arguments(),
  _requested_variables(),
  _requested_sections(),
  request_recording_f()
{
  this->parse_input_file(FileName, CommentStart, CommentEnd, FieldSeparator);
}

References parse_input_file().

◆ GetPot() [6/6]

GETPOT_NAMESPACE::GetPot::GetPot	(	std::istream &	FileStream,
		const std::string &	CommentStart = `std::string("#")`,
		const std::string &	CommentEnd = `std::string("\n")`,
		const std::string &	FieldSeparator = `std::string(" \t\n")`
	)

inline

This constructor is mainly for testing.

The std::string based constructor should be preferred.

Definition at line 933 of file getpot.h.

                                                :
  prefix(),
  section(),
  section_list(),
  argv(),
  cursor(),
  search_loop_f(),
  search_failed_f(),
  nominus_cursor(),
  idx_nominus(),
  variables(),
  _comment_start(),
  _comment_end(),
  _field_separator(),
#if !defined(GETPOT_DISABLE_MUTEX)
  _getpot_mtx(),
#endif
  _internal_string_container(),
  _requested_arguments(),
  _requested_variables(),
  _requested_sections(),
  request_recording_f()
{
  this->parse_input_stream(FileStream,
                           std::string("ParsedFromStream"),// We don't have a filename here
                           CommentStart, CommentEnd, FieldSeparator);
}

References parse_input_stream().

◆ ~GetPot()

GETPOT_NAMESPACE::GetPot::~GetPot ( )

inlinedefault

Member Function Documentation

◆ _basic_initialization()

void GETPOT_NAMESPACE::GetPot::_basic_initialization ( )

inlineprivate

Definition at line 741 of file getpot.h.

{
  cursor = 0;
  nominus_cursor = -1;
  search_failed_f = true;
  search_loop_f = true;
  prefix = "";
  section = "";
 
  // automatic request recording for later ufo detection
  request_recording_f = true;
 
  // comment start and end strings
  _comment_start = std::string("#");
  _comment_end   = std::string("\n");
 
  // default: separate vector elements by whitespaces
  _field_separator = " \t\n";
}

References _comment_end, _comment_start, _field_separator, cursor, nominus_cursor, prefix, request_recording_f, search_failed_f, search_loop_f, and section.

Referenced by GetPot(), parse_command_line(), and parse_input_stream().

◆ _check_flags()

bool GETPOT_NAMESPACE::GetPot::_check_flags	(	const std::string &	Str,
		const char *	FlagList
	)		const

inlineprivate

support search for flags in a specific argument

Definition at line 2151 of file getpot.h.

{
  for (const char* p=FlagList; *p != '\0' ; p++)
    if (Str.find(*p) != std::string::npos)
      return true; // found something
  return false;
}

Referenced by argument_contains(), and options_contain().

◆ _convert_from_type()

template<typename T >

static std::string GETPOT_NAMESPACE::GetPot::_convert_from_type ( const T & Value )

inlinestaticprivate

Definition at line 711 of file getpot.h.

  {
    std::ostringstream out_string;
    out_string << Value;
    return out_string.str();
  }

Referenced by _DBE_expand().

◆ _convert_to_type() [1/4]

template<>

bool GETPOT_NAMESPACE::GetPot::_convert_to_type	(	const std::string &	String,
		const bool &	Default
	)		const

inlineprivate

Definition at line 1596 of file getpot.h.

{
  std::string newstring(String);
  //std::transform(newstring.begin(), newstring.end(), newstring.begin(), std::toupper);
  for (unsigned int i=0; i<newstring.length(); ++i)
    newstring[i] = getpot_cast_int<char>(toupper(newstring[i]));
 
  // "true"/"True"/"TRUE" should work
  if (newstring.find("TRUE")!=std::string::npos)
    return true;
 
  if (newstring.find("FALSE")!=std::string::npos)
    return false;
 
  // And if we don't find that, let's search for an integer and use C unsigned
  // int->bool conversion before giving up; i.e. a user could specify "0" for
  // false or "1" for true
  std::istringstream in_string(String);
  unsigned int retval;
  in_string >> retval;
  if (in_string.fail())
    return Default;
 
  return retval;
}

◆ _convert_to_type() [2/4]

std::string GETPOT_NAMESPACE::GetPot::_convert_to_type	(	const std::string &	String,
		const char *	Default
	)		const

inlineprivate

Definition at line 1587 of file getpot.h.

{
  return String;
}

◆ _convert_to_type() [3/4]

template<>

std::string GETPOT_NAMESPACE::GetPot::_convert_to_type	(	const std::string &	String,
		const std::string &
	)		const

inline

Definition at line 1578 of file getpot.h.

{
  return String;
}

◆ _convert_to_type() [4/4]

template<typename T >

T GETPOT_NAMESPACE::GetPot::_convert_to_type	(	const std::string &	String,
		const T &	Default
	)		const

inlineprivate

type conversion if possible

Definition at line 1563 of file getpot.h.

{
  std::istringstream in_string(String);
  T retval;
  in_string >> retval;
  if (in_string.fail())
    retval = Default;
  return retval;
}

Referenced by _DBE_expand(), direct_follow(), get(), next(), operator()(), and operator()().

◆ _convert_to_type_no_default() [1/4]

template<>

std::string GETPOT_NAMESPACE::GetPot::_convert_to_type_no_default	(	const char *	,
		const std::string &	String,
		const std::string &
	)		const

inline

Definition at line 1647 of file getpot.h.

{
  return String;
}

◆ _convert_to_type_no_default() [2/4]

template<>

bool GETPOT_NAMESPACE::GetPot::_convert_to_type_no_default	(	const char *	VarName,
		const std::string &	String,
		const bool &
	)		const

inlineprivate

Definition at line 1665 of file getpot.h.

{
  std::string newstring(String);
  //std::transform(newstring.begin(), newstring.end(), newstring.begin(), std::toupper);
  for (unsigned int i=0; i<newstring.length(); ++i)
    {
      newstring[i]=getpot_cast_int<char>(toupper(newstring[i]));
    }
 
  // "true"/"True"/"TRUE" should work
  if (newstring.find("TRUE")!=std::string::npos)
    return true;
 
  if (newstring.find("FALSE")!=std::string::npos)
    return false;
 
  // And if we don't find that, let's search for an integer and use C unsigned
  // int->bool conversion before giving up; i.e. a user could specify "0" for
  // false or "1" for true
  std::istringstream in_string(String);
  unsigned int retval;
  in_string >> retval;
  if (in_string.fail())
    {
      getpot_cerr <<"ERROR: Input value for variable "<<VarName<<" is of the wrong type."<<std::endl;
      getpot_cerr <<"       value = "<<String<<" expected type = "<<typeid(bool).name()<<std::endl;
      getpot_error();
    }
 
  return retval;
}

◆ _convert_to_type_no_default() [3/4]

std::string GETPOT_NAMESPACE::GetPot::_convert_to_type_no_default	(	const char *	VarName,
		const std::string &	String,
		const char *	Default
	)		const

inlineprivate

Definition at line 1656 of file getpot.h.

{
  return String;
}

◆ _convert_to_type_no_default() [4/4]

template<typename T >

T GETPOT_NAMESPACE::GetPot::_convert_to_type_no_default	(	const char *	VarName,
		const std::string &	String,
		const T &	Default
	)		const

inlineprivate

Definition at line 1628 of file getpot.h.

{
  std::istringstream in_string(String);
  T retval;
  in_string >> retval;
  if (in_string.fail())
    {
      getpot_cerr <<"ERROR: Input value for variable "<<VarName<<" is of the wrong type."<<std::endl;
      getpot_cerr <<"       value = "<<String<<" expected type = "<<typeid(T).name()<<std::endl;
      getpot_error();
    }
  return retval;
}

Referenced by get_value_no_default(), and get_value_no_default().

◆ _DBE_expand()

std::string GETPOT_NAMESPACE::GetPot::_DBE_expand ( const std::string & str )

inlineprivate

Definition at line 2922 of file getpot.h.

{
  // ${: } pure text
  if (expr[0] == ':')
    return expr.substr(1);
 
  // ${& expr expr ... } text concatenation
  else if (expr[0] == '&')
    {
      const STRING_VECTOR A = _DBE_get_expr_list(expr.substr(1), 1);
 
      STRING_VECTOR::const_iterator it = A.begin();
      std::string result = *it++;
      for (; it != A.end(); ++it) result += *it;
 
      return result;
    }
 
  // ${<-> expr expr expr} text replacement
  else if (expr.length() >= 3 && expr.substr(0, 3) == "<->")
    {
      STRING_VECTOR A = _DBE_get_expr_list(expr.substr(3), 3);
      size_t tmp = 0;
      const size_t L = A[1].length();
 
      while ((tmp = A[0].find(A[1])) != std::string::npos)
        A[0].replace(tmp, L, A[2]);
 
      return A[0];
    }
 
  // ${=func [expr...] } function evaluation
  else if (expr.length() >= 2 &&
           expr.substr(0, 1) == "=" &&
           expr.substr(0, 2) != "==")
    {
      size_t funcnamestart = expr.find_first_not_of(" \t", 1);
      if (funcnamestart != std::string::npos)
        {
          size_t funcnameend = expr.find_first_of(" \t",funcnamestart);
          std::string funcname = expr.substr(funcnamestart,
                                             funcnameend-funcnamestart);
          if (funcname == "log")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::log(arg));
            }
          else if (funcname == "log10")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::log10(arg));
            }
          else if (funcname == "exp")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::exp(arg));
            }
          else if (funcname == "sin")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::sin(arg));
            }
          else if (funcname == "cos")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::cos(arg));
            }
          else if (funcname == "tan")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::tan(arg));
            }
          else if (funcname == "asin")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::asin(arg));
            }
          else if (funcname == "acos")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::acos(arg));
            }
          else if (funcname == "atan")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::atan(arg));
            }
          else if (funcname == "atan2")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 2);
              double arg1 = _convert_to_type(A[0], 0.0);
              double arg2 = _convert_to_type(A[1], 0.0);
              return _convert_from_type(std::atan2(arg1, arg2));
            }
          else if (funcname == "sinh")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::sinh(arg));
            }
          else if (funcname == "cosh")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::cosh(arg));
            }
          else if (funcname == "tanh")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::tanh(arg));
            }
#ifdef HAVE_INVERSE_HYPERBOLIC_SINE
          else if (funcname == "asinh")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::asinh(arg));
            }
#endif
#ifdef HAVE_INVERSE_HYPERBOLIC_COSINE
          else if (funcname == "acosh")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::acosh(arg));
            }
#endif
#ifdef HAVE_INVERSE_HYPERBOLIC_TANGENT
          else if (funcname == "atanh")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::atanh(arg));
            }
#endif
          else if (funcname == "sqrt")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::sqrt(arg));
            }
          else if (funcname == "abs")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::abs(arg));
            }
          else if (funcname == "max")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              STRING_VECTOR::const_iterator it = A.begin();
              double result = _convert_to_type(*it++, 0.0);
              for (; it != A.end(); ++it)
                result = std::max(result, _convert_to_type(*it, 0.0));
              return _convert_from_type(result);
            }
          else if (funcname == "min")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              STRING_VECTOR::const_iterator it = A.begin();
              double result = _convert_to_type(*it++, 0.0);
              for (; it != A.end(); ++it)
                result = std::min(result, _convert_to_type(*it, 0.0));
              return _convert_from_type(result);
            }
          else if (funcname == "ceil")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::ceil(arg));
            }
          else if (funcname == "floor")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              double arg = _convert_to_type(A[0], 0.0);
              return _convert_from_type(std::floor(arg));
            }
          else if (funcname == "fmod")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 2);
              double arg1 = _convert_to_type(A[0], 0.0);
              double arg2 = _convert_to_type(A[1], 0.0);
              return _convert_from_type(std::fmod(arg1, arg2));
            }
          else if (funcname == "srand")
            {
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              unsigned int arg = _convert_to_type(A[0], 0u);
              std::srand(arg);
              return A[0];
            }
          // ${=rand range} with default range==RAND_MAX
          else if (funcname == "rand")
            {
              if (funcnameend >= expr.length() ||
                  expr.find_first_not_of(" \t", funcnameend) == std::string::npos)
                return _convert_from_type(std::rand());
 
              STRING_VECTOR A =
                _DBE_get_expr_list(expr.substr(funcnameend), 1);
              unsigned int range = _convert_to_type(A[0],0u);
              if (!range)
                return _convert_from_type(0);
              const unsigned int x = (RAND_MAX + 1u) / range;
              const unsigned int y = x * range;
              unsigned int returnval;
              do
                {
                  returnval = rand();
                } while (returnval >= y);
              return _convert_from_type(returnval / x);
            }
          else if (funcname == "time")
            return _convert_from_type(std::time(NULL));
          else
            {
              getpot_cerr << "ERROR: unrecognized function "
                          << funcname << std::endl;
              getpot_error();
            }
        }
    }
 
  // ${+ ...}, ${- ...}, ${* ...}, ${/ ...} expressions
  else if (expr[0] == '+')
    {
      STRING_VECTOR A = _DBE_get_expr_list(expr.substr(1), 2);
      STRING_VECTOR::const_iterator it = A.begin();
      double result = _convert_to_type(*it++, 0.0);
      for (; it != A.end(); ++it)
        result += _convert_to_type(*it, 0.0);
 
      return _convert_from_type(result);
    }
  else if (expr[0] == '-')
    {
      STRING_VECTOR A = _DBE_get_expr_list(expr.substr(1), 2);
      STRING_VECTOR::const_iterator it = A.begin();
      double result = _convert_to_type(*it++, 0.0);
      for (; it != A.end(); ++it)
        result -= _convert_to_type(*it, 0.0);
 
      return _convert_from_type(result);
    }
  else if (expr[0] == '*')
    {
      STRING_VECTOR A = _DBE_get_expr_list(expr.substr(1), 2);
      STRING_VECTOR::const_iterator it = A.begin();
      double result = _convert_to_type(*it++, 0.0);
      for (; it != A.end(); ++it)
        result *= _convert_to_type(*it, 0.0);
 
      return _convert_from_type(result);
    }
  else if (expr[0] == '/')
    {
      STRING_VECTOR A = _DBE_get_expr_list(expr.substr(1), 2);
      STRING_VECTOR::const_iterator it = A.begin();
      double result = _convert_to_type(*it++, 0.0);
      if (result == 0)
        return "0.0";
 
      for (; it != A.end(); ++it)
        {
          const double Q = _convert_to_type(*it, 0.0);
          result /= Q;
        }
      return _convert_from_type(result);
    }
 
  // ${^ ... } power expressions
  else if (expr[0] == '^')
    {
      STRING_VECTOR A = _DBE_get_expr_list(expr.substr(1), 2);
      STRING_VECTOR::const_iterator it = A.begin();
      double result = _convert_to_type(*it++, 0.0);
      for (; it != A.end(); ++it)
        result = pow(result, _convert_to_type(*it, 0.0));
      return _convert_from_type(result);
    }
 
  // ${==  } ${<=  } ${>= } comparisons (return the number of the first 'match'
  else if (expr.length() >= 2 &&
           (expr.substr(0,2) == "==" || expr.substr(0,2) == ">=" ||
            expr.substr(0,2) == "<=" || expr[0] == '>'           || expr[0] == '<'))
    {
      // differentiate between two and one sign operators
      unsigned op = 0;
      enum { EQ, GEQ, LEQ, GT, LT };
 
      if (expr.substr(0, 2) == "==")
        op = EQ;
 
      else if (expr.substr(0, 2) == ">=")
        op = GEQ;
 
      else if (expr.substr(0, 2) == "<=")
        op = LEQ;
 
      else if (expr[0] == '>')
        op = GT;
 
      else
        op = LT;
 
      STRING_VECTOR a;
      if (op == GT || op == LT)
        a = _DBE_get_expr_list(expr.substr(1), 2);
 
      else
        a = _DBE_get_expr_list(expr.substr(2), 2);
 
      std::string   x_orig = a[0];
      double   x = _convert_to_type(x_orig, 1e37);
      unsigned i = 1;
 
      STRING_VECTOR::const_iterator y_orig = a.begin();
      for (y_orig++; y_orig != a.end(); ++y_orig)
        {
          double y = _convert_to_type(*y_orig, 1e37);
 
          // set the strings as reference if one wasn't a number
          if (x == 1e37 || y == 1e37)
            {
              // it's a string comparison
              if ((op == EQ  && x_orig == *y_orig) || (op == GEQ && x_orig >= *y_orig) ||
                  (op == LEQ && x_orig <= *y_orig) || (op == GT  && x_orig >  *y_orig) ||
                  (op == LT  && x_orig <  *y_orig))
                return _convert_from_type(i);
            }
          else
            {
              // it's a number comparison
              if ((op == EQ  && x == y) || (op == GEQ && x >= y) ||
                  (op == LEQ && x <= y) || (op == GT  && x >  y) ||
                  (op == LT  && x <  y))
                return _convert_from_type(i);
            }
          i++;
        }
 
      // nothing fulfills the condition => return 0
      return "0";
    }
 
  // ${?? expr expr} select
  else if (expr.length() >= 2 && expr.substr(0, 2) == "??")
    {
      STRING_VECTOR a = _DBE_get_expr_list(expr.substr(2), 2);
      double x = _convert_to_type(a[0], 1e37);
 
      // last element is always the default argument
      if (x == 1e37 || x < 0 || x >= double(a.size() - 1))
        return a[a.size()-1];
 
      // round x to closest integer
      return a[int(x+0.5)];
    }
 
  // ${? expr expr expr} if then else conditions
  else if (expr[0] == '?')
    {
      STRING_VECTOR a = _DBE_get_expr_list(expr.substr(1), 2);
 
      if (_convert_to_type(a[0], 0.0) == 1.0)
        return a[1];
 
      else if (a.size() > 2)
        return a[2];
    }
  // ${! expr} maxro expansion
  else if (expr[0] == '!')
    {
      const GetPot::variable* Var = _DBE_get_variable(expr.substr(1));
      // error
      if (Var->name == "")
        return std::string(Var->original);
 
      const STRING_VECTOR A = _DBE_get_expr_list(Var->original, 2);
      return A[0];
    }
  // ${@: } - string subscription
  else if (expr.length() >= 2 && expr.substr(0,2) == "@:")
    {
      const STRING_VECTOR A = _DBE_get_expr_list(expr.substr(2), 2);
      double x = _convert_to_type(A[1], 1e37);
 
      // last element is always the default argument
      if (x == 1e37 || x < 0 || x >= double(A[0].size() - 1))
        return "<<1st index out of range>>";
 
      if (A.size() > 2)
        {
          double y = _convert_to_type(A[2], 1e37);
          if (y != 1e37 && y > 0 && y <= double(A[0].size() - 1) && y > x)
            return A[0].substr(int(x+0.5), int(y+1.5) - int(x+0.5));
 
          else if (y == -1)
            return A[0].substr(int(x+0.5));
 
          return "<<2nd index out of range>>";
        }
      else
        {
          char* tmp = new char[2];
          tmp[0] = A[0][int(x+0.5)]; tmp[1] = '\0';
          std::string result(tmp);
          delete [] tmp;
          return result;
        }
    }
  // ${@ } - vector subscription
  else if (expr[0] == '@')
    {
      STRING_VECTOR          A   = _DBE_get_expr_list(expr.substr(1), 2);
      const GetPot::variable* Var = _DBE_get_variable(A[0]);
      // error
      if (Var->name == "")
        {
          // make a copy of the string if an error occurred
          // (since the error variable is a static variable inside get_variable())
          return std::string(Var->original);
        }
 
      double x = _convert_to_type(A[1], 1e37);
 
      // last element is always the default argument
      if (x == 1e37 || x < 0 || x >= double(Var->value.size()))
        return "<<1st index out of range>>";
 
      if (A.size() > 2)
        {
          double y = _convert_to_type(A[2], 1e37);
          int    begin = int(x+0.5);
          int    end = 0;
          if (y != 1e37 && y > 0 && y <= double(Var->value.size()) && y > x)
            end = int(y+1.5);
          else if (y == -1)
            end = int(Var->value.size());
          else
            return "<<2nd index out of range>>";
 
          std::string result = *(Var->get_element(begin));
          for (int i = begin+1; i < end; i++)
            result += std::string(" ") + *(Var->get_element(i));
          return result;
        }
      else
        return *(Var->get_element(int(x+0.5)));
    }
 
  const STRING_VECTOR    A = _DBE_get_expr_list(expr, 1);
  const GetPot::variable* B = _DBE_get_variable(A[0]);
 
  // make a copy of the string if an error occurred
  // (since the error variable is a static variable inside get_variable())
  if (B->name == "")
    return std::string(B->original);
 
  // (psuggs@pobox.com mentioned to me the warning MSVC++6.0 produces
  //  with:  else return B->original (thanks))
  return B->original;
}

References _convert_from_type(), _convert_to_type(), _DBE_get_expr_list(), _DBE_get_variable(), GETPOT_NAMESPACE::GetPot::variable::get_element(), int, GETPOT_NAMESPACE::GetPot::variable::name, GETPOT_NAMESPACE::GetPot::variable::original, size(), and GETPOT_NAMESPACE::GetPot::variable::value.

Referenced by _DBE_expand_string(), and _DBE_get_expr_list().

◆ _DBE_expand_string()

std::string GETPOT_NAMESPACE::GetPot::_DBE_expand_string ( const std::string & str )

inlineprivate

dollar bracket expressions

Definition at line 2764 of file getpot.h.

{
  // Parses for closing operators '${ }' and expands them letting
  // white spaces and other letters as they are.
  std::string   new_string = "";
  unsigned open_brackets = 0;
  unsigned first = 0;
  for (unsigned i = 0;  i<str.size(); i++)
    {
      if (i + 2 < str.size() && str.substr(i, 2) == "${")
        {
          if (open_brackets == 0)
            first = i+2;
          open_brackets++;
        }
      else if (str[i] == '}' && open_brackets > 0)
        {
          open_brackets -= 1;
          if (open_brackets == 0)
            {
              const std::string Replacement = _DBE_expand(str.substr(first, i - first));
              new_string += Replacement;
            }
        }
      else if (open_brackets == 0)
        new_string += str[i];
    }
  return new_string;
}

References _DBE_expand().

Referenced by _parse_argument_vector().

◆ _DBE_get_expr_list()

STRING_VECTOR GETPOT_NAMESPACE::GetPot::_DBE_get_expr_list	(	const std::string &	str,
		const unsigned	ExpectedNumber
	)

inlineprivate

Definition at line 2797 of file getpot.h.

{
  // ensures that the resulting vector has the expected number
  // of arguments, but they may contain an error message
  std::string str = str_;
  // Separates expressions by non-bracketed whitespaces, expands them
  // and puts them into a list.
 
  unsigned i=0;
  // (1) eat initial whitespaces
  for (; i < str.size(); i++)
    if (!std::isspace(str[i]))
      break;
 
  STRING_VECTOR   expr_list;
  unsigned         open_brackets = 0;
  std::vector<unsigned> start_idx;
  unsigned         start_new_string = i;
  unsigned         l = (unsigned)(str.size());
 
  // (2) search for ${ } expressions ...
  while (i < l)
    {
      const char letter = str[i];
      // whitespace -> end of expression
      if (std::isspace(letter) && open_brackets == 0)
        {
          expr_list.push_back(str.substr(start_new_string, i - start_new_string));
          bool no_breakout_f = true;
          for (i++; i < l ; i++)
            {
              if (!std::isspace(str[i]))
                {
                  no_breakout_f = false;
                  start_new_string = i;
                  break;
                }
            }
 
          if (no_breakout_f)
            {
              // end of expression list
              if (expr_list.size() < ExpectedNumber)
                {
                  const std::string   pre_tmp("<< ${ }: missing arguments>>");
                  STRING_VECTOR tmp(ExpectedNumber - expr_list.size(), pre_tmp);
                  expr_list.insert(expr_list.end(), tmp.begin(), tmp.end());
                }
              return expr_list;
            }
        }
 
      // dollar-bracket expression
      if (str.length() >= i+2 && str.substr(i, 2) == "${")
        {
          open_brackets++;
          start_idx.push_back(i+2);
        }
 
      else if (letter == '}' && open_brackets > 0)
        {
          int start = start_idx[start_idx.size()-1];
          start_idx.pop_back();
          const std::string Replacement = _DBE_expand(str.substr(start, i-start));
          if (start - 3 < (int)0)
            str = Replacement + str.substr(i+1);
          else
            str = str.substr(0, start-2) + Replacement + str.substr(i+1);
          l = (int)(str.size());
          i = start + (int)(Replacement.size()) - 3;
          open_brackets--;
        }
      i++;
    }
 
  // end of expression list
  expr_list.push_back(str.substr(start_new_string, i-start_new_string));
 
  if (expr_list.size() < ExpectedNumber)
    {
      const std::string   pre_tmp("<< ${ }: missing arguments>>");
      STRING_VECTOR tmp(ExpectedNumber - expr_list.size(), pre_tmp);
      expr_list.insert(expr_list.end(), tmp.begin(), tmp.end());
    }
 
  return expr_list;
}

References _DBE_expand(), and int.

Referenced by _DBE_expand().

◆ _DBE_get_variable()

const GetPot::variable * GETPOT_NAMESPACE::GetPot::_DBE_get_variable ( const std::string & str )

inlineprivate

Definition at line 2888 of file getpot.h.

{
  static GetPot::variable ev;
  std::string secure_Prefix = prefix;
 
  prefix = section;
  // (1) first search in currently active section
  const GetPot::variable* var = _request_variable(VarName.c_str());
  if (var != 0)
    {
      prefix = secure_Prefix;
      return var;
    }
 
  // (2) search in root name space
  prefix = "";
  var = _request_variable(VarName.c_str());
  if (var != 0)
    {
      prefix = secure_Prefix;
      return var;
    }
 
  prefix = secure_Prefix;
 
  // error occurred => variable name == ""
  ev.original = "<<${ } variable '";
  ev.original += VarName + "' undefined>>";
  return &ev;
}

References _request_variable(), GETPOT_NAMESPACE::GetPot::variable::original, prefix, and section.

Referenced by _DBE_expand().

◆ _find_variable()

const GetPot::variable * GETPOT_NAMESPACE::GetPot::_find_variable ( const char * VarName ) const

inlineprivate

helpers for argument list processing

search for a variable in 'variables' array

Definition at line 2651 of file getpot.h.

{
  const std::string Name = prefix + VarName;
 
  std::vector<variable>::const_iterator it = variables.begin();
  for (; it != variables.end(); ++it)
    {
      if ((*it).name == Name)
        return &(*it);
    }
  return 0;
}

References prefix, and variables.

Referenced by _request_variable(), and _set_variable().

◆ _get_next_token()

const std::string GETPOT_NAMESPACE::GetPot::_get_next_token ( std::istream & istr )

inlineprivate

Definition at line 1362 of file getpot.h.

{
  // get next concatenates string token. consider quotes that embrace
  // whitespaces
  std::string token;
  int    tmp = 0;
  while (true)
    {
      int last_letter = tmp;
      tmp = istr.get();
 
      if (tmp == '=')
        {
          // Always break at '='.
          // This separates '=' at the beginning of a word into its own word.
          token += getpot_cast_int<char>(tmp);
          return token;
        }
 
      else if (tmp == EOF || ((tmp == ' ' || tmp == '\t' || tmp == '\n') && last_letter != '\\'))
        return token;
 
      else if (tmp == '\'' && last_letter != '\\')
        {
          // QUOTES: un-backslashed quotes => it's a string
          token += _get_string(istr);
          continue;
        }
 
      else if (tmp == '{' && last_letter == '$')
        {
          token += '{' + _get_until_closing_bracket(istr);
          continue;
        }
 
      else if (tmp == '[')
        {
          token += '[' + _get_until_closing_square_bracket(istr);
          continue;
        }
 
      else if (tmp == '$' && last_letter == '\\')
        {
          token += getpot_cast_int<char>(tmp); tmp = 0;  //  so that last_letter will become = 0, not '$';
          continue;
        }
 
      else if (tmp == '\\' && last_letter != '\\')
        continue;              // don't append un-backslashed backslashes
 
      token += getpot_cast_int<char>(tmp);
    }
}

References _get_string(), _get_until_closing_bracket(), and _get_until_closing_square_bracket().

Referenced by _read_in_stream().

◆ _get_remaining_string()

const std::string GETPOT_NAMESPACE::GetPot::_get_remaining_string	(	const std::string &	String,
		const std::string &	Start
	)		const

inlineprivate

prefix extraction

Definition at line 1732 of file getpot.h.

{
  if (Start == "")
    return String;
 
  // note: java.lang.String: substring(a,b) = from a to b-1
  //        C++ string:      substr(a,b)    = from a to a + b
  if (String.find(Start) == 0)
    return String.substr(Start.length());
 
  else
    return "";
}

Referenced by argument_contains(), get_variable_names(), next(), options_contain(), unidentified_arguments(), unidentified_flags(), unidentified_nominuses(), unidentified_options(), unidentified_sections(), and unidentified_variables().

◆ _get_section_tree()

static STRING_VECTOR GETPOT_NAMESPACE::GetPot::_get_section_tree ( const std::string & FullPath )

inlinestaticprivate

cuts a variable name into a tree of sub-sections.

this is requested for recording requested sections when dealing with 'ufo' detection.

Definition at line 722 of file getpot.h.

  {
    STRING_VECTOR   result;
    for (std::size_t pos = 0; pos != FullPath.size(); ++pos)
      {
        if (FullPath[pos] == '/')
          result.push_back(FullPath.substr(0,pos));
      }
 
    return result;
  }

Referenced by _record_argument_request(), and _record_variable_request().

◆ _get_string()

const std::string GETPOT_NAMESPACE::GetPot::_get_string ( std::istream & istr )

inlineprivate

Definition at line 1419 of file getpot.h.

{
  // parse input until next matching '
  std::string str;
  int    tmp = 0;
  while (true)
    {
      int last_letter = tmp;
      tmp = istr.get();
      if (tmp == EOF)
        return str;
 
      // un-backslashed quotes => it's the end of the string
      else if (tmp == '\'' && last_letter != '\\')
        return str;
 
      else if (tmp == '\\' && last_letter != '\\')
        continue; // don't append
 
      str += getpot_cast_int<char>(tmp);
    }
}

Referenced by _get_next_token().

◆ _get_until_closing_bracket()

const std::string GETPOT_NAMESPACE::GetPot::_get_until_closing_bracket ( std::istream & istr )

inlineprivate

Definition at line 1445 of file getpot.h.

{
  // parse input until next matching }
  std::string str = "";
  int    tmp = 0;
  int    brackets = 1;
  while (true)
    {
      int last_letter = tmp;
      tmp = istr.get();
      if (tmp == EOF)
        return str;
 
      else if (tmp == '{' && last_letter == '$')
        brackets += 1;
 
      else if (tmp == '}')
        {
          brackets -= 1;
          // un-backslashed brackets => it's the end of the string
          if (brackets == 0)
            return str + '}';
 
          else if (tmp == '\\' && last_letter != '\\')
            continue;  // do not append an unbackslashed backslash
        }
      str += getpot_cast_int<char>(tmp);
    }
}

Referenced by _get_next_token().

◆ _get_until_closing_square_bracket()

const std::string GETPOT_NAMESPACE::GetPot::_get_until_closing_square_bracket ( std::istream & istr )

inlineprivate

Definition at line 1478 of file getpot.h.

{
  // parse input until next matching ]
  std::string str = "";
  int    brackets = 1;
  while (true)
    {
      int tmp = istr.get();
      if (tmp == EOF)
        return str;
 
      else if (tmp == '[')
        brackets += 1;
 
      else if (tmp == ']')
        {
          brackets -= 1;
          if (brackets == 0)
            return str + ']';
        }
 
      str += getpot_cast_int<char>(tmp);
    }
}

Referenced by _get_next_token().

◆ _internal_managed_copy()

const char * GETPOT_NAMESPACE::GetPot::_internal_managed_copy ( const std::string & Arg ) const

inlineprivate

some functions return a char pointer to a temporarily existing string this function adds them to our container

Definition at line 1701 of file getpot.h.

{
  const char* arg = Arg.c_str();
 
  // Get a lock before touching anything mutable
  SCOPED_MUTEX;
 
  // See if there's already an identical string saved
  // If so, return it
  if (auto it = _internal_string_container.find(arg);
      it != _internal_string_container.end())
    return it->get();
 
  // Otherwise, create a new one
  auto newcopy = std::make_unique<char[]>(strlen(arg)+1);
  // Note: strcpy() is safe here because we allocated enough space and
  // "arg" is guaranteed to be null-terminated.
  strcpy(newcopy.get(), arg);
  auto pr = _internal_string_container.insert(std::move(newcopy));
  return pr.first->get();
}

References _internal_string_container.

Referenced by direct_follow(), follow(), get_value_no_default(), next(), next_nominus(), and operator()().

◆ _match_starting_string()

const char * GETPOT_NAMESPACE::GetPot::_match_starting_string ( const char * StartString )

inlineprivate

support finding directly followed arguments

Definition at line 2053 of file getpot.h.

{
  const unsigned N =
    getpot_cast_int<unsigned>(strlen(StartString));
  unsigned       OldCursor = cursor;
 
  if (OldCursor >= argv.size())
    OldCursor = getpot_cast_int<unsigned>(argv.size() - 1);
  search_failed_f = true;
 
  // (*) first loop from cursor position until end
  for (unsigned c = cursor; c < argv.size(); c++)
    {
      if (strncmp(StartString, argv[c].c_str(), N) == 0)
        {
          cursor = c;
          search_failed_f = false;
          return &(argv[c].c_str()[N]);
        }
    }
 
  if (!search_loop_f)
    return NULL;
 
  // (*) second loop from 0 to old cursor position
  for (unsigned c = 1; c < OldCursor; c++)
    {
      if (strncmp(StartString, argv[c].c_str(), N) == 0)
        {
          cursor = c;
          search_failed_f = false;
          return &(argv[c].c_str()[N]);
        }
    }
  return 0;
}

References argv, cursor, search_failed_f, and search_loop_f.

Referenced by direct_follow().

◆ _parse_argument_vector()

void GETPOT_NAMESPACE::GetPot::_parse_argument_vector ( const STRING_VECTOR & ARGV )

inlineprivate

produce three basic data vectors:

argument vector
nominus vector
variable dictionary

Definition at line 1125 of file getpot.h.

{
  if (ARGV.empty())
    return;
 
  // build internal databases:
  //   1) array with no-minus arguments (usually used as filenames)
  //   2) variable assignments:
  //             'variable name' '=' number | string
  STRING_VECTOR                 section_stack;
  STRING_VECTOR::const_iterator it = ARGV.begin();
 
 
  section = "";
 
  // -- do not parse the first argument, so that this parsing source
  // name is not interpreted a s a nominus or so.  If we already
  // have parsed arguments, don't bother adding another parsing
  // source name
  if (argv.empty())
    argv.push_back(*it);
  ++it;
 
  // -- loop over remaining arguments
  for (; it != ARGV.end(); ++it)
    {
      std::string arg = *it;
 
      if (arg.length() == 0)
        continue;
 
      // -- [section] labels and [include file] directives
      if (arg.length() > 1 && arg[0] == '[' && arg[arg.length()-1] == ']')
        {
 
          // Is this an include file directive?
          std::size_t include_pos = arg.find("include ", 1);
          if (include_pos != std::string::npos)
            {
 
              const std::string includefile =
                _DBE_expand_string(arg.substr(9, arg.length()-9-include_pos));
 
              this->parse_input_file
                (includefile, _comment_start, _comment_end, _field_separator);
            }
 
          else
            {
              // (*) sections are considered 'requested arguments'
              if (request_recording_f)
                {
                  // Get a lock before touching anything mutable
                  SCOPED_MUTEX;
 
                  _requested_arguments.insert(arg);
                }
 
              const std::string Name = _DBE_expand_string(arg.substr(1, arg.length()-2));
              section = _process_section_label(Name, section_stack);
              // new section --> append to list of sections
              if (find(section_list.begin(), section_list.end(), section) == section_list.end())
                if (section.length() != 0) section_list.push_back(section);
              argv.push_back(arg);
            }
        }
      else
        {
          arg = section + _DBE_expand_string(arg);
          argv.push_back(arg);
        }
 
      // -- separate array for nominus arguments
      if (arg[0] != '-')
        idx_nominus.push_back(getpot_cast_int<unsigned>(argv.size()-1));
 
      // -- variables: does arg contain a '=' operator ?
      const std::size_t equals_pos = arg.find_first_of('=');
      if (equals_pos != std::string::npos)
        {
          // (*) record for later ufo detection
          //     arguments carrying variables are always treated as 'requested' arguments.
          //     unrequested variables have to be detected with the ufo-variable
          //     detection routine.
          if (request_recording_f)
            {
              // Get a lock before touching anything mutable
              SCOPED_MUTEX;
 
              _requested_arguments.insert(arg);
            }
 
          // => arg (from start to '=') = Name of variable
          //        (from '=' to end)   = value of variable
          _set_variable(arg.substr(0,equals_pos),
                        arg.substr(equals_pos+1), false);
        }
    }
}

References _comment_end, _comment_start, _DBE_expand_string(), _field_separator, _process_section_label(), _requested_arguments, _set_variable(), argv, idx_nominus, parse_input_file(), request_recording_f, section, and section_list.

Referenced by parse_command_line(), and parse_input_stream().

◆ _process_section_label()

std::string GETPOT_NAMESPACE::GetPot::_process_section_label	(	const std::string &	Section,
		STRING_VECTOR &	section_stack
	)

inlineprivate

Definition at line 1506 of file getpot.h.

{
  std::string sname = Section;
  //  1) subsection of actual section ('./' prefix)
  if (sname.length() >= 2 && sname.substr(0, 2) == "./")
    sname = sname.substr(2);
 
  //  2) subsection of parent section ('../' prefix)
  else if (sname.length() >= 3 && sname.substr(0, 3) == "../")
    {
      do
        {
          if (section_stack.end() != section_stack.begin())
            section_stack.pop_back();
          sname = sname.substr(3);
        } while (sname.substr(0, 3) == "../");
    }
 
  // 3) subsection of the root-section
  else
    // [] => back to root section
    section_stack.erase(section_stack.begin(), section_stack.end());
 
  if (sname != "")
    {
      // parse section name for 'slashes'
      unsigned i=0;
      while (i < sname.length())
        {
          if (sname[i] == '/')
            {
              section_stack.push_back(sname.substr(0,i));
              if (i+1 < sname.length())
                sname = sname.substr(i+1);
              i = 0;
            }
          else
            i++;
        }
      section_stack.push_back(sname);
    }
 
  std::string section_label = "";
  if (!section_stack.empty())
    {
      victorate(std::string, section_stack, it)
        section_label += *it + "/";
    }
  return section_label;
}

Referenced by _parse_argument_vector().

◆ _read_in_stream()

STRING_VECTOR GETPOT_NAMESPACE::GetPot::_read_in_stream ( std::istream & istr )

inlineprivate

Definition at line 1228 of file getpot.h.

{
  STRING_VECTOR  brute_tokens;
  while (istr)
    {
      _skip_whitespace(istr);
      const std::string Token = _get_next_token(istr);
      // Allow 'keyword =' to parse with an empty string as value.
      // Only break at EOF.
      // if (Token.length() == 0 || Token[0] == EOF) break;
      if (Token[0] == EOF)
        break;
      brute_tokens.push_back(Token);
    }
 
  // -- reduce expressions of token1'='token2 to a single
  //    string 'token1=token2'
  // -- copy everything into 'argv'
  // -- arguments preceded by something like '[' name ']' (section)
  //    produce a second copy of each argument with a prefix '[name]argument'
  unsigned i1 = 0;
  unsigned i2 = 1;
  unsigned i3 = 2;
 
  STRING_VECTOR  arglist;
  while (i1 < brute_tokens.size())
    {
      // 1) concatenate 'abcdef' '=' 'efgasdef' to 'abcdef=efgasdef'
      // note: java.lang.String: substring(a,b) = from a to b-1
      //        C++ string:      substr(a,b)    = from a to a + b
      std::string result;
      if (i2 < brute_tokens.size() && brute_tokens[i2] == "=")
        {
          if (i3 >= brute_tokens.size())
            result = brute_tokens[i1] + brute_tokens[i2];
          else
            result = brute_tokens[i1] + brute_tokens[i2] + brute_tokens[i3];
          i1 = i3+1; i2 = i3+2; i3 = i3+3;
        }
      else if (i2 < brute_tokens.size() &&
               brute_tokens[i2].length() > 0 &&
               brute_tokens[i2][0] == '=')
        {
          // This case should not be hit if '=' at the beginning of a word
          //   is always separated into its own word
          result = brute_tokens[i1] + brute_tokens[i2];
          i1 = i3; i2 = i3+1; i3 = i3+2;
        }
      else if (i2 < brute_tokens.size() && brute_tokens[i1][brute_tokens[i1].size()-1] == '=')
        {
          result = brute_tokens[i1] + brute_tokens[i2];
          i1 = i3; i2 = i3+1; i3 = i3+2;
        }
      else
        {
          result = brute_tokens[i1];
          i1=i2; i2=i3; i3++;
        }
 
      // Now strip out any comment
      size_t comment_start_loc = result.find(_comment_start, 0);
      if (comment_start_loc != std::string::npos)
        result = result.substr(0, comment_start_loc);
 
      arglist.push_back(result);
    }
  return arglist;
}

References _comment_start, _get_next_token(), and _skip_whitespace().

Referenced by parse_input_stream().

◆ _record_argument_request()

void GETPOT_NAMESPACE::GetPot::_record_argument_request ( const std::string & Arg ) const

inlineprivate

if an argument is requested record it and the 'tag' the section branch to which it belongs.

Caution: both functions mark the sections as 'tagged'. These are "const" functions but they do modify the mutable requested* members

Definition at line 2450 of file getpot.h.

{
  if (!request_recording_f)
    return;
 
  // Get a lock before touching anything mutable
  SCOPED_MUTEX;
 
  // (*) record requested variable for later ufo detection
  _requested_arguments.insert(Name);
 
  // (*) record considered section for ufo detection
  STRING_VECTOR      STree = _get_section_tree(Name);
  victorate(std::string, STree, it)
    if (_requested_sections.find(*it) == _requested_sections.end())
      if (section.length() != 0)
        _requested_sections.insert(*it);
}

References _get_section_tree(), _requested_arguments, _requested_sections, request_recording_f, and section.

Referenced by argument_contains(), direct_follow(), next(), next_nominus(), next_nominus_string(), nominus_vector(), search(), and search().

◆ _record_variable_request()

void GETPOT_NAMESPACE::GetPot::_record_variable_request ( const std::string & Arg ) const

inlineprivate

Definition at line 2472 of file getpot.h.

{
  if (!request_recording_f)
    return;
 
  // Get a lock before touching anything mutable
  SCOPED_MUTEX;
 
  // (*) record requested variable for later ufo detection
  _requested_variables.insert(Name);
 
  // (*) record considered section for ufo detection
  STRING_VECTOR      STree = _get_section_tree(Name);
  victorate(std::string, STree, it)
    if (_requested_sections.find(*it) == _requested_sections.end())
      if (section.length() != 0)
        _requested_sections.insert(*it);
}

References _get_section_tree(), _requested_sections, _requested_variables, request_recording_f, and section.

Referenced by _request_variable().

◆ _request_variable()

const GetPot::variable * GETPOT_NAMESPACE::GetPot::_request_variable ( const char * VarName ) const

inlineprivate

search (and record request) for a variable in 'variables' array

Definition at line 2667 of file getpot.h.

{
  // (*) record requested variable for later ufo detection
  this->_record_variable_request(VarName);
 
  return this->_find_variable(VarName);
}

References _find_variable(), and _record_variable_request().

Referenced by _DBE_get_variable(), _set_variable(), get_value_no_default(), get_value_no_default(), have_variable(), operator()(), operator()(), and vector_variable_size().

◆ _search_string_vector()

bool GETPOT_NAMESPACE::GetPot::_search_string_vector	(	const STRING_VECTOR &	Vec,
		const std::string &	Str
	)		const

inlineprivate

search for a specific string

Definition at line 3427 of file getpot.h.

{
  victorate(std::string, VecStr, itk)
    {
      if (*itk == Str)
        return true;
    }
  return false;
}

◆ _set_variable()

void GETPOT_NAMESPACE::GetPot::_set_variable	(	const std::string &	VarName,
		const std::string &	Value,
		const bool	Requested
	)

inlineprivate

helper functions

set variable from inside GetPot (no prefix considered)

Definition at line 2496 of file getpot.h.

{
  const GetPot::variable* Var = Requested ?
    _request_variable(VarName.c_str()) :
    _find_variable(VarName.c_str());
  if (Var == 0)
    variables.push_back(variable(VarName.c_str(), Value.c_str(), _field_separator.c_str()));
  else
    {
      overridden_vars.insert(VarName.c_str());
      (const_cast<GetPot::variable*>(Var))->take(Value.c_str(), _field_separator.c_str());
    }
}

References _field_separator, _find_variable(), _request_variable(), overridden_vars, and variables.

Referenced by _parse_argument_vector(), set(), and set().

◆ _skip_whitespace()

void GETPOT_NAMESPACE::GetPot::_skip_whitespace ( std::istream & istr )

inlineprivate

helpers to parse input file create an argument vector based on data found in an input file, i.e.: 1) delete comments (in between '_comment_start' '_comment_end') 2) contract assignment expressions, such as my-variable = '007 J.

B.' into my-variable='007 J. B.' 3) interpret sections like '[../my-section]' etc.

Definition at line 1300 of file getpot.h.

{
  // find next non-whitespace while deleting comments
  int tmp = istr.get();
  do {
    // -- search a non whitespace
    while (std::isspace(tmp))
      {
        tmp = istr.get();
        if (!istr)
          return;
      }
 
    // -- look if characters match the comment starter string
    for (unsigned i=0; i<_comment_start.length() ; i++)
      {
        if (tmp != _comment_start[i])
          {
            // -- one step more backwards, since 'tmp' already at non-whitespace
            istr.unget();
            return;
          }
 
        // RHS: Why is this here?  It breaks on empty comments
        //    tmp = istr.get();
        //    if (!istr) { istr.unget(); return; }
      }
    // 'tmp' contains last character of _comment_starter
 
    // -- comment starter found -> search for comment ender
    unsigned match_no=0;
    while (true)
      {
        tmp = istr.get();
        if (!istr)
          {
            istr.unget();
            return;
          }
 
        if (tmp == _comment_end[match_no])
          {
            match_no++;
            if (match_no == _comment_end.length())
              {
                istr.unget();
                break; // shuffle more whitespace, end of comment found
              }
          }
        else
          match_no = 0;
      }
 
    tmp = istr.get();
 
  } while (istr);
  istr.unget();
}

References _comment_end, and _comment_start.

Referenced by _read_in_stream().

◆ absorb()

void GETPOT_NAMESPACE::GetPot::absorb ( const GetPot & Other )

inline

absorbing contents of another GetPot object

Definition at line 1082 of file getpot.h.

{
  if (&Other == this)
    return;
 
  // variables that are not influenced by absorption:
  //               _comment_start
  //               _comment_end
  //               cursor
  //               nominus_cursor
  //               search_failed
  //               idx_nominus
  //               search_loop_f
  argv      = Other.argv;
  variables = Other.variables;
 
  if (request_recording_f)
    {
      // Get a lock before touching anything mutable
      SCOPED_MUTEX;
 
      _requested_arguments.insert(Other._requested_arguments.begin(), Other._requested_arguments.end());
      _requested_variables.insert(Other._requested_variables.begin(), Other._requested_variables.end());
      _requested_sections.insert(Other._requested_sections.begin(), Other._requested_sections.end());
    }
}

References _requested_arguments, _requested_sections, _requested_variables, argv, request_recording_f, and variables.

◆ argument_contains()

bool GETPOT_NAMESPACE::GetPot::argument_contains	(	unsigned	Idx,
		const char *	FlagList
	)		const

inline

Definition at line 2116 of file getpot.h.

{
  if (Idx >= argv.size())
    return false;
 
  // (*) record requested of argument for later ufo-detection
  //     an argument that is checked for flags is considered to be 'requested'
  _record_argument_request(argv[Idx]);
 
  if (prefix == "")
    // search argument for any flag in flag list
    return _check_flags(argv[Idx], FlagList);
 
  // if a prefix is set, then the argument index is the index
  //   inside the 'namespace'
  // => only check list of arguments that start with prefix
  unsigned no_matches = 0;
  for (unsigned i=0; i<argv.size(); i++)
    {
      const std::string Remain = _get_remaining_string(argv[i], prefix);
      if (Remain != "")
        {
          no_matches += 1;
          if (no_matches == Idx)
            return _check_flags(Remain, FlagList);
        }
    }
 
  // no argument in this namespace
  return false;
}

References _check_flags(), _get_remaining_string(), _record_argument_request(), argv, and prefix.

◆ clear_requests()

void GETPOT_NAMESPACE::GetPot::clear_requests ( )

inline

for ufo detection: recording requested arguments, options etc.

Definition at line 1112 of file getpot.h.

{
  // Get a lock before touching anything mutable
  SCOPED_MUTEX;
 
  _requested_arguments.clear();
  _requested_variables.clear();
  _requested_sections.clear();
}

References _requested_arguments, _requested_sections, and _requested_variables.

◆ direct_follow() [1/2]

const char * GETPOT_NAMESPACE::GetPot::direct_follow	(	const char *	Default,
		const char *	Option
	)

inline

Definition at line 2042 of file getpot.h.

{
  return _internal_managed_copy(direct_follow(std::string(Default), Option));
}

References _internal_managed_copy(), and direct_follow().

◆ direct_follow() [2/2]

template<typename T >

T GETPOT_NAMESPACE::GetPot::direct_follow	(	const T &	Default,
		const char *	Option
	)

inline

directly followed arguments

Definition at line 2024 of file getpot.h.

{
  const char* FollowStr = _match_starting_string(Option);
 
  // (*) record requested of argument for later ufo-detection
  _record_argument_request(std::string(Option) + FollowStr);
 
  if (FollowStr == 0)
    return Default;
 
  if (++cursor >= argv.size())
    cursor = getpot_cast_int<unsigned>(argv.size());
  return _convert_to_type(FollowStr, Default);
}

References _convert_to_type(), _match_starting_string(), _record_argument_request(), argv, and cursor.

Referenced by direct_follow().

◆ disable_loop()

void GETPOT_NAMESPACE::GetPot::disable_loop ( )

inline

enable/disable search for an option in loop

Definition at line 362 of file getpot.h.

362{ search_loop_f = false; }

References search_loop_f.

Referenced by init_multiple_occurrence().

◆ disable_request_recording()

void GETPOT_NAMESPACE::GetPot::disable_request_recording ( )

inline

Definition at line 211 of file getpot.h.

211{ request_recording_f = false; }

References request_recording_f.

◆ enable_loop()

void GETPOT_NAMESPACE::GetPot::enable_loop ( )

inline

Definition at line 363 of file getpot.h.

363{ search_loop_f = true; }

References search_loop_f.

◆ enable_request_recording()

void GETPOT_NAMESPACE::GetPot::enable_request_recording ( )

inline

Definition at line 212 of file getpot.h.

212{ request_recording_f = true; }

References request_recording_f.

◆ follow() [1/5]

const char * GETPOT_NAMESPACE::GetPot::follow	(	const char *	Default,
		const char *	Option
	)

inline

Definition at line 1954 of file getpot.h.

{
  return _internal_managed_copy(follow(std::string(Default), Option));
}

References _internal_managed_copy(), and follow().

◆ follow() [2/5]

const char * GETPOT_NAMESPACE::GetPot::follow	(	const char *	Default,
		unsigned	No,
		const char *	Option,
			...
	)

inline

Definition at line 1992 of file getpot.h.

{
  // (*) record requested of argument is entirely handled in 'search()' and 'next()'
  if (No == 0)
    return Default;
 
  if (search(P) == true)
    return next(Default);
 
  va_list ap;
  va_start(ap, P);
  for (unsigned i=1; i<No; i++)
    {
      char* Opt = va_arg(ap, char *);
      if (search(Opt) == true)
        {
          va_end(ap);
          return next(Default);
        }
    }
  va_end(ap);
  return Default;
}

References next(), and search().

◆ follow() [3/5]

template<typename T >

T GETPOT_NAMESPACE::GetPot::follow	(	const T &	Default,
		const char *	Option
	)

inline

search for option and get argument at cursor++

Definition at line 1942 of file getpot.h.

{
  // (*) record requested of argument is entirely handled in 'search()' and 'next()'
  if (search(Option) == false)
    return Default;
 
  return next(Default);
}

References next(), and search().

Referenced by follow().

◆ follow() [4/5]

template<typename T >

T GETPOT_NAMESPACE::GetPot::follow	(	const T &	Default,
		unsigned int	No,
		const char *	P,
			...
	)

inline

Definition at line 1965 of file getpot.h.

{
  // (*) record requested of argument is entirely handled in 'search()' and 'next()'
  if (No == 0)
    return Default;
 
  if (search(P) == true)
    return next(Default);
 
  va_list ap;
  va_start(ap, P);
  for (unsigned i=1; i<No; i++)
    {
      char* Opt = va_arg(ap, char *);
      if (search(Opt) == true)
        {
          va_end(ap);
          return next(Default);
        }
    }
  va_end(ap);
  return Default;
}

References next(), and search().

◆ follow() [5/5]

template<typename T >

T GETPOT_NAMESPACE::GetPot::follow	(	const T &	Default,
		unsigned	No,
		const char *	Option,
			...
	)

inline

search for one of the given options and get argument that follows it

◆ get() [1/3]

const char * GETPOT_NAMESPACE::GetPot::get	(	unsigned	Idx,
		const char *	Default
	)		const

inline

◆ get() [2/3]

template<typename T >

T GETPOT_NAMESPACE::GetPot::get	(	unsigned	Idx,
		const T &	Default
	)		const

inline

◆ get() [3/3]

template<typename T >

T GETPOT_NAMESPACE::GetPot::get	(	unsigned int	Idx,
		const T &	Default
	)		const

inline

Definition at line 1879 of file getpot.h.

{
  if (Idx >= argv.size())
    return Default;
  return _convert_to_type(argv[Idx], Default);
}

References _convert_to_type(), and argv.

◆ get_overridden_variables()

std::set< std::string > GETPOT_NAMESPACE::GetPot::get_overridden_variables ( ) const

inline

Definition at line 2643 of file getpot.h.

{
  return overridden_vars;
}

References overridden_vars.

◆ get_requested_arguments()

std::set< std::string > GETPOT_NAMESPACE::GetPot::get_requested_arguments ( ) const

inline

Accessors for requested variables.

Definition at line 3877 of file getpot.h.

{
  return _requested_arguments;
}

References _requested_arguments.

◆ get_requested_sections()

std::set< std::string > GETPOT_NAMESPACE::GetPot::get_requested_sections ( ) const

inline

Definition at line 3895 of file getpot.h.

{
  return _requested_sections;
}

References _requested_sections.

◆ get_requested_variables()

std::set< std::string > GETPOT_NAMESPACE::GetPot::get_requested_variables ( ) const

inline

Definition at line 3886 of file getpot.h.

{
  return _requested_variables;
}

References _requested_variables.

◆ get_section_names()

STRING_VECTOR GETPOT_NAMESPACE::GetPot::get_section_names ( ) const

inline

Definition at line 2585 of file getpot.h.

{
  return section_list;
}

References section_list.

◆ get_subsection_names()

STRING_VECTOR GETPOT_NAMESPACE::GetPot::get_subsection_names ( const std::string & section_name ) const

inline

Definition at line 2593 of file getpot.h.

{
  // GetPot functions should understand user-provided section names
  // either with or without a trailing slash.
  const std::string full_prefix =
    *sec_prefix.rbegin() == '/' ? sec_prefix : sec_prefix + '/';
 
  const std::size_t full_prefix_len = full_prefix.size();
 
  // Subsections-of-subsections are in the section_list, so we'll be
  // adding subsections multiple times.  Using std::set as an
  // intermediate data structure helps us check for duplicates with
  // O(N log N) rather than O(N^2) cost.
  std::set<std::string> subsections;
 
  STRING_VECTOR returnval;
 
  for (STRING_VECTOR::const_iterator it = section_list.begin();
       it != section_list.end(); ++it)
    {
      const std::string & section_name = *it;
 
      // If this section name begins with the prefix
      if (section_name.compare(0, full_prefix_len, full_prefix) == 0)
        {
          const std::size_t next_slash_len =
            section_name.find('/', full_prefix_len);
 
          const std::string subsection_name =
            section_name.substr(full_prefix_len,
                                next_slash_len - full_prefix_len);
 
          // If there is a subsection, and if this is the first time
          // we've seen it, add the prefix-less, postfix-less
          // subsection name.
          if (!subsection_name.empty() &&
              !subsections.count(subsection_name))
            {
              returnval.push_back(subsection_name);
              subsections.insert(subsection_name);
            }
        }
    }
 
  return returnval;
}

References section_list.

◆ get_value_no_default() [1/10]

const char * GETPOT_NAMESPACE::GetPot::get_value_no_default	(	const char *	VarName,
		const char *	Default
	)		const

inline

Definition at line 2386 of file getpot.h.

{
  return _internal_managed_copy(get_value_no_default(VarName, std::string(Default)));
}

References _internal_managed_copy(), and get_value_no_default().

◆ get_value_no_default() [2/10]

const char * GETPOT_NAMESPACE::GetPot::get_value_no_default	(	const char *	VarName,
		const char *	Default,
		unsigned	Idx
	)		const

inline

◆ get_value_no_default() [3/10]

template<typename T >

T GETPOT_NAMESPACE::GetPot::get_value_no_default	(	const char *	VarName,
		const T &	Default
	)		const

inline

access variables, but error out if not present scalar values

Definition at line 2362 of file getpot.h.

{
  // (*) recording of requested variables happens in '_request_variable()'
  const variable*  sv = _request_variable(VarName);
  if (sv == 0)
    {
      getpot_cerr << "ERROR: cannot find variable "<<VarName<<std::endl;
      getpot_error();
    }
  return _convert_to_type_no_default(VarName, sv->original, Default);
}

References _convert_to_type_no_default(), _request_variable(), and GETPOT_NAMESPACE::GetPot::variable::original.

Referenced by get_value_no_default(), get_value_no_default(), get_value_no_default(), and get_value_no_default().

◆ get_value_no_default() [4/10]

template<typename T >

T GETPOT_NAMESPACE::GetPot::get_value_no_default	(	const char *	VarName,
		const T &	Default,
		unsigned	Idx
	)		const

inline

vectors

◆ get_value_no_default() [5/10]

template<typename T >

T GETPOT_NAMESPACE::GetPot::get_value_no_default	(	const char *	VarName,
		const T &	Default,
		unsigned int	Idx
	)		const

inline

Definition at line 2403 of file getpot.h.

{
  // (*) recording of requested variables happens in '_request_variable()'
  const variable* sv = _request_variable(VarName);
  if (sv == 0)
    {
      getpot_cerr << "ERROR: cannot find variable "<<VarName<<std::endl;
      getpot_error();
    }
 
  const std::string*  element = sv->get_element(Idx);
  if (element == 0)
    {
      getpot_cerr << "ERROR: cannot find index "<<Idx<<" of variable "<<VarName<<std::endl;
      getpot_error();
    }
  return _convert_to_type_no_default(VarName, *element, Default);
}

References _convert_to_type_no_default(), _request_variable(), and GETPOT_NAMESPACE::GetPot::variable::get_element().

◆ get_value_no_default() [6/10]

const char * GETPOT_NAMESPACE::GetPot::get_value_no_default	(	const std::string &	VarName,
		const char *	Default
	)		const

inline

Definition at line 2394 of file getpot.h.

{
  return get_value_no_default(VarName.c_str(),Default);
}

References get_value_no_default().

◆ get_value_no_default() [7/10]

const char * GETPOT_NAMESPACE::GetPot::get_value_no_default	(	const std::string &	VarName,
		const char *	Default,
		unsigned	Idx
	)		const

inline

◆ get_value_no_default() [8/10]

template<typename T >

T GETPOT_NAMESPACE::GetPot::get_value_no_default	(	const std::string &	VarName,
		const T &	Default
	)		const

inline

Definition at line 2378 of file getpot.h.

{
  return get_value_no_default(VarName.c_str(),Default);
}

References get_value_no_default().

◆ get_value_no_default() [9/10]

template<typename T >

T GETPOT_NAMESPACE::GetPot::get_value_no_default	(	const std::string &	VarName,
		const T &	Default,
		unsigned	Idx
	)		const

inline

◆ get_value_no_default() [10/10]

template<typename T >

T GETPOT_NAMESPACE::GetPot::get_value_no_default	(	const std::string &	VarName,
		const T &	Default,
		unsigned int	Idx
	)		const

inline

Definition at line 2426 of file getpot.h.

{
  return get_value_no_default(VarName.c_str(), Default, Idx);
}

References get_value_no_default().

◆ get_variable_names()

STRING_VECTOR GETPOT_NAMESPACE::GetPot::get_variable_names ( ) const

inline

Definition at line 2569 of file getpot.h.

{
  STRING_VECTOR  result;
  std::vector<GetPot::variable>::const_iterator it = variables.begin();
  for (; it != variables.end(); ++it)
    {
      const std::string Tmp = _get_remaining_string((*it).name, prefix);
      if (Tmp != "")
        result.push_back(Tmp);
    }
  return result;
}

References _get_remaining_string(), prefix, and variables.

◆ have_section() [1/2]

bool GETPOT_NAMESPACE::GetPot::have_section ( const char * section_name ) const

inline

Check for a section name.

When querying, the section_name can be of the form Section1 or Section1/

Section1/Section2 or Section1/Section2/

etc.

Definition at line 2251 of file getpot.h.

{
  std::string s = std::string(section_name);
  return this->have_section(s);
}

References have_section().

Referenced by have_section().

◆ have_section() [2/2]

bool GETPOT_NAMESPACE::GetPot::have_section ( const std::string & section_name ) const

inline

Check for a section name.

When querying, the section_name can be of the form Section1 or Section1/

Section1/Section2 or Section1/Section2/

etc.

Definition at line 2258 of file getpot.h.

{
  const char slash('/');
 
  std::string::const_reverse_iterator it = section_name.rbegin();
 
  bool found_section = false;
 
  // Check if section_name ends with a "/". If not, append it for the search since
  // the section names are stored with a "/" at the end.
  if( (*it) != slash )
    // We need to use a linear search because we can't sort section_list
    // without violating some assumptions. See libMesh #481 for more discussion.
    found_section = ( std::find(section_list.begin(), section_list.end(), section_name+slash) != section_list.end() );
  else
    found_section = ( std::find(section_list.begin(), section_list.end(), section_name) != section_list.end() );
 
  return found_section;
}

References section_list.

◆ have_variable() [1/2]

bool GETPOT_NAMESPACE::GetPot::have_variable ( const char * VarName ) const

inline

variables

check for a variable

Definition at line 2232 of file getpot.h.

{
  const variable* sv = _request_variable(VarName);
 
  if (sv == 0)
    return false;
 
  return true;
}

References _request_variable().

Referenced by have_variable().

◆ have_variable() [2/2]

bool GETPOT_NAMESPACE::GetPot::have_variable ( const std::string & VarName ) const

inline

Definition at line 2245 of file getpot.h.

{
  return have_variable(VarName.c_str());
}

References have_variable().

◆ init_multiple_occurrence()

void GETPOT_NAMESPACE::GetPot::init_multiple_occurrence ( )

inline

Definition at line 1857 of file getpot.h.

{
  disable_loop();
  reset_cursor();
}

References disable_loop(), and reset_cursor().

◆ next() [1/2]

const char * GETPOT_NAMESPACE::GetPot::next ( const char * Default )

inline

Definition at line 1931 of file getpot.h.

{
  return _internal_managed_copy(next(std::string(Default)));
}

References _internal_managed_copy(), and next().

◆ next() [2/2]

template<typename T >

T GETPOT_NAMESPACE::GetPot::next ( const T & Default )

inline

get argument at cursor++

Definition at line 1909 of file getpot.h.

{
  if (search_failed_f)
    return Default;
  cursor++;
  if (cursor >= argv.size())
    {
      cursor = getpot_cast_int<unsigned>(argv.size());
      return Default;
    }
 
  // (*) record requested argument for later ufo detection
  _record_argument_request(argv[cursor]);
 
  const std::string Remain = _get_remaining_string(argv[cursor], prefix);
 
  return Remain != "" ? _convert_to_type(Remain, Default) : Default;
}

References _convert_to_type(), _get_remaining_string(), _record_argument_request(), argv, cursor, prefix, and search_failed_f.

Referenced by follow(), follow(), follow(), and next().

◆ next_nominus()

const char * GETPOT_NAMESPACE::GetPot::next_nominus ( )

inline

Definition at line 2185 of file getpot.h.

{
  if (nominus_cursor < int(idx_nominus.size()) - 1)
    {
      const std::string Tmp = argv[idx_nominus[++nominus_cursor]];
 
      // (*) record for later ufo-detection
      _record_argument_request(Tmp);
 
      return _internal_managed_copy(Tmp);
    }
 
  return 0;
}

References _internal_managed_copy(), _record_argument_request(), argv, idx_nominus, and nominus_cursor.

◆ next_nominus_string()

std::string GETPOT_NAMESPACE::GetPot::next_nominus_string ( )

inline

Definition at line 2202 of file getpot.h.

{
  if (nominus_cursor < int(idx_nominus.size()) - 1)
    {
      const std::string Tmp = argv[idx_nominus[++nominus_cursor]];
 
      // (*) record for later ufo-detection
      _record_argument_request(Tmp);
 
      return Tmp;
    }
 
  return "";
}

References _record_argument_request(), argv, idx_nominus, and nominus_cursor.

◆ nominus_size()

unsigned GETPOT_NAMESPACE::GetPot::nominus_size ( ) const

inline

Definition at line 415 of file getpot.h.

415{ return getpot_cast_int<unsigned>(idx_nominus.size()); }

References idx_nominus.

◆ nominus_vector()

STRING_VECTOR GETPOT_NAMESPACE::GetPot::nominus_vector ( ) const

inline

Definition at line 2166 of file getpot.h.

{
  STRING_VECTOR nv;
  std::vector<unsigned>::const_iterator it = idx_nominus.begin();
  for (; it != idx_nominus.end(); ++it)
    {
      nv.push_back(argv[*it]);
 
      // (*) record for later ufo-detection
      //     when a nominus vector is requested, the entire set of nominus arguments are
      //     tagged as 'requested'
      _record_argument_request(argv[*it]);
    }
  return nv;
}

References _record_argument_request(), argv, and idx_nominus.

◆ operator()() [1/10]

const char * GETPOT_NAMESPACE::GetPot::operator()	(	const char *	VarName,
		const char *	Default
	)		const

inline

Definition at line 2303 of file getpot.h.

{
  return _internal_managed_copy(operator()(VarName, std::string(Default)));
}

References _internal_managed_copy().

◆ operator()() [2/10]

const char * GETPOT_NAMESPACE::GetPot::operator()	(	const char *	VarName,
		const char *	Default,
		unsigned	Idx
	)		const

inline

◆ operator()() [3/10]

template<typename T >

T GETPOT_NAMESPACE::GetPot::operator()	(	const char *	VarName,
		const T &	Default
	)		const

inline

scalar values

Definition at line 2280 of file getpot.h.

{
  // (*) recording of requested variables happens in '_request_variable()'
  const variable*  sv = _request_variable(VarName);
 
  if (sv == 0)
    return Default;
 
  return _convert_to_type(sv->original, Default);
}

References _convert_to_type(), _request_variable(), and GETPOT_NAMESPACE::GetPot::variable::original.

Referenced by operator()(), operator()(), and operator()().

◆ operator()() [4/10]

template<typename T >

T GETPOT_NAMESPACE::GetPot::operator()	(	const char *	VarName,
		const T &	Default,
		unsigned	Idx
	)		const

inline

vectors

◆ operator()() [5/10]

template<typename T >

T GETPOT_NAMESPACE::GetPot::operator()	(	const char *	VarName,
		const T &	Default,
		unsigned int	Idx
	)		const

inline

Definition at line 2320 of file getpot.h.

{
  // (*) recording of requested variables happens in '_request_variable()'
  const variable* sv = _request_variable(VarName);
  if (sv == 0)
    return Default;
 
  const std::string*  element = sv->get_element(Idx);
  if (element == 0)
    return Default;
  return _convert_to_type(*element, Default);
}

References _convert_to_type(), _request_variable(), and GETPOT_NAMESPACE::GetPot::variable::get_element().

◆ operator()() [6/10]

const char * GETPOT_NAMESPACE::GetPot::operator()	(	const std::string &	VarName,
		const char *	Default
	)		const

inline

Definition at line 2311 of file getpot.h.

{
  return operator()(VarName.c_str(), Default);
}

References operator()().

◆ operator()() [7/10]

const char * GETPOT_NAMESPACE::GetPot::operator()	(	const std::string &	VarName,
		const char *	Default,
		unsigned	Idx
	)		const

inline

◆ operator()() [8/10]

template<typename T >

T GETPOT_NAMESPACE::GetPot::operator()	(	const std::string &	VarName,
		const T &	Default
	)		const

inline

Definition at line 2295 of file getpot.h.

{
  return operator()(VarName.c_str(), Default);
}

References operator()().

◆ operator()() [9/10]

template<typename T >

T GETPOT_NAMESPACE::GetPot::operator()	(	const std::string &	VarName,
		const T &	Default,
		unsigned	Idx
	)		const

inline

◆ operator()() [10/10]

template<typename T >

T GETPOT_NAMESPACE::GetPot::operator()	(	const std::string &	VarName,
		const T &	Default,
		unsigned int	Idx
	)		const

inline

Definition at line 2337 of file getpot.h.

{
  return operator()(VarName.c_str(), Default, Idx);
}

References operator()().

◆ operator=()

GetPot & GETPOT_NAMESPACE::GetPot::operator= ( const GetPot & Other )

inline

Definition at line 1038 of file getpot.h.

{
  if (&Other == this)
    return *this;
 
  prefix               = Other.prefix;
  section              = Other.section;
  section_list         = Other.section_list;
  argv                 = Other.argv;
  cursor               = Other.cursor;
  search_loop_f        = Other.search_loop_f;
  search_failed_f      = Other.search_failed_f;
  nominus_cursor       = Other.nominus_cursor;
  overridden_vars      = Other.overridden_vars;
  idx_nominus          = Other.idx_nominus;
  variables            = Other.variables;
  _comment_start       = Other._comment_start;
  _comment_end         = Other._comment_end;
  _field_separator     = Other._field_separator;
  // #if !defined(GETPOT_DISABLE_MUTEX)
  //   _getpot_mtx          = Other._getpot_mtx;
  // #endif
  _requested_arguments = Other._requested_arguments;
  _requested_variables = Other._requested_variables;
  _requested_sections  = Other._requested_sections;
  request_recording_f  = Other.request_recording_f;
 
  // Clear existing strings
  _internal_string_container.clear();
 
  for (const auto & otherstr : Other._internal_string_container)
    {
      auto newlen = strlen(otherstr.get()) + 1;
      auto newcopy = std::make_unique<char[]>(newlen);
      strncpy(newcopy.get(), otherstr.get(), newlen);
      this->_internal_string_container.insert(std::move(newcopy));
    }
 
  return *this;
}

References _comment_end, _comment_start, _field_separator, _internal_string_container, _requested_arguments, _requested_sections, _requested_variables, argv, cursor, idx_nominus, nominus_cursor, overridden_vars, prefix, request_recording_f, search_failed_f, search_loop_f, section, section_list, and variables.

Referenced by GETPOT_NAMESPACE::GetPot::variable::variable().

◆ operator[]()

const char * GETPOT_NAMESPACE::GetPot::operator[] ( unsigned Idx ) const

inline

direct access to command line arguments

Definition at line 1870 of file getpot.h.

{
  return idx<argv.size() ? argv[idx].c_str() : 0;
}

References argv.

◆ options_contain()

bool GETPOT_NAMESPACE::GetPot::options_contain ( const char * FlagList ) const

inline

flags

Definition at line 2097 of file getpot.h.

{
  // go through all arguments that start with a '-' (but not '--')
  std::string str;
  STRING_VECTOR::const_iterator it = argv.begin();
  for (; it != argv.end(); ++it)
    {
      str = _get_remaining_string(*it, prefix);
 
      if (str.length() >= 2 && str[0] == '-' && str[1] != '-')
        if (_check_flags(str, FlagList))
          return true;
    }
  return false;
}

References _check_flags(), _get_remaining_string(), argv, and prefix.

◆ parse_command_line()

void GETPOT_NAMESPACE::GetPot::parse_command_line	(	const int	argc_,
		const char const	argv_,
		const char *	FieldSeparator = `0x0`
	)

inline

Re-initialization methods.

Definition at line 825 of file getpot.h.

{
  _basic_initialization();
 
  // if specified -> overwrite default string
  if (FieldSeparator)
    _field_separator = std::string(FieldSeparator);
 
  // -- make an internal copy of the argument list:
  STRING_VECTOR _apriori_argv;
  // -- for the sake of clarity: we do want to include the first
  //    argument of the first parsing source in the argument vector!
  //    it will not be a nominus argument, though. This gives us a
  //    minimum vector size of one which facilitates error checking
  //    in many functions. Also the user will be able to retrieve
  //    the name of his application or input file by "get[0]"
  _apriori_argv.push_back(std::string(argv_[0]));
  for (int i=1; i<argc_; i++)
    {
      std::string tmp(argv_[i]);   // recall the problem with temporaries,
      _apriori_argv.push_back(tmp);       // reference counting in argument lists ...
    }
  _parse_argument_vector(_apriori_argv);
}

References _basic_initialization(), _field_separator, and _parse_argument_vector().

Referenced by GetPot().

◆ parse_input_file()

void GETPOT_NAMESPACE::GetPot::parse_input_file	(	const std::string &	FileName,
		const std::string &	CommentStart = `std::string("#")`,
		const std::string &	CommentEnd = `std::string("\n")`,
		const std::string &	FieldSeparator = `std::string(" \t\n")`
	)

inline

Definition at line 918 of file getpot.h.

{
  std::ifstream input(FileName.c_str());
 
  if (!input)
    getpot_file_error(FileName);
 
  this->parse_input_stream(input,FileName,CommentStart,CommentEnd,FieldSeparator);
}

References parse_input_stream().

Referenced by _parse_argument_vector(), GetPot(), and GetPot().

◆ parse_input_stream()

void GETPOT_NAMESPACE::GetPot::parse_input_stream	(	std::istream &	FileStream,
		const std::string &	FileName = `std::string("ParsedFromStream")`,
		const std::string &	CommentStart = `std::string("#")`,
		const std::string &	CommentEnd = `std::string("\n")`,
		const std::string &	FieldSeparator = `std::string(" \t\n")`
	)

inline

Definition at line 966 of file getpot.h.

{
  _basic_initialization();
 
  // overwrite default strings
  _comment_start = std::string(CommentStart);
  _comment_end   = std::string(CommentEnd);
  _field_separator = FieldSeparator;
 
  STRING_VECTOR _apriori_argv;
  // -- the first element of the argument vector stores the name of
  //    the first parsing source; however, this element is not
  //    parsed for variable assignments or nominuses.
  //
  //    Regardless, we don't add more than one name to the argument
  //    vector. In this case, we're parsing from a stream, so we'll
  //    hardcode the "filename" to "ParsedFromStream"
  _apriori_argv.push_back(FileName);
 
  STRING_VECTOR args = _read_in_stream(FileStream);
  _apriori_argv.insert(_apriori_argv.begin()+1, args.begin(), args.end());
  _parse_argument_vector(_apriori_argv);
}

References _basic_initialization(), _comment_end, _comment_start, _field_separator, _parse_argument_vector(), and _read_in_stream().

Referenced by GetPot(), and parse_input_file().

◆ print() [1/2]

int GETPOT_NAMESPACE::GetPot::print	(	const char *	custom_prefix,
		std::ostream &	out_stream = `std::cout`,
		unsigned int	skip_count = `1`
	)		const

inline

Print everything after skipping skip_count arguments, with a custom prefix.

skip_count defaults to 1 to handle the common "executable input_file" command line case.

Definition at line 2700 of file getpot.h.

{
  STRING_VECTOR::const_iterator it = argv.begin();
  it += skip_count;
  for (; it != argv.end(); ++it)
    {
      out_stream << custom_prefix;
      out_stream << *it << std::endl;
    }
  out_stream << std::endl;
  return 1;
}

References argv.

◆ print() [2/2]

int GETPOT_NAMESPACE::GetPot::print ( std::ostream & out_stream = std::cout ) const

inline

output

Print everything

Definition at line 2682 of file getpot.h.

{
  out_stream << "argc = " << argv.size() << std::endl;
  STRING_VECTOR::const_iterator it = argv.begin();
  for (; it != argv.end(); ++it)
    out_stream << *it << std::endl;
  out_stream << std::endl;
  return 1;
}

References argv.

◆ reset_cursor()

void GETPOT_NAMESPACE::GetPot::reset_cursor ( )

inline

reset cursor to position '1'

Definition at line 1848 of file getpot.h.

{
  search_failed_f = false;
  cursor = 0;
}

References cursor, and search_failed_f.

Referenced by init_multiple_occurrence().

◆ reset_nominus_cursor()

void GETPOT_NAMESPACE::GetPot::reset_nominus_cursor ( )

inline

nominus arguments

Definition at line 2220 of file getpot.h.

{
  nominus_cursor = -1;
}

References nominus_cursor.

◆ search() [1/3]

bool GETPOT_NAMESPACE::GetPot::search ( const char * option )

inline

search for a certain option and set cursor to position

Definition at line 1759 of file getpot.h.

{
  unsigned           OldCursor = cursor;
  const std::string  SearchTerm = prefix + Option;
 
  // (*) record requested arguments for later ufo detection
  _record_argument_request(SearchTerm);
 
  if (OldCursor >= argv.size())
    OldCursor = getpot_cast_int<unsigned>(argv.size() - 1);
  search_failed_f = true;
 
  // (*) first loop from cursor position until end
  for (unsigned c = cursor; c < argv.size(); c++)
    {
      if (argv[c] == SearchTerm)
        {
          cursor = c;
          search_failed_f = false;
          return true;
        }
    }
  if (!search_loop_f)
    return false;
 
  // (*) second loop from 0 to old cursor position
  for (unsigned c = 1; c <= OldCursor; c++)
    {
      if (argv[c] == SearchTerm)
        {
          cursor = c;
          search_failed_f = false;
          return true;
        }
    }
 
  // in case nothing is found the cursor stays where it was
  return false;
}

References _record_argument_request(), argv, cursor, prefix, search_failed_f, and search_loop_f.

Referenced by follow(), follow(), follow(), search(), and search().

◆ search() [2/3]

bool GETPOT_NAMESPACE::GetPot::search ( const std::string & option )

inline

Definition at line 1750 of file getpot.h.

{
  return search(Option.c_str());
}

References search().

◆ search() [3/3]

bool GETPOT_NAMESPACE::GetPot::search	(	unsigned	No,
		const char *	P,
			...
	)

inline

Definition at line 1802 of file getpot.h.

{
  // (*) recording the requested arguments happens in subroutine 'search'
  if (No == 0)
    return false;
 
  // search for the first argument
  if (search(P) == true)
    return true;
 
  // start interpreting variable argument list
  va_list ap;
  va_start(ap, P);
  unsigned i = 1;
  for (; i < No; i++)
    {
      char* Opt = va_arg(ap, char *);
      // (*) search records itself for later ufo detection
      if (search(Opt) == true)
        break;
    }
 
  if (i < No)
    {
      i++;
      // loop was left before end of array --> hit but
      // make sure that the rest of the search terms is marked
      // as requested.
      for (; i < No; i++)
        {
          char* Opt = va_arg(ap, char *);
          // (*) record requested arguments for later ufo detection
          _record_argument_request(Opt);
        }
      va_end(ap);
      return true;
    }
 
  va_end(ap);
  // loop was left normally --> no hit
  return false;
}

References _record_argument_request(), and search().

◆ search_failed()

bool GETPOT_NAMESPACE::GetPot::search_failed ( ) const

inline

Definition at line 357 of file getpot.h.

357{ return search_failed_f; }

References search_failed_f.

◆ set() [1/4]

void GETPOT_NAMESPACE::GetPot::set	(	const char *	VarName,
		const char *	Value,
		const bool	Requested = `true`
	)

inline

Definition at line 2534 of file getpot.h.

{
  _set_variable(VarName, Value, Requested);
}

References _set_variable().

◆ set() [2/4]

template<typename T >

void GETPOT_NAMESPACE::GetPot::set	(	const char *	VarName,
		const T &	Value,
		const bool	Requested = `true`
	)

inline

setting variables i) from outside of GetPot (considering prefix etc.) ii) from inside, use '_set_variable()' below

Definition at line 2515 of file getpot.h.

{
  std::ostringstream string_value;
  string_value << Value;
  _set_variable(VarName, string_value.str().c_str(), Requested);
}

References _set_variable().

Referenced by set(), and set().

◆ set() [3/4]

void GETPOT_NAMESPACE::GetPot::set	(	const std::string &	VarName,
		const char *	Value,
		const bool	Requested = `true`
	)

inline

Definition at line 2542 of file getpot.h.

{
  set(VarName.c_str(), Value, Requested);
}

References set().

◆ set() [4/4]

template<typename T >

void GETPOT_NAMESPACE::GetPot::set	(	const std::string &	VarName,
		const T &	Value,
		const bool	Requested = `true`
	)

inline

Definition at line 2526 of file getpot.h.

{
  set(VarName.c_str(), Value, Requested);
}

References set().

◆ set_prefix()

void GETPOT_NAMESPACE::GetPot::set_prefix ( const char * Prefix )

inline

cursor oriented functions

Definition at line 356 of file getpot.h.

356{ prefix = std::string(Prefix); }

References prefix.

◆ size()

unsigned GETPOT_NAMESPACE::GetPot::size ( ) const

inline

Definition at line 1899 of file getpot.h.

{
  return getpot_cast_int<unsigned>(argv.size());
}

References argv.

Referenced by _DBE_expand().

◆ unidentified_arguments() [1/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_arguments ( ) const

inline

Definition at line 3462 of file getpot.h.

{
  return unidentified_arguments(_requested_arguments);
}

References _requested_arguments, and unidentified_arguments().

Referenced by unidentified_arguments(), unidentified_arguments(), unidentified_arguments(), and unidentified_options().

◆ unidentified_arguments() [2/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_arguments ( const std::set< std::string > & Knowns ) const

inline

Definition at line 3480 of file getpot.h.

{
  STRING_VECTOR ufos;
  STRING_VECTOR::const_iterator it = argv.begin();
  ++it; // forget about argv[0] (application or filename)
  for (; it != argv.end(); ++it)
    {
      // -- argument belongs to prefixed section ?
      const std::string arg = _get_remaining_string(*it, prefix);
      if (arg == "")
        continue;
 
      // -- check if in list
      if (Knowns.find(arg) == Knowns.end())
        ufos.push_back(*it);
    }
  return ufos;
}

References _get_remaining_string(), argv, and prefix.

◆ unidentified_arguments() [3/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_arguments ( const std::vector< std::string > & Knowns ) const

inline

Definition at line 3470 of file getpot.h.

{
  // We use set for efficiency, but want to support vector inputs for
  // backwards compatibility.
  return unidentified_arguments(std::set<std::string> (Knowns.begin(), Knowns.end()));
}

References unidentified_arguments().

◆ unidentified_arguments() [4/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_arguments	(	unsigned	Number,
		const char *	Known,
			...
	)		const

inline

unidentified flying objects

Definition at line 3440 of file getpot.h.

{
  std::set<std::string> known_arguments;
 
  // (1) create a vector of known arguments
  if (Number == 0)
    return STRING_VECTOR();
 
  va_list ap;
  va_start(ap, KnownArgument1);
  known_arguments.insert(std::string(KnownArgument1));
  for (unsigned i=1; i<Number; i++)
    known_arguments.insert(std::string(va_arg(ap, char *)));
  va_end(ap);
 
  return unidentified_arguments(known_arguments);
}

References unidentified_arguments().

◆ unidentified_flags()

std::string GETPOT_NAMESPACE::GetPot::unidentified_flags	(	const char *	Known,
		int	ArgumentNumber = `-1`
	)		const

inline

Definition at line 3578 of file getpot.h.

{
  std::string         ufos;
  // STRING_VECTOR known_arguments;
  std::string         KFL(KnownFlagList);
 
  // (2) iteration over '-' arguments (options)
  if (ArgumentNumber == -1)
    {
      STRING_VECTOR::const_iterator it = argv.begin();
      ++it; // forget about argv[0] (application or filename)
      for (; it != argv.end(); ++it)
        {
          // -- argument belongs to prefixed section ?
          const std::string arg = _get_remaining_string(*it, prefix);
          if (arg == "") continue;
 
          // -- does arguments start with '-' (but not '--')
          if (arg.length() < 2)
            continue;
 
          else if (arg[0] != '-')
            continue;
 
          else if (arg[1] == '-')
            continue;
 
          // -- check out if flags inside option are contained in KnownFlagList
          const char* p=arg.c_str();
          p++; // skip starting minus
          for (; *p != '\0' ; p++)
            if (KFL.find(*p) == std::string::npos) ufos += *p;
        }
    }
  // (1) check specific argument
  else
    {
      // -- only check arguments that start with prefix
      int no_matches = 0;
      for (unsigned i=1; i<argv.size(); i++)
        {
          const std::string Remain = _get_remaining_string(argv[i], prefix);
          if (Remain != "")
            {
              no_matches++;
              if (no_matches == ArgumentNumber)
                {
                  // -- the right argument number inside the section is found
                  // => check it for flags
                  const char* p = Remain.c_str();
                  p++; // skip starting minus
                  for (; *p != '\0' ; p++)
                    if (KFL.find(*p) == std::string::npos) ufos += *p;
                  return ufos;
                }
            }
        }
    }
  return ufos;
}

References _get_remaining_string(), argv, and prefix.

◆ unidentified_nominuses() [1/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_nominuses ( ) const

inline

Definition at line 3801 of file getpot.h.

{
  // -- every nominus is an argument.
  // -- the set of requested arguments contains the set of requested nominuss.
  // -- IF the set of requested arguments contains unrequested nominuss,
  //    THEN they were requested as 'follow' and 'next' arguments and not as real nominuses.
  //
  // => it is not necessary to separate requested nominus from the list
 
  return unidentified_nominuses(_requested_arguments);
}

References _requested_arguments, and unidentified_nominuses().

Referenced by unidentified_nominuses(), unidentified_nominuses(), and unidentified_nominuses().

◆ unidentified_nominuses() [2/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_nominuses ( const std::set< std::string > & Knowns ) const

inline

Definition at line 3826 of file getpot.h.

{
  STRING_VECTOR ufos;
 
  // (2) iterate over all arguments
  STRING_VECTOR::const_iterator it = argv.begin();
  ++it; // forget about argv[0] (application or filename)
  for (; it != argv.end(); ++it)
    {
      // -- check if nominus part of prefix
      const std::string arg = _get_remaining_string(*it, prefix);
      if (arg == "")
        continue;
 
      if (arg.length() < 1)
        continue;
 
      // option ? --> not a nomius
      if (arg[0] == '-')
        continue;
 
      // section ? --> not a real nominus
      if (arg[0] == '[' && arg[arg.length()-1] == ']')
        continue;
 
      // variable definition ? --> not a real nominus
      bool continue_f = false;
      for (unsigned i=0; i<arg.length() ; i++)
        if (arg[i] == '=')
          {
            continue_f = true;
            break;
          }
 
      if (continue_f)
        continue;
 
      // real nominuses are compared with the given list
      if (Knowns.find(arg) == Knowns.end())
        ufos.push_back(*it);
    }
  return ufos;
}

References _get_remaining_string(), argv, and prefix.

◆ unidentified_nominuses() [3/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_nominuses ( const std::vector< std::string > & Knowns ) const

inline

Definition at line 3816 of file getpot.h.

{
  // We use set for efficiency, but want to support vector inputs for
  // backwards compatibility.
  return unidentified_nominuses(std::set<std::string> (Knowns.begin(), Knowns.end()));
}

References unidentified_nominuses().

◆ unidentified_nominuses() [4/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_nominuses	(	unsigned	Number,
		const char *	Known,
			...
	)		const

inline

Definition at line 3775 of file getpot.h.

{
  std::set<std::string> known_nominuses;
 
  // create vector of known arguments
  if (Number == 0)
    return STRING_VECTOR();
 
  va_list ap;
  va_start(ap, Known);
  known_nominuses.insert(std::string(Known));
  for (unsigned i=1; i<Number; i++)
    {
      std::string tmp = std::string(va_arg(ap, char *));
      if (tmp.length() == 0)
        continue;
      known_nominuses.insert(tmp);
    }
  va_end(ap);
 
  return unidentified_nominuses(known_nominuses);
}

References unidentified_nominuses().

◆ unidentified_options() [1/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_options ( ) const

inline

Definition at line 3524 of file getpot.h.

{
  // -- every option is an argument.
  // -- the set of requested arguments contains the set of requested options.
  // -- IF the set of requested arguments contains unrequested options,
  //    THEN they were requested as 'follow' and 'next' arguments and not as real options.
  //
  // => it is not necessary to separate requested options from the list
  return unidentified_arguments(_requested_arguments);
}

References _requested_arguments, and unidentified_arguments().

Referenced by unidentified_options(), and unidentified_options().

◆ unidentified_options() [2/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_options ( const std::set< std::string > & Knowns ) const

inline

Definition at line 3548 of file getpot.h.

{
  STRING_VECTOR ufos;
  STRING_VECTOR::const_iterator it = argv.begin();
  ++it; // forget about argv[0] (application or filename)
  for (; it != argv.end(); ++it)
    {
      // -- argument belongs to prefixed section ?
      const std::string arg = _get_remaining_string(*it, prefix);
      if (arg == "")
        continue;
 
      // is argument really an option (starting with '-') ?
      if (arg.length() < 1 || arg[0] != '-')
        continue;
 
      if (Knowns.find(arg) == Knowns.end())
        ufos.push_back(*it);
    }
 
  return ufos;
}

References _get_remaining_string(), argv, and prefix.

◆ unidentified_options() [3/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_options ( const std::vector< std::string > & Knowns ) const

inline

Definition at line 3538 of file getpot.h.

{
  // We use set for efficiency, but want to support vector inputs for
  // backwards compatibility.
  return unidentified_options(std::set<std::string> (Knowns.begin(), Knowns.end()));
}

References unidentified_options().

◆ unidentified_options() [4/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_options	(	unsigned	Number,
		const char *	Known,
			...
	)		const

inline

Definition at line 3502 of file getpot.h.

{
  std::set<std::string> known_options;
 
  // (1) create a vector of known arguments
  if (Number == 0)
    return STRING_VECTOR();
 
  va_list ap;
  va_start(ap, KnownOption1);
  known_options.insert(std::string(KnownOption1));
  for (unsigned i=1; i<Number; i++)
    known_options.insert(std::string(va_arg(ap, char *)));
  va_end(ap);
 
  return unidentified_options(known_options);
}

References unidentified_options().

◆ unidentified_sections() [1/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_sections ( ) const

inline

Definition at line 3735 of file getpot.h.

{
  return unidentified_sections(_requested_sections);
}

References _requested_sections, and unidentified_sections().

Referenced by unidentified_sections(), unidentified_sections(), and unidentified_sections().

◆ unidentified_sections() [2/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_sections ( const std::set< std::string > & Knowns ) const

inline

Definition at line 3753 of file getpot.h.

{
  STRING_VECTOR ufos;
 
  victorate(std::string, section_list, it)
    {
      // -- check if section conform to prefix
      const std::string sec_name = _get_remaining_string(*it, prefix);
      if (sec_name == "")
        continue;
 
      // -- check if section is known
      if (Knowns.find(sec_name) == Knowns.end())
        ufos.push_back(*it);
    }
 
  return ufos;
}

References _get_remaining_string(), prefix, and section_list.

◆ unidentified_sections() [3/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_sections ( const std::vector< std::string > & Knowns ) const

inline

Definition at line 3743 of file getpot.h.

{
  // We use set for efficiency, but want to support vector inputs for
  // backwards compatibility.
  return unidentified_sections(std::set<std::string> (Knowns.begin(), Knowns.end()));
}

References unidentified_sections().

◆ unidentified_sections() [4/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_sections	(	unsigned	Number,
		const char *	Known,
			...
	)		const

inline

Definition at line 3703 of file getpot.h.

{
  std::set<std::string> known_sections;
 
  // (1) create a vector of known arguments
  if (Number == 0)
    return STRING_VECTOR();
 
  va_list ap;
  va_start(ap, KnownSection1);
  known_sections.insert(std::string(KnownSection1));
  for (unsigned i=1; i<Number; i++)
    {
      std::string tmp = std::string(va_arg(ap, char *));
 
      if (tmp.length() == 0)
        continue;
 
      if (tmp[tmp.length()-1] != '/')
        tmp += '/';
 
      known_sections.insert(tmp);
    }
  va_end(ap);
 
  return unidentified_sections(known_sections);
}

References unidentified_sections().

◆ unidentified_variables() [1/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_variables ( ) const

inline

Definition at line 3695 of file getpot.h.

{
  return unidentified_variables(_requested_variables);
}

References _requested_variables, and unidentified_variables().

Referenced by unidentified_variables(), unidentified_variables(), and unidentified_variables().

◆ unidentified_variables() [2/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_variables ( const std::set< std::string > & Knowns ) const

inline

Definition at line 3674 of file getpot.h.

{
  STRING_VECTOR ufos;
 
  victorate(GetPot::variable, variables, it)
    {
      // -- check if variable has specific prefix
      const std::string var_name = _get_remaining_string((*it).name, prefix);
      if (var_name == "")
        continue;
 
      // -- check if variable is known
      if (Knowns.find(var_name) == Knowns.end())
        ufos.push_back((*it).name);
    }
  return ufos;
}

References _get_remaining_string(), prefix, and variables.

◆ unidentified_variables() [3/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_variables ( const std::vector< std::string > & Knowns ) const

inline

Definition at line 3664 of file getpot.h.

{
  // We use set for efficiency, but want to support vector inputs for
  // backwards compatibility.
  return unidentified_variables(std::set<std::string> (Knowns.begin(), Knowns.end()));
}

References unidentified_variables().

◆ unidentified_variables() [4/4]

STRING_VECTOR GETPOT_NAMESPACE::GetPot::unidentified_variables	(	unsigned	Number,
		const char *	Known,
			...
	)		const

inline

Definition at line 3642 of file getpot.h.

{
  std::set<std::string> known_variables;
 
  // create vector of known arguments
  if (Number == 0)
    return STRING_VECTOR();
 
  va_list ap;
  va_start(ap, KnownVariable1);
  known_variables.insert(std::string(KnownVariable1));
  for (unsigned i=1; i<Number; i++)
    known_variables.insert(std::string(va_arg(ap, char *)));
  va_end(ap);
 
  return unidentified_variables(known_variables);
}

References unidentified_variables().

◆ vector_variable_size() [1/2]

unsigned GETPOT_NAMESPACE::GetPot::vector_variable_size ( const char * VarName ) const

inline

Definition at line 2550 of file getpot.h.

{
  const variable*  sv = _request_variable(VarName);
  if (sv == 0)
    return 0;
  return (unsigned)(sv->value.size());
}

References _request_variable(), and GETPOT_NAMESPACE::GetPot::variable::value.

Referenced by vector_variable_size().

◆ vector_variable_size() [2/2]

unsigned GETPOT_NAMESPACE::GetPot::vector_variable_size ( const std::string & VarName ) const

inline

Definition at line 2561 of file getpot.h.

{
  return vector_variable_size(VarName.c_str());
}

References vector_variable_size().

Member Data Documentation

◆ _comment_end

std::string GETPOT_NAMESPACE::GetPot::_comment_end

private

Definition at line 538 of file getpot.h.

Referenced by _basic_initialization(), _parse_argument_vector(), _skip_whitespace(), operator=(), and parse_input_stream().

◆ _comment_start

std::string GETPOT_NAMESPACE::GetPot::_comment_start

private

comment delimiters

Definition at line 537 of file getpot.h.

Referenced by _basic_initialization(), _parse_argument_vector(), _read_in_stream(), _skip_whitespace(), operator=(), and parse_input_stream().

◆ _field_separator

std::string GETPOT_NAMESPACE::GetPot::_field_separator

private

field separator (separating elements of a vector)

Definition at line 543 of file getpot.h.

Referenced by _basic_initialization(), _parse_argument_vector(), _set_variable(), operator=(), parse_command_line(), and parse_input_stream().

◆ _internal_string_container

std::set<std::unique_ptr<const char[]>, ltstr> GETPOT_NAMESPACE::GetPot::_internal_string_container

mutableprivate

some functions return a char pointer to a string created on the fly.

this container makes them 'available' until the getpot object is destroyed. user codes are recommended to instead request std::string values. We use char* here because c_str() results are only guaranteed to remain valid until a non-const string method is called

Definition at line 588 of file getpot.h.

Referenced by _internal_managed_copy(), GetPot(), and operator=().

◆ _requested_arguments

std::set<std::string> GETPOT_NAMESPACE::GetPot::_requested_arguments

mutableprivate

keeping track about arguments that are requested, so that the UFO detection can be simplified

Definition at line 600 of file getpot.h.

Referenced by _parse_argument_vector(), _record_argument_request(), absorb(), clear_requests(), get_requested_arguments(), operator=(), unidentified_arguments(), unidentified_nominuses(), and unidentified_options().

◆ _requested_sections

std::set<std::string> GETPOT_NAMESPACE::GetPot::_requested_sections

mutableprivate

Definition at line 602 of file getpot.h.

Referenced by _record_argument_request(), _record_variable_request(), absorb(), clear_requests(), get_requested_sections(), operator=(), and unidentified_sections().

◆ _requested_variables

std::set<std::string> GETPOT_NAMESPACE::GetPot::_requested_variables

mutableprivate

Definition at line 601 of file getpot.h.

Referenced by _record_variable_request(), absorb(), clear_requests(), get_requested_variables(), operator=(), and unidentified_variables().

◆ argv

STRING_VECTOR GETPOT_NAMESPACE::GetPot::argv

private

argument vector

Definition at line 517 of file getpot.h.

Referenced by _match_starting_string(), _parse_argument_vector(), absorb(), argument_contains(), direct_follow(), get(), next(), next_nominus(), next_nominus_string(), nominus_vector(), operator=(), operator[](), options_contain(), print(), print(), search(), size(), unidentified_arguments(), unidentified_flags(), unidentified_nominuses(), and unidentified_options().

◆ cursor

unsigned GETPOT_NAMESPACE::GetPot::cursor

private

Definition at line 518 of file getpot.h.

Referenced by _basic_initialization(), _match_starting_string(), direct_follow(), next(), operator=(), reset_cursor(), and search().

◆ GETPOT_MUTEX_DECLARE

GETPOT_NAMESPACE::GetPot::GETPOT_MUTEX_DECLARE

private

we have some mutable non-thread-safe members, but we want to be able to call const member functions from multiple threads at once, so we'll wrap access to mutable objects in a mutex.

Definition at line 551 of file getpot.h.

◆ idx_nominus

std::vector<unsigned> GETPOT_NAMESPACE::GetPot::idx_nominus

private

Definition at line 527 of file getpot.h.

Referenced by _parse_argument_vector(), next_nominus(), next_nominus_string(), nominus_size(), nominus_vector(), and operator=().

◆ nominus_cursor

int GETPOT_NAMESPACE::GetPot::nominus_cursor

private

nominus vector

Definition at line 526 of file getpot.h.

Referenced by _basic_initialization(), next_nominus(), next_nominus_string(), operator=(), and reset_nominus_cursor().

◆ overridden_vars

std::set<std::string> GETPOT_NAMESPACE::GetPot::overridden_vars

private

Definition at line 521 of file getpot.h.

Referenced by _set_variable(), get_overridden_variables(), and operator=().

◆ prefix

std::string GETPOT_NAMESPACE::GetPot::prefix

private

member variables

Definition at line 510 of file getpot.h.

Referenced by _basic_initialization(), _DBE_get_variable(), _find_variable(), argument_contains(), get_variable_names(), next(), operator=(), options_contain(), search(), set_prefix(), unidentified_arguments(), unidentified_flags(), unidentified_nominuses(), unidentified_options(), unidentified_sections(), and unidentified_variables().

◆ request_recording_f

bool GETPOT_NAMESPACE::GetPot::request_recording_f

private

Definition at line 604 of file getpot.h.

Referenced by _basic_initialization(), _parse_argument_vector(), _record_argument_request(), _record_variable_request(), absorb(), disable_request_recording(), enable_request_recording(), and operator=().

◆ search_failed_f

bool GETPOT_NAMESPACE::GetPot::search_failed_f

private

Definition at line 520 of file getpot.h.

Referenced by _basic_initialization(), _match_starting_string(), next(), operator=(), reset_cursor(), search(), and search_failed().

◆ search_loop_f

bool GETPOT_NAMESPACE::GetPot::search_loop_f

private

Definition at line 519 of file getpot.h.

Referenced by _basic_initialization(), _match_starting_string(), disable_loop(), enable_loop(), operator=(), and search().

◆ section

std::string GETPOT_NAMESPACE::GetPot::section

private

Definition at line 511 of file getpot.h.

Referenced by _basic_initialization(), _DBE_get_variable(), _parse_argument_vector(), _record_argument_request(), _record_variable_request(), and operator=().

◆ section_list

STRING_VECTOR GETPOT_NAMESPACE::GetPot::section_list

private

Definition at line 512 of file getpot.h.

Referenced by _parse_argument_vector(), get_section_names(), get_subsection_names(), have_section(), operator=(), and unidentified_sections().

◆ variables

std::vector<variable> GETPOT_NAMESPACE::GetPot::variables

private

variables (arguments of the form "variable=value")

Definition at line 532 of file getpot.h.

Referenced by _find_variable(), _set_variable(), absorb(), get_variable_names(), operator=(), and unidentified_variables().

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

include/base/getpot.h

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ GetPot() [1/6]

◆ GetPot() [2/6]

◆ GetPot() [3/6]

◆ GetPot() [4/6]

◆ GetPot() [5/6]

◆ GetPot() [6/6]

◆ ~GetPot()

Member Function Documentation

◆ _basic_initialization()

◆ _check_flags()

◆ _convert_from_type()

◆ _convert_to_type() [1/4]

◆ _convert_to_type() [2/4]

◆ _convert_to_type() [3/4]

◆ _convert_to_type() [4/4]

◆ _convert_to_type_no_default() [1/4]

◆ _convert_to_type_no_default() [2/4]

◆ _convert_to_type_no_default() [3/4]

◆ _convert_to_type_no_default() [4/4]

◆ _DBE_expand()

◆ _DBE_expand_string()

◆ _DBE_get_expr_list()

◆ _DBE_get_variable()

◆ _find_variable()

◆ _get_next_token()

◆ _get_remaining_string()

◆ _get_section_tree()

◆ _get_string()

◆ _get_until_closing_bracket()

◆ _get_until_closing_square_bracket()

◆ _internal_managed_copy()

◆ _match_starting_string()

◆ _parse_argument_vector()

◆ _process_section_label()

◆ _read_in_stream()

◆ _record_argument_request()

◆ _record_variable_request()

◆ _request_variable()

◆ _search_string_vector()

◆ _set_variable()

◆ _skip_whitespace()

◆ absorb()

◆ argument_contains()

◆ clear_requests()

◆ direct_follow() [1/2]

◆ direct_follow() [2/2]

◆ disable_loop()

◆ disable_request_recording()

◆ enable_loop()

◆ enable_request_recording()

◆ follow() [1/5]

◆ follow() [2/5]

◆ follow() [3/5]

◆ follow() [4/5]

◆ follow() [5/5]

◆ get() [1/3]

◆ get() [2/3]

◆ get() [3/3]

◆ get_overridden_variables()

◆ get_requested_arguments()

◆ get_requested_sections()

◆ get_requested_variables()

◆ get_section_names()

◆ get_subsection_names()

◆ get_value_no_default() [1/10]

◆ get_value_no_default() [2/10]

◆ get_value_no_default() [3/10]

◆ get_value_no_default() [4/10]

◆ get_value_no_default() [5/10]

◆ get_value_no_default() [6/10]

◆ get_value_no_default() [7/10]

◆ get_value_no_default() [8/10]

◆ get_value_no_default() [9/10]