How to use JavaCPP to Create an Object Instance for an Abstract C++ Class associated with a Win32 DLL?

[cartel1]

1. I have a win32 DLL and its header file
2. The header file contains the declaration of an abstract C++ class (all pure virtual functions with no constructors).
3. The header file also contains a declared function pointer for a function in the DLL that when assigned with the address of the function and invoked, will create and return the C++ object instance to invoke the functions of the related abstract class.
4. A section of the header file looks like this:

class MyInterface
{
public:

virtual int Connect(LPCSTR server) =0;
virtual int Disconnect() =0;
virtual int IsConnected() =0;
virtual int Login(const int login,LPCSTR password)=0;
virtual int LoginSecured(LPCSTR key_path) =0;
...
};

typedef int (*InterfaceVersion_t)(void);
typedef int (*CreateInterface)(int version,MyInterface**my_interface);

I'm new to JavaCPP and have managed to use it to generate the peer Java mapping classes for the header file of the win32 DLL, but I have no idea how to use JavaCPP to reference the address of the CreateInterface function on the win32 DLL and assign it to the C++ *CreateInterface function pointer variable for it to be invoked to create and return a reference to a MyInterface object instance.

JavaCPP generated the peer Java FunctionPointer class of the C++ CreateInterface function pointer. The generated FunctionPointer class has a public native int call(int version, @cast(MyInterface*) PointerPointer my_interface) method for the C++ CreateInterface function pointer variable, but I'm not sure what to do from there to invoke the public native int call(int version, @cast(MyInterface*) PointerPointer my_interface) method such that a Java MyInterface object reference can be returned and accessed in its PointerPointer output variable.

If someone can advise on how to get this working, I'd really appreciate it. Thank you.

[saudet]

Your CreateInterface is just a typedef, it's not a variable or anything we can actually call. You'll need to consult the API and figure out first how to use it from C++.

[cartel1]

You are correct about the typedef.

The full header file details has another class declaration with inline functions. One of those inline functions is used to create the MyInterface object reference, but it actually does this based on the implementation summary shown below:

inline MyInterface * CreateMyInterface(const int version) const {
HMODULE dll_lib = ::LoadLibraryA("interface_win32.dll");
CreateInterface pCreateInterfce = reinterpret_cast(::GetProcAddress(dll_lib, "CreateInterface "));
MyInterface *myInterface = NULL;
(*pCreateInterfce)(version, &myInterface);
return myInterface;
}

The problem is that calling this function is not working. Basically, the returned myInterface variable is null. Note that the interface_win32.dll file is placed in all the required places for it to be found and loaded, but it's not working out. This could be for various reasons which I can elaborate on in another discussion thread. For now, I would prefer an alternative option to calling the above mentioned function. i.e. - if javacpp can be used to do what the above mentioned function is doing to create the MyInterface object reference, that would be great.

I'm looking at alternative solutions, but I would like to know if what I am trying to achieve can be done using javacpp.

Thanks.

[saudet]

JavaCPP just wraps C++, so it can be done. If allocation fails it's most likely unrelated to JavaCPP.

[cartel1]

I agree.

[cartel1]

I solved this problem by creating a C wrapper 64 bit DLL for the target Win 64 bit DLL variant of the Win 32 bit DLL. Then, I used the jextract tool to create Java FFM (Foreign Function and Memory) bindings that allowed me to interact with the target Win 64 bit DLL.

The limitation encountered when trying to directly interface with both target 32 bit and 64 bit DLLs was that 64 bit JVMs are now not supporting 32 bit DLLs and both DLLs are using __stdcall function call standard which is not supported by Java/Java FFM. Therefore, it was necessary to create the wrapper DLL which uses __cdecl function call standard which allowed Java to indirectly integrate with the target DLL.

Also, a C wrapper DLL was created for the target DLL because the jextract tool does not currently support generating Java bindings from C++ header files. It currently only supports C header files.