Re: How can I use unqualified names? (Possibly hard or impossible?)
* James Kanze:
On Jul 25, 8:28 am, "Alf P. Steinbach" <al...@start.no> wrote:
* James Kanze:
On Jul 19, 5:12 pm, "Alf P. Steinbach" <al...@start.no> wrote:
Original problem: a pack of options that may contain a
great many simple numerical and bitset options (defined by
external API), and that should be (1) extensible for at
least two levels, like class derivation, (2) easy to
define, (3) easily constructible specifying only those
options of interest, defaulting on the rest, (4) clean
notation for accessing options, with compile time checking,
and (5) if possible as efficient as possible access of
options.
[snip]
My test usage code for all-C++ solution now looks like this:
<code>
//------------------------ Usage:
#include <iostream>
namespace blahblah {
namespace reallyLongName {
namespace california {
CPPX_DEFINE_OPTION( x, double )
I suppose that this is your macro, but I'm not sure what it's
supposed to generate. In a macro based solution, I would have
expected to see something like:
#define MYPREFIX_DEFINE_OPTION( name, type )\
public: \
Options& name( type new_ ## name ) \
{ \
my_ ## name = new_ ## name ; \
return *this ; \
} \
type name() const \
{ \
return my_ ## name ; \
} \
private: \
type my_ ## name
class Options
{
MYPREFIX_DEFINE_OPTION( y, double ) ;
// ...
} ;
#undef MYPREFIX_DEFINE_OPTION
That still leaves having to list all of the defaults in the
constructor. (The AWK script would only be a few lines longer
than the above, and would also generate the constructor.)
Well, one beauty of having each option as a type is that each option has its own
constructor, so that the default can be specified along with the "declaration"
of the option, like
CPPX_DEFINE_OPTION_AND_DEFAULT( y, double, 12345 )
CPPX_DEFINE_OPTION( y, double )
CPPX_DEFINE_2OPTIONCLASS( Pos2Options, cppx::options::NoBase, x, y )
CPPX_DEFINE_OPTION( z, double )
CPPX_DEFINE_1OPTIONCLASS( Pos3Options, Pos2Options, z )
}}} // namespace blahblah::reallyLongName::california
struct UserClass1
{
typedef ::blahblah::reallyLongName::california::Pos2Options
Pos2Options;
UserClass1( Pos2Options const& options )
{
using namespace std;
cout << options.x() << endl;
cout << options.y() << endl;
}
};
struct UserClass2: UserClass1
{
typedef ::blahblah::reallyLongName::california::Pos3Options
Pos3Options;
UserClass2( Pos3Options const& options )
: UserClass1( options )
{
using namespace std;
cout << std::endl;
cout << options.x() << endl;
cout << options.y() << endl;
cout << options.z() << endl;
}
};
int main()
{
typedef UserClass2::Pos3Options Pos3Options;
UserClass2( Pos3Options().x( 3.14 ).z( 42 ) );
}
</code>
<results>
3.14
0
3.14
0
42
</results>
Works with both g++ and MSVC.
I'm interested in whether anyone can find a /simple/ way to do
it, because the support needed to get that final
Pos3Options().x( 3.14 ).z( 42 )
expression to work turned out, with the way I did it, to be a
little in-elegant (I guess that's what some folks call "too
smart" code)...
I don't know. I don't really understand what's going on,
without seeing the definitions of the macros you're using.
They're ugly! :-)
Or "in-elegant"...
Hence the plea for simpler pure-C++ solution that supports the same, in
particular extension and simple notation (client code).
<code>
#include <boost/mpl/clear.hpp>
#include <boost/mpl/front.hpp>
#include <boost/mpl/inherit.hpp>
#include <boost/mpl/inherit_linearly.hpp>
#include <boost/mpl/list.hpp>
#include <boost/mpl/pop_front.hpp>
namespace cppx { namespace typelist {
typedef boost::mpl::clear< boost::mpl::list<> >::type Empty;
template< class TypeList >
struct InheritLinearly_
{
typedef typename boost::mpl::inherit_linearly<
TypeList,
boost::mpl::inherit< boost::mpl::_1, boost::mpl::_2 >
>::type Type;
};
template< class TypeList >
struct Car
{
typedef typename boost::mpl::front< TypeList >::type Type;
};
template< class TypeList >
struct Cdr
{
typedef typename boost::mpl::pop_front< TypeList >::type Type;
};
} } // namespace cppx::typelist
namespace cppx { namespace options {
template< class T, class UniqueIdType >
class Value_
{
private:
T myValue;
public:
Value_(): myValue() {}
Value_( T const& v ): myValue( v ) {}
T const& value() const { return myValue; }
void setValue( T const& v ) { myValue = v; }
operator T const& () const { return value(); }
Value_& operator=( T const& v )
{
setValue( v ); return *this;
}
};
class NoBase {};
template< class SetterResult, class TopBase >
class NoBase_TemplatedSetters_: public TopBase {};
template<
class OptionTypes,
class SetterResult,
class TopBase,
template< class, class, class > class OptionSetter_
>
class TemplatedSetters_;
template<
class SetterResult,
class TopBase,
template< class, class, class > class OptionSetter_
>
class TemplatedSetters_<
cppx::typelist::Empty, SetterResult, TopBase, OptionSetter_
>
: public TopBase
{};
template<
class OptionTypes,
class SetterResult,
class TopBase,
template< class, class, class > class OptionSetter_
>
class TemplatedSetters_
: public OptionSetter_<
typename cppx::typelist::Car<OptionTypes>::Type,
SetterResult,
TemplatedSetters_<
typename cppx::typelist::Cdr<OptionTypes>::Type,
SetterResult,
TopBase,
OptionSetter_
>
>
{};
#define CPPX_OPTION( name ) OptionValue_##name
#define CPPX_DEFINE_OPTION_SETTER( name, type ) \
template< class OptionValue, class SetterResult, class Base > \
class OptionSetter_; \
\
template< class SetterResult, class Base > \
class OptionSetter_<CPPX_OPTION( name ), SetterResult, Base> \
: public Base \
{ \
public: \
type const& name() const \
{ return CPPX_OPTION( name )::value(); } \
\
SetterResult& name( type const& value ) \
{ \
CPPX_OPTION( name )::setValue( value ); \
return static_cast<SetterResult&>( *this ); \
} \
};
#define CPPX_DEFINE_OPTION( name, type ) \
typedef ::cppx::options::Value_< \
type, struct UniqueIdTypeFor_##name \
> CPPX_OPTION( name ); \
CPPX_DEFINE_OPTION_SETTER( name, type )
#define CPPX_DEFINE_OPTION_AND_DEFAULT( name, type, defValue ) \
class CPPX_OPTION( name ) \
: public ::cppx::options::Value_< \
type, struct UniqueIdTypeFor_##name \
> \
{ \
typedef ::cppx::options::Value_< \
type, struct UniqueIdTypeFor_##name \
> Base; \
public: \
CPPX_OPTION( name )(): Base( defValue ) {} \
CPPX_OPTION( name )( type const& v ): Base( v ) {} \
}; \
CPPX_DEFINE_OPTION_SETTER( name, type )
#define CPPX_DEFINE_VALUECLASS( name, base ) \
class name##_Values \
: public base \
, public ::cppx::typelist::InheritLinearly_< \
name##_OptionTypes \
>::Type \
{};
#define CPPX_DEFINE_TEMPLATED_SETTERS( name ) \
template< class SetterResult, class TopBase > \
class name##_TemplatedSetters_ \
: public ::cppx::options::TemplatedSetters_< \
name##_OptionTypes, \
SetterResult, \
TopBase, \
OptionSetter_ \
> \
{};
#define CPPX_DEFINE_OPTIONCLASS( name, base ) \
class name \
: public name##_TemplatedSetters_< \
name, \
base##_TemplatedSetters_<name, name##_Values> \
> \
{};
#define CPPX_DEFINE_VTANDO( name, base ) \
CPPX_DEFINE_VALUECLASS( name, base ) \
CPPX_DEFINE_TEMPLATED_SETTERS( name ) \
CPPX_DEFINE_OPTIONCLASS( name, base )
#define CPPX_DEFINE_1OPTIONCLASS( name, base, option1 ) \
typedef ::boost::mpl::list< \
CPPX_OPTION( option1 ) \
> name##_OptionTypes; \
CPPX_DEFINE_VTANDO( name, base )
#define CPPX_DEFINE_2OPTIONCLASS( name, base, option1, option2 ) \
typedef ::boost::mpl::list< \
CPPX_OPTION( option1 ), \
CPPX_OPTION( option2 ) \
> name##_OptionTypes; \
CPPX_DEFINE_VTANDO( name, base )
// ...
} } // namespace cppx::options
</code>
Cheers,
- Alf (he he, I *mean* it when I say something's "ugly" :-) )
(but then, the ugly beast is easy to ride, good tempered animal)