Re: [boost] About member extraction
Daryle Walker ha escrito:
But doesn't the PtrToMember template parameter already imply the
Type and Class parameters? So specifying all three would be
redundant. Could we reduce it by:
//
template typename PtrToMember
struct member_extractor
{
// Don't know if this is a real type-traits class
BOOST_STATIC_ASSERT(is_pointer_data_memberPtrToMember::value);
// The extractor traits classes aren't real (yet, maybe)
typedef get_class_typePtrToMember argument_type;
typedef get_member_typePtrToMember return_type;
return_type const operator ()( argument_type const c ) const
{ return c.*PtrToMember; }
return_type operator ()( argument_type c ) const
{ return c.*PtrToMember; }
};
Of the approaches you propose, this is the one that I like best, but
I'm afraid it cannot be implemented: Note that PtrToMember is a
*type* (something like int A::*), not a pointer to member.
member_extractor would have to defined as
template typename PtrToMember, PtrToMember ptr
struct member_extractor
and used as
member_extractorint A::*,A::x; // x is an int member of A
which takes us again to the redundancy we were trying to avoid.
Something in the way of eliminating this redundancy, however, would be
a boon. Maybe some metaprogramming gurus here can think of
something.
Joaquín M López Muñoz
Telefónica, Investigación y Desarrollo
___
Unsubscribe other changes: http://lists.boost.org/mailman/listinfo.cgi/boost
Re: [boost] About member extraction
Subject: Re: [boost] About member extraction
From: Joaquín Mª López Muñoz [EMAIL PROTECTED]
Date: Mon, 14 Jul 2003 14:24:37 +0200
To: Boost mailing list [EMAIL PROTECTED]
Daryle Walker ha escrito:
But doesn't the PtrToMember template parameter already imply the
Type and Class parameters? So specifying all three would be
redundant. Could we reduce it by:
//
template typename PtrToMember
struct member_extractor
{
// Don't know if this is a real type-traits class
BOOST_STATIC_ASSERT(is_pointer_data_memberPtrToMember::value);
// The extractor traits classes aren't real (yet, maybe)
typedef get_class_typePtrToMember argument_type;
typedef get_member_typePtrToMember return_type;
return_type const operator ()( argument_type const c ) const
{ return c.*PtrToMember; }
return_type operator ()( argument_type c ) const
{ return c.*PtrToMember; }
};
Of the approaches you propose, this is the one that I like best, but
I'm afraid it cannot be implemented: Note that PtrToMember is a
*type* (something like int A::*), not a pointer to member.
member_extractor would have to defined as
template typename PtrToMember, PtrToMember ptr
struct member_extractor
and used as
member_extractorint A::*,A::x; // x is an int member of A
Actually, I think it's worse (I don't have a C++ compiler with me right now:-( )
Something in the lines of:
template typename type, typename result, result type::* ptr
struct member_extractor
which takes us again to the redundancy we were trying to avoid.
Something in the way of eliminating this redundancy, however, would be
a boon. Maybe some metaprogramming gurus here can think of
something.
I would really love to see a solution to this ;-)
Best,
John
Joaquín M López Muñoz
Telefónica, Investigación y Desarrollo
___
Unsubscribe other changes: http://lists.boost.org/mailman/listinfo.cgi/boost
___
Unsubscribe other changes: http://lists.boost.org/mailman/listinfo.cgi/boost
Re: [boost] About member extraction
John Torjo ha escrito:
Subject: Re: [boost] About member extraction
From: Joaquín Mª López Muñoz [EMAIL PROTECTED]
Date: Mon, 14 Jul 2003 14:24:37 +0200
To: Boost mailing list [EMAIL PROTECTED]
Daryle Walker ha escrito:
But doesn't the PtrToMember template parameter already imply the
Type and Class parameters? So specifying all three would be
redundant. Could we reduce it by:
//
template typename PtrToMember
struct member_extractor
{
// Don't know if this is a real type-traits class
BOOST_STATIC_ASSERT(is_pointer_data_memberPtrToMember::value);
// The extractor traits classes aren't real (yet, maybe)
typedef get_class_typePtrToMember argument_type;
typedef get_member_typePtrToMember return_type;
return_type const operator ()( argument_type const c ) const
{ return c.*PtrToMember; }
return_type operator ()( argument_type c ) const
{ return c.*PtrToMember; }
};
Of the approaches you propose, this is the one that I like best, but
I'm afraid it cannot be implemented: Note that PtrToMember is a
*type* (something like int A::*), not a pointer to member.
member_extractor would have to defined as
template typename PtrToMember, PtrToMember ptr
struct member_extractor
and used as
member_extractorint A::*,A::x; // x is an int member of A
Actually, I think it's worse (I don't have a C++ compiler with me right now:-( )
Something in the lines of:
template typename type, typename result, result type::* ptr
struct member_extractor
Actually, extracting A and int from int A::* is easy:
#include boost/static_assert.hpp
#include boost/type_traits.hpp
using namespace std;
struct A
{
int x;
};
template typename PtrToMember
struct ptr_to_member_descriptor;
template typename Class,typename Member
struct ptr_to_member_descriptorMember Class::*
{
typedef Class class_type;
typedef Member member_type;
};
int main()
{
BOOST_STATIC_ASSERT((
boost::is_same
ptr_to_member_descriptorint A::*::class_type,
A::value));
BOOST_STATIC_ASSERT((
boost::is_same
ptr_to_member_descriptorint A::*::member_type,
int::value));
return 0;
}
The really hard part is how to obtain int A::* from A::x. I don't
think this is possible, but then again people here sometimes do magic :)
Joaquín M López Muñoz
Telefónica, Investigación y Desarrollo
___
Unsubscribe other changes: http://lists.boost.org/mailman/listinfo.cgi/boost
[boost] About member extraction
In another thread, by Joaquín M López Muñoz, there is talk of a helper
class like:
//
template
class Class,typename Type,
Type Class::*PtrToMember,
typename Compare=std::lessType
struct less_by
{
less_by(const Compare comp=Compare()):comp(comp){}
bool operator()(const Class x,const Class y)const
{
return comp(x.*PtrToMember,y.*PtrToMember);
}
bool operator()(const Type x,const Class y)const
{
return comp(x,y.*PtrToMember);
}
bool operator()(const Class x,const Type y)const
{
return comp(x.*PtrToMember,y);
}
private:
Compare comp;
};
//
[That was cut from the multindex trial code.] The author later
decided to segregate the extraction from the comparison. No code has
been given yet, but that class could be like:
//
template
class Class,typename Type,
Type Class::*PtrToMember
struct member
{
Type const operator ()( Class const c ) const
{ return c.*PtrToMember; }
Type operator ()( Class c ) const
{ return c.*PtrToMember; }
};
//
But doesn't the PtrToMember template parameter already imply the
Type and Class parameters? So specifying all three would be
redundant. Could we reduce it by:
//
template typename PtrToMember
struct member_extractor
{
// Don't know if this is a real type-traits class
BOOST_STATIC_ASSERT(is_pointer_data_memberPtrToMember::value);
// The extractor traits classes aren't real (yet, maybe)
typedef get_class_typePtrToMember argument_type;
typedef get_member_typePtrToMember return_type;
return_type const operator ()( argument_type const c ) const
{ return c.*PtrToMember; }
return_type operator ()( argument_type c ) const
{ return c.*PtrToMember; }
};
//
Or we can simplify the type extraction, at the cost/gain of needing to
specify the exact member at construction time by:
//
template class Class, typename Type
class member_extractor
{
public:
typedef Class argument_type;
typedef Type return_type;
typedef Type Class::* member_type;
explicit member_extractor( member_type m )
: member_( m ) {}
return_type const operator ()( argument_type const c ) const
{ return c.*member_; }
return_type operator ()( argument_type c ) const
{ return c.*member_; }
member_type get_member() const
{ return this-member_; }
private:
member_type member_;
};
//
Daryle
___
Unsubscribe other changes: http://lists.boost.org/mailman/listinfo.cgi/boost
