Merge commit 'd361e123c6642006deb4ec4127a5ff1b28d7dd74' into feat-refactor

boost/boost/program_options/detail/cmdline.hpp

@@ -136,7 +136,7 @@ namespace boost { namespace program_options { namespace detail {
                       const std::vector<style_parser>& style_parsers);
 
         // Copies of input.
-        std::vector<std::string> args;
+        std::vector<std::string> m_args;
         style_t m_style;
         bool m_allow_unregistered;
 

boost/boost/program_options/detail/parsers.hpp

@@ -12,20 +12,6 @@
 
 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<
@@ -38,9 +24,7 @@ namespace boost { namespace program_options {
     basic_command_line_parser<charT>::
     basic_command_line_parser(int argc, const charT* const 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, const charT* const*>(argv+1, argv+argc+!argc))),
+        to_internal(std::vector<std::basic_string<charT> >(argv+1, argv+argc))),
         m_desc()
     {}
 
@@ -49,7 +33,7 @@ namespace boost { namespace program_options {
     basic_command_line_parser<charT>& 
     basic_command_line_parser<charT>::options(const options_description& desc)
     {
-       detail::cmdline::set_options_description(desc);
+        detail::cmdline::set_options_description(desc);
         m_desc = &desc;
         return *this;
     }

boost/boost/program_options/detail/value_semantic.hpp

@@ -8,6 +8,9 @@
 
 #include <boost/throw_exception.hpp>
 
+// forward declaration
+namespace boost { template<class T> class optional; }
+
 namespace boost { namespace program_options { 
 
     extern BOOST_PROGRAM_OPTIONS_DECL std::string arg;
@@ -152,6 +155,20 @@ namespace boost { namespace program_options {
         }
     }
 
+    /** Validates optional arguments. */
+    template<class T, class charT>
+    void validate(boost::any& v,
+                  const std::vector<std::basic_string<charT> >& s,
+                  boost::optional<T>*,
+                  int)
+    {
+        validators::check_first_occurrence(v);
+        validators::get_single_string(s);
+        boost::any a;
+        validate(a, s, (T*)0, 0);
+        v = boost::any(boost::optional<T>(boost::any_cast<T>(a)));
+    }
+
     template<class T, class charT>
     void 
     typed_value<T, charT>::

boost/boost/program_options/eof_iterator.hpp

@@ -68,7 +68,11 @@ namespace boost {
 
 
     private: // iterator core operations
-        friend class iterator_core_access;
+#ifdef __DCC__ 
+        friend class boost::iterator_core_access; 
+#else 
+        friend class iterator_core_access; 	 
+#endif
 
         void increment()
         {

boost/boost/program_options/errors.hpp

@@ -26,7 +26,12 @@ namespace boost { namespace program_options {
     inline std::string strip_prefixes(const std::string& text)
     {
         // "--foo-bar" -> "foo-bar"
-        return text.substr(text.find_first_not_of("-/"));
+        std::string::size_type i = text.find_first_not_of("-/");
+        if (i == std::string::npos) {
+            return text;
+        } else {
+            return text.substr(i);
+        }
     }
 
     /** Base class for all errors in the library. */
@@ -169,7 +174,7 @@ namespace boost { namespace program_options {
         virtual void set_option_name(const std::string& option_name)
         {           set_substitute("option", option_name);}
 
-        std::string get_option_name() const throw()
+        std::string get_option_name() const
         {           return get_canonical_option_name();         }
 
         void set_original_token(const std::string& original_token)
@@ -370,12 +375,15 @@ namespace boost { namespace program_options {
                    const std::string& option_name = "",
                    const std::string& original_token = "",
                    int option_style              = 0):
-        error_with_option_name(get_template(kind), option_name, original_token, option_style)
+        error_with_option_name(get_template(kind), option_name, original_token, option_style),
+        m_kind(kind)
         {
         }
 
         ~validation_error() throw() {}
 
+        kind_t kind() const { return m_kind; }
+
     protected:
         /** Used to convert kind_t to a related error text */
         std::string get_template(kind_t kind);

boost/boost/program_options/option.hpp

@@ -31,6 +31,7 @@ namespace boost { namespace program_options {
         basic_option(const std::string& xstring_key, 
                const std::vector< std::string> &xvalue)
         : string_key(xstring_key)
+        , position_key(-1)
         , value(xvalue)
         , unregistered(false)
         , case_insensitive(false)

boost/boost/program_options/options_description.hpp

@@ -22,6 +22,7 @@
 #include <set>
 #include <map>
 #include <stdexcept>
+#include <utility>
 
 #include <iosfwd>
 
@@ -106,14 +107,16 @@ namespace program_options {
         /** Returns the canonical name for the option description to enable the user to
             recognised a matching option.
             1) For short options ('-', '/'), returns the short name prefixed.
-            2) For long options ('--' / '-') returns the long name prefixed
-            3) All other cases, returns the long name (if present) or the short name,
-                unprefixed.
+            2) For long options ('--' / '-') returns the first long name prefixed
+            3) All other cases, returns the first long name (if present) or the short
+               name, unprefixed.
         */
         std::string canonical_display_name(int canonical_option_style = 0) const;
 
         const std::string& long_name() const;
 
+        const std::pair<const std::string*, std::size_t> long_names() const;
+
         /// Explanation of this option
         const std::string& description() const;
 
@@ -129,9 +132,24 @@ namespace program_options {
 
     private:
     
-        option_description& set_name(const char* name);
+        option_description& set_names(const char* name);
+
+        /**
+         * a one-character "switch" name - with its prefix,
+         * so that this is either empty or has length 2 (e.g. "-c"
+         */
+        std::string m_short_name;
+
+        /**
+         *  one or more names by which this option may be specified
+         *  on a command-line or in a config file, which are not
+         *  a single-letter switch. The names here are _without_
+         * any prefix.
+         */
+        std::vector<std::string> m_long_names;
+
+        std::string m_description;
 
-        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;

boost/boost/program_options/parsers.hpp

@@ -190,7 +190,11 @@ namespace boost { namespace program_options {
         Read from file with the given name. The character type is
         passed to the file stream.
     */
+#ifdef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
     template<class charT>
+#else
+    template<class charT = char>
+#endif
 #if ! BOOST_WORKAROUND(__ICL, BOOST_TESTED_AT(700))
     BOOST_PROGRAM_OPTIONS_DECL
 #endif

boost/boost/program_options/value_semantic.hpp

@@ -38,11 +38,6 @@ namespace boost { namespace program_options {
             should be present on the command line. */
         virtual unsigned max_tokens() const = 0;
 
-        /** Returns true if the option should only take adjacent token,
-            not one from further command-line arguments.
-        */
-        virtual bool adjacent_tokens_only() 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.
@@ -53,7 +48,7 @@ namespace boost { namespace program_options {
 
         */
         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
@@ -139,7 +134,6 @@ namespace boost { namespace program_options {
 
         unsigned min_tokens() const;
         unsigned max_tokens() const;
-        bool adjacent_tokens_only() const { return false; }
 
         bool is_composing() const { return false; }
 
@@ -224,10 +218,7 @@ namespace boost { namespace program_options {
 
         /** 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.
+            Using this implies that an explicit value is optional,
         */
         typed_value* implicit_value(const T &v)
         {
@@ -331,8 +322,6 @@ namespace boost { namespace program_options {
             }
         }
 
-        bool adjacent_tokens_only() const { return !m_implicit_value.empty(); }
-
         bool is_required() const { return m_required; }
 
         /** Creates an instance of the 'validator' class and calls

boost/boost/program_options/version.hpp

@@ -15,5 +15,8 @@
 #endif
 #define BOOST_PROGRAM_OPTIONS_VERSION 2
 
+// Signal that implicit options will use values from next
+// token, if available.
+#define BOOST_PROGRAM_OPTIONS_IMPLICIT_VALUE_NEXT_TOKEN 1
 
 #endif