| // 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> |
| |
| #if defined(BOOST_MSVC) |
| # pragma warning (push) |
| # pragma warning (disable:4251) // 'boost::program_options::variable_value::v' : class 'boost::any' needs to have dll-interface to be used by clients of class 'boost::program_options::variable_value |
| #endif |
| |
| 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& xv, bool xdefaulted) |
| : v(xv), m_defaulted(xdefaulted) |
| {} |
| |
| /** If stored value if of type T, returns that value. Otherwise, |
| throws boost::bad_any_cast exception. */ |
| template<class T> |
| const T& as() const { |
| return boost::any_cast<const T&>(v); |
| } |
| /** @overload */ |
| template<class T> |
| T& as() { |
| return boost::any_cast<T&>(v); |
| } |
| |
| /// Returns true if no value is stored. |
| bool empty() const; |
| /** Returns true if the value was not explicitly |
| given, but has default value. */ |
| bool defaulted() const; |
| /** Returns the contained value. */ |
| const boost::any& value() const; |
| |
| /** Returns the contained value. */ |
| boost::any& value(); |
| private: |
| boost::any v; |
| bool m_defaulted; |
| // Internal reference to value semantic. We need to run |
| // notifications when *final* values of options are known, and |
| // they are known only after all sources are stored. By that |
| // time options_description for the first source might not |
| // be easily accessible, so we need to store semantic here. |
| shared_ptr<const value_semantic> m_value_semantic; |
| |
| friend BOOST_PROGRAM_OPTIONS_DECL |
| void store(const basic_parsed_options<char>& options, |
| variables_map& m, bool); |
| |
| friend BOOST_PROGRAM_OPTIONS_DECL class variables_map; |
| }; |
| |
| /** Implements string->string mapping with convenient value casting |
| facilities. */ |
| class BOOST_PROGRAM_OPTIONS_DECL abstract_variables_map { |
| public: |
| abstract_variables_map(); |
| abstract_variables_map(const abstract_variables_map* next); |
| |
| virtual ~abstract_variables_map() {} |
| |
| /** Obtains the value of variable 'name', from *this and |
| possibly from the chain of variable maps. |
| |
| - if there's no value in *this. |
| - if there's next variable map, returns value from it |
| - otherwise, returns empty value |
| |
| - if there's defaulted value |
| - if there's next varaible map, which has a non-defauled |
| value, return that |
| - otherwise, return value from *this |
| |
| - if there's a non-defauled value, returns it. |
| */ |
| const variable_value& operator[](const std::string& name) const; |
| |
| /** Sets next variable map, which will be used to find |
| variables not found in *this. */ |
| void next(abstract_variables_map* next); |
| |
| private: |
| /** Returns value of variable 'name' stored in *this, or |
| empty value otherwise. */ |
| virtual const variable_value& get(const std::string& name) const = 0; |
| |
| const abstract_variables_map* m_next; |
| }; |
| |
| /** Concrete variables map which store variables in real map. |
| |
| This class is derived from std::map<std::string, variable_value>, |
| so you can use all map operators to examine its content. |
| */ |
| class BOOST_PROGRAM_OPTIONS_DECL variables_map : public abstract_variables_map, |
| public std::map<std::string, variable_value> |
| { |
| public: |
| variables_map(); |
| variables_map(const abstract_variables_map* next); |
| |
| // Resolve conflict between inherited operators. |
| const variable_value& operator[](const std::string& name) const |
| { return abstract_variables_map::operator[](name); } |
| |
| void notify(); |
| |
| private: |
| /** Implementation of abstract_variables_map::get |
| which does 'find' in *this. */ |
| const variable_value& get(const std::string& name) const; |
| |
| /** Names of option with 'final' values -- which should not |
| be changed by subsequence assignments. */ |
| std::set<std::string> m_final; |
| |
| friend BOOST_PROGRAM_OPTIONS_DECL |
| void store(const basic_parsed_options<char>& options, |
| variables_map& xm, |
| bool utf8); |
| |
| /** Names of required options, filled by parser which has |
| access to options_description. */ |
| std::set<std::string> m_required; |
| }; |
| |
| |
| /* |
| * Templates/inlines |
| */ |
| |
| inline bool |
| variable_value::empty() const |
| { |
| return v.empty(); |
| } |
| |
| inline bool |
| variable_value::defaulted() const |
| { |
| return m_defaulted; |
| } |
| |
| inline |
| const boost::any& |
| variable_value::value() const |
| { |
| return v; |
| } |
| |
| inline |
| boost::any& |
| variable_value::value() |
| { |
| return v; |
| } |
| |
| }} |
| |
| #endif |