Re: [boost] typeof

From: Daryle Walker (darylew_at_[hidden])
Date: 2004-05-05 00:52:35

On 5/2/04 9:38 PM, "Arkadiy Vertleyb" <vertleyb_at_[hidden]> wrote:

> A couple of weeks ago I initiated the discussion about simple typeof
> emulation, and provided an example on how it can be done with the help of
> MPL vector of integral constants.  I then used MS-specific __COUNTER__ macro
> to spare the user from specifying the unique integer for each registered
> class/template.  I hoped to find a way to do something similar in standard
> C++, and asked preprocessor experts for help.
> 
> Indeed, Paul Mensonides suggested such a way.  At first I thought that it
> will not be good enough replacement for the __COUNTER__, but then I realized
> that I was wrong.  So I re-worked my implementation of typeof, and now
> offerring it to your attention.
> 
> Besides removing __COUNTER__, I used the Boost.Preprocessor library to
> cleanup the implementation.  Also, after the discussion with Jody Hagins, I
> put the encoding/decoding classes inside anonimous namespace to avoid
> collisions between translation units.
> 
> The provided example shows what registration needs to be done to calculate
> the type of a lambda functor:
> 
> #include BOOST_TYPEOF_BEGIN_REGISTRATION()
> 
> BOOST_TYPEOF_REGISTER_TEMPLATE(tuples::tuple, 2);
> BOOST_TYPEOF_REGISTER_TEMPLATE(lambda_functor, 1);
> BOOST_TYPEOF_REGISTER_TEMPLATE(lambda_functor_base, 2);
> BOOST_TYPEOF_REGISTER_TEMPLATE(relational_action, 1);
> BOOST_TYPEOF_REGISTER_TEMPLATE(logical_action, 1);
> BOOST_TYPEOF_REGISTER_TYPE(greater_action);
> BOOST_TYPEOF_REGISTER_TYPE(less_action);
> BOOST_TYPEOF_REGISTER_TYPE(and_action);
> BOOST_TYPEOF_REGISTER_TYPE(placeholder<1>);
> BOOST_TYPEOF_REGISTER_TYPE(placeholder<2>);
> 
> #include BOOST_TYPEOF_END_REGISTRATION()
> 
> main()
> {
>   BOOST_TYPEOF_ALLOCATE(fun, _1 > 15 && _2 < 20);  // <unspecified> fun(_1
>> 15 && _2 < 20);
>   int n = 19;
>   assert(fun(n, n));
> }
[TRUNCATE]

Wouldn't the program need exactly one master type-of list?  Since C and C++
don't have cross-module consolidation, just text dumps of common files that
work by "coincidence", couldn't you break ODR by:

File1.cpp:
    #include BOOST_TYPEOF_BEGIN_REGISTRATION()
    BOOST_TYPEOF_REGISTER_TYPE(greater_action);  //1
    BOOST_TYPEOF_REGISTER_TYPE(less_action);     //2
    BOOST_TYPEOF_REGISTER_TYPE(and_action);      //3
    #include BOOST_TYPEOF_END_REGISTRATION()
    int my_func1() { /*...*/}

File2.cpp:
    #include BOOST_TYPEOF_BEGIN_REGISTRATION()
    BOOST_TYPEOF_REGISTER_TYPE(placeholder<1>);  //1
    BOOST_TYPEOF_REGISTER_TYPE(less_action);     //2 (only one the same)
    BOOST_TYPEOF_REGISTER_TYPE(greater_action);  //3
    #include BOOST_TYPEOF_END_REGISTRATION()
    int my_func2() { /*...*/}

This wouldn't break if the preprocessor counter doesn't reset between files,
but then the same type-of would get lots of Ids.

-- 
Daryle Walker
Mac, Internet, and Video Game Junkie
darylew AT hotmail DOT com