C++'s out parameter object creation and JNA

[Nathan Barraille]

Hello,

Disclaimer: I ignore pretty much everything about C++, so I hope I'm not saying stupid things here, if I am, please feel free to correct me.

As a Java developer, when I want to create a new object, I use a constructor method that will allocate this object in memory and return a handle on it for me, and I will store this handle in a variable, I do it like this.

Foo o = new Foo();

But in C++, I've been given to understand, that despite the fact it is possible to do so

Foo createFoo(){ Foo f; f.doSomething(); return f; } // ... Foo f = createFoo();

I can also define a handle by myself, and then call a initializer on it that will allocate memory and bind the handle on it, like this:

void initializeFoo(Foo **f){ f.doSomething(); return; } // ... Foo f; initializeFoo(&f);

So my question is, what happens when we want to use those C++ methods in Java, with JNA?

Let's suppose I have the following C++ header:

typedef struct Foo f; Foo createFoo(); void initializeFoo(Foo **f);

As I don't have any idea on what a Foo is, or what the Foo structure contains, I'm just going to create a JNA PointerType to declare my structure:

public class Foo extends PointerType{

    public Foo(Pointer address) {
        super(address);
    }
    public Foo() {
        super();
    }
}

Using the createFoo method should be pretty easy as well:

public class TestFoo{
    static{
        System.loadLibrary("foolib");
    }

    public static void main(String[] args){
        FooLib lib = (FooLib)Native.loadLibrary("foolib", FooLib.class);

        Foo f = lib.createFoo();
    }

Right?

But my question is, how can I use the initializeFoo function??? I suppose I would have to create a Pointer and give it to the function, but how do I create a non NULL pointer in JNA? I tried the following code, but it results in an EXCEPTION_ACCESS_VIOLATION.

public class TestFoo{
    static{
        System.loadLibrary("foolib");
    }

    public static void main(String[] args){
        FooLib lib = (FooLib)Native.loadLibrary("foolib", FooLib.class);

        Foo f = new Foo();
        lib.initializeFoo(f); // EXCEPTION_ACCESS_VIOLATION
        lib.initializeFoo(f.getPointer()); // EXCEPTION_ACCESS_VIOLATION
    }

Any idea?

Thanks!

[Rob Spoor]

You Java Foo matches a Foo*. Your method requires a Foo**. So you must get a Pointer to the Foo instance. I think that requires a PointerByReference.

If not then perhaps this piece of the Javadoc of Structure.getPointer() may help you out:

Note that if you use the structure's pointer as a function argument, you are responsible for calling write() prior to the call and read() after the call. These calls are normally handled automatically by the Function object when it encounters a Structure argument or return value.

[Nathan Barraille]

Thank you Rob.

Using a PointerByReference did the trick!

[Rob Spoor]

You're welcome