3/14 We have this licenced proprietary C++ library but no source, just
a dynamicaly-linked library and the .h file. We have some C++ code
that calls the library. I'd like to be able to call this closed-source
library from within Java. Since I already know how to call its
functions, can I just use System.loadLibrary("Proprietry"); to access
this library, or do I have to make a seperate C++->Java wrapper using
say JNI?
\_ You have to write some JNI wrappers. There's special code on
both the Java side and the C side to make JNI work. (Unless, of
course, they have some JNI wrappers included. Look for .java or
.class files.) -jrleek
\_ They have no Java wrappers and are out of business. I guess
I know my next project...
\_ Well, first, make sure their libraries were compiled with
the same compiler as your JVM. If it's Sun's JVM on
linux, it's gcc. In order to work with Sun's JVM, the
library needs to have been compiled with gcc, or icc 8.1
or later. Another possibility for an earlier version of
icc is Jrocket. -jrleek
\_ Presuming their libraries are compiled with some old wierd
obsolete compiler, if I make a JNI wrapper (in C++) for
their code and compile it with the right compiler, will I
be able to call my wrapper from Java? Or are we screwed?
\_ You are very likely screwed. Wierd stuff can happen
if your C++ compilers are not binary compatiable.
Although you may get lucky. In my experience
linking gcc compiled JNI with an icc 8.0 library,
everything was cool as long as the library didn't
throw an exception. If an exception was thrown,
everything always crashed. No matter who threw the
exception or from where or who was supposed to
catch it. Java can be touchy. -jrleek
\_ It's even worse. If it's not the same compiler /with
the same options when you compile/ you're probably
out of luck. -emarkp
\_ We have in-house C++ code that calls this old
library just fine when compiled with (I think)
the MSFT compiler. If I compile my JNI wrapper
with the same compiler, shouldn't that also work?
This funky library just sits there processing
input data and never throws exceptions.
\_ If I may make an architectural suggestion,
I believe that you shouldn't be utilizing
JNI to call this library. Instead, I believe
that you should utilize CORBA and write a
wrapper around your library in that fashion.
This is especially relevant if you plan on
utilizing this library in the future. I realize
that this may be a performance hit. Again,
use best judgement given time/performance/etc.
Just a suggestion.
\_ It might work out for you then. I'm pretty
sure the JNI on windows is compiled with
the MSFT compiler. I can't really say
though. I'm niether a C++ or windows
guru. -jrleek
\_ If that works, then, in the worst case, you
should be able to write a pure C wrapper
on the C++ code, compile the wrapper with
VC++, call the C wrapper in your JNI layer
and compile the JNI stuff using another
compiler. |