Boost-Commit :

Date view	Thread view	Subject view	Author view

From: troy_at_[hidden]
Date: 2008-07-01 12:54:15

Author: troy
Date: 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
New Revision: 46969
URL: http://svn.boost.org/trac/boost/changeset/46969

Log:
use modularize targets, not externals to manage modularization
Added:
   branches/CMake/release/libs/program_options/include/boost/program_options/
   branches/CMake/release/libs/program_options/include/boost/program_options/cmdline.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/config.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/detail/
   branches/CMake/release/libs/program_options/include/boost/program_options/detail/cmdline.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/detail/config_file.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/detail/convert.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/detail/parsers.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/detail/utf8_codecvt_facet.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/detail/value_semantic.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/environment_iterator.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/eof_iterator.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/errors.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/option.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/options_description.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/parsers.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/positional_options.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/value_semantic.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/variables_map.hpp (contents, props changed)
   branches/CMake/release/libs/program_options/include/boost/program_options/version.hpp (contents, props changed)
Properties modified:
   branches/CMake/release/libs/program_options/include/boost/ (props changed)

Added: branches/CMake/release/libs/program_options/include/boost/program_options/cmdline.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/cmdline.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,85 @@
+// 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,
+ /// 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 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 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
+

Added: branches/CMake/release/libs/program_options/include/boost/program_options/config.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/config.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -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
+

Added: branches/CMake/release/libs/program_options/include/boost/program_options/detail/cmdline.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/detail/cmdline.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,136 @@
+// 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;
+
+
+ void init(const std::vector<std::string>& args);
+
+ void
+ finish_option(option& opt,
+ std::vector<std::string>& other_tokens);
+
+ // 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
+

Added: branches/CMake/release/libs/program_options/include/boost/program_options/detail/config_file.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/detail/config_file.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -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

Added: branches/CMake/release/libs/program_options/include/boost/program_options/detail/convert.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/detail/convert.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -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

Added: branches/CMake/release/libs/program_options/include/boost/program_options/detail/parsers.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/detail/parsers.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,144 @@
+// 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)
+ : 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

Added: branches/CMake/release/libs/program_options/include/boost/program_options/detail/utf8_codecvt_facet.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/detail/utf8_codecvt_facet.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,25 @@
+// Copyright © 2001 Ronald Garcia, Indiana University (garcia_at_[hidden])
+// Andrew Lumsdaine, Indiana University (lums_at_[hidden]). 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

Added: branches/CMake/release/libs/program_options/include/boost/program_options/detail/value_semantic.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/detail/value_semantic.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,208 @@
+// 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<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&) {
+ 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;
+ }
+
+
+
+}}

Added: branches/CMake/release/libs/program_options/include/boost/program_options/environment_iterator.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/environment_iterator.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -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

Added: branches/CMake/release/libs/program_options/include/boost/program_options/eof_iterator.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/eof_iterator.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -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
+

Added: branches/CMake/release/libs/program_options/include/boost/program_options/errors.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/errors.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,146 @@
+// 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);
+
+ const char* what() const throw();
+ 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.
+ };
+
+ 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

Added: branches/CMake/release/libs/program_options/include/boost/program_options/option.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/option.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,60 @@
+// 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) {}
+ basic_option(const std::string& string_key,
+ const std::vector< std::string> &value)
+ : string_key(string_key), value(value), unregistered(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;
+
+ };
+ typedef basic_option<char> option;
+ typedef basic_option<wchar_t> woption;
+
+}}
+
+#endif

Added: branches/CMake/release/libs/program_options/include/boost/program_options/options_description.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/options_description.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,241 @@
+// 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) 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);
+ /** Creates the instance. The 'caption' parameter gives the name of
+ this 'options_description' instance. Primarily useful for output.
+ */
+ options_description(const std::string& caption,
+ unsigned line_length = m_default_line_length);
+ /** 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)
+ const;
+
+ const option_description* find_nothrow(const std::string& name,
+ bool approx) 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;
+ // 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

Added: branches/CMake/release/libs/program_options/include/boost/program_options/parsers.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/parsers.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,229 @@
+// 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.
+ */
+ 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);
+
+ /** 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);
+
+ #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

Added: branches/CMake/release/libs/program_options/include/boost/program_options/positional_options.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/positional_options.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -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
+

Added: branches/CMake/release/libs/program_options/include/boost/program_options/value_semantic.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/value_semantic.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,390 @@
+// 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;
+
+ /** 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; }
+
+ /** 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)
+ {}
+
+ /** 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;
+ }
+
+
+ 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;
+ }
+ }
+
+
+ /** 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;
+ 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
+

Added: branches/CMake/release/libs/program_options/include/boost/program_options/variables_map.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/variables_map.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,199 @@
+// 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 void 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.
+
+ 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); }
+
+ 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);
+ };
+
+
+ /*
+ * 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

Added: branches/CMake/release/libs/program_options/include/boost/program_options/version.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/program_options/include/boost/program_options/version.hpp 2008-07-01 12:54:13 EDT (Tue, 01 Jul 2008)
@@ -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

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk