I've never used boost::type_traits personally, but I would think it
would work. Not sure though. If not, you could define a template and
then specialize accordingly. I gave it a try, thinking most STL
iterators would be derived from std::iterator:
#include <iterator>
template < typename Type >
struct is_iterator_type
{
enum { value = false };
};
template < class Category, class Type, class Distance, class Pointer,
class Reference >
struct is_iterator_type< std::iterator< Category, Type, Distance,
Pointer, Reference > >
{
enum { value = true };
};
template < typename Type >
struct is_iterator_type< Type* >
{
enum { value = true };
};
template < typename Type >
struct is_iterator_type< Type const* >
{
enum { value = true };
};
/*
Helper function that deduces the type of some value
*/
template < typename Type >
inline bool is_iterator( Type const& )
{
return is_iterator_type< Type >::value;
}
/.. [snip]
Unfortunately, the assertion failed on the container iterators. So you
would need to specialize is_iterator_type for every possibility. And
as far as detected a container type, again, neither do these have a
common base class, so you would have to define and specialize a
template for every know type.
I've never used boost::type_traits personally, but I would think it
would work. Not sure though. If not, you could define a template and
then specialize accordingly. I gave it a try, thinking most STL
iterators would be derived from std::iterator:#include <iterator>template < typename Type >
struct is_iterator_type
{
enum { value = false };
template < class Category, class Type, class Distance, class Pointer,
class Reference >
struct is_iterator_type< std::iterator< Category, Type, Distance,
Pointer, Reference > >
{
enum { value = true };
template < typename Type >
struct is_iterator_type< Type* >
{
enum { value = true };
template < typename Type >
struct is_iterator_type< Type const* >
{
enum { value = true };
/*
Helper function that deduces the type of some value
*/
template < typename Type >
inline bool is_iterator( Type const& )
{
return is_iterator_type< Type >::value;
/.. [snip]Unfortunately, the assertion failed on the container iterators. So you
would need to specialize is_iterator_type for every possibility. And
as far as detected a container type, again, neither do these have a
common base class, so you would have to define and specialize a
template for every know type.
This seems a bit complicated, it is easier using SFINAE on
type_trait<T>::iterator_category.
I mean std::iterator_traits said:template<typename T>
class is_iterator{
private:
typedef char hasItTrait;
typedef struct { char a[2]; } hasNotItTrait;
static hasItTrait test( int ,
std::iterator_traits<T>::iterator_category=std::iterator_traits<T>::iterator_category
());
static HasNotItTrait test(...);
public:
static const bool value = sizeof(is_iterator<T>::test(0)) == sizeof
(hasItTrait);
};
Not tested but it should work well enough.
[snip]Michael, after staring at your code for a while it finally occured to
me what you were getting at (except for the padded struct bit). Quite
ingenious, actually. So I put together something I thought should
work, and indeed it does detect iterators perfectly. Unfortunately,
gcc appears not to be handling SFINAE correctly, and when I pass along
a non-iterator I get an error! Am I doing something wrong here?
Want to reply to this thread or ask your own question?
You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.