text: // 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); }
  
          // Override to clear some extra fields.
          void clear(); 
          
          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.
              The map values are the "canonical" names for each corresponding option.
              This is useful in creating diagnostic messages when the option is absent. */
          std::map<std::string, 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;
      }
  
  }}
  
  #if defined(BOOST_MSVC)
  #   pragma warning (pop)
  #endif
  
  #endif
  