Idiomatically deduce the system of an iterator from the internal pointer type

[correaa]

This question is about helping Thrust deduce the system of a custom iterator.

I have a custom iterator for which I want Thrust to determine its "system".

For example

template<class Ptr = int*>
struct MyIterator<Ptr> {
   using pointer = Ptr;
};

In principle, Thrust, by default, could look if the iterator has a pointer type inside and, if so, determine the system for it.

At the moment, I have to do this:

namespace thrust {
template<class Ptr>
struct iterator_system<MyIterator<Ptr> >{
        ...
	using pointer = typename ::thrust::iterator_system<
               Ptr //or typename std::iterator_traits<MyIterator<Ptr>::pointer>
       >::type;
};
}

This has two problems: one, it is very easy to get wrong (when MyIterator has many template parameters), and second, it introduces a hard dependency on Thrust, when Thrust could have deduced this.
Note that in principle, this could be transparent to the user (e.g., if Ptr is a thrust::pointer)

I could not achieve this in the primary template iterator_system and iterator_system_impl definitions, but I may be missing something.

Is there a better way than using the specialization above explicitly?
If not, could Thrust do this by default (i.e., deduce system from internal pointer)?

[bernhardmgruber]

I would be cautious to try to infer information on an iterator by inspecting the presence and properties of a nested It::pointer type.

For example, the system of an int* is host. So if you have a custom device iterator:

using pointer = int*;
pointer operator->() { .. }

thrust::iterator_system<cuda::std::iterator_traits<...>::pointer>, would tell me host, whereas your iterator would be intended to be a device iterator. Of course you could argue that then pointer should be thrust::pointer<int>, but users are not always consistent :)

I think your approach of specializing thrust::iterator_system is the right way. You could simplify it a bit:

namespace thrust {
  template<class Ptr>
  struct iterator_system<MyIterator<Ptr>> : iterator_system<Ptr> {};
}

[correaa]

Of course you could argue that then pointer should be thrust::pointer, but users are not always consistent

Exactly

I am proposing a default (or a way to get the right default). People (users) that are inconsistent are the ones that should need the specialization.

You could simplify it a bit…

Of course, it I did it in the complicated way to show how the main template could do it.

It seems that the main template, or its base has a void argument that could be used for this. (having the sensible default). I couldn't figure out what this void_t detection is really doing.