Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost')
19 files changed, 2640 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/program_options.hpp b/3rdParty/Boost/src/boost/program_options.hpp new file mode 100644 index 0000000..9d12b08 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options.hpp @@ -0,0 +1,25 @@ +// 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) + +// See www.boost.org/libs/program_options for documentation. + +#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 diff --git a/3rdParty/Boost/src/boost/program_options/cmdline.hpp b/3rdParty/Boost/src/boost/program_options/cmdline.hpp new file mode 100644 index 0000000..8705e60 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/cmdline.hpp @@ -0,0 +1,90 @@ +// 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 options is also configurable. + + Option's value can be specified in the same token as name + ("--foo=bar"), or in the next token. + + It's possible to introduce long options by the same character as + short options, 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, + /// Allow "-<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 next 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 if guessing is in effect. + */ + allow_guessing = allow_sticky << 1, + /** Ignore the difference in case for long options. + */ + long_case_insensitive = allow_guessing << 1, + /** Ignore the difference in case for short options. + */ + short_case_insensitive = long_case_insensitive << 1, + /** Ignore the difference in case for all options. + */ + case_insensitive = (long_case_insensitive | short_case_insensitive), + /** Allow long options with single option starting character, + e.g <tt>-foo=10</tt> + */ + allow_long_disguise = short_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 + diff --git a/3rdParty/Boost/src/boost/program_options/config.hpp b/3rdParty/Boost/src/boost/program_options/config.hpp new file mode 100644 index 0000000..0c69c14 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/config.hpp @@ -0,0 +1,55 @@ +// 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 + diff --git a/3rdParty/Boost/src/boost/program_options/detail/cmdline.hpp b/3rdParty/Boost/src/boost/program_options/detail/cmdline.hpp new file mode 100644 index 0000000..8d60ead --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/detail/cmdline.hpp @@ -0,0 +1,138 @@ +// 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/program_options/option.hpp> +#include <boost/program_options/options_description.hpp> +#include <boost/program_options/positional_options.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; + + typedef function1<std::vector<option>, std::vector<std::string>&> + style_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); + + /** @overload */ + cmdline(int argc, const char*const * argv); + + void style(int style); + void allow_unregistered(); + + void set_options_description(const options_description& desc); + void set_positional_options( + const positional_options_description& m_positional); + + std::vector<option> run(); + + std::vector<option> parse_long_option(std::vector<std::string>& args); + std::vector<option> parse_short_option(std::vector<std::string>& args); + std::vector<option> parse_dos_option(std::vector<std::string>& args); + std::vector<option> parse_disguised_long_option( + std::vector<std::string>& args); + std::vector<option> parse_terminator( + std::vector<std::string>& args); + std::vector<option> handle_additional_parser( + std::vector<std::string>& args); + + + /** 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); + + void extra_style_parser(style_parser s); + + void check_style(int style) const; + + bool is_style_active(style_t style) const; + + void init(const std::vector<std::string>& args); + + void + finish_option(option& opt, + std::vector<std::string>& other_tokens, + const std::vector<style_parser>& style_parsers); + + // Copies of input. + std::vector<std::string> args; + style_t m_style; + bool m_allow_unregistered; + + const options_description* m_desc; + const positional_options_description* m_positional; + + additional_parser m_additional_parser; + style_parser m_style_parser; + }; + + void test_cmdline_detail(); + +}}} + +#endif + diff --git a/3rdParty/Boost/src/boost/program_options/detail/config_file.hpp b/3rdParty/Boost/src/boost/program_options/detail/config_file.hpp new file mode 100644 index 0000000..91caac7 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/detail/config_file.hpp @@ -0,0 +1,182 @@ +// 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 + +#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) +#include <istream> // std::getline +#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, + bool allow_unregistered = false); + + 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; + bool m_allow_unregistered; + }; + + 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, + bool allow_unregistered = false); + + 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, + bool allow_unregistered) + : common_config_file_iterator(allowed_options, allow_unregistered) + { + 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)) || \ + (defined(__sgi) && BOOST_WORKAROUND(_COMPILER_VERSION, BOOST_TESTED_AT(741))) + template<> + bool + basic_config_file_iterator<wchar_t>::getline(std::string& s); +#endif + + + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/program_options/detail/convert.hpp b/3rdParty/Boost/src/boost/program_options/detail/convert.hpp new file mode 100644 index 0000000..a22dd6f --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/detail/convert.hpp @@ -0,0 +1,107 @@ +// 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 defined(BOOST_NO_STDC_NAMESPACE) +#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 diff --git a/3rdParty/Boost/src/boost/program_options/detail/parsers.hpp b/3rdParty/Boost/src/boost/program_options/detail/parsers.hpp new file mode 100644 index 0000000..ee19207 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/detail/parsers.hpp @@ -0,0 +1,146 @@ +// 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> + +#include <iterator> + +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) + : detail::cmdline(to_internal(args)) + {} + + + template<class charT> + basic_command_line_parser<charT>:: + basic_command_line_parser(int argc, charT* argv[]) + : detail::cmdline( + // 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+!argc))) + {} + + + template<class charT> + basic_command_line_parser<charT>& + basic_command_line_parser<charT>::options(const options_description& desc) + { + detail::cmdline::set_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) + { + detail::cmdline::set_positional_options(desc); + return *this; + } + + template<class charT> + basic_command_line_parser<charT>& + basic_command_line_parser<charT>::style(int style) + { + detail::cmdline::style(style); + return *this; + } + + template<class charT> + basic_command_line_parser<charT>& + basic_command_line_parser<charT>::extra_parser(ext_parser ext) + { + detail::cmdline::set_additional_parser(ext); + return *this; + } + + template<class charT> + basic_command_line_parser<charT>& + basic_command_line_parser<charT>::allow_unregistered() + { + detail::cmdline::allow_unregistered(); + return *this; + } + + template<class charT> + basic_command_line_parser<charT>& + basic_command_line_parser<charT>::extra_style_parser(style_parser s) + { + detail::cmdline::extra_style_parser(s); + return *this; + } + + + + template<class charT> + basic_parsed_options<charT> + basic_command_line_parser<charT>::run() + { + parsed_options result(m_desc); + result.options = detail::cmdline::run(); + + // Presense of parsed_options -> wparsed_options conversion + // does the trick. + return basic_parsed_options<charT>(result); + } + + + 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(); + } + + template<class charT> + std::vector< std::basic_string<charT> > + collect_unrecognized(const std::vector< basic_option<charT> >& options, + enum collect_unrecognized_mode mode) + { + std::vector< std::basic_string<charT> > result; + for(unsigned i = 0; i < options.size(); ++i) + { + if (options[i].unregistered || + (mode == include_positional && options[i].position_key != -1)) + { + copy(options[i].original_tokens.begin(), + options[i].original_tokens.end(), + back_inserter(result)); + } + } + return result; + } + + +}} + +#endif diff --git a/3rdParty/Boost/src/boost/program_options/detail/utf8_codecvt_facet.hpp b/3rdParty/Boost/src/boost/program_options/detail/utf8_codecvt_facet.hpp new file mode 100644 index 0000000..b77b551 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/detail/utf8_codecvt_facet.hpp @@ -0,0 +1,25 @@ +// Copyright (c) 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. + +#ifndef BOOST_PROGRAM_OPTIONS_UTF8_CODECVT_FACET_HPP +#define BOOST_PROGRAM_OPTIONS_UTF8_CODECVT_FACET_HPP + +#include <boost/program_options/config.hpp> + +#define BOOST_UTF8_BEGIN_NAMESPACE \ + namespace boost { namespace program_options { namespace detail { + +#define BOOST_UTF8_END_NAMESPACE }}} +#define BOOST_UTF8_DECL BOOST_PROGRAM_OPTIONS_DECL + +#include <boost/detail/utf8_codecvt_facet.hpp> + +#undef BOOST_UTF8_BEGIN_NAMESPACE +#undef BOOST_UTF8_END_NAMESPACE +#undef BOOST_UTF8_DECL + +#endif diff --git a/3rdParty/Boost/src/boost/program_options/detail/value_semantic.hpp b/3rdParty/Boost/src/boost/program_options/detail/value_semantic.hpp new file mode 100644 index 0000000..464e306 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/detail/value_semantic.hpp @@ -0,0 +1,207 @@ +// 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. + +#include <boost/throw_exception.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_implicit_value.empty() && !m_implicit_value_as_text.empty()) { + std::string msg = "[=arg(=" + m_implicit_value_as_text + ")]"; + if (!m_default_value.empty() && !m_default_value_as_text.empty()) + msg += " (=" + m_default_value_as_text + ")"; + return msg; + } + else 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<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) + boost::throw_exception(validation_error(validation_error::multiple_values_not_allowed)); + else if (v.size() == 1) + return v.front(); + else if (!allow_empty) + boost::throw_exception(validation_error(validation_error::at_least_one_value_required)); + return empty; + } + + /* 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&) { + boost::throw_exception(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(NULL != tv); + for (unsigned i = 0; i < s.size(); ++i) + { + try { + /* We call validate so that if user provided + a validator for class T, we use it even + when parsing vector<T>. */ + boost::any a; + std::vector<std::basic_string<charT> > v; + v.push_back(s[i]); + validate(a, v, (T*)0, 0); + tv->push_back(boost::any_cast<T>(a)); + } + catch(const bad_lexical_cast& /*e*/) { + boost::throw_exception(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 + { + // If no tokens were given, and the option accepts an implicit + // value, then assign the implicit value as the stored value; + // otherwise, validate the user-provided token(s). + if (new_tokens.empty() && !m_implicit_value.empty()) + value_store = m_implicit_value; + else + 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; + } + + + +}} diff --git a/3rdParty/Boost/src/boost/program_options/environment_iterator.hpp b/3rdParty/Boost/src/boost/program_options/environment_iterator.hpp new file mode 100644 index 0000000..c815693 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/environment_iterator.hpp @@ -0,0 +1,51 @@ +// 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 diff --git a/3rdParty/Boost/src/boost/program_options/eof_iterator.hpp b/3rdParty/Boost/src/boost/program_options/eof_iterator.hpp new file mode 100644 index 0000000..0efa6f7 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/eof_iterator.hpp @@ -0,0 +1,97 @@ +// 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 + diff --git a/3rdParty/Boost/src/boost/program_options/errors.hpp b/3rdParty/Boost/src/boost/program_options/errors.hpp new file mode 100644 index 0000000..116af58 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/errors.hpp @@ -0,0 +1,236 @@ +// 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: + enum kind_t { + long_not_allowed = 30, + long_adjacent_not_allowed, + short_adjacent_not_allowed, + empty_adjacent_parameter, + missing_parameter, + extra_parameter, + unrecognized_line + }; + + invalid_syntax(const std::string& tokens, kind_t kind); + + // gcc says that throw specification on dtor is loosened + // without this line + ~invalid_syntax() throw() {} + + kind_t kind() const; + + const std::string& tokens() const; + + protected: + /** Used to convert kind_t to a related error text */ + static std::string error_message(kind_t kind); + + private: + // TODO: copy ctor might throw + std::string m_tokens; + + kind_t m_kind; + }; + + /** 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)), + m_option_name(name) + {} + + // gcc says that throw specification on dtor is loosened + // without this line + ~unknown_option() throw() {} + + const std::string& get_option_name() const throw(); + + private: + std::string m_option_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)) + , m_alternatives(alternatives) + , m_option_name(name) + {} + + ~ambiguous_option() throw() {} + + const std::string& get_option_name() const throw(); + + const std::vector<std::string>& alternatives() const throw(); + + private: + // TODO: copy ctor might throw + std::vector<std::string> m_alternatives; + std::string m_option_name; + }; + + /** 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() + : error("multiple values") + , m_option_name() {} + + ~multiple_values() throw() {} + + void set_option_name(const std::string& option); + + const std::string& get_option_name() const throw(); + + private: + std::string m_option_name; // The name of the option which + // caused the exception. + }; + + /** 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() + : error("multiple occurrences") + , m_option_name() {} + + ~multiple_occurrences() throw() {} + + void set_option_name(const std::string& option); + + const std::string& get_option_name() const throw(); + + private: + std::string m_option_name; // The name of the option which + // caused the exception. + }; + + /** Class thrown when value of option is incorrect. */ + class BOOST_PROGRAM_OPTIONS_DECL validation_error : public error { + public: + enum kind_t { + multiple_values_not_allowed = 30, + at_least_one_value_required, + invalid_bool_value, + invalid_option_value, + invalid_option + }; + + validation_error(kind_t kind, + const std::string& option_value = "", + const std::string& option_name = ""); + + ~validation_error() throw() {} + + void set_option_name(const std::string& option); + + const std::string& get_option_name() const throw(); + + const char* what() const throw(); + + protected: + /** Used to convert kind_t to a related error text */ + static std::string error_message(kind_t kind); + + private: + kind_t m_kind; + std::string m_option_name; // The name of the option which + // caused the exception. + std::string m_option_value; // Optional: value of the option m_options_name + mutable std::string m_message; // For on-demand formatting in 'what' + + }; + + /** Class thrown if there is an invalid option value givenn */ + 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. + This is a programming error. + */ + class BOOST_PROGRAM_OPTIONS_DECL too_many_positional_options_error : public error { + public: + too_many_positional_options_error() + : error("too many positional options") + {} + }; + + /** Class thrown when there are syntax errors in given command line */ + class BOOST_PROGRAM_OPTIONS_DECL invalid_command_line_syntax : public invalid_syntax { + public: + invalid_command_line_syntax(const std::string& tokens, kind_t kind); + }; + + /** Class thrown when there are programming error related to style */ + class BOOST_PROGRAM_OPTIONS_DECL invalid_command_line_style : public error { + public: + invalid_command_line_style(const std::string& msg) + : error(msg) + {} + }; + + /** Class thrown if config file can not be read */ + class BOOST_PROGRAM_OPTIONS_DECL reading_file : public error { + public: + reading_file(const char* filename) + : error(std::string("can not read file ").append(filename)) + {} + }; + + /** Class thrown when a required/mandatory option is missing */ + class BOOST_PROGRAM_OPTIONS_DECL required_option : public error { + public: + required_option(const std::string& name) + : error(std::string("missing required option ").append(name)) + , m_option_name(name) + {} + + ~required_option() throw() {} + + const std::string& get_option_name() const throw(); + + private: + std::string m_option_name; // The name of the option which + // caused the exception. + }; +}} + + +#endif diff --git a/3rdParty/Boost/src/boost/program_options/option.hpp b/3rdParty/Boost/src/boost/program_options/option.hpp new file mode 100644 index 0000000..557c692 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/option.hpp @@ -0,0 +1,70 @@ +// 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) + , unregistered(false) + , case_insensitive(false) + {} + basic_option(const std::string& string_key, + const std::vector< std::string> &value) + : string_key(string_key) + , value(value) + , unregistered(false) + , case_insensitive(false) + {} + + /** 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; + /** The original unchanged tokens this option was + created from. */ + std::vector< std::basic_string<charT> > original_tokens; + /** True if option was not recognized. In that case, + 'string_key' and 'value' are results of purely + syntactic parsing of source. The original tokens can be + recovered from the "original_tokens" member. + */ + bool unregistered; + /** True if string_key has to be handled + case insensitive. + */ + bool case_insensitive; + }; + typedef basic_option<char> option; + typedef basic_option<wchar_t> woption; + +}} + +#endif diff --git a/3rdParty/Boost/src/boost/program_options/options_description.hpp b/3rdParty/Boost/src/boost/program_options/options_description.hpp new file mode 100644 index 0000000..0486f02 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/options_description.hpp @@ -0,0 +1,254 @@ +// Copyright Vladimir Prus 2002-2004. +// Copyright Bertolt Mildner 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(); + + enum match_result { no_match, full_match, approximate_match }; + + /** Given 'option', specified in the input source, + return 'true' is 'option' specifies *this. + */ + match_result match(const std::string& option, bool approx, + bool long_ignore_case, bool short_ignore_case) const; + + /** Return the key that should identify the option, in + particular in the variables_map class. + The 'option' parameter is the option spelling from the + input source. + If option name contains '*', returns 'option'. + If long name was specified, it's the long name, otherwise + it's a short name with prepended '-'. + */ + const std::string& key(const std::string& option) const; + + 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& set_name(const char* name); + + std::string m_short_name, m_long_name, m_description; + // 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: + static const unsigned m_default_line_length; + + /** Creates the instance. */ + options_description(unsigned line_length = m_default_line_length, + unsigned min_description_length = m_default_line_length / 2); + /** Creates the instance. The 'caption' parameter gives the name of + this 'options_description' instance. Primarily useful for output. + The 'description_length' specifies the number of columns that + should be reserved for the description text; if the option text + encroaches into this, then the description will start on the next + line. + */ + options_description(const std::string& caption, + unsigned line_length = m_default_line_length, + unsigned min_description_length = m_default_line_length / 2); + /** 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(); + + const option_description& find(const std::string& name, + bool approx, + bool long_ignore_case = false, + bool short_ignore_case = false) const; + + const option_description* find_nothrow(const std::string& name, + bool approx, + bool long_ignore_case = false, + bool short_ignore_case = false) const; + + + const std::vector< shared_ptr<option_description> >& options() 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; + const unsigned m_line_length; + const unsigned m_min_description_length; + + // 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> > m_options; + + // 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 diff --git a/3rdParty/Boost/src/boost/program_options/parsers.hpp b/3rdParty/Boost/src/boost/program_options/parsers.hpp new file mode 100644 index 0000000..e2a4467 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/parsers.hpp @@ -0,0 +1,262 @@ +// 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/program_options/detail/cmdline.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; + + /** Command line parser. + + The class allows one to specify all the information needed for parsing + and to 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. + + There are two typedefs -- command_line_parser and wcommand_line_parser, + for charT == char and charT == wchar_t cases. + */ + template<class charT> + class basic_command_line_parser : private detail::cmdline { + 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 parameters should be the same as passed 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); + + /** Parses the options and returns the result of parsing. + Throws on error. + */ + basic_parsed_options<charT> run(); + + /** Specifies that unregistered options are allowed and should + be passed though. For each command like token that looks + like an option but does not contain a recognized name, an + instance of basic_option<charT> will be added to result, + with 'unrecognized' field set to 'true'. It's possible to + collect all unrecognized options with the 'collect_unrecognized' + funciton. + */ + basic_command_line_parser& allow_unregistered(); + + using detail::cmdline::style_parser; + + basic_command_line_parser& extra_style_parser(style_parser s); + + private: + const options_description* m_desc; + }; + + 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. + + Read from given stream. + */ + 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&, + bool allow_unregistered = false); + + /** Parse a config file. + + Read from file with the given name. The character type is + passed to the file stream. + */ + template<class charT> +#if ! BOOST_WORKAROUND(__ICL, BOOST_TESTED_AT(700)) + BOOST_PROGRAM_OPTIONS_DECL +#endif + basic_parsed_options<charT> + parse_config_file(const char* filename, const options_description&, + bool allow_unregistered = false); + + /** Controls if the 'collect_unregistered' function should + include positional options, or not. */ + enum collect_unrecognized_mode + { include_positional, exclude_positional }; + + /** Collects the original tokens for all named options with + 'unregistered' flag set. If 'mode' is 'include_positional' + also collects all positional options. + Returns the vector of origianl tokens for all collected + options. + */ + template<class charT> + std::vector< std::basic_string<charT> > + collect_unrecognized(const std::vector< basic_option<charT> >& options, + enum collect_unrecognized_mode mode); + + /** 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); + + /** Splits a given string to a collection of single strings which + can be passed to command_line_parser. The second parameter is + used to specify a collection of possible seperator chars used + for splitting. The seperator is defaulted to space " ". + Splitting is done in a unix style way, with respect to quotes '"' + and escape characters '\' + */ + BOOST_PROGRAM_OPTIONS_DECL std::vector<std::string> + split_unix(const std::string& cmdline, const std::string& seperator = " \t", + const std::string& quote = "'\"", const std::string& escape = "\\"); + +#ifndef BOOST_NO_STD_WSTRING + /** @overload */ + BOOST_PROGRAM_OPTIONS_DECL std::vector<std::wstring> + split_unix(const std::wstring& cmdline, const std::wstring& seperator = L" \t", + const std::wstring& quote = L"'\"", const std::wstring& escape = L"\\"); +#endif + + #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 "boost/program_options/detail/parsers.hpp" + +#endif diff --git a/3rdParty/Boost/src/boost/program_options/positional_options.hpp b/3rdParty/Boost/src/boost/program_options/positional_options.hpp new file mode 100644 index 0000000..01406e0 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/positional_options.hpp @@ -0,0 +1,65 @@ +// 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'. + */ + positional_options_description& + 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 + diff --git a/3rdParty/Boost/src/boost/program_options/value_semantic.hpp b/3rdParty/Boost/src/boost/program_options/value_semantic.hpp new file mode 100644 index 0000000..033009e --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/value_semantic.hpp @@ -0,0 +1,405 @@ +// 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> +#include <typeinfo> + +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; + + /** The minimum number of tokens for this option that + should be present on the command line. */ + virtual unsigned min_tokens() const = 0; + + /** The maximum number of tokens for this option that + should be present on the command line. */ + virtual unsigned max_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 value must be given. Non-optional value + + */ + virtual bool is_required() 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. + }; + + /** Helper conversion class for values that accept ascii + strings as input. + Overrides the 'parse' method and defines new 'xparse' + method taking std::string. Depending on whether input + to parse is ascii or UTF8, will pass it to xparse unmodified, + or with UTF8->ascii conversion. + */ + 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; + }; + + /** Helper conversion class for values that accept ascii + strings as input. + Overrides the 'parse' method and defines new 'xparse' + method taking std::wstring. Depending on whether input + to parse is ascii or UTF8, will recode input to Unicode, or + pass it unmodified. + */ + 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; + + unsigned min_tokens() const; + unsigned max_tokens() const; + + bool is_composing() const { return false; } + + bool is_required() 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; + }; + + /** Base class for all option that have a fixed type, and are + willing to announce this type to the outside world. + Any 'value_semantics' for which you want to find out the + type can be dynamic_cast-ed to typed_value_base. If conversion + succeeds, the 'type' method can be called. + */ + class typed_value_base + { + public: + // Returns the type of the value described by this + // object. + virtual const std::type_info& value_type() const = 0; + // Not really needed, since deletion from this + // class is silly, but just in case. + virtual ~typed_value_base() {} + }; + + + /** Class which handles value of a specific type. */ + template<class T, class charT = char> + class typed_value : public value_semantic_codecvt_helper<charT>, + public typed_value_base + { + 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_multitoken(false), m_zero_tokens(false), + m_required(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 an implicit value, which will be used + if the option is given, but without an adjacent value. + Using this implies that an explicit value is optional, but if + given, must be strictly adjacent to the option, i.e.: '-ovalue' + or '--option=value'. Giving '-o' or '--option' will cause the + implicit value to be applied. + */ + typed_value* implicit_value(const T &v) + { + m_implicit_value = boost::any(v); + m_implicit_value_as_text = + boost::lexical_cast<std::string>(v); + return this; + } + + /** Specifies an implicit value, which will be used + if the option is given, but without an adjacent value. + Using this implies that an explicit value is optional, but if + given, must be strictly adjacent to the option, i.e.: '-ovalue' + or '--option=value'. Giving '-o' or '--option' will cause the + implicit value to be applied. + 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* implicit_value(const T &v, const std::string& textual) + { + m_implicit_value = boost::any(v); + m_implicit_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 can span multiple tokens. */ + typed_value* multitoken() + { + m_multitoken = true; + return this; + } + + typed_value* zero_tokens() + { + m_zero_tokens = true; + return this; + } + + /** Specifies that the value must occur. */ + typed_value* required() + { + m_required = true; + return this; + } + + public: // value semantic overrides + + std::string name() const; + + bool is_composing() const { return m_composing; } + + unsigned min_tokens() const + { + if (m_zero_tokens || !m_implicit_value.empty()) { + return 0; + } else { + return 1; + } + } + + unsigned max_tokens() const { + if (m_multitoken) { + return 32000; + } else if (m_zero_tokens) { + return 0; + } else { + return 1; + } + } + + bool is_required() const { return m_required; } + + /** Creates an instance of the 'validator' class and calls + its operator() to perform the actual 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; + + public: // typed_value_base overrides + + const std::type_info& value_type() const + { + return typeid(T); + } + + + 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; + boost::any m_implicit_value; + std::string m_implicit_value_as_text; + bool m_composing, m_implicit, m_multitoken, m_zero_tokens, m_required; + 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 "boost/program_options/detail/value_semantic.hpp" + +#endif + diff --git a/3rdParty/Boost/src/boost/program_options/variables_map.hpp b/3rdParty/Boost/src/boost/program_options/variables_map.hpp new file mode 100644 index 0000000..02c4af2 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/variables_map.hpp @@ -0,0 +1,206 @@ +// 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> +#include <set> + +namespace boost { namespace program_options { + + template<class charT> + class basic_parsed_options; + + class value_semantic; + class variables_map; + + // forward declaration + + /** 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); + + /** 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 { + return boost::any_cast<const T&>(v); + } + /** @overload */ + template<class T> + T& as() { + return boost::any_cast<T&>(v); + } + + /// 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 BOOST_PROGRAM_OPTIONS_DECL + void store(const basic_parsed_options<char>& options, + variables_map& m, bool); + + friend BOOST_PROGRAM_OPTIONS_DECL class variables_map; + }; + + /** 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. + + This class is derived from std::map<std::string, variable_value>, + so you can use all map operators to examine its content. + */ + 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); } + + void notify(); + + private: + /** Implementation of abstract_variables_map::get + which does 'find' in *this. */ + const variable_value& get(const std::string& name) const; + + /** Names of option with 'final' values -- which should not + be changed by subsequence assignments. */ + std::set<std::string> m_final; + + friend BOOST_PROGRAM_OPTIONS_DECL + void store(const basic_parsed_options<char>& options, + variables_map& xm, + bool utf8); + + /** Names of required options, filled by parser which has + access to options_description. */ + std::set<std::string> m_required; + }; + + + /* + * 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; + } + +}} + +#endif diff --git a/3rdParty/Boost/src/boost/program_options/version.hpp b/3rdParty/Boost/src/boost/program_options/version.hpp new file mode 100644 index 0000000..7480943 --- /dev/null +++ b/3rdParty/Boost/src/boost/program_options/version.hpp @@ -0,0 +1,19 @@ +// 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 |