| Home | Libraries | People | FAQ | More

## Class template typed_value

boost::program_options::typed_value

## Synopsis

    // In header: <boost/program_options/value_semantic.hpp>

    template<typename T, typename charT = char>
    class typed_value : public boost::program_options::value_semantic_codecvt_helper< charT >,
                        public boost::program_options::typed_value_base
    {
    public:
      // construct/copy/destruct
      typed_value(T *);

      // public member functions
      typed_value * default_value(const T &);
      typed_value * default_value(const T &, const std::string &);
      typed_value * implicit_value(const T &);
      typed_value * implicit_value(const T &, const std::string &);
      typed_value * notifier(function1< void, const T & >);
      typed_value * composing();
      typed_value * multitoken();
      typed_value * zero_tokens();
      typed_value * required();
      std::string name() const;
      bool is_composing() const;
      unsigned min_tokens() const;
      unsigned max_tokens() const;
      bool is_required() const;
      void xparse(boost::any &, const std::vector< std::basic_string< charT > > &) const;
      bool apply_default(boost::any &) const;
      void notify(const boost::any &) const;
      const std::type_info & value_type() const;
    };

## Description

Class which handles value of a specific type.

### `typed_value` public construct/copy/destruct

1.     typed_value(T * store_to);

   Ctor. The 'store_to' parameter tells where to store the value when it's known. The parameter can be NULL.

### `typed_value` public member functions

1.     typed_value * default_value(const T & v);

   Specifies default value, which will be used if none is explicitly specified. The type 'T' should provide operator<< for ostream.

2.     typed_value * default_value(const T & v, const std::string & textual);

   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.

3.     typed_value * implicit_value(const T & v);

   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.

4.     typed_value * implicit_value(const T & v, const std::string & textual);

   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.

5.     typed_value * notifier(function1< void, const T & > f);

   Specifies a function to be called when the final value is determined.

6.     typed_value * composing();

   Specifies that the value is composing. See the 'is_composing' method for explanation.

7.     typed_value * multitoken();

   Specifies that the value can span multiple tokens.

8.     typed_value * zero_tokens();

9.     typed_value * required();

   Specifies that the value must occur.

10.     std::string name() const;

11.     bool is_composing() const;

12.     unsigned min_tokens() const;

13.     unsigned max_tokens() const;

14.     bool is_required() const;

15.     void xparse(boost::any & value_store,
                    const std::vector< std::basic_string< charT > > & new_tokens) const;

    Creates an instance of the 'validator' class and calls its operator() to perform the actual conversion.

16.     bool apply_default(boost::any & value_store) 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.

17.     void notify(const boost::any & value_store) const;

    If an address of variable to store value was specified when creating *this, stores the value there. Otherwise, does nothing.

18.     const std::type_info & value_type() const;