X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fyoink;a=blobdiff_plain;f=src%2Fstlplus%2Fsubsystems%2Fcli_parser.hpp;fp=src%2Fstlplus%2Fsubsystems%2Fcli_parser.hpp;h=0000000000000000000000000000000000000000;hp=dc9740d48ec48646c3cde4ec93764bc5e3dcf69e;hb=5846afb00833cc72fe72422ca896d2387c712cb4;hpb=a97500609dc3c1b11f9786d32bc458eb00de4c36 diff --git a/src/stlplus/subsystems/cli_parser.hpp b/src/stlplus/subsystems/cli_parser.hpp deleted file mode 100644 index dc9740d..0000000 --- a/src/stlplus/subsystems/cli_parser.hpp +++ /dev/null @@ -1,309 +0,0 @@ -#ifndef STLPLUS_CLI_PARSER -#define STLPLUS_CLI_PARSER -//////////////////////////////////////////////////////////////////////////////// - -// Author: Andy Rushton -// Copyright: (c) Southampton University 1999-2004 -// (c) Andy Rushton 2004-2009 -// License: BSD License, see ../docs/license.html - -// A subsystem for managing command-line parsing, including using INI files to -// control the default options. - -//////////////////////////////////////////////////////////////////////////////// -#include "subsystems_fixes.hpp" -#include "message_handler.hpp" -#include "ini_manager.hpp" -#include "smart_ptr.hpp" -#include -#include - -namespace stlplus -{ - - //////////////////////////////////////////////////////////////////////////////// - // Internals - - class cli_parser_data; - - //////////////////////////////////////////////////////////////////////////////// - // declarations - - // enum to define the basic behaviour of an argument - // - a switch is an option with no value but which can be switched on or off e.g. -help and -nohelp - // - a value is an option followed by a value e.g. -output results.txt - // (a default value can be removed by using the option as a negated switch e.g. -nooutput) - // - command-line values (i.e. any strings not preceded by '-') are treated - // internally as an option with no name and must be values - enum cli_kind_t {cli_switch_kind, cli_value_kind}; - - // the mode controls the behaviour if an option appears more than once in either the command-line or the ini files - // - a single mode option overrides all previous values so will only be found once in the parsed result - // - a multiple mode option can be repeated to define multiple values, but overrides values from ini files - // - a cumulative mode option is a multiple mode option which keeps ini file values as well - enum cli_mode_t {cli_single_mode, cli_multiple_mode, cli_cumulative_mode}; - - // There are two structures used for defining command-line parameters - // (1) a C struct which is used in a C array - this is used for declaring - // command-line parameters in a static declaration - // (2) a C++ class which is used in an STL vector - this is used for building - // command-line parameters within code - - // The C struct for definitions - struct cli_definition_t - { - // the name of the option, e.g. "help" - const char* m_name; - - // the kind of the option, e.g. cli_switch_kind - cli_kind_t m_kind; - - // the mode e.g. cli_single_mode - cli_mode_t m_mode; - - // the mnemonic for the message giving usage information for this option - const char* m_message; - - // built-in default value - null if not present - const char* m_default; - }; - - // The C array of the C struct. The array must be terminated by END_CLI_DEFINITIONS. - typedef cli_definition_t cli_definitions_t []; -#define END_CLI_DEFINITIONS {0,stlplus::cli_switch_kind,stlplus::cli_single_mode,"",0} - - // The C++ class for definitions - class cli_definition - { - public: - // constructor that allows a definition to be created in one line - cli_definition(const std::string& name, cli_kind_t kind, cli_mode_t mode, - const std::string& message, const std::string& default_value = std::string()) : - m_name(name), m_kind(kind), m_mode(mode), m_message(message), m_default(default_value) {} - - // the name of the option, e.g. "help" - const std::string& name(void) const; - - // the kind of the option, e.g. switch_kind - cli_kind_t kind(void) const; - - // the mode e.g. single_mode - cli_mode_t mode(void) const; - - // the mnemonic for the message giving usage - const std::string& message(void) const; - - // built-in default value - empty string if not present - const std::string& default_value(void) const; - - private: - std::string m_name; - cli_kind_t m_kind; - cli_mode_t m_mode; - std::string m_message; - std::string m_default; - }; - - // The C++ vector of the C++ class - typedef std::vector cli_definitions; - - ////////////////////////////////////////////////////////////////////////////// - // exceptions that can be thrown by the CLI parser - // they are all derivatives of std::logic_error because all errors are predictable by code inspection - // a correct program will never throw an exception - - // thrown if a command-line argument is accessed with the wrong mode - i.e. attempt to get the value of a switch - class cli_mode_error : public std::invalid_argument - { - public: - cli_mode_error(const std::string& arg) : std::invalid_argument(arg) {} - ~cli_mode_error(void) throw() {} - }; - - // similar to std::out_of_range thrown for using an index out of range - class cli_index_error : public std::out_of_range - { - public: - cli_index_error(const std::string& arg) : std::out_of_range(arg) {} - ~cli_index_error(void) throw() {} - }; - - // similar to std::invalid_argument - thrown for passing an illegal argument to a method - class cli_argument_error : public std::invalid_argument - { - public: - cli_argument_error(const std::string& arg) : std::invalid_argument(arg) {} - ~cli_argument_error(void) throw() {} - }; - - //////////////////////////////////////////////////////////////////////////////// - - class cli_parser - { - public: - // Type definitions map the global type names onto convenient scoped names - - typedef cli_kind_t kind_t; - typedef cli_mode_t mode_t; - typedef cli_definition_t definition_t; - typedef cli_definitions_t definitions_t; - typedef cli_definition definition; - typedef cli_definitions definitions; - - //////////////////////////////////////////////////////////////////////////////// - // Methods - - // various constructors - - // you have a choice of either creating an uninitialised CLI parser and then - // calling separate functions to set it up or of calling one of the - // composite constructors. However, you must set up the error handler in the - // constructor. - - // set up the parser with its error handler - // defer everything else - cli_parser(message_handler& errors) - throw(); - - // constructors using the C definitions_t structure - - // set up the parser with the error handler and define all the command-line options - // defer default values and parameter parsing - cli_parser(cli_definitions_t, message_handler& errors) - throw(cli_mode_error); - // set up the parser with the error handler and define all the command-line - // options and their default from the ini files - // defer parameter parsing - cli_parser(cli_definitions_t, const ini_manager& defaults, const std::string& ini_section, message_handler& errors) - throw(cli_mode_error); - // set up the parser with the error handler and define all the command-line - // options no ini files used for default values, so only built-in defaults - // supported then parse the command line - cli_parser(char* argv[], cli_definitions_t, message_handler& errors) - throw(cli_mode_error,message_handler_id_error,message_handler_format_error); - // set up the parser with the error handler and define all the command-line - // options and their default from the ini files then parse the command line - cli_parser(char* argv[], cli_definitions_t, const ini_manager& defaults, const std::string& ini_section, message_handler& errors) - throw(cli_mode_error,message_handler_id_error,message_handler_format_error); - - // constructors using the C++ definitions structure - - // set up the parser with the error handler and define all the command-line - // options from a C array of structs - // defer default values and parameter parsing - cli_parser(cli_definitions, message_handler& errors) - throw(cli_mode_error); - // set up the parser with the error handler and define all the command-line - // options and their default from the ini files - // defer parameter parsing - cli_parser(cli_definitions, const ini_manager& defaults, const std::string& ini_section, message_handler& errors) - throw(cli_mode_error); - // set up the parser with the error handler and define all the command-line - // options no ini files used for default values, so only built-in defaults - // supported then parse the command line - cli_parser(char* argv[], cli_definitions, message_handler& errors) - throw(cli_mode_error,message_handler_id_error,message_handler_format_error); - // set up the parser with the error handler and define all the command-line - // options and their default from the ini files then parse the command line - cli_parser(char* argv[], cli_definitions, const ini_manager& defaults, const std::string& ini_section, message_handler& errors) - throw(cli_mode_error,message_handler_id_error,message_handler_format_error); - - ~cli_parser(void) - throw(); - - // the separate functions for initialising the parser in steps. These are - // declared in the order of use. Firts, add definitions of command-line - // arguments. Then optionally load default values from ini files, then - // finally parse the command line. - - // add a set of C definitions. The definitions will be given ID codes from 0 - // to the number of elements - 1 in the array - void add_definitions(cli_definitions_t) - throw(cli_mode_error); - // add a single C definition, returning the ID code for it - unsigned add_definition(const definition_t&) - throw(cli_mode_error,cli_argument_error); - // add a set of C++ definitions. The definitions will be given ID codes from - // 0 to the number of elements - 1 in the array - void add_definitions(cli_definitions) - throw(cli_mode_error); - // add a single C++ definition, returning the ID code for it - unsigned add_definition(const definition&) - throw(cli_mode_error); - - // All definitions have an optional built-in default value which is stored - // in the definition types above. However, these can optionally be - // overridden by a value from an ini file. If you want this functionality, - // call this function. If you don't want ini file handling, simply don't - // call it. The values will be searched for only in the named section of the - // ini file (sections are labelled by e.g. [vassemble]), so in this case you - // would specify the section name as "vassemble" (exclude the brackets). - void set_defaults(const ini_manager& defaults, const std::string& ini_section) - throw(); - - // the final stage of initialisation is to read the command-line and extract - // the values from it. If parse errors are found, this will report the - // errors using the error handler and return false. - bool parse(char* argv[]) - throw(cli_argument_error,message_handler_id_error,message_handler_format_error); - - // test for whether the CLI parser is still valid (no errors have happened) - // after the initialisation phase - bool valid(void) - throw(); - - // iteration functions avoiding the use of iterators. Just loop through the - // arguments from 0 to size()-1 and use the index of the loop to interrogate - // the command-line for the value at that position. - - // the number of values to read, indexed 0 to size()-1 - unsigned size(void) const - throw(); - - // the argument name - std::string name(unsigned i) const - throw(cli_index_error); - // the argument ID, that is, the offset into the original definitions - unsigned id(unsigned i) const - throw(cli_index_error); - - // the kind (switch or value) and short-cut tests for the different kinds - cli_kind_t kind(unsigned i) const - throw(cli_index_error); - bool switch_kind(unsigned i) const - throw(cli_index_error); - bool value_kind(unsigned i) const - throw(cli_index_error); - - // the mode (single, multiple, cumulative) and short-cut tests for the - // different modes - you rarely need to know this since it mainly controls - // the parsing - cli_mode_t mode(unsigned i) const - throw(cli_index_error); - bool single_mode(unsigned i) const - throw(cli_index_error); - bool multiple_mode(unsigned i) const - throw(cli_index_error); - bool cumulative_mode(unsigned i) const - throw(cli_index_error); - - // get the switch's value, but only if the value is of switch kind - bool switch_value(unsigned i) const - throw(cli_mode_error,cli_index_error); - - // get the option's value, but only if it is of value kind - std::string string_value(unsigned i) const - throw(cli_mode_error,cli_index_error); - - // print the usage report - typically in response to the -help switch being on - void usage(void) const - throw(std::runtime_error); - - private: - friend class cli_parser_data; - smart_ptr_nocopy m_data; - }; - -} // end namespace stlplus - -#endif