From: "Ovanes Markarian" <om_boost@keywallet.com >

Hello all,

I am trying to specialize boost::is_pointer so, that it can determine if a type is a pointer
wrapper (shared_ptr, auto_ptr, weak_ptr).

Does anybody has ideas how this can be done? May be it would be possible to handle if e.g. one can
determine if a class/struct has some typedef inside:



You can make a template to detect typedefs - I wrote a has_value_type<T> for value_type.  In my case I needed to know if the underlying type was char or wchar_t, so I ended up with a recursive thing that would even resolve things like a 'list of vectors of strings', etc.



Somehow I am not certain if I am on the right path. My problem is that I have a variant container
type with different types. One could access a value using -> operator. The operator returns the
pointer to the value. But if this value is a pointer (that can be determined by boost::is_pointer
type trait) it should return the pointer and not pointer to pointer value. Now what happens if I
store shared_ptr or any other type which overload -> operator? This will result in compiler error,
because the compiler tries to access member of the pointer to pointer and not of the pointer
instance.


You can also write a has_specific_member_function<T>, and thus I suspect you could also do it for operator->().  I think it depends on whether you can take a member function pointer to an operator function.


google for has_foo, or try http://groups.google.com/group/comp.lang.c++.moderated/browse_frm/thread/a69f4423b407b1ab/0814dfec14027822?lnk=st&q=has_foo&rnum=1#0814dfec14027822

 

Is there may be a way to determine if the member access operator is overloaded? What if ->
operator is defined in the base? And what if child class inherits base as protected or private?

Haven't tried any variations on public/protected/private - I suspect that you need to have a template that checks publicly, then another that checks for protected (I suspect that version of has_arrow_op<T> would probably need to derive from T) and I doubt you could tell the difference between a class that doesn't have ->, and a class that has a private ->.  But I doubt you would want to know - if it doesn't have a callable ->, then you should probably act like it doesn't have one at all - ie it doesn't want you to think of it as a pointer.

The other solution would be to force every user to write a specialized class is_pointer for every
type stored in variant, but this would be not so nice.


With Kind Regards,

Ovanes Markarian


Tony