void accept_modifier( Modifier const& m ) { optionally_assign( m_value_handler, m, handler ); optionally_assign( m_value_interpreter, m, interpreter ); if( m.has( default_value ) ) { BOOST_RT_PARAM_VALIDATE_LOGIC( !m_value_generator, BOOST_RT_PARAM_LITERAL( "multiple value generators for parameter" ) ); T const& dv_ref = m[default_value]; m_value_generator = rt_cla_detail::const_generator<T>( dv_ref ); } if( m.has( default_refer_to ) ) { BOOST_RT_PARAM_VALIDATE_LOGIC( !m_value_generator, BOOST_RT_PARAM_LITERAL( "multiple value generators for parameter" ) ); cstring ref_id = m[default_refer_to]; m_value_generator = rt_cla_detail::ref_generator<T>( ref_id ); } if( m.has( assign_to ) ) { BOOST_RT_PARAM_VALIDATE_LOGIC( !m_value_handler, BOOST_RT_PARAM_LITERAL( "multiple value handlers for parameter" ) ); m_value_handler = rt_cla_detail::assigner<T>( m[assign_to] ); } }
virtual void usage_info( format_stream& fs ) const { fs << BOOST_RT_PARAM_LITERAL( '{' ); m_primary.usage_info( fs ); fs << BOOST_RT_PARAM_LITERAL( '|' ); m_secondary.usage_info( fs ); fs << BOOST_RT_PARAM_LITERAL( '}' ); }
void usage_info( format_stream& fs ) const { m_id_policy.usage_info( fs ); if( p_optional_value ) fs << BOOST_RT_PARAM_LITERAL( '[' ); m_arg_factory.argument_usage_info( fs ); if( p_optional_value ) fs << BOOST_RT_PARAM_LITERAL( ']' ); }
inline argument_ptr typed_argument_factory<T>::produce_using( parameter& p, argv_traverser& tr ) { hexerboost::optional<T> value; try { m_value_interpreter( tr, value ); } catch( ... ) { // !! should we do that? BOOST_RT_PARAM_TRACE( "Fail to parse argument value" ); if( !p.p_optional_value ) throw; } argument_ptr actual_arg = p.actual_argument(); BOOST_RT_CLA_VALIDATE_INPUT( !!value || p.p_optional_value, tr, BOOST_RT_PARAM_LITERAL( "Argument value missing for parameter " ) << p.id_2_report() ); BOOST_RT_CLA_VALIDATE_INPUT( !actual_arg || p.p_multiplicable, tr, BOOST_RT_PARAM_LITERAL( "Unexpected repetition of the parameter " ) << p.id_2_report() ); if( !!value && !!m_value_handler ) m_value_handler( p, *value ); if( !p.p_multiplicable ) actual_arg.reset( p.p_optional_value && (rtti::type_id<T>() != rtti::type_id<bool>()) ? static_cast<argument*>(new typed_argument<hexerboost::optional<T> >( p, value )) : static_cast<argument*>(new typed_argument<T>( p, *value )) ); else { typedef std::list<hexerboost::optional<T> > optional_list; if( !actual_arg ) actual_arg.reset( p.p_optional_value ? static_cast<argument*>(new typed_argument<optional_list>( p )) : static_cast<argument*>(new typed_argument<std::list<T> >( p )) ); if( p.p_optional_value ) { optional_list& values = arg_value<optional_list>( *actual_arg ); values.push_back( value ); } else { std::list<T>& values = arg_value<std::list<T> >( *actual_arg ); values.push_back( *value ); } } return actual_arg; }
void accept_modifier( Modifier const& m ) { cla::parameter::accept_modifier( m ); m_arg_factory.accept_modifier( m ); BOOST_RT_PARAM_VALIDATE_LOGIC( !p_optional || !m_arg_factory.m_value_generator, BOOST_RT_PARAM_LITERAL( "couldn't define a value generator for optional parameter " ) << id_2_report() ); }
inline bool interpret_argument_value( cstring source, hexerboost::optional<std::list<T> >& res, int ) { BOOST_RT_PARAM_TRACE( "In interpret_argument_value<std::list<T>>" ); res = std::list<T>(); while( !source.is_empty() ) { // !! should we use token_iterator cstring::iterator single_value_end = std::find( source.begin(), source.end(), BOOST_RT_PARAM_LITERAL( ',' ) ); hexerboost::optional<T> value; interpret_argument_value( cstring( source.begin(), single_value_end ), value, 0 ); res->push_back( *value ); source.trim_left( single_value_end + 1 ); } return true; }