1 files changed, 405 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/program_options/value_semantic.hpp b/3rdParty/Boost/src/boost/program_options/value_semantic.hpp
new file mode 100644
index 0000000..033009e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/program_options/value_semantic.hpp
@@ -0,0 +1,405 @@
+// Copyright Vladimir Prus 2004.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_VALUE_SEMANTIC_HPP_VP_2004_02_24
+#define BOOST_VALUE_SEMANTIC_HPP_VP_2004_02_24
+
+#include <boost/program_options/config.hpp>
+#include <boost/program_options/errors.hpp>
+
+#include <boost/any.hpp>
+#include <boost/function/function1.hpp>
+#include <boost/lexical_cast.hpp>
+
+
+#include <string>
+#include <vector>
+#include <typeinfo>
+
+namespace boost { namespace program_options {
+
+    /** Class which specifies how the option's value is to be parsed
+        and converted into C++ types.
+    */
+    class BOOST_PROGRAM_OPTIONS_DECL value_semantic {
+    public:
+        /** Returns the name of the option. The name is only meaningful
+            for automatic help message.
+         */
+        virtual std::string name() const = 0;
+
+        /** The minimum number of tokens for this option that
+            should be present on the command line. */
+        virtual unsigned min_tokens() const = 0;
+
+        /** The maximum number of tokens for this option that
+            should be present on the command line. */
+        virtual unsigned max_tokens() const = 0;
+
+        /** Returns true if values from different sources should be composed.
+            Otherwise, value from the first source is used and values from
+            other sources are discarded.
+        */
+        virtual bool is_composing() const = 0;
+
+        /** Returns true if value must be given. Non-optional value
+
+        */
+        virtual bool is_required() const = 0;
+        
+        /** Parses a group of tokens that specify a value of option.
+            Stores the result in 'value_store', using whatever representation
+            is desired. May be be called several times if value of the same
+            option is specified more than once.
+        */
+        virtual void parse(boost::any& value_store, 
+                           const std::vector<std::string>& new_tokens,
+                           bool utf8) const 
+            = 0;
+
+        /** Called to assign default value to 'value_store'. Returns
+            true if default value is assigned, and false if no default
+            value exists. */
+        virtual bool apply_default(boost::any& value_store) const = 0;
+                                   
+        /** Called when final value of an option is determined. 
+        */
+        virtual void notify(const boost::any& value_store) const = 0;
+        
+        virtual ~value_semantic() {}
+    };
+
+    /** Helper class which perform necessary character conversions in the 
+        'parse' method and forwards the data further.
+    */
+    template<class charT>
+    class value_semantic_codecvt_helper {
+        // Nothing here. Specializations to follow.
+    };
+
+    /** Helper conversion class for values that accept ascii
+        strings as input.
+        Overrides the 'parse' method and defines new 'xparse'
+        method taking std::string. Depending on whether input
+        to parse is ascii or UTF8, will pass it to xparse unmodified,
+        or with UTF8->ascii conversion.
+    */
+    template<>
+    class BOOST_PROGRAM_OPTIONS_DECL 
+    value_semantic_codecvt_helper<char> : public value_semantic {
+    private: // base overrides
+        void parse(boost::any& value_store, 
+                   const std::vector<std::string>& new_tokens,
+                   bool utf8) const;
+    protected: // interface for derived classes.
+        virtual void xparse(boost::any& value_store, 
+                            const std::vector<std::string>& new_tokens) 
+            const = 0;
+    };
+
+    /** Helper conversion class for values that accept ascii
+        strings as input.
+        Overrides the 'parse' method and defines new 'xparse'
+        method taking std::wstring. Depending on whether input
+        to parse is ascii or UTF8, will recode input to Unicode, or
+        pass it unmodified.
+    */
+    template<>
+    class BOOST_PROGRAM_OPTIONS_DECL
+    value_semantic_codecvt_helper<wchar_t> : public value_semantic {
+    private: // base overrides
+        void parse(boost::any& value_store, 
+                   const std::vector<std::string>& new_tokens,
+                   bool utf8) const;
+    protected: // interface for derived classes.
+#if !defined(BOOST_NO_STD_WSTRING)
+        virtual void xparse(boost::any& value_store, 
+                            const std::vector<std::wstring>& new_tokens) 
+            const = 0;
+#endif
+    };
+
+    /** Class which specifies a simple handling of a value: the value will
+        have string type and only one token is allowed. */    
+    class BOOST_PROGRAM_OPTIONS_DECL 
+    untyped_value : public value_semantic_codecvt_helper<char>  {
+    public:
+        untyped_value(bool zero_tokens = false)
+        : m_zero_tokens(zero_tokens)
+        {}
+
+        std::string name() const;
+
+        unsigned min_tokens() const;
+        unsigned max_tokens() const;
+
+        bool is_composing() const { return false; }
+
+        bool is_required() const { return false; }
+        
+        /** If 'value_store' is already initialized, or new_tokens
+            has more than one elements, throws. Otherwise, assigns
+            the first string from 'new_tokens' to 'value_store', without
+            any modifications.
+         */
+        void xparse(boost::any& value_store,
+                    const std::vector<std::string>& new_tokens) const;
+
+        /** Does nothing. */
+        bool apply_default(boost::any&) const { return false; }
+
+        /** Does nothing. */
+        void notify(const boost::any&) const {}        
+    private:
+        bool m_zero_tokens;
+    };
+
+    /** Base class for all option that have a fixed type, and are
+        willing to announce this type to the outside world.
+        Any 'value_semantics' for which you want to find out the
+        type can be dynamic_cast-ed to typed_value_base. If conversion
+        succeeds, the 'type' method can be called.
+    */
+    class typed_value_base 
+    {
+    public:
+        // Returns the type of the value described by this
+        // object.
+        virtual const std::type_info& value_type() const = 0;
+        // Not really needed, since deletion from this
+        // class is silly, but just in case.
+        virtual ~typed_value_base() {}
+    };
+
+
+    /** Class which handles value of a specific type. */
+    template<class T, class charT = char>
+    class typed_value : public value_semantic_codecvt_helper<charT>,
+                        public typed_value_base
+    {
+    public:
+        /** Ctor. The 'store_to' parameter tells where to store
+            the value when it's known. The parameter can be NULL. */
+        typed_value(T* store_to) 
+        : m_store_to(store_to), m_composing(false),
+          m_multitoken(false), m_zero_tokens(false),
+          m_required(false)
+        {} 
+
+        /** Specifies default value, which will be used
+            if none is explicitly specified. The type 'T' should
+            provide operator<< for ostream.
+        */
+        typed_value* default_value(const T& v)
+        {
+            m_default_value = boost::any(v);
+            m_default_value_as_text = boost::lexical_cast<std::string>(v);
+            return this;
+        }
+
+        /** Specifies default value, which will be used
+            if none is explicitly specified. Unlike the above overload,
+            the type 'T' need not provide operator<< for ostream,
+            but textual representation of default value must be provided
+            by the user.
+        */
+        typed_value* default_value(const T& v, const std::string& textual)
+        {
+            m_default_value = boost::any(v);
+            m_default_value_as_text = textual;
+            return this;
+        }
+
+        /** Specifies an implicit value, which will be used
+            if the option is given, but without an adjacent value.
+            Using this implies that an explicit value is optional, but if
+            given, must be strictly adjacent to the option, i.e.: '-ovalue'
+            or '--option=value'.  Giving '-o' or '--option' will cause the
+            implicit value to be applied.
+        */
+        typed_value* implicit_value(const T &v)
+        {
+            m_implicit_value = boost::any(v);
+            m_implicit_value_as_text =
+                boost::lexical_cast<std::string>(v);
+            return this;
+        }
+
+        /** Specifies an implicit value, which will be used
+            if the option is given, but without an adjacent value.
+            Using this implies that an explicit value is optional, but if
+            given, must be strictly adjacent to the option, i.e.: '-ovalue'
+            or '--option=value'.  Giving '-o' or '--option' will cause the
+            implicit value to be applied.
+            Unlike the above overload, the type 'T' need not provide
+            operator<< for ostream, but textual representation of default
+            value must be provided by the user.
+        */
+        typed_value* implicit_value(const T &v, const std::string& textual)
+        {
+            m_implicit_value = boost::any(v);
+            m_implicit_value_as_text = textual;
+            return this;
+        }
+
+        /** Specifies a function to be called when the final value
+            is determined. */
+        typed_value* notifier(function1<void, const T&> f)
+        {
+            m_notifier = f;
+            return this;
+        }
+
+        /** Specifies that the value is composing. See the 'is_composing' 
+            method for explanation. 
+        */
+        typed_value* composing()
+        {
+            m_composing = true;
+            return this;
+        }
+
+        /** Specifies that the value can span multiple tokens. */
+        typed_value* multitoken()
+        {
+            m_multitoken = true;
+            return this;
+        }
+
+        typed_value* zero_tokens() 
+        {
+            m_zero_tokens = true;
+            return this;
+        }
+            
+        /** Specifies that the value must occur. */
+        typed_value* required()
+        {
+            m_required = true;
+            return this;
+        }
+
+    public: // value semantic overrides
+
+        std::string name() const;
+
+        bool is_composing() const { return m_composing; }
+
+        unsigned min_tokens() const
+        {
+            if (m_zero_tokens || !m_implicit_value.empty()) {
+                return 0;
+            } else {
+                return 1;
+            }
+        }
+
+        unsigned max_tokens() const {
+            if (m_multitoken) {
+                return 32000;
+            } else if (m_zero_tokens) {
+                return 0;
+            } else {
+                return 1;
+            }
+        }
+
+        bool is_required() const { return m_required; }
+
+        /** Creates an instance of the 'validator' class and calls
+            its operator() to perform the actual conversion. */
+        void xparse(boost::any& value_store, 
+                    const std::vector< std::basic_string<charT> >& new_tokens) 
+            const;
+
+        /** If default value was specified via previous call to 
+            'default_value', stores that value into 'value_store'.
+            Returns true if default value was stored.
+        */
+        virtual bool apply_default(boost::any& value_store) const
+        {
+            if (m_default_value.empty()) {
+                return false;
+            } else {
+                value_store = m_default_value;
+                return true;
+            }
+        }
+
+        /** If an address of variable to store value was specified
+            when creating *this, stores the value there. Otherwise,
+            does nothing. */
+        void notify(const boost::any& value_store) const;
+
+    public: // typed_value_base overrides
+        
+        const std::type_info& value_type() const
+        {
+            return typeid(T);
+        }
+        
+
+    private:
+        T* m_store_to;
+        
+        // Default value is stored as boost::any and not
+        // as boost::optional to avoid unnecessary instantiations.
+        boost::any m_default_value;
+        std::string m_default_value_as_text;
+        boost::any m_implicit_value;
+        std::string m_implicit_value_as_text;
+        bool m_composing, m_implicit, m_multitoken, m_zero_tokens, m_required;
+        boost::function1<void, const T&> m_notifier;
+    };
+
+
+    /** Creates a typed_value<T> instance. This function is the primary
+        method to create value_semantic instance for a specific type, which
+        can later be passed to 'option_description' constructor.
+        The second overload is used when it's additionally desired to store the 
+        value of option into program variable.
+    */
+    template<class T>
+    typed_value<T>*
+    value();
+
+    /** @overload 
+    */
+    template<class T>
+    typed_value<T>*
+    value(T* v);
+
+    /** Creates a typed_value<T> instance. This function is the primary
+        method to create value_semantic instance for a specific type, which
+        can later be passed to 'option_description' constructor.
+    */
+    template<class T>
+    typed_value<T, wchar_t>*
+    wvalue();
+
+    /** @overload   
+    */
+    template<class T>
+    typed_value<T, wchar_t>*
+    wvalue(T* v);
+
+    /** Works the same way as the 'value<bool>' function, but the created
+        value_semantic won't accept any explicit value. So, if the option 
+        is present on the command line, the value will be 'true'.
+    */
+    BOOST_PROGRAM_OPTIONS_DECL typed_value<bool>*
+    bool_switch();
+
+    /** @overload
+    */
+    BOOST_PROGRAM_OPTIONS_DECL typed_value<bool>*    
+    bool_switch(bool* v);
+
+}}
+
+#include "boost/program_options/detail/value_semantic.hpp"
+
+#endif
+