mirror of
https://github.com/boostorg/program_options.git
synced 2026-01-19 16:32:15 +00:00
Compare commits
3 Commits
develop
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
|
b7397bb984 | ||
|
|
86f68a636a | ||
|
c346a1b8a2 |
@@ -1,23 +0,0 @@
|
||||
// Copyright Vladimir Prus 2002.
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef PROGRAM_OPTIONS_VP_2003_05_19
|
||||
#define PROGRAM_OPTIONS_VP_2003_05_19
|
||||
|
||||
#if _MSC_VER >= 1020
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/program_options/options_description.hpp>
|
||||
#include <boost/program_options/positional_options.hpp>
|
||||
#include <boost/program_options/parsers.hpp>
|
||||
#include <boost/program_options/variables_map.hpp>
|
||||
#include <boost/program_options/cmdline.hpp>
|
||||
#include <boost/program_options/errors.hpp>
|
||||
#include <boost/program_options/option.hpp>
|
||||
#include <boost/program_options/value_semantic.hpp>
|
||||
#include <boost/program_options/version.hpp>
|
||||
|
||||
#endif
|
||||
@@ -1,85 +0,0 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_CMDLINE_HPP_VP_2004_03_13
|
||||
#define BOOST_CMDLINE_HPP_VP_2004_03_13
|
||||
|
||||
namespace boost { namespace program_options { namespace command_line_style {
|
||||
/** Various possible styles of options.
|
||||
|
||||
There are "long" options, which start with "--" and "short",
|
||||
which start with either "-" or "/". Both kinds can be allowed or
|
||||
disallowed, see allow_long and allow_short. The allowed character
|
||||
for short option is also configurable.
|
||||
|
||||
Option's value can be specified in the same token as value
|
||||
("--foo=bar"), or in the next token.
|
||||
|
||||
It's possible to introduce long option by the same character as
|
||||
long option, see allow_long_disguise.
|
||||
|
||||
Finally, guessing (specifying only prefix of option) and case
|
||||
insensitive processing are supported.
|
||||
*/
|
||||
enum style_t {
|
||||
/// Allow "--long_name" style
|
||||
allow_long = 1,
|
||||
/// Alow "-<single character" style
|
||||
allow_short = allow_long << 1,
|
||||
/// Allow "-" in short options
|
||||
allow_dash_for_short = allow_short << 1,
|
||||
/// Allow "/" in short options
|
||||
allow_slash_for_short = allow_dash_for_short << 1,
|
||||
/** Allow option parameter in the same token
|
||||
for long option, like in
|
||||
@verbatim
|
||||
--foo=10
|
||||
@endverbatim
|
||||
*/
|
||||
long_allow_adjacent = allow_slash_for_short << 1,
|
||||
/** Allow option parameter in the same token for
|
||||
long options. */
|
||||
long_allow_next = long_allow_adjacent << 1,
|
||||
/** Allow option parameter in the same token for
|
||||
short options. */
|
||||
short_allow_adjacent = long_allow_next << 1,
|
||||
/** Allow option parameter in the next token for
|
||||
short options. */
|
||||
short_allow_next = short_allow_adjacent << 1,
|
||||
/** Allow to merge several short options together,
|
||||
so that "-s -k" become "-sk". All of the options
|
||||
but last should accept no parameter. For example, if
|
||||
"-s" accept a parameter, then "k" will be taken as
|
||||
parameter, not another short option.
|
||||
Dos-style short options cannot be sticky.
|
||||
*/
|
||||
allow_sticky = short_allow_next << 1,
|
||||
/** Allow abbreviated spellings for long options,
|
||||
if they unambiguously identify long option.
|
||||
No long option name should be prefix of other
|
||||
long option name is guessing is in effect.
|
||||
*/
|
||||
allow_guessing = allow_sticky << 1,
|
||||
/** Ignore the difference in case for options.
|
||||
@todo Should this apply to long options only?
|
||||
*/
|
||||
case_insensitive = allow_guessing << 1,
|
||||
/** Allow long options with single option starting character,
|
||||
e.g <tt>-foo=10</tt>
|
||||
*/
|
||||
allow_long_disguise = case_insensitive << 1,
|
||||
/** The more-or-less traditional unix style. */
|
||||
unix_style = (allow_short | short_allow_adjacent | short_allow_next
|
||||
| allow_long | long_allow_adjacent | long_allow_next
|
||||
| allow_sticky | allow_guessing
|
||||
| allow_dash_for_short),
|
||||
/** The default style. */
|
||||
default_style = unix_style
|
||||
};
|
||||
}}}
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,55 +0,0 @@
|
||||
// Copyright (c) 2004 Hartmut Kaiser
|
||||
//
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_PROGRAM_OPTIONS_CONFIG_HK_2004_01_11
|
||||
#define BOOST_PROGRAM_OPTIONS_CONFIG_HK_2004_01_11
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/version.hpp>
|
||||
|
||||
// Support for autolinking.
|
||||
#if BOOST_VERSION >= 103100 // works beginning from Boost V1.31.0
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// enable automatic library variant selection
|
||||
#if !defined(BOOST_PROGRAM_OPTIONS_SOURCE) && !defined(BOOST_ALL_NO_LIB) && \
|
||||
!defined(BOOST_PROGRAM_OPTIONS_NO_LIB)
|
||||
|
||||
// Set the name of our library, this will get undef'ed by auto_link.hpp
|
||||
// once it's done with it:
|
||||
#define BOOST_LIB_NAME boost_program_options
|
||||
// tell the auto-link code to select a dll when required:
|
||||
#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_PROGRAM_OPTIONS_DYN_LINK)
|
||||
# define BOOST_DYN_LINK
|
||||
#endif
|
||||
|
||||
// And include the header that does the work:
|
||||
#include <boost/config/auto_link.hpp>
|
||||
|
||||
#endif // auto-linking disabled
|
||||
|
||||
#endif // BOOST_VERSION
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Windows DLL suport
|
||||
#ifdef BOOST_HAS_DECLSPEC
|
||||
#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_PROGRAM_OPTIONS_DYN_LINK)
|
||||
// export if this is our own source, otherwise import:
|
||||
#ifdef BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
# define BOOST_PROGRAM_OPTIONS_DECL __declspec(dllexport)
|
||||
#else
|
||||
# define BOOST_PROGRAM_OPTIONS_DECL __declspec(dllimport)
|
||||
#endif // BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
#endif // DYN_LINK
|
||||
#endif // BOOST_HAS_DECLSPEC
|
||||
|
||||
#ifndef BOOST_PROGRAM_OPTIONS_DECL
|
||||
#define BOOST_PROGRAM_OPTIONS_DECL
|
||||
#endif
|
||||
|
||||
|
||||
#endif // PROGRAM_OPTIONS_CONFIG_HK_2004_01_11
|
||||
|
||||
@@ -1,287 +0,0 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#ifndef BOOST_CMDLINE_VP_2003_05_19
|
||||
#define BOOST_CMDLINE_VP_2003_05_19
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/errors.hpp>
|
||||
#include <boost/program_options/cmdline.hpp>
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/function.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace boost { namespace program_options { namespace detail {
|
||||
|
||||
/** Command line parser class. Main requirements were:
|
||||
- Powerful enough to support all common uses.
|
||||
- Simple and easy to learn/use.
|
||||
- Minimal code size and external dependencies.
|
||||
- Extensible for custom syntaxes.
|
||||
|
||||
First all options are registered. After that, elements of command line
|
||||
are extracted using operator++.
|
||||
|
||||
For each element, user can find
|
||||
- if it's an option or an argument
|
||||
- name of the option
|
||||
- index of the option
|
||||
- option value(s), if any
|
||||
|
||||
Sometimes the registered option name is not equal to the encountered
|
||||
one, for example, because name abbreviation is supported. Therefore
|
||||
two option names can be obtained:
|
||||
- the registered one
|
||||
- the one found at the command line
|
||||
|
||||
There are lot of style options, which can be used to tune the command
|
||||
line parsing. In addition, it's possible to install additional parser
|
||||
which will process custom option styles.
|
||||
|
||||
@todo mininal match length for guessing?
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL cmdline {
|
||||
public:
|
||||
|
||||
typedef ::boost::program_options::command_line_style::style_t style_t;
|
||||
|
||||
typedef function1<std::pair<std::string, std::string>,
|
||||
const std::string&>
|
||||
additional_parser;
|
||||
|
||||
/** Constructs a command line parser for (argc, argv) pair. Uses
|
||||
style options passed in 'style', which should be binary or'ed values
|
||||
of style_t enum. It can also be zero, in which case a "default"
|
||||
style will be used. If 'allow_unregistered' is true, then allows
|
||||
unregistered options. They will be assigned index 1 and are
|
||||
assumed to have optional parameter.
|
||||
*/
|
||||
cmdline(const std::vector<std::string>& args, int style,
|
||||
bool allow_unregistered = false);
|
||||
|
||||
/** @overload */
|
||||
cmdline(int argc, const char*const * argv, int style,
|
||||
bool allow_unregistered = false);
|
||||
|
||||
/** Set additional parser. This will be called for each token
|
||||
of command line. If first string in pair is not empty,
|
||||
then the token is considered matched by this parser,
|
||||
and the first string will be considered an option name
|
||||
(which can be long or short), while the second will be
|
||||
option's parameter (if not empty).
|
||||
Note that additional parser can match only one token.
|
||||
*/
|
||||
void set_additional_parser(additional_parser p);
|
||||
|
||||
/** Registers a new option.
|
||||
@param long_name Long name to use. When ending '*', symbols up to
|
||||
it give an allowed prefix -- all options starting with it will be
|
||||
allowed. The first character may not be '-'. Empty string means no
|
||||
long name.
|
||||
@param short_name Short name to use. Value of '\0' means no short
|
||||
name.
|
||||
@param properties Tell about possible parameters
|
||||
'|' -- no parameter
|
||||
'?' -- optional parameter
|
||||
':' -- required parameter
|
||||
'*' -- 0 or more parameters
|
||||
'+' -- 1 or more parameters
|
||||
@param index A distinguishing value for the option.
|
||||
The index will be returned by 'option_index' member function.
|
||||
Indices need not be unique -- e.g. client can set all indices to 0,
|
||||
and use the string value to recognize options.
|
||||
*/
|
||||
void add_option(const std::string& long_name, char short_name,
|
||||
char properties = '|', int index = 0);
|
||||
|
||||
/** @overload */
|
||||
void add_option(const char* long_name, char short_name,
|
||||
char properties = '|', int index = 0);
|
||||
|
||||
|
||||
/** Returns false when nothing more can be extracted */
|
||||
operator bool() const;
|
||||
|
||||
/** Advances to the next element on command line.
|
||||
When called for the first time, positions on the first element. */
|
||||
cmdline& operator++();
|
||||
|
||||
/// Tells if the current element is option.
|
||||
bool at_option() const;
|
||||
|
||||
/// Tells if the current element is argument.
|
||||
bool at_argument() const;
|
||||
|
||||
/** Returns the option name. If there's long option name associated with
|
||||
this option, it is returned, even if short name was used in command
|
||||
line.Otherwise, the short name given to 'add_option' is returned
|
||||
with a '-' prefix.
|
||||
For purposes of simplicity, '-' is used even when dos-style short
|
||||
option was found.
|
||||
*/
|
||||
const std::string& option_name() const;
|
||||
/** Returns the index for the current option. */
|
||||
int option_index() const;
|
||||
/** Returns the option name as found on the command line. Any symbols
|
||||
that introduce the option, or delimit its parameter will be
|
||||
stripped. This function allows to work with allowed prefixes, in
|
||||
which case 'option_name' will return the prefix specification, and
|
||||
full option name should be queried explicitly.
|
||||
*/
|
||||
const std::string& raw_option_name() const;
|
||||
/** Returns the first of option values. If there's more than one option
|
||||
throws multiple_values. If there are no options, returns empty
|
||||
string. */
|
||||
const std::string& option_value() const;
|
||||
/** Returns all option values. */
|
||||
const std::vector<std::string>& option_values() const;
|
||||
/** Returns the argument. */
|
||||
const std::string& argument() const;
|
||||
|
||||
/** Returns all arguments read by this command line parser. */
|
||||
const std::vector<std::string>& arguments() const;
|
||||
|
||||
/** Returns the token that was current when 'operator++' was
|
||||
last invoked. */
|
||||
const std::string& last() const;
|
||||
|
||||
private:
|
||||
|
||||
// Properties of an option.
|
||||
enum properties_t {
|
||||
no_parameter = 1,
|
||||
/// 0 or 1 parameter
|
||||
allow_parameter,
|
||||
/// exactly 1 parameter
|
||||
require_parameter,
|
||||
/// 0 or more parameters
|
||||
allow_parameters,
|
||||
/// 1 or more parameters
|
||||
require_parameters
|
||||
};
|
||||
|
||||
enum element_kind_t {
|
||||
ek_option = 0,
|
||||
ek_argument
|
||||
};
|
||||
|
||||
// General error status.
|
||||
enum error_type_t {
|
||||
no_error = 0,
|
||||
unknown_option,
|
||||
ambiguous_option,
|
||||
invalid_syntax
|
||||
};
|
||||
|
||||
// Detailed error status.
|
||||
enum error_description_t {
|
||||
ed_success = 0,
|
||||
ed_long_not_allowed,
|
||||
ed_long_adjacent_not_allowed,
|
||||
ed_short_adjacent_not_allowed,
|
||||
ed_empty_adjacent_parameter,
|
||||
ed_missing_parameter,
|
||||
ed_extra_parameter,
|
||||
ed_unknown_option,
|
||||
ed_ambiguous_option
|
||||
};
|
||||
|
||||
// The standard say that nested classes has no access to
|
||||
// private member of enclosing class. However, most compilers
|
||||
// allow that and it's likely be to allowed in future:
|
||||
// http://std.dkuug.dk/jtc1/sc22/wg21/docs/cwg_defects.html#45
|
||||
// For Sun compiler, try using friend declaration.
|
||||
#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x560))
|
||||
struct option;
|
||||
friend struct option;
|
||||
#endif
|
||||
|
||||
struct option {
|
||||
option(const std::string& long_name, char short_name,
|
||||
properties_t properties, int index)
|
||||
: long_name(long_name), short_name(short_name), index(index),
|
||||
properties(properties)
|
||||
{}
|
||||
|
||||
std::string long_name;
|
||||
char short_name;
|
||||
int index;
|
||||
properties_t properties;
|
||||
};
|
||||
|
||||
|
||||
std::vector<option> options;
|
||||
|
||||
void init(const std::vector<std::string>& args, int style,
|
||||
bool allow_unregistered);
|
||||
void check_style(int style) const;
|
||||
|
||||
void next();
|
||||
|
||||
const option* find_long_option(const char* name);
|
||||
const option* find_short_option(char name);
|
||||
|
||||
enum option_kind { error_option, no_option, long_option, short_option,
|
||||
dos_option };
|
||||
option_kind is_option(const char* s);
|
||||
// All handle_* member functions take string without any "--" or "-" or "/"
|
||||
// They return true and success and set m_num_tokens to the number of
|
||||
// tokens that were consumed.
|
||||
bool handle_long_option(const char* s);
|
||||
bool handle_short_option(const char* s, bool ignore_sticky = false);
|
||||
bool handle_dos_option(const char* s);
|
||||
// Attempts to apply additional parser to 's'.
|
||||
bool handle_additional_parser(const std::pair<std::string, std::string>& p);
|
||||
|
||||
bool process_parameter(const option* opt, bool adjacent_parameter,
|
||||
bool next_parameter);
|
||||
void advance(int count);
|
||||
|
||||
/// Converts parameter property character into enum value.
|
||||
properties_t translate_property(char p);
|
||||
|
||||
/** Clears the error state. If there were an error, throws appripriate
|
||||
exception. */
|
||||
void clear_error();
|
||||
|
||||
// Copies of input.
|
||||
std::vector<std::string> args;
|
||||
style_t style;
|
||||
bool allow_unregistered;
|
||||
|
||||
// Current state of parsing.
|
||||
unsigned index;
|
||||
const char* m_current;
|
||||
const char* m_next;
|
||||
const char* pending_short_option;
|
||||
bool m_no_more_options;
|
||||
error_description_t m_error_description;
|
||||
element_kind_t m_element_kind;
|
||||
int m_option_index;
|
||||
|
||||
// Results of parsing the last option
|
||||
std::string m_last;
|
||||
const option* m_opt;
|
||||
std::string m_option_name, m_raw_option_name, m_argument;
|
||||
std::vector<std::string> m_option_values;
|
||||
int m_num_tokens;
|
||||
bool m_disguised_long;
|
||||
|
||||
std::vector<std::string> m_arguments;
|
||||
|
||||
additional_parser m_additional_parser;
|
||||
};
|
||||
|
||||
void test_cmdline_detail();
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,173 +0,0 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#ifndef BOOST_CONFIG_FILE_VP_2003_01_02
|
||||
#define BOOST_CONFIG_FILE_VP_2003_01_02
|
||||
|
||||
#include <iosfwd>
|
||||
#include <string>
|
||||
#include <set>
|
||||
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/option.hpp>
|
||||
#include <boost/program_options/eof_iterator.hpp>
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202))
|
||||
#include <boost/program_options/detail/convert.hpp>
|
||||
#endif
|
||||
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
|
||||
|
||||
|
||||
namespace boost { namespace program_options { namespace detail {
|
||||
|
||||
/** Standalone parser for config files in ini-line format.
|
||||
The parser is a model of single-pass lvalue iterator, and
|
||||
default constructor creates past-the-end-iterator. The typical usage is:
|
||||
config_file_iterator i(is, ... set of options ...), e;
|
||||
for(; i !=e; ++i) {
|
||||
*i;
|
||||
}
|
||||
|
||||
Syntax conventions:
|
||||
|
||||
- config file can not contain positional options
|
||||
- '#' is comment character: it is ignored together with
|
||||
the rest of the line.
|
||||
- variable assignments are in the form
|
||||
name '=' value.
|
||||
spaces around '=' are trimmed.
|
||||
- Section names are given in brackets.
|
||||
|
||||
The actual option name is constructed by combining current section
|
||||
name and specified option name, with dot between. If section_name
|
||||
already contains dot at the end, new dot is not inserted. For example:
|
||||
@verbatim
|
||||
[gui.accessibility]
|
||||
visual_bell=yes
|
||||
@endverbatim
|
||||
will result in option "gui.accessibility.visual_bell" with value
|
||||
"yes" been returned.
|
||||
|
||||
TODO: maybe, we should just accept a pointer to options_description
|
||||
class.
|
||||
*/
|
||||
class common_config_file_iterator
|
||||
: public eof_iterator<common_config_file_iterator, option>
|
||||
{
|
||||
public:
|
||||
common_config_file_iterator() { found_eof(); }
|
||||
common_config_file_iterator(
|
||||
const std::set<std::string>& allowed_options);
|
||||
|
||||
virtual ~common_config_file_iterator() {}
|
||||
|
||||
public: // Method required by eof_iterator
|
||||
|
||||
void get();
|
||||
|
||||
protected: // Stubs for derived classes
|
||||
|
||||
// Obtains next line from the config file
|
||||
// Note: really, this design is a bit ugly
|
||||
// The most clean thing would be to pass 'line_iterator' to
|
||||
// constructor of this class, but to avoid templating this class
|
||||
// we'd need polymorphic iterator, which does not exist yet.
|
||||
virtual bool getline(std::string&) { return false; }
|
||||
|
||||
private:
|
||||
/** Adds another allowed option. If the 'name' ends with
|
||||
'*', then all options with the same prefix are
|
||||
allowed. For example, if 'name' is 'foo*', then 'foo1' and
|
||||
'foo_bar' are allowed. */
|
||||
void add_option(const char* name);
|
||||
|
||||
// Returns true if 's' is a registered option name.
|
||||
bool allowed_option(const std::string& s) const;
|
||||
|
||||
// That's probably too much data for iterator, since
|
||||
// it will be copied, but let's not bother for now.
|
||||
std::set<std::string> allowed_options;
|
||||
// Invariant: no element is prefix of other element.
|
||||
std::set<std::string> allowed_prefixes;
|
||||
std::string m_prefix;
|
||||
};
|
||||
|
||||
template<class charT>
|
||||
class basic_config_file_iterator : public common_config_file_iterator {
|
||||
public:
|
||||
basic_config_file_iterator()
|
||||
{
|
||||
found_eof();
|
||||
}
|
||||
|
||||
/** Creates a config file parser for the specified stream.
|
||||
*/
|
||||
basic_config_file_iterator(std::basic_istream<charT>& is,
|
||||
const std::set<std::string>& allowed_options);
|
||||
|
||||
private: // base overrides
|
||||
|
||||
bool getline(std::string&);
|
||||
|
||||
private: // internal data
|
||||
shared_ptr<std::basic_istream<charT> > is;
|
||||
};
|
||||
|
||||
typedef basic_config_file_iterator<char> config_file_iterator;
|
||||
typedef basic_config_file_iterator<wchar_t> wconfig_file_iterator;
|
||||
|
||||
|
||||
struct null_deleter
|
||||
{
|
||||
void operator()(void const *) const {}
|
||||
};
|
||||
|
||||
|
||||
template<class charT>
|
||||
basic_config_file_iterator<charT>::
|
||||
basic_config_file_iterator(std::basic_istream<charT>& is,
|
||||
const std::set<std::string>& allowed_options)
|
||||
: common_config_file_iterator(allowed_options)
|
||||
{
|
||||
this->is.reset(&is, null_deleter());
|
||||
get();
|
||||
}
|
||||
|
||||
// Specializing this function for wchar_t causes problems on
|
||||
// borland and vc7, as well as on metrowerks. On the first two
|
||||
// I don't know a workaround, so make use of 'to_internal' to
|
||||
// avoid specialization.
|
||||
template<class charT>
|
||||
bool
|
||||
basic_config_file_iterator<charT>::getline(std::string& s)
|
||||
{
|
||||
std::basic_string<charT> in;
|
||||
if (std::getline(*is, in)) {
|
||||
s = to_internal(in);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Specialization is needed to workaround getline bug on Comeau.
|
||||
#if BOOST_WORKAROUND(__COMO_VERSION__, BOOST_TESTED_AT(4303))
|
||||
template<>
|
||||
bool
|
||||
basic_config_file_iterator<wchar_t>::getline(std::string& s);
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
@@ -1,107 +0,0 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_CONVERT_HPP_VP_2004_04_28
|
||||
#define BOOST_CONVERT_HPP_VP_2004_04_28
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#if !defined(BOOST_NO_STD_WSTRING)
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <locale>
|
||||
// for mbstate_t
|
||||
#include <cwchar>
|
||||
#include <stdexcept>
|
||||
|
||||
#if BOOST_WORKAROUND(__ICL, <= 700) || BOOST_WORKAROUND(_MSC_VER, <= 1200)
|
||||
#include <wchar.h>
|
||||
namespace std
|
||||
{
|
||||
using ::mbstate_t;
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
/** Converts from local 8 bit encoding into wchar_t string using
|
||||
the specified locale facet. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::wstring
|
||||
from_8_bit(const std::string& s,
|
||||
const std::codecvt<wchar_t, char, std::mbstate_t>& cvt);
|
||||
|
||||
/** Converts from wchar_t string into local 8 bit encoding into using
|
||||
the specified locale facet. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string
|
||||
to_8_bit(const std::wstring& s,
|
||||
const std::codecvt<wchar_t, char, std::mbstate_t>& cvt);
|
||||
|
||||
|
||||
/** Converts 's', which is assumed to be in UTF8 encoding, into wide
|
||||
string. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::wstring
|
||||
from_utf8(const std::string& s);
|
||||
|
||||
/** Converts wide string 's' into string in UTF8 encoding. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string
|
||||
to_utf8(const std::wstring& s);
|
||||
|
||||
/** Converts wide string 's' into local 8 bit encoding determined by
|
||||
the current locale. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string
|
||||
to_local_8_bit(const std::wstring& s);
|
||||
|
||||
/** Converts 's', which is assumed to be in local 8 bit encoding, into wide
|
||||
string. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::wstring
|
||||
from_local_8_bit(const std::string& s);
|
||||
|
||||
namespace program_options
|
||||
{
|
||||
/** Convert the input string into internal encoding used by
|
||||
program_options. Presence of this function allows to avoid
|
||||
specializing all methods which access input on wchar_t.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string to_internal(const std::string&);
|
||||
/** @overload */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string to_internal(const std::wstring&);
|
||||
|
||||
template<class T>
|
||||
std::vector<std::string> to_internal(const std::vector<T>& s)
|
||||
{
|
||||
std::vector<std::string> result;
|
||||
for (unsigned i = 0; i < s.size(); ++i)
|
||||
result.push_back(to_internal(s[i]));
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#else
|
||||
#include <vector>
|
||||
#include <string>
|
||||
namespace boost{
|
||||
namespace program_options{
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string to_internal(const std::string&);
|
||||
|
||||
template<class T>
|
||||
std::vector<std::string> to_internal(const std::vector<T>& s)
|
||||
{
|
||||
std::vector<std::string> result;
|
||||
for (unsigned i = 0; i < s.size(); ++i)
|
||||
result.push_back(to_internal(s[i]));
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
@@ -1,103 +0,0 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_PARSERS_HPP_VP_2004_05_06
|
||||
#define BOOST_PARSERS_HPP_VP_2004_05_06
|
||||
|
||||
#include <boost/program_options/detail/convert.hpp>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
namespace detail {
|
||||
template<class charT, class Iterator>
|
||||
std::vector<std::basic_string<charT> >
|
||||
make_vector(Iterator i, Iterator e)
|
||||
{
|
||||
std::vector<std::basic_string<charT> > result;
|
||||
// Some compilers don't have templated constructor for
|
||||
// vector, so we can't create vector from (argv+1, argv+argc) range
|
||||
for(; i != e; ++i)
|
||||
result.push_back(*i);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>::
|
||||
basic_command_line_parser(const std::vector<
|
||||
std::basic_string<charT> >& args)
|
||||
: common_command_line_parser(to_internal(args))
|
||||
{}
|
||||
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>::
|
||||
basic_command_line_parser(int argc, charT* argv[])
|
||||
: common_command_line_parser(
|
||||
// Explicit template arguments are required by gcc 3.3.1
|
||||
// (at least mingw version), and do no harm on other compilers.
|
||||
to_internal(detail::make_vector<charT, charT**>(argv+1, argv+argc)))
|
||||
{}
|
||||
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>&
|
||||
basic_command_line_parser<charT>::options(const options_description& desc)
|
||||
{
|
||||
m_desc = &desc;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>&
|
||||
basic_command_line_parser<charT>::positional(
|
||||
const positional_options_description& desc)
|
||||
{
|
||||
m_positional = &desc;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>&
|
||||
basic_command_line_parser<charT>::style(int style)
|
||||
{
|
||||
m_style = style;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>&
|
||||
basic_command_line_parser<charT>::extra_parser(ext_parser ext)
|
||||
{
|
||||
m_ext = ext;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class charT>
|
||||
basic_parsed_options<charT>
|
||||
basic_command_line_parser<charT>::run() const
|
||||
{
|
||||
// Presense of parsed_options -> wparsed_options conversion
|
||||
// does the trick.
|
||||
return basic_parsed_options<charT>(
|
||||
common_command_line_parser::run());
|
||||
}
|
||||
|
||||
|
||||
template<class charT>
|
||||
basic_parsed_options<charT>
|
||||
parse_command_line(int argc, charT* argv[],
|
||||
const options_description& desc,
|
||||
int style,
|
||||
function1<std::pair<std::string, std::string>,
|
||||
const std::string&> ext)
|
||||
{
|
||||
return basic_command_line_parser<charT>(argc, argv).options(desc).
|
||||
style(style).extra_parser(ext).run();
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -1,221 +0,0 @@
|
||||
#ifndef BOOST_UTF8_CODECVT_FACET_HPP
|
||||
#define BOOST_UTF8_CODECVT_FACET_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// utf8_codecvt_facet.hpp
|
||||
|
||||
// Copyright © 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
|
||||
// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu). Permission to copy,
|
||||
// use, modify, sell and distribute this software is granted provided this
|
||||
// copyright notice appears in all copies. This software is provided "as is"
|
||||
// without express or implied warranty, and with no claim as to its suitability
|
||||
// for any purpose.
|
||||
|
||||
// Note:(Robert Ramey). I have made the following alterations in the original
|
||||
// code.
|
||||
// a) Rendered utf8_codecvt<wchar_t, char> with using templates
|
||||
// b) Move longer functions outside class definition to prevent inlining
|
||||
// and make code smaller
|
||||
// c) added on a derived class to permit translation to/from current
|
||||
// locale to utf8
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// archives stored as text - note these ar templated on the basic
|
||||
// stream templates to accommodate wide (and other?) kind of characters
|
||||
//
|
||||
// note the fact that on libraries without wide characters, ostream is
|
||||
// is not a specialization of basic_ostream which in fact is not defined
|
||||
// in such cases. So we can't use basic_ostream<OStream::char_type> but rather
|
||||
// use two template parameters
|
||||
//
|
||||
// utf8_codecvt_facet
|
||||
// This is an implementation of a std::codecvt facet for translating
|
||||
// from UTF-8 externally to UCS-4. Note that this is not tied to
|
||||
// any specific types in order to allow customization on platforms
|
||||
// where wchar_t is not big enough.
|
||||
//
|
||||
// NOTES: The current implementation jumps through some unpleasant hoops in
|
||||
// order to deal with signed character types. As a std::codecvt_base::result,
|
||||
// it is necessary for the ExternType to be convertible to unsigned char.
|
||||
// I chose not to tie the extern_type explicitly to char. But if any combination
|
||||
// of types other than <wchar_t,char_t> is used, then std::codecvt must be
|
||||
// specialized on those types for this to work.
|
||||
|
||||
#include <locale>
|
||||
// for mbstate_t
|
||||
#include <wchar.h>
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#if BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x551))
|
||||
#ifndef _RWSTD_NO_NAMESPACE
|
||||
using std::codecvt;
|
||||
using std::min;
|
||||
#ifdef _RWSTD_NO_MBSTATE_T
|
||||
using std::mbstate_t;
|
||||
#endif
|
||||
#endif
|
||||
#elif defined(__COMO__) || defined(_MSC_VER) && _MSC_VER <= 1300
|
||||
typedef ::mbstate_t mbstate_t;
|
||||
#elif defined(BOOST_NO_STDC_NAMESPACE)
|
||||
typedef std::mbstate_t mbstate_t;
|
||||
namespace std{
|
||||
using ::codecvt;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
// maximum lenght of a multibyte string
|
||||
#define MB_LENGTH_MAX 8
|
||||
|
||||
namespace boost { namespace program_options { namespace detail {
|
||||
|
||||
struct BOOST_PROGRAM_OPTIONS_DECL utf8_codecvt_facet_wchar_t :
|
||||
public std::codecvt<wchar_t, char, mbstate_t>
|
||||
{
|
||||
public:
|
||||
explicit utf8_codecvt_facet_wchar_t(std::size_t no_locale_manage=0)
|
||||
: std::codecvt<wchar_t, char, mbstate_t>(no_locale_manage)
|
||||
{}
|
||||
protected:
|
||||
virtual std::codecvt_base::result do_in(
|
||||
mbstate_t& state,
|
||||
const char * from,
|
||||
const char * from_end,
|
||||
const char * & from_next,
|
||||
wchar_t * to,
|
||||
wchar_t * to_end,
|
||||
wchar_t*& to_next
|
||||
) const;
|
||||
|
||||
virtual std::codecvt_base::result do_out(
|
||||
mbstate_t & state, const wchar_t * from,
|
||||
const wchar_t * from_end, const wchar_t* & from_next,
|
||||
char * to, char * to_end, char * & to_next
|
||||
) const;
|
||||
|
||||
bool invalid_continuing_octet(unsigned char octet_1) const {
|
||||
return (octet_1 < 0x80|| 0xbf< octet_1);
|
||||
}
|
||||
|
||||
bool invalid_leading_octet(unsigned char octet_1) const {
|
||||
return (0x7f < octet_1 && octet_1 < 0xc0) ||
|
||||
(octet_1 > 0xfd);
|
||||
}
|
||||
|
||||
// continuing octets = octets except for the leading octet
|
||||
static unsigned int get_cont_octet_count(unsigned char lead_octet) {
|
||||
return get_octet_count(lead_octet) - 1;
|
||||
}
|
||||
|
||||
static unsigned int get_octet_count(unsigned char lead_octet);
|
||||
|
||||
// How many "continuing octets" will be needed for this word
|
||||
// == total octets - 1.
|
||||
int get_cont_octet_out_count(wchar_t word) const ;
|
||||
|
||||
virtual bool do_always_noconv() const throw() { return false; }
|
||||
|
||||
// UTF-8 isn't really stateful since we rewind on partial conversions
|
||||
virtual std::codecvt_base::result do_unshift(
|
||||
mbstate_t&,
|
||||
char * from,
|
||||
char * to,
|
||||
char * & next
|
||||
) const
|
||||
{
|
||||
next = from;
|
||||
return ok;
|
||||
}
|
||||
|
||||
virtual int do_encoding() const throw() {
|
||||
const int variable_byte_external_encoding=0;
|
||||
return variable_byte_external_encoding;
|
||||
}
|
||||
|
||||
// How many char objects can I process to get <= max_limit
|
||||
// wchar_t objects?
|
||||
virtual int do_length(
|
||||
mbstate_t &,
|
||||
const char * from,
|
||||
const char * from_end,
|
||||
std::size_t max_limit
|
||||
#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
|
||||
) const throw();
|
||||
#else
|
||||
) const;
|
||||
#endif
|
||||
|
||||
// Largest possible value do_length(state,from,from_end,1) could return.
|
||||
virtual int do_max_length() const throw () {
|
||||
return 6; // largest UTF-8 encoding of a UCS-4 character
|
||||
}
|
||||
};
|
||||
|
||||
#if 0 // not used - incorrect in any case
|
||||
// Robert Ramey - use the above to make a code converter from multi-byte
|
||||
// char strings to utf8 encoding
|
||||
struct utf8_codecvt_facet_char : public utf8_codecvt_facet_wchar_t
|
||||
{
|
||||
typedef utf8_codecvt_facet_wchar_t base_class;
|
||||
public:
|
||||
explicit utf8_codecvt_facet_char(size_t no_locale_manage=0)
|
||||
: base_class(no_locale_manage)
|
||||
{}
|
||||
protected:
|
||||
virtual std::codecvt_base::result do_in(
|
||||
mbstate_t & state,
|
||||
const char * from,
|
||||
const char * from_end,
|
||||
const char * & from_next,
|
||||
char * to,
|
||||
char * to_end,
|
||||
char * & to_next
|
||||
) const;
|
||||
|
||||
virtual std::codecvt_base::result do_out(
|
||||
mbstate_t & state,
|
||||
const char * from,
|
||||
const char * from_end,
|
||||
const char* & from_next,
|
||||
char * to,
|
||||
char * to_end,
|
||||
char * & to_next
|
||||
) const;
|
||||
|
||||
// How many char objects can I process to get <= max_limit
|
||||
// char objects?
|
||||
virtual int do_length(
|
||||
const mbstate_t&,
|
||||
const char * from,
|
||||
const char * from_end,
|
||||
size_t max_limit
|
||||
) const;
|
||||
};
|
||||
#endif
|
||||
|
||||
template<class Internal, class External>
|
||||
struct utf8_codecvt_facet
|
||||
{};
|
||||
|
||||
template<>
|
||||
struct BOOST_PROGRAM_OPTIONS_DECL utf8_codecvt_facet<wchar_t, char>
|
||||
: public utf8_codecvt_facet_wchar_t
|
||||
{};
|
||||
|
||||
#if 0
|
||||
template<>
|
||||
struct utf8_codecvt_facet<char, char>
|
||||
: public utf8_codecvt_facet_char
|
||||
{};
|
||||
#endif
|
||||
|
||||
}}}
|
||||
|
||||
#endif // BOOST_UTF8_CODECVT_FACET_HPP
|
||||
@@ -1,187 +0,0 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// This file defines template functions that are declared in
|
||||
// ../value_semantic.hpp.
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
extern BOOST_PROGRAM_OPTIONS_DECL std::string arg;
|
||||
|
||||
template<class T, class charT>
|
||||
std::string
|
||||
typed_value<T, charT>::name() const
|
||||
{
|
||||
if (!m_default_value.empty() && !m_default_value_as_text.empty()) {
|
||||
return arg + " (=" + m_default_value_as_text + ")";
|
||||
} else {
|
||||
return arg;
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class charT>
|
||||
void
|
||||
typed_value<T, charT>::notify(const boost::any& value_store) const
|
||||
{
|
||||
const T* value = boost::any_cast<const T>(&value_store);
|
||||
if (m_store_to) {
|
||||
*m_store_to = *value;
|
||||
}
|
||||
if (m_notifier) {
|
||||
m_notifier(*value);
|
||||
}
|
||||
}
|
||||
|
||||
namespace validators {
|
||||
/* If v.size() > 1, throw validation_error.
|
||||
If v.size() == 1, return v.front()
|
||||
Otherwise, returns a reference to a statically allocated
|
||||
empty string if 'allow_empty' and throws validation_error
|
||||
otherwise. */
|
||||
template<class charT>
|
||||
const std::basic_string<charT>& get_single_string(
|
||||
const std::vector<std::basic_string<charT> >& v,
|
||||
bool allow_empty = false)
|
||||
{
|
||||
static std::basic_string<charT> empty;
|
||||
if (v.size() > 1)
|
||||
throw validation_error("multiple values not allowed");
|
||||
if (v.size() == 1)
|
||||
return v.front();
|
||||
else if (allow_empty)
|
||||
return empty;
|
||||
else
|
||||
throw validation_error("at least one value required");
|
||||
}
|
||||
|
||||
/* Throws multiple_occurrences if 'value' is not empty. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL void
|
||||
check_first_occurrence(const boost::any& value);
|
||||
}
|
||||
|
||||
using namespace validators;
|
||||
|
||||
/** Validates 's' and updates 'v'.
|
||||
@pre 'v' is either empty or in the state assigned by the previous
|
||||
invocation of 'validate'.
|
||||
The target type is specified via a parameter which has the type of
|
||||
pointer to the desired type. This is workaround for compilers without
|
||||
partial template ordering, just like the last 'long/int' parameter.
|
||||
*/
|
||||
template<class T, class charT>
|
||||
void validate(boost::any& v,
|
||||
const std::vector< std::basic_string<charT> >& xs,
|
||||
T*, long)
|
||||
{
|
||||
validators::check_first_occurrence(v);
|
||||
std::basic_string<charT> s(validators::get_single_string(xs));
|
||||
try {
|
||||
v = any(lexical_cast<T>(s));
|
||||
}
|
||||
catch(const bad_lexical_cast&) {
|
||||
throw invalid_option_value(s);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL void validate(boost::any& v,
|
||||
const std::vector<std::string>& xs,
|
||||
bool*,
|
||||
int);
|
||||
|
||||
#if !defined(BOOST_NO_STD_WSTRING)
|
||||
BOOST_PROGRAM_OPTIONS_DECL void validate(boost::any& v,
|
||||
const std::vector<std::wstring>& xs,
|
||||
bool*,
|
||||
int);
|
||||
#endif
|
||||
// For some reason, this declaration, which is require by the standard,
|
||||
// cause gcc 3.2 to not generate code to specialization defined in
|
||||
// value_semantic.cpp
|
||||
#if ! ( ( BOOST_WORKAROUND(__GNUC__, <= 3) &&\
|
||||
BOOST_WORKAROUND(__GNUC_MINOR__, < 3) ) || \
|
||||
( BOOST_WORKAROUND(BOOST_MSVC, == 1310) ) \
|
||||
)
|
||||
BOOST_PROGRAM_OPTIONS_DECL void validate(boost::any& v,
|
||||
const std::vector<std::string>& xs,
|
||||
std::string*,
|
||||
int);
|
||||
|
||||
#if !defined(BOOST_NO_STD_WSTRING)
|
||||
BOOST_PROGRAM_OPTIONS_DECL void validate(boost::any& v,
|
||||
const std::vector<std::wstring>& xs,
|
||||
std::string*,
|
||||
int);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/** Validates sequences. Allows multiple values per option occurrence
|
||||
and multiple occurrences. */
|
||||
template<class T, class charT>
|
||||
void validate(boost::any& v,
|
||||
const std::vector<std::basic_string<charT> >& s,
|
||||
std::vector<T>*,
|
||||
int)
|
||||
{
|
||||
if (v.empty()) {
|
||||
v = boost::any(std::vector<T>());
|
||||
}
|
||||
std::vector<T>* tv = boost::any_cast< std::vector<T> >(&v);
|
||||
assert(tv);
|
||||
for (unsigned i = 0; i < s.size(); ++i)
|
||||
{
|
||||
try {
|
||||
tv->push_back(boost::lexical_cast<T>(s[i]));
|
||||
}
|
||||
catch(const bad_lexical_cast& /*e*/) {
|
||||
throw invalid_option_value(s[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class charT>
|
||||
void
|
||||
typed_value<T, charT>::
|
||||
xparse(boost::any& value_store,
|
||||
const std::vector<std::basic_string<charT> >& new_tokens) const
|
||||
{
|
||||
validate(value_store, new_tokens, (T*)0, 0);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
typed_value<T>*
|
||||
value()
|
||||
{
|
||||
// Explicit qualification is vc6 workaround.
|
||||
return boost::program_options::value<T>(0);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
typed_value<T>*
|
||||
value(T* v)
|
||||
{
|
||||
typed_value<T>* r = new typed_value<T>(v);
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
typed_value<T, wchar_t>*
|
||||
wvalue()
|
||||
{
|
||||
return wvalue<T>(0);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
typed_value<T, wchar_t>*
|
||||
wvalue(T* v)
|
||||
{
|
||||
typed_value<T, wchar_t>* r = new typed_value<T, wchar_t>(v);
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
|
||||
}}
|
||||
@@ -1,51 +0,0 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_ENVIRONMENT_ITERATOR_VP_2004_05_14
|
||||
#define BOOST_ENVIRONMENT_ITERATOR_VP_2004_05_14
|
||||
|
||||
#include "eof_iterator.hpp"
|
||||
|
||||
#include <utility>
|
||||
#include <string>
|
||||
#include <cassert>
|
||||
|
||||
namespace boost {
|
||||
|
||||
class environment_iterator
|
||||
: public eof_iterator<environment_iterator,
|
||||
std::pair<std::string, std::string> >
|
||||
{
|
||||
public:
|
||||
environment_iterator(char** environment)
|
||||
: m_environment(environment)
|
||||
{
|
||||
get();
|
||||
}
|
||||
|
||||
environment_iterator()
|
||||
{
|
||||
found_eof();
|
||||
}
|
||||
|
||||
void get()
|
||||
{
|
||||
if (*m_environment == 0)
|
||||
found_eof();
|
||||
else {
|
||||
std::string s(*m_environment);
|
||||
std::string::size_type n = s.find('=');
|
||||
assert(n != s.npos);
|
||||
value().first = s.substr(0, n);
|
||||
value().second = s.substr(n+1);
|
||||
}
|
||||
++m_environment;
|
||||
}
|
||||
|
||||
private:
|
||||
char** m_environment;
|
||||
};
|
||||
}
|
||||
#endif
|
||||
@@ -1,97 +0,0 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_EOF_ITERATOR_VP_2004_03_12
|
||||
#define BOOST_EOF_ITERATOR_VP_2004_03_12
|
||||
|
||||
#include <boost/iterator/iterator_facade.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
/** The 'eof_iterator' class is useful for constructing forward iterators
|
||||
in cases where iterator extract data from some source and it's easy
|
||||
to detect 'eof' -- i.e. the situation where there's no data. One
|
||||
apparent example is reading lines from a file.
|
||||
|
||||
Implementing such iterators using 'iterator_facade' directly would
|
||||
require to create class with three core operation, a couple of
|
||||
constructors. When using 'eof_iterator', the derived class should define
|
||||
only one method to get new value, plus a couple of constructors.
|
||||
|
||||
The basic idea is that iterator has 'eof' bit. Two iterators are equal
|
||||
only if both have their 'eof' bits set. The 'get' method either obtains
|
||||
the new value or sets the 'eof' bit.
|
||||
|
||||
Specifically, derived class should define:
|
||||
|
||||
1. A default constructor, which creates iterator with 'eof' bit set. The
|
||||
constructor body should call 'found_eof' method defined here.
|
||||
2. Some other constructor. It should initialize some 'data pointer' used
|
||||
in iterator operation and then call 'get'.
|
||||
3. The 'get' method. It should operate this way:
|
||||
- look at some 'data pointer' to see if new element is available;
|
||||
if not, it should call 'found_eof'.
|
||||
- extract new element and store it at location returned by the 'value'
|
||||
method.
|
||||
- advance the data pointer.
|
||||
|
||||
Essentially, the 'get' method has the functionality of both 'increment'
|
||||
and 'dereference'. It's very good for the cases where data extraction
|
||||
implicitly moves data pointer, like for stream operation.
|
||||
*/
|
||||
template<class Derived, class ValueType>
|
||||
class eof_iterator : public iterator_facade<Derived, const ValueType,
|
||||
forward_traversal_tag>
|
||||
{
|
||||
public:
|
||||
eof_iterator()
|
||||
: m_at_eof(false)
|
||||
{}
|
||||
|
||||
protected: // interface for derived
|
||||
|
||||
/** Returns the reference which should be used by derived
|
||||
class to store the next value. */
|
||||
ValueType& value()
|
||||
{
|
||||
return m_value;
|
||||
}
|
||||
|
||||
/** Should be called by derived class to indicate that it can't
|
||||
produce next element. */
|
||||
void found_eof()
|
||||
{
|
||||
m_at_eof = true;
|
||||
}
|
||||
|
||||
|
||||
private: // iterator core operations
|
||||
friend class iterator_core_access;
|
||||
|
||||
void increment()
|
||||
{
|
||||
static_cast<Derived&>(*this).get();
|
||||
}
|
||||
|
||||
bool equal(const eof_iterator& other) const
|
||||
{
|
||||
if (m_at_eof && other.m_at_eof)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
const ValueType& dereference() const
|
||||
{
|
||||
return m_value;
|
||||
}
|
||||
|
||||
bool m_at_eof;
|
||||
ValueType m_value;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,145 +0,0 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#ifndef BOOST_ERRORS_VP_2003_01_02
|
||||
#define BOOST_ERRORS_VP_2003_01_02
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <stdexcept>
|
||||
#include <vector>
|
||||
|
||||
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
/** Base class for all errors in the library. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL error : public std::logic_error {
|
||||
public:
|
||||
error(const std::string& what) : std::logic_error(what) {}
|
||||
};
|
||||
|
||||
class BOOST_PROGRAM_OPTIONS_DECL invalid_syntax : public error {
|
||||
public:
|
||||
invalid_syntax(const std::string& tokens, const std::string& msg)
|
||||
: error(std::string(msg).append(" in '").append(tokens).append("'")),
|
||||
tokens(tokens), msg(msg)
|
||||
{}
|
||||
|
||||
// gcc says that throw specification on dtor is loosened
|
||||
// without this line
|
||||
~invalid_syntax() throw() {}
|
||||
|
||||
// TODO: copy ctor might throw
|
||||
std::string tokens, msg;
|
||||
};
|
||||
|
||||
/** Class thrown when option name is not recognized. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL unknown_option : public error {
|
||||
public:
|
||||
unknown_option(const std::string& name)
|
||||
: error(std::string("unknown option ").append(name))
|
||||
{}
|
||||
};
|
||||
|
||||
/** Class thrown when there's ambiguity amoung several possible options. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL ambiguous_option : public error {
|
||||
public:
|
||||
ambiguous_option(const std::string& name,
|
||||
const std::vector<std::string>& alternatives)
|
||||
: error(std::string("ambiguous option ").append(name)),
|
||||
alternatives(alternatives)
|
||||
{}
|
||||
|
||||
~ambiguous_option() throw() {}
|
||||
|
||||
// TODO: copy ctor might throw
|
||||
std::vector<std::string> alternatives;
|
||||
};
|
||||
|
||||
/** Class thrown when there are several option values, but
|
||||
user called a method which cannot return them all. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL multiple_values : public error {
|
||||
public:
|
||||
multiple_values(const std::string& what) : error(what) {}
|
||||
};
|
||||
|
||||
/** Class thrown when there are several occurrences of an
|
||||
option, but user called a method which cannot return
|
||||
them all. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL multiple_occurrences : public error {
|
||||
public:
|
||||
multiple_occurrences(const std::string& what) : error(what) {}
|
||||
};
|
||||
|
||||
/** Class thrown when value of option is incorrect. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL validation_error : public error {
|
||||
public:
|
||||
validation_error(const std::string& what) : error(what) {}
|
||||
~validation_error() throw() {}
|
||||
void set_option_name(const std::string& option);
|
||||
private:
|
||||
mutable std::string m_message; // For on-demand formatting in 'what'
|
||||
std::string m_option_name; // The name of the option which
|
||||
// caused the exception.
|
||||
const char* what() const throw();
|
||||
};
|
||||
|
||||
class BOOST_PROGRAM_OPTIONS_DECL invalid_option_value
|
||||
: public validation_error
|
||||
{
|
||||
public:
|
||||
invalid_option_value(const std::string& value);
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
invalid_option_value(const std::wstring& value);
|
||||
#endif
|
||||
};
|
||||
|
||||
/** Class thrown when there are too many positional options. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL too_many_positional_options_error : public error {
|
||||
public:
|
||||
too_many_positional_options_error(const std::string& what)
|
||||
: error(what) {}
|
||||
};
|
||||
|
||||
/** Class thrown when there are too few positional options. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL too_few_positional_options_error : public error {
|
||||
public:
|
||||
too_few_positional_options_error(const std::string& what)
|
||||
: error(what) {}
|
||||
};
|
||||
|
||||
class BOOST_PROGRAM_OPTIONS_DECL invalid_command_line_syntax : public invalid_syntax {
|
||||
public:
|
||||
enum kind_t {
|
||||
long_not_allowed = 30,
|
||||
long_adjacent_not_allowed,
|
||||
short_adjacent_not_allowed,
|
||||
empty_adjacent_parameter,
|
||||
missing_parameter,
|
||||
extra_parameter
|
||||
};
|
||||
|
||||
invalid_command_line_syntax(const std::string& tokens, kind_t kind);
|
||||
kind_t kind() const;
|
||||
protected:
|
||||
static std::string error_message(kind_t kind);
|
||||
private:
|
||||
kind_t m_kind;
|
||||
};
|
||||
|
||||
class BOOST_PROGRAM_OPTIONS_DECL invalid_command_line_style : public error {
|
||||
public:
|
||||
invalid_command_line_style(const std::string& msg)
|
||||
: error(msg)
|
||||
{}
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
|
||||
#endif
|
||||
@@ -1,50 +0,0 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_OPTION_HPP_VP_2004_02_25
|
||||
#define BOOST_OPTION_HPP_VP_2004_02_25
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
/** Option found in input source.
|
||||
Contains a key and a value. The key, in turn, can be a string (name of
|
||||
an option), or an integer (position in input source) -- in case no name
|
||||
is specified. The latter is only possible for command line.
|
||||
The template parameter specifies the type of char used for storing the
|
||||
option's value.
|
||||
*/
|
||||
template<class charT>
|
||||
class basic_option {
|
||||
public:
|
||||
basic_option() : position_key(-1) {}
|
||||
basic_option(const std::string& string_key,
|
||||
const std::vector< std::string> &value)
|
||||
: string_key(string_key), value(value)
|
||||
{}
|
||||
|
||||
/** String key of this option. Intentionally independent of the template
|
||||
parameter. */
|
||||
std::string string_key;
|
||||
/** Position key of this option. All options without an explicit name are
|
||||
sequentially numbered starting from 0. If an option has explicit name,
|
||||
'position_key' is equal to -1. It is possible that both
|
||||
position_key and string_key is specified, in case name is implicitly
|
||||
added.
|
||||
*/
|
||||
int position_key;
|
||||
/** Option's value */
|
||||
std::vector< std::basic_string<charT> > value;
|
||||
};
|
||||
typedef basic_option<char> option;
|
||||
typedef basic_option<wchar_t> woption;
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -1,243 +0,0 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#ifndef BOOST_OPTION_DESCRIPTION_VP_2003_05_19
|
||||
#define BOOST_OPTION_DESCRIPTION_VP_2003_05_19
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/errors.hpp>
|
||||
#include <boost/program_options/value_semantic.hpp>
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/any.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <stdexcept>
|
||||
|
||||
#include <iosfwd>
|
||||
|
||||
/** Boost namespace */
|
||||
namespace boost {
|
||||
/** Namespace for the library. */
|
||||
namespace program_options {
|
||||
|
||||
/** Describes one possible command line/config file option. There are two
|
||||
kinds of properties of an option. First describe it syntactically and
|
||||
are used only to validate input. Second affect interpretation of the
|
||||
option, for example default value for it or function that should be
|
||||
called when the value is finally known. Routines which perform parsing
|
||||
never use second kind of properties -- they are side effect free.
|
||||
@sa options_description
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL option_description {
|
||||
public:
|
||||
|
||||
option_description();
|
||||
|
||||
/** Initializes the object with the passed data.
|
||||
|
||||
Note: it would be nice to make the second parameter auto_ptr,
|
||||
to explicitly pass ownership. Unfortunately, it's often needed to
|
||||
create objects of types derived from 'value_semantic':
|
||||
options_description d;
|
||||
d.add_options()("a", parameter<int>("n")->default_value(1));
|
||||
Here, the static type returned by 'parameter' should be derived
|
||||
from value_semantic.
|
||||
|
||||
Alas, derived->base conversion for auto_ptr does not really work,
|
||||
see
|
||||
http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2000/n1232.pdf
|
||||
http://std.dkuug.dk/jtc1/sc22/wg21/docs/cwg_defects.html#84
|
||||
|
||||
So, we have to use plain old pointers. Besides, users are not
|
||||
expected to use the constructor directly.
|
||||
|
||||
|
||||
The 'name' parameter is interpreted by the following rules:
|
||||
- if there's no "," character in 'name', it specifies long name
|
||||
- otherwise, the part before "," specifies long name and the part
|
||||
after -- long name.
|
||||
*/
|
||||
option_description(const char* name,
|
||||
const value_semantic* s);
|
||||
|
||||
/** Initializes the class with the passed data.
|
||||
*/
|
||||
option_description(const char* name,
|
||||
const value_semantic* s,
|
||||
const char* description);
|
||||
|
||||
virtual ~option_description();
|
||||
|
||||
/// Name to be used with short-style option ("-w").
|
||||
const std::string& short_name() const;
|
||||
|
||||
/// Name to be used with long-style option ("--whatever").
|
||||
const std::string& long_name() const;
|
||||
/// Explanation of this option
|
||||
const std::string& description() const;
|
||||
|
||||
/// Semantic of option's value
|
||||
shared_ptr<const value_semantic> semantic() const;
|
||||
|
||||
/// Returns the option name, formatted suitably for usage message.
|
||||
std::string format_name() const;
|
||||
|
||||
/** Return the parameter name and properties, formatted suitably for
|
||||
usage message. */
|
||||
std::string format_parameter() const;
|
||||
|
||||
private:
|
||||
|
||||
option_description& name(const char* name);
|
||||
|
||||
std::string m_short_name, m_long_name, m_description;
|
||||
std::string m_default_value, m_default_parameter;
|
||||
// shared_ptr is needed to simplify memory management in
|
||||
// copy ctor and destructor.
|
||||
shared_ptr<const value_semantic> m_value_semantic;
|
||||
};
|
||||
|
||||
class options_description;
|
||||
|
||||
/** Class which provides convenient creation syntax to option_description.
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL options_description_easy_init {
|
||||
public:
|
||||
options_description_easy_init(options_description* owner);
|
||||
|
||||
options_description_easy_init&
|
||||
operator()(const char* name,
|
||||
const char* description);
|
||||
|
||||
options_description_easy_init&
|
||||
operator()(const char* name,
|
||||
const value_semantic* s);
|
||||
|
||||
options_description_easy_init&
|
||||
operator()(const char* name,
|
||||
const value_semantic* s,
|
||||
const char* description);
|
||||
|
||||
private:
|
||||
options_description* owner;
|
||||
};
|
||||
|
||||
|
||||
/** A set of option descriptions. This provides convenient interface for
|
||||
adding new option (the add_options) method, and facilities to search
|
||||
for options by name.
|
||||
|
||||
See @ref a_adding_options "here" for option adding interface discussion.
|
||||
@sa option_description
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL options_description {
|
||||
public:
|
||||
|
||||
/** Creates the instance. */
|
||||
options_description();
|
||||
/** Creates the instance. The 'caption' parameter gives the name of
|
||||
this 'options_description' instance. Primarily useful for output.
|
||||
*/
|
||||
options_description(const std::string& caption);
|
||||
/** Adds new variable description. Throws duplicate_variable_error if
|
||||
either short or long name matches that of already present one.
|
||||
*/
|
||||
void add(shared_ptr<option_description> desc);
|
||||
/** Adds a group of option description. This has the same
|
||||
effect as adding all option_descriptions in 'desc'
|
||||
individually, except that output operator will show
|
||||
a separate group.
|
||||
Returns *this.
|
||||
*/
|
||||
options_description& add(const options_description& desc);
|
||||
|
||||
public:
|
||||
/** Returns an object of implementation-defined type suitable for adding
|
||||
options to options_description. The returned object will
|
||||
have overloaded operator() with parameter type matching
|
||||
'option_description' constructors. Calling the operator will create
|
||||
new option_description instance and add it.
|
||||
*/
|
||||
options_description_easy_init add_options();
|
||||
|
||||
/** Count the number of option descriptions with given name.
|
||||
Returns 0 or 1.
|
||||
The 'name' parameter can be either name of long option, and short
|
||||
option prefixed by '-'.
|
||||
*/
|
||||
unsigned count(const std::string& name) const;
|
||||
/** Count the number of descriptions having the given string as
|
||||
prefix. This makes sense only for long options.
|
||||
*/
|
||||
unsigned count_approx(const std::string& prefix) const;
|
||||
/** Returns description given a name.
|
||||
@pre count(name) == 1
|
||||
*/
|
||||
const option_description& find(const std::string& name) const;
|
||||
/** Returns description given a prefix. Throws
|
||||
@pre count_approx(name) == 1
|
||||
*/
|
||||
const option_description& find_approx(const std::string& prefix) const;
|
||||
/// Returns all such strings x for which count(x) == 1
|
||||
std::set<std::string> keys() const;
|
||||
/** For each option description stored, contains long name if not empty,
|
||||
if it is empty, short name is returned.
|
||||
*/
|
||||
std::set<std::string> primary_keys() const;
|
||||
/// Returns all such long options for which 'prefix' is prefix
|
||||
std::set<std::string> approximations(const std::string& prefix) const;
|
||||
|
||||
/** Produces a human readable output of 'desc', listing options,
|
||||
their descriptions and allowed parameters. Other options_description
|
||||
instances previously passed to add will be output separately. */
|
||||
friend BOOST_PROGRAM_OPTIONS_DECL std::ostream& operator<<(std::ostream& os,
|
||||
const options_description& desc);
|
||||
|
||||
/** Output 'desc' to the specified stream, calling 'f' to output each
|
||||
option_description element. */
|
||||
void print(std::ostream& os) const;
|
||||
|
||||
private:
|
||||
typedef std::map<std::string, int>::const_iterator name2index_iterator;
|
||||
typedef std::pair<name2index_iterator, name2index_iterator>
|
||||
approximation_range;
|
||||
|
||||
|
||||
approximation_range find_approximation(const std::string& prefix) const;
|
||||
|
||||
std::string m_caption;
|
||||
// Data organization is chosen because:
|
||||
// - there could be two names for one option
|
||||
// - option_add_proxy needs to know the last added option
|
||||
std::vector< shared_ptr<option_description> > options;
|
||||
std::map<std::string, int> name2index;
|
||||
// Whether the option comes from one of declared groups.
|
||||
#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(313))
|
||||
// vector<bool> is buggy there, see
|
||||
// http://support.microsoft.com/default.aspx?scid=kb;en-us;837698
|
||||
std::vector<char> belong_to_group;
|
||||
#else
|
||||
std::vector<bool> belong_to_group;
|
||||
#endif
|
||||
|
||||
std::vector< shared_ptr<options_description> > groups;
|
||||
|
||||
};
|
||||
|
||||
/** Class thrown when duplicate option description is found. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL duplicate_option_error : public error {
|
||||
public:
|
||||
duplicate_option_error(const std::string& what) : error(what) {}
|
||||
};
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -1,206 +0,0 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#ifndef BOOST_PARSERS_VP_2003_05_19
|
||||
#define BOOST_PARSERS_VP_2003_05_19
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/option.hpp>
|
||||
|
||||
#include <boost/function/function1.hpp>
|
||||
|
||||
#include <iosfwd>
|
||||
#include <vector>
|
||||
#include <utility>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
class options_description;
|
||||
class positional_options_description;
|
||||
|
||||
|
||||
/** Results of parsing an input source.
|
||||
The primary use of this class is passing information from parsers
|
||||
component to value storage component. This class does not makes
|
||||
much sense itself.
|
||||
*/
|
||||
template<class charT>
|
||||
class basic_parsed_options {
|
||||
public:
|
||||
explicit basic_parsed_options(const options_description* description)
|
||||
: description(description) {}
|
||||
/** Options found in the source. */
|
||||
std::vector< basic_option<charT> > options;
|
||||
/** Options description that was used for parsing.
|
||||
Parsers should return pointer to the instance of
|
||||
option_description passed to them, and issues of lifetime are
|
||||
up to the caller. Can be NULL.
|
||||
*/
|
||||
const options_description* description;
|
||||
};
|
||||
|
||||
/** Specialization of basic_parsed_options which:
|
||||
- provides convenient conversion from basic_parsed_options<char>
|
||||
- stores the passed char-based options for later use.
|
||||
*/
|
||||
template<>
|
||||
class BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options<wchar_t> {
|
||||
public:
|
||||
/** Constructs wrapped options from options in UTF8 encoding. */
|
||||
explicit basic_parsed_options(const basic_parsed_options<char>& po);
|
||||
|
||||
std::vector< basic_option<wchar_t> > options;
|
||||
const options_description* description;
|
||||
|
||||
/** Stores UTF8 encoded options that were passed to constructor,
|
||||
to avoid reverse conversion in some cases. */
|
||||
basic_parsed_options<char> utf8_encoded_options;
|
||||
};
|
||||
|
||||
typedef basic_parsed_options<char> parsed_options;
|
||||
typedef basic_parsed_options<wchar_t> wparsed_options;
|
||||
|
||||
/** Augments basic_parsed_options<wchar_t> with conversion from
|
||||
'parsed_options' */
|
||||
|
||||
|
||||
typedef function1<std::pair<std::string, std::string>, const std::string&> ext_parser;
|
||||
|
||||
/** Character-type independent command line parser. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL common_command_line_parser {
|
||||
public:
|
||||
/// Creates the parsers. The arguments must be in internal encoding.
|
||||
common_command_line_parser(const std::vector<std::string>& args);
|
||||
/// Parses the command line and returns parsed options in internal
|
||||
/// encoding.
|
||||
parsed_options run() const;
|
||||
protected:
|
||||
int m_style;
|
||||
const options_description* m_desc;
|
||||
const positional_options_description* m_positional;
|
||||
function1<std::pair<std::string, std::string>, const std::string&> m_ext;
|
||||
|
||||
// Intentionally independent from charT
|
||||
std::vector<std::string> m_args;
|
||||
};
|
||||
|
||||
/** Command line parser.
|
||||
|
||||
The class allows one to specify all the information needed for parsing
|
||||
and to parser the parse the command line. It is primarily needed to
|
||||
emulate named function parameters -- a regular function with 5
|
||||
parameters will be hard to use and creating overloads with a smaller
|
||||
nuber of parameters will be confusing.
|
||||
|
||||
For the most common case, the function parse_command_line is a better
|
||||
alternative.
|
||||
*/
|
||||
template<class charT>
|
||||
class basic_command_line_parser : private common_command_line_parser {
|
||||
public:
|
||||
/** Creates a command line parser for the specified arguments
|
||||
list. The 'args' parameter should not include program name.
|
||||
*/
|
||||
basic_command_line_parser(const std::vector<
|
||||
std::basic_string<charT> >& args);
|
||||
/** Creates a command line parser for the specified arguments
|
||||
list. The parameter should be the same as passes to 'main'.
|
||||
*/
|
||||
basic_command_line_parser(int argc, charT* argv[]);
|
||||
|
||||
/** Sets options descriptions to use. */
|
||||
basic_command_line_parser& options(const options_description& desc);
|
||||
/** Sets positional options description to use. */
|
||||
basic_command_line_parser& positional(
|
||||
const positional_options_description& desc);
|
||||
|
||||
/** Sets the command line style. */
|
||||
basic_command_line_parser& style(int);
|
||||
/** Sets the extra parsers. */
|
||||
basic_command_line_parser& extra_parser(ext_parser);
|
||||
|
||||
basic_parsed_options<charT> run() const;
|
||||
private:
|
||||
};
|
||||
|
||||
typedef basic_command_line_parser<char> command_line_parser;
|
||||
typedef basic_command_line_parser<wchar_t> wcommand_line_parser;
|
||||
|
||||
/** Creates instance of 'command_line_parser', passes parameters to it,
|
||||
and returns the result of calling the 'run' method.
|
||||
*/
|
||||
template<class charT>
|
||||
basic_parsed_options<charT>
|
||||
parse_command_line(int argc, charT* argv[],
|
||||
const options_description&,
|
||||
int style = 0,
|
||||
function1<std::pair<std::string, std::string>,
|
||||
const std::string&> ext
|
||||
= ext_parser());
|
||||
|
||||
/** Parse a config file.
|
||||
*/
|
||||
template<class charT>
|
||||
#if ! BOOST_WORKAROUND(__ICL, BOOST_TESTED_AT(700))
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
#endif
|
||||
basic_parsed_options<charT>
|
||||
parse_config_file(std::basic_istream<charT>&, const options_description&);
|
||||
|
||||
/** Parse environment.
|
||||
|
||||
For each environment variable, the 'name_mapper' function is called to
|
||||
obtain the option name. If it returns empty string, the variable is
|
||||
ignored.
|
||||
|
||||
This is done since naming of environment variables is typically
|
||||
different from the naming of command line options.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL parsed_options
|
||||
parse_environment(const options_description&,
|
||||
const function1<std::string, std::string>& name_mapper);
|
||||
|
||||
/** Parse environment.
|
||||
|
||||
Takes all environment variables which start with 'prefix'. The option
|
||||
name is obtained from variable name by removing the prefix and
|
||||
converting the remaining string into lower case.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL parsed_options
|
||||
parse_environment(const options_description&, const std::string& prefix);
|
||||
|
||||
/** @overload
|
||||
This function exists to resolve ambiguity between the two above
|
||||
functions when second argument is of 'char*' type. There's implicit
|
||||
conversion to both function1 and string.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL parsed_options
|
||||
parse_environment(const options_description&, const char* prefix);
|
||||
|
||||
#ifdef _WIN32
|
||||
/** Parses the char* string which is passed to WinMain function on
|
||||
windows. This function is provided for convenience, and because it's
|
||||
not clear how to portably access split command line string from
|
||||
runtime library and if it always exists.
|
||||
This function is available only on Windows.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::vector<std::string>
|
||||
split_winmain(const std::string& cmdline);
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
/** @overload */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::vector<std::wstring>
|
||||
split_winmain(const std::wstring& cmdline);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
}}
|
||||
|
||||
#undef DECL
|
||||
|
||||
#include "detail/parsers.hpp"
|
||||
|
||||
#endif
|
||||
@@ -1,64 +0,0 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_PROGRAM_OPTIONS_POSITIONAL_OPTIONS_VP_2004_03_02
|
||||
#define BOOST_PROGRAM_OPTIONS_POSITIONAL_OPTIONS_VP_2004_03_02
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
/** Describes positional options.
|
||||
|
||||
The class allows to guess option names for positional options, which
|
||||
are specified on the command line and are identified by the position.
|
||||
The class uses the information provided by the user to associate a name
|
||||
with every positional option, or tell that no name is known.
|
||||
|
||||
The primary assumption is that only the relative order of the
|
||||
positional options themselves matters, and that any interleaving
|
||||
ordinary options don't affect interpretation of positional options.
|
||||
|
||||
The user initializes the class by specifying that first N positional
|
||||
options should be given the name X1, following M options should be given
|
||||
the name X2 and so on.
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL positional_options_description {
|
||||
public:
|
||||
positional_options_description();
|
||||
|
||||
/** Species that up to 'max_count' next positional options
|
||||
should be given the 'name'. The value of '-1' means 'unlimited'.
|
||||
No calls to 'add' can be made after call with 'max_value' equal to
|
||||
'-1'.
|
||||
*/
|
||||
void add(const char* name, int max_count);
|
||||
|
||||
/** Returns the maximum number of positional options that can
|
||||
be present. Can return numeric_limits<unsigned>::max() to
|
||||
indicate unlimited number. */
|
||||
unsigned max_total_count() const;
|
||||
|
||||
/** Returns the name that should be associated with positional
|
||||
options at 'position'.
|
||||
Precondition: position < max_total_count()
|
||||
*/
|
||||
const std::string& name_for_position(unsigned position) const;
|
||||
|
||||
private:
|
||||
// List of names corresponding to the positions. If the number of
|
||||
// positions is unlimited, then the last name is stored in
|
||||
// m_trailing;
|
||||
std::vector<std::string> m_names;
|
||||
std::string m_trailing;
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,310 +0,0 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_VALUE_SEMANTIC_HPP_VP_2004_02_24
|
||||
#define BOOST_VALUE_SEMANTIC_HPP_VP_2004_02_24
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/errors.hpp>
|
||||
|
||||
#include <boost/any.hpp>
|
||||
#include <boost/function/function1.hpp>
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
/** Class which specifies how the option's value is to be parsed
|
||||
and converted into C++ types.
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL value_semantic {
|
||||
public:
|
||||
/** Returns the name of the option. The name is only meaningful
|
||||
for automatic help message.
|
||||
*/
|
||||
virtual std::string name() const = 0;
|
||||
|
||||
/** Returns true if value cannot be specified in source at all.
|
||||
Other methods can still set the value somehow, but
|
||||
user can't affect it.
|
||||
*/
|
||||
virtual bool is_zero_tokens() const = 0;
|
||||
|
||||
/** Returns true if values from different sources should be composed.
|
||||
Otherwise, value from the first source is used and values from
|
||||
other sources are discarded.
|
||||
*/
|
||||
virtual bool is_composing() const = 0;
|
||||
|
||||
/** Returns true if explicit value of an option can be omitted.
|
||||
*/
|
||||
virtual bool is_implicit() const = 0;
|
||||
|
||||
/** Returns true if value can span several token in input source. */
|
||||
virtual bool is_multitoken() const = 0;
|
||||
|
||||
/** Parses a group of tokens that specify a value of option.
|
||||
Stores the result in 'value_store', using whatever representation
|
||||
is desired. May be be called several times if value of the same
|
||||
option is specified more than once.
|
||||
*/
|
||||
virtual void parse(boost::any& value_store,
|
||||
const std::vector<std::string>& new_tokens,
|
||||
bool utf8) const
|
||||
= 0;
|
||||
|
||||
/** Called to assign default value to 'value_store'. Returns
|
||||
true if default value is assigned, and false if no default
|
||||
value exists. */
|
||||
virtual bool apply_default(boost::any& value_store) const = 0;
|
||||
|
||||
/** Called when final value of an option is determined.
|
||||
*/
|
||||
virtual void notify(const boost::any& value_store) const = 0;
|
||||
|
||||
virtual ~value_semantic() {}
|
||||
};
|
||||
|
||||
/** Helper class which perform necessary character conversions in the
|
||||
'parse' method and forwards the data further.
|
||||
*/
|
||||
template<class charT>
|
||||
class value_semantic_codecvt_helper {
|
||||
// Nothing here. Specializations to follow.
|
||||
};
|
||||
|
||||
template<>
|
||||
class BOOST_PROGRAM_OPTIONS_DECL
|
||||
value_semantic_codecvt_helper<char> : public value_semantic {
|
||||
private: // base overrides
|
||||
void parse(boost::any& value_store,
|
||||
const std::vector<std::string>& new_tokens,
|
||||
bool utf8) const;
|
||||
protected: // interface for derived classes.
|
||||
virtual void xparse(boost::any& value_store,
|
||||
const std::vector<std::string>& new_tokens)
|
||||
const = 0;
|
||||
};
|
||||
|
||||
template<>
|
||||
class BOOST_PROGRAM_OPTIONS_DECL
|
||||
value_semantic_codecvt_helper<wchar_t> : public value_semantic {
|
||||
private: // base overrides
|
||||
void parse(boost::any& value_store,
|
||||
const std::vector<std::string>& new_tokens,
|
||||
bool utf8) const;
|
||||
protected: // interface for derived classes.
|
||||
#if !defined(BOOST_NO_STD_WSTRING)
|
||||
virtual void xparse(boost::any& value_store,
|
||||
const std::vector<std::wstring>& new_tokens)
|
||||
const = 0;
|
||||
#endif
|
||||
};
|
||||
/** Class which specifies a simple handling of a value: the value will
|
||||
have string type and only one token is allowed. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL
|
||||
untyped_value : public value_semantic_codecvt_helper<char> {
|
||||
public:
|
||||
untyped_value(bool zero_tokens = false)
|
||||
: m_zero_tokens(zero_tokens)
|
||||
{}
|
||||
|
||||
std::string name() const;
|
||||
|
||||
bool is_zero_tokens() const { return m_zero_tokens; }
|
||||
bool is_composing() const { return false; }
|
||||
bool is_implicit() const { return false; }
|
||||
bool is_multitoken() const { return false; }
|
||||
|
||||
/** If 'value_store' is already initialized, or new_tokens
|
||||
has more than one elements, throws. Otherwise, assigns
|
||||
the first string from 'new_tokens' to 'value_store', without
|
||||
any modifications.
|
||||
*/
|
||||
void xparse(boost::any& value_store,
|
||||
const std::vector<std::string>& new_tokens) const;
|
||||
|
||||
/** Does nothing. */
|
||||
bool apply_default(boost::any&) const { return false; }
|
||||
|
||||
/** Does nothing. */
|
||||
void notify(const boost::any&) const {}
|
||||
private:
|
||||
bool m_zero_tokens;
|
||||
};
|
||||
|
||||
/** Class which handles value of a specific type. */
|
||||
template<class T, class charT = char>
|
||||
class typed_value : public value_semantic_codecvt_helper<charT> {
|
||||
public:
|
||||
/** Ctor. The 'store_to' parameter tells where to store
|
||||
the value when it's known. The parameter can be NULL. */
|
||||
typed_value(T* store_to)
|
||||
: m_store_to(store_to), m_composing(false),
|
||||
m_implicit(false), m_multitoken(false), m_zero_tokens(false)
|
||||
{}
|
||||
|
||||
/** Specifies default value, which will be used
|
||||
if none is explicitly specified. The type 'T' should
|
||||
provide operator<< for ostream.
|
||||
*/
|
||||
typed_value* default_value(const T& v)
|
||||
{
|
||||
m_default_value = boost::any(v);
|
||||
m_default_value_as_text = boost::lexical_cast<std::string>(v);
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies default value, which will be used
|
||||
if none is explicitly specified. Unlike the above overload,
|
||||
the type 'T' need not provide operator<< for ostream,
|
||||
but textual representation of default value must be provided
|
||||
by the user.
|
||||
*/
|
||||
typed_value* default_value(const T& v, const std::string& textual)
|
||||
{
|
||||
m_default_value = boost::any(v);
|
||||
m_default_value_as_text = textual;
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies a function to be called when the final value
|
||||
is determined. */
|
||||
typed_value* notifier(function1<void, const T&> f)
|
||||
{
|
||||
m_notifier = f;
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies that the value is composing. See the 'is_composing'
|
||||
method for explanation.
|
||||
*/
|
||||
typed_value* composing()
|
||||
{
|
||||
m_composing = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies that the value is implicit. */
|
||||
typed_value* implicit()
|
||||
{
|
||||
m_implicit = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies that the value can span multiple tokens. */
|
||||
typed_value* multitoken()
|
||||
{
|
||||
m_multitoken = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
typed_value* zero_tokens()
|
||||
{
|
||||
m_zero_tokens = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
public: // value semantic overrides
|
||||
|
||||
std::string name() const;
|
||||
|
||||
bool is_zero_tokens() const { return m_zero_tokens; }
|
||||
bool is_composing() const { return m_composing; }
|
||||
bool is_implicit() const { return m_implicit; }
|
||||
bool is_multitoken() const { return m_multitoken; }
|
||||
|
||||
|
||||
/** Creates an instance of the 'validator' class and calls
|
||||
its operator() to perform athe ctual conversion. */
|
||||
void xparse(boost::any& value_store,
|
||||
const std::vector< std::basic_string<charT> >& new_tokens)
|
||||
const;
|
||||
|
||||
/** If default value was specified via previous call to
|
||||
'default_value', stores that value into 'value_store'.
|
||||
Returns true if default value was stored.
|
||||
*/
|
||||
virtual bool apply_default(boost::any& value_store) const
|
||||
{
|
||||
if (m_default_value.empty()) {
|
||||
return false;
|
||||
} else {
|
||||
value_store = m_default_value;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
/** If an address of variable to store value was specified
|
||||
when creating *this, stores the value there. Otherwise,
|
||||
does nothing. */
|
||||
void notify(const boost::any& value_store) const;
|
||||
|
||||
|
||||
private:
|
||||
T* m_store_to;
|
||||
|
||||
// Default value is stored as boost::any and not
|
||||
// as boost::optional to avoid unnecessary instantiations.
|
||||
boost::any m_default_value;
|
||||
std::string m_default_value_as_text;
|
||||
bool m_composing, m_implicit, m_multitoken, m_zero_tokens;
|
||||
boost::function1<void, const T&> m_notifier;
|
||||
};
|
||||
|
||||
|
||||
/** Creates a typed_value<T> instance. This function is the primary
|
||||
method to create value_semantic instance for a specific type, which
|
||||
can later be passed to 'option_description' constructor.
|
||||
The second overload is used when it's additionally desired to store the
|
||||
value of option into program variable.
|
||||
*/
|
||||
template<class T>
|
||||
typed_value<T>*
|
||||
value();
|
||||
|
||||
/** @overload
|
||||
*/
|
||||
template<class T>
|
||||
typed_value<T>*
|
||||
value(T* v);
|
||||
|
||||
/** Creates a typed_value<T> instance. This function is the primary
|
||||
method to create value_semantic instance for a specific type, which
|
||||
can later be passed to 'option_description' constructor.
|
||||
*/
|
||||
template<class T>
|
||||
typed_value<T, wchar_t>*
|
||||
wvalue();
|
||||
|
||||
/** @overload
|
||||
*/
|
||||
template<class T>
|
||||
typed_value<T, wchar_t>*
|
||||
wvalue(T* v);
|
||||
|
||||
/** Works the same way as the 'value<bool>' function, but the created
|
||||
value_semantic won't accept any explicit value. So, if the option
|
||||
is present on the command line, the value will be 'true'.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL typed_value<bool>*
|
||||
bool_switch();
|
||||
|
||||
/** @overload
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL typed_value<bool>*
|
||||
bool_switch(bool* v);
|
||||
|
||||
}}
|
||||
|
||||
#include "detail/value_semantic.hpp"
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,194 +0,0 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#ifndef BOOST_VARIABLES_MAP_VP_2003_05_19
|
||||
#define BOOST_VARIABLES_MAP_VP_2003_05_19
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#include <boost/any.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <map>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
template<class charT>
|
||||
class basic_parsed_options;
|
||||
|
||||
class value_semantic;
|
||||
class variables_map;
|
||||
|
||||
/** Class holding value of option. Contains details about how the
|
||||
value is set and allows to conveniently obtain the value.
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL variable_value {
|
||||
public:
|
||||
variable_value() : m_defaulted(false) {}
|
||||
variable_value(const boost::any& v, bool defaulted)
|
||||
: v(v), m_defaulted(defaulted)
|
||||
{}
|
||||
|
||||
/** If stored value if of type T, returns that value. Otherwise,
|
||||
throws boost::bad_any_cast exception. */
|
||||
template<class T> const T& as() const;
|
||||
|
||||
/** @overload */
|
||||
template<class T> T& as();
|
||||
|
||||
/// Returns true if no value is stored.
|
||||
bool empty() const;
|
||||
/** Returns true if the value was not explicitly
|
||||
given, but has default value. */
|
||||
bool defaulted() const;
|
||||
/** Returns the contained value. */
|
||||
const boost::any& value() const;
|
||||
|
||||
/** Returns the contained value. */
|
||||
boost::any& value();
|
||||
private:
|
||||
boost::any v;
|
||||
bool m_defaulted;
|
||||
// Internal reference to value semantic. We need to run
|
||||
// notifications when *final* values of options are known, and
|
||||
// they are known only after all sources are stored. By that
|
||||
// time options_description for the first source might not
|
||||
// be easily accessible, so we need to store semantic here.
|
||||
shared_ptr<const value_semantic> m_value_semantic;
|
||||
|
||||
friend void BOOST_PROGRAM_OPTIONS_DECL
|
||||
store(const basic_parsed_options<char>& options,
|
||||
variables_map& m, bool);
|
||||
friend void BOOST_PROGRAM_OPTIONS_DECL notify(variables_map& m);
|
||||
};
|
||||
|
||||
/** Implements string->string mapping with convenient value casting
|
||||
facilities. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL abstract_variables_map {
|
||||
public:
|
||||
abstract_variables_map();
|
||||
abstract_variables_map(const abstract_variables_map* next);
|
||||
|
||||
virtual ~abstract_variables_map() {}
|
||||
|
||||
/** Obtains the value of variable 'name', from *this and
|
||||
possibly from the chain of variable maps.
|
||||
|
||||
- if there's no value in *this.
|
||||
- if there's next variable map, returns value from it
|
||||
- otherwise, returns empty value
|
||||
|
||||
- if there's defaulted value
|
||||
- if there's next varaible map, which has a non-defauled
|
||||
value, return that
|
||||
- otherwise, return value from *this
|
||||
|
||||
- if there's a non-defauled value, returns it.
|
||||
*/
|
||||
const variable_value& operator[](const std::string& name) const;
|
||||
|
||||
/** Sets next variable map, which will be used to find
|
||||
variables not found in *this. */
|
||||
void next(abstract_variables_map* next);
|
||||
|
||||
private:
|
||||
/** Returns value of variable 'name' stored in *this, or
|
||||
empty value otherwise. */
|
||||
virtual const variable_value& get(const std::string& name) const = 0;
|
||||
|
||||
const abstract_variables_map* m_next;
|
||||
};
|
||||
|
||||
/** Concrete variables map which store variables in real map. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL variables_map : public abstract_variables_map,
|
||||
public std::map<std::string, variable_value>
|
||||
{
|
||||
public:
|
||||
variables_map();
|
||||
variables_map(const abstract_variables_map* next);
|
||||
|
||||
// Resolve conflict between inherited operators.
|
||||
const variable_value& operator[](const std::string& name) const
|
||||
{ return abstract_variables_map::operator[](name); }
|
||||
|
||||
private:
|
||||
/** Implementation of abstract_variables_map::get
|
||||
which does 'find' in *this. */
|
||||
const variable_value& get(const std::string& name) const;
|
||||
};
|
||||
|
||||
/** Stores in 'm' all options that are defined in 'options'.
|
||||
If 'm' already has a non-defaulted value of an option, that value
|
||||
is not changed, even if 'options' specify some value.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL void store(const basic_parsed_options<char>& options, variables_map& m,
|
||||
bool utf8 = false);
|
||||
|
||||
/** Stores in 'm' all options that are defined in 'options'.
|
||||
If 'm' already has a non-defaulted value of an option, that value
|
||||
is not changed, even if 'options' specify some value.
|
||||
This is wide character variant.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL void store(const basic_parsed_options<wchar_t>& options,
|
||||
variables_map& m);
|
||||
|
||||
|
||||
/** Runs all 'notify' function for options in 'm'. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL void notify(variables_map& m);
|
||||
|
||||
|
||||
/*
|
||||
* Templates/inlines
|
||||
*/
|
||||
|
||||
inline bool
|
||||
variable_value::empty() const
|
||||
{
|
||||
return v.empty();
|
||||
}
|
||||
|
||||
inline bool
|
||||
variable_value::defaulted() const
|
||||
{
|
||||
return m_defaulted;
|
||||
}
|
||||
|
||||
inline
|
||||
const boost::any&
|
||||
variable_value::value() const
|
||||
{
|
||||
return v;
|
||||
}
|
||||
|
||||
inline
|
||||
boost::any&
|
||||
variable_value::value()
|
||||
{
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
template<class T>
|
||||
const T&
|
||||
variable_value::as() const {
|
||||
const T* r = boost::any_cast<T>(&v);
|
||||
if (!r)
|
||||
throw boost::bad_any_cast();
|
||||
return *r;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
T&
|
||||
variable_value::as() {
|
||||
T* r = boost::any_cast<T>(&v);
|
||||
if (!r)
|
||||
throw boost::bad_any_cast();
|
||||
return *r;
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -1,19 +0,0 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_PROGRAM_OPTIONS_VERSION_HPP_VP_2004_04_05
|
||||
#define BOOST_PROGRAM_OPTIONS_VERSION_HPP_VP_2004_04_05
|
||||
|
||||
/** The version of the source interface.
|
||||
The value will be incremented whenever a change is made which might
|
||||
cause compilation errors for existing code.
|
||||
*/
|
||||
#ifdef BOOST_PROGRAM_OPTIONS_VERSION
|
||||
#error BOOST_PROGRAM_OPTIONS_VERSION already defined
|
||||
#endif
|
||||
#define BOOST_PROGRAM_OPTIONS_VERSION 2
|
||||
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user