Downcasting of return values

[nyholku]

I've managed to hack together, compile and test POC for opencascade::handle and it seems to function in trivial cases: creating and passing classes and derived classes to OCC native API.

How should I go about going the other way? When the API returns an opencascade object (via opencascade::handle) I would like to downcast the object to the appropriate actual Java class so that instanceof etc work as expected.

The ancient jCAE SWIG interface uses something like this but I have not figured out how to inject something like this to the JavaCPP generated code. I'm not even sure if this it is feasible to do this on the Java side ... should this use some kind of adapter code on the C++ side...

    private static Object downcastImpl(long ptr, String cName, Class fallback) {
        Constructor ct = constructors.get(cName);
        try {
            if(ct == null) {
                // TODO: may be something about Handle_ prefix
                Class clazz;
                try {
                    clazz = Class.forName("occjava." + cName);
                } catch(ClassNotFoundException ex) {
                    clazz = fallback;
                }
                ct = clazz.getDeclaredConstructor(Long.TYPE, Boolean.TYPE);
                constructors.put(cName, ct);
            }
            return ct.newInstance(ptr, true);

        // TODO: replace with ReflectiveOperationException ?
        } catch(NoSuchMethodException ex) {
            ex.printStackTrace();
        } catch(InstantiationException ex) {
            ex.printStackTrace();
        } catch(IllegalAccessException ex) {
            ex.printStackTrace();
        } catch(InvocationTargetException ex) {
            ex.printStackTrace();
        }
        return null;
    }

PS It seems I somehow miss use this Discussions mechanism in github as I cannot mark any of my threads as answered...

[saudet]

We can easily do a reinterpret cast from anything to anything else with the constructors that accept a Pointer argument, like this one:
http://bytedeco.org/javacpp/apidocs/org/bytedeco/javacpp/BytePointer.html#BytePointer-org.bytedeco.javacpp.Pointer-
Or do you mean how to have it do that automatically? That's not something JavaCPP can do automatically right now, but you can provide your own helper methods for that, that's very straightforward. I'm not sure what your question is... Could you elaborate?

PS It seems I somehow miss use this Discussions mechanism in github as I cannot mark any of my threads as answered...

Don't mind, just do it when you figure it out :)

[saudet]

Like I keep telling you, that can't be done with the current state of JavaCPP. You'll need to do the downcasting manually from Java, provide some helper methods, etc. Unless of course you would like to make a contribution and make that work nicely, that would be great! You cannot expect me to do everything for you, unless there is money involved, obviously.

[nyholku]

Sorry I did not understood that.

I was convinced that there is such mechanism and that I was just too dump to figure it out. I am not expecting anyone to do anything, I was just looking for information how to do this because I was under the misapprehension that of course this sort of basic functionality would be there.

My bad.

I will have a look to see if this is something I could contribute.

As to money, we are both in the same boat, I'm doing this as labor of love to heltp to contribute modern Java bindings for OCC which is an amazing toolkit collection for doing CSG.

Thank you for your attention and time.

[saudet]

I was convinced that there is such mechanism and that I was just too dump to figure it out. I am not expecting anyone to do anything, I was just looking for information how to do this because I was under the misapprehension that of course this sort of basic functionality would be there.

It's not "basic functionality", none of the libraries listed here, except Qt, needs RTTI: https://github.com/bytedeco/javacpp-presets

And I keep telling you, we can very easily provide a couple of helper methods. Your downcastImpl() works pretty much as is with JavaCPP. Why is this unsatisfactory? Why do you need perfection? Unless you are willing to spend extraordinary amounts of energy and time in this, no solutions is every going to be perfect! Please be realistic in your expectations.

[nyholku]

I don't think we are communicating very effective and productively.

You keep saying that you keep telling me and I don't see what you are telling me.

For instance, what are those "easily provide a couple of helper methods" where are they?

Anyways, I'm not looking for perfection. But I do think that I want the users of OCC be able to do:

Geom_Gemoetry obj = SomeToolkit.someFunction();
if (obj instanceof Geom_Plane) {
   Geom_Plane asPlane = (Geom_Plane) obj;
   asPlane.foobar_from_Geom_Plane_Class();

instead of something like this:

Geom_Gemoetry obj = SomeToolkit.someFunction();
if (obj.DynamicType().name.equals("Geom_Plane))
     Geom_Plane geomObj = new Geom_Plane(obj.getPointer());
     asPlane.foobar_from_Geom_Plane_Class();

[saudet]

With your helper method downcastImpl() you could do something like downcastImpl(obj) instanceof Geom_Plane or put it as a non-static method like obj.downcastImpl() instanceof Geom_Plane, but you're saying that's not good enough, so, yes, you are seeking perfection. That's fine, but you need to keep your expectations in line with your resources, so to get perfection you'll need to increase the resources that you are willing to allocate into solving this problem. I also already told you that contributions are welcome. If you'd like to do that, I will be happy to assist you with issues that you may encounter in doing so, but you will need to show a little bit of effort on your part.

[nyholku]

Hi,

I took a stab at providing a new feature for JavaCPP that allows adding automatic downcasting if so desired.

This is very much WIP and a first stab and I could envision a lot of different ways to do that.

You can find the code here:

https://github.com/nyholku/javacpp/tree/feature/autodowncast

It is very simple.

I added a parameter downcast to @Adapter. The default value is false so it is downwards compatible (I hope) with any existing annotations.

Then I modified the code generation to generate a call to jobject createPointer(JNIEnv* env) in the adapter template class if the downcast value is true (instead of calling the JavaCPP_createPointer). If the parameter is false then the generated code is a before.

The user then needs to implement this method in the adapterd and do what ever it takes to dynamically downcast the pointer that the adapter hosts.

I'm in no way sure memory is managed correctly, but a trivial test case runs.

For OCC I've create an adapter template class, here:

https://github.com/nyholku/javacpp-occ/blob/master

specifically here:

https://github.com/nyholku/javacpp-occ/blob/master/src/occ-handle-adapter.hxx

There is a fake C++ OCC API included that uses the OCC class and calling convention here:

https://github.com/nyholku/javacpp-occ/blob/master/src/FakeOccDemoApi.hxx

and a Java demo that demonstrates calling an API function that returns calls with OCC handle to the native API and returns a downcast correct Java class from that call more or less automatically.

https://github.com/nyholku/javacpp-occ/blob/master/src/OccDowncastDemo.java

The build.sh is all over the place and only works on my machine without mods and it requires the OCC headers.

This is in no way representative how the OCC Java bindings should or perhaps will be done and structured, but the https://github.com/nyholku/javacpp-occ/blob/master/src/occ/TKernelConfig.java demonstrates how some of the fundamental OCC headers can be used as-is with my modified JavaCPP.

All comments are welcome.

(Also fixed an array subscript error in Parser IIRC.)

[saudet]

That's a step in the right direction, thanks! Please open a draft pull request with this instead of posting a new "answer" here though.

However, with your proposal, users need to code in JNI, and that's something I want to avoid. Since JNI is just a bad way of coding what should be done in Java anyway, what about letting the user write a method in Java, and use an annotation maybe like @Downcaster Base downcast() { /* custom user code in Java */ } that tells JavaCPP to call that method before returning a new object?