This is merely duplicating what we already have in Indexer. If this is all the functionality you need, please use Indexer instead.

I'm using Indexer as you suggested, but maybe I'm missing something: isn't it the Indexers just a layer on top of array/buffer/pointer? Why are they accessing internal pointer structures using Unsafe, shouldn't the Indexers just call pointer.get()/pointer.put()?

Another example: I'm using the HDF5 JavaCPP preset and it takes and returns pointers objects, why I should wrap the pointer in an Indexer to access its data? I would like just to consider the pointer as a basic data storage (just like array or buffers), not a Indexer with a shape and indexing.

Yes, Indexer is basically a wrapper for arrays, buffers, and pointers, and we need to use sun.misc.Unsafe for arrays and buffers as well, it's not just a pointer thing...

I cannot find where Unsafe is used to access arrays or buffers: I'm looking at FloatArrayIndexerand FloatBufferIndexer for example, I guess I'm missing something obvious here

Another example: I'm using the HDF5 JavaCPP preset and it takes and returns pointers objects, why I should wrap the pointer in an Indexer to access its data? I would like just to consider the pointer as a basic data storage (just like array or buffers), not a Indexer with a shape and indexing.

That's what Pointer does, using JNI. How would you use sun.misc.Unsafe to access something like std::map<std::string,std::string>?

If you can do everything you need with Indexer though, what is the issue?

I cannot find where Unsafe is used to access arrays or buffers: I'm looking at FloatArrayIndexerand FloatBufferIndexer for example, I guess I'm missing something obvious here

https://github.com/bytedeco/javacpp/blob/master/src/main/java/org/bytedeco/javacpp/indexer/ByteArrayIndexer.java and we would also need it for Buffer if/when we decide to add optimizations to skip bounds checking, see issue #156.

OK, I see: for primitive pointers (whose element is a primitive in Java) we can actually use Unsafe for get() and put(), but for more complicated pointers (for any struct for example std::map<std::string,std::string>) I guess you need JNI because they might be aligned differently in different architectures? Did I understand correctly this is your point?

Right, the definition of classes like std::map<std::string,std::string> is implementation dependent, so we basically need to run C++ code to access them.

If you're just worried about creating an instance of Indexer, we could add those as static methods like FloatIndexer.get(FloatPointer p, int i), which would be a lot easier to maintain and I think would also make more sense.

I was actually more concerned from an architecture point of view: I see now Pointers in general have been created for the JavaCPP bridge purposes, so to account for structs/classes/unions in C++.
But in hindsight I was considering primitive Pointers being like a drop-in replacement of Java Buffers, so I expected them to be as fast as possible. What about creating a PrimitivePointer abstract class as a super class for all primitive pointers and have them use Unsafe for get()/put()?

And have Indexers just a layer on top of arrays/Buffers/Pointers/MemoryHandles/etc. for shaping and indexing purposes.
In fact Indexers are not really used to deal with structs/classes/unions from C++.

I'm repeating myself, but we need sun.misc.Unsafe for buffers and arrays as well. What you're proposing makes it harder to maintain. You could fork JavaCPP and maintain that if you want, but someone will need to maintain it and that person is not me.

Also, don't forget to consider what to do when sun.misc.Unsafe is not available.