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.