Re: explicit calling of member template constructor...
On 25 mar, 15:53, werasm <wer...@gmail.com> wrote:
On Mar 25, 2:43 pm, Michael Doubez <michael.dou...@free.fr> wrote:
[snip]
Example:
struct ArgHolder
{
template <class T>
explicit ArgHolder( const T* pValue )
: any_( pValue ){}
template <class T>
const T& subject() const
{
return *boost::any_cast<const T*>(any_);
}
private:
boost::any any_;
};
In your example, the type of the input seems itself part of the
contract.
Yes, one would think that an output that converts to
Base does not break that contract. Boost::any
does not allow that conversion though (at it turned
out it requires exact type match):
struct Base{}; struct Derived : Base{};
//...
boost::any d = new Derived();
Base* b = boost::any_cast<Base*>( d );
//...
//Fails - bad_cast.
Then, using a plain unchecked template is IMHO a design error: it is
too greedy.
I disagree considering what it is used for. It is used to
obtain configuration parameter information of arbitrary
type. The type is determined by the name of the option
and the position of the field. The reader of the
configuration information (that could be obtained in various
ways such as from a file or command line etc) has to know
what the representing type is (as he specifies the format
of the configuration file). If he gets that wrong the cast
fails.
Which makes the life not really easy.
If you can put some constraints on the input type, it is IMO better.
Example:
// define a holder to check the type of argument
template <class T>
struct TypedArg
{
typedef T value_type;
explicit TypedArg(T* t): t_(t){}
T* t_;
}
struct ArgHolder
{
template <class T>
explicit ArgHolder( const TypedArg<T>& pValue )
: any_( pValue.t_ ){}
template <class T>
const T& subject() const
{
return *boost::any_cast<const T*>(any_);
}
private:
boost::any any_;
};
Then when you want to push an argument, you must specify its type:
config.pushOption(TypedArg<unsigned>(&portNumber));
Best of course would be to have a header:
typedef TypedArg<int> IntegralType;
typedef TypedArg<unsigned int> UnsignedType;
....
and use:
ArgHolder option( UnsignedType(&portNumber) );
And on the other side:
config.getOption( "SomePort" ).arg( 0 ).as<UnsignedType::value_type>();
But it adds some couplingwhich is what we want here but may not be
desirable.
[snip]
unsigned portNumber =
config.getOption( "SomePort" ).arg( 0 ).as<unsigned>();
//Requires no type change...
Except if you naturally assume that a port number is an unsigned
short :)
[snip]
--
Michael