You can put all the native methods in one class.

But if you need 35 different classes with data, then I can not
see any way to avoid writing them.

Arne

I recommend SWIG. See www.swig.org. This is what I used to interface
to a proprietary C library for a server that we wanted to be in java.
SWIG would take the prototype above and create corresponding java
classes for where there is no natural mapping, e.g it would create a
class for stat.

Output from SWIG is in the form of two files, one is C glue to go into
a dynamic library, the other is the java class that contains all the
methods for the functions you want to call. Other java files are
created for the new classes it creates, like stat. Your java program
has to load the dynamic library first.

Regards,

Andrew Marlow

This is one of the uglier parts of Java.  It supports multiple inputs
to a method but only one output.

How to kludge?

one way is to return an array of double or array of objects.  You to
lose typing and keyword identification of results.

Another approach is to create a class with a number of internal
variables.  To use it you call setXXX to set each of the inputs, then
call calcXXX  to calculate.  Then call getXXX to get each of the
results.  This is the most Javaesque solution.

It is considered bad form to create result classes of scattered crap
that is not logically related.  

Have your method return a result, and if there is a problem throw an
exception, rather than returning a result and status as you would in
C.

Rethink your methods so that there are a small number of possible
result classes that have physical meaning.

They problem you are having is made worse if you try to write C in
Java, rather than thinking OO.

Well, firstly, are you aware that there is already a java binding of FUSE?

http://sourceforge.net/projects/fuse-j/

If you don't want to use that, or if this isn't what you're working on, to
answer your question, i'd do a straightforward conversion of the C
interface, and pass a writeable object from C to java, get java to write
into it, then copy back from the java object to the C one. Like so:

// java:

public class Stat {
    public int ino ;
    // etc
}

public interface Filesystem {
    public int getattr(String path, Stat sb) ;
}

public class FUSEManager {
    static {
        System.loadLibrary("fuse") ;
    }
    public static native void init(Filesystem fs) ;
}

// C:

/* error checking omitted for clarity! */

#define OK 0

JavaVM *jvm ; // JVM ref, get in a setup method

jobject fs ; // ref to a Filesystem object, get in a setup method
jclass fsClass ;
jmethodID getattrID ;

jclass statClass ;
jmethodID statCtorID ;
jfieldID statInoID ;
// etc for other fields

JNIEXPORT void JNICALL Java_FUSEManager_init(JNIEnv *env, jclass class, jobject _fs) {
    (*env)->GetJavaVM(env, &jvm) ;
    fs = (*env)->NewGlobalRef(env, _fs) ;
    jclass _fsClass = (*env)->GetObjectClass(env, fs) ;
    fsClass = (*env)->NewGlobalRef(env, _fsClass) ;
    getattrID = (*env)->GetMethodID(env, fsClass, "getattr", "(Ljava/lang/String;LStat;)I") ;
    jclass _statClass = (*env)->FindClass(env, "com/mypackage/Stat") ;
    statClass = (*env)->NewGlobalRef(env, _statClass) ;
    statCtorID = (*env)->GetMethodID(env, statClass, "<init>", "()V") ;
    statInoID = (*env)->GetFieldID(env, statClass, "ino", "I") ;
    // etc for other fields
}

void copyStatIn(JNIEnv *env, jobject statObj, struct stat *stat) {
    stat->st_ino = (*env)->GetIntField(env, statObj, statInoID) ;
    // etc for other fields
}

// would define a copyStatOut for setattr

int getattr(const char *path, struct stat *stat) {
    JNIEnv *env = NULL ;
    (*jvm)->AttachCurrentThread(jvm, &env, NULL) ;
    jstring pathStr = (*env)->NewStringUTF(env, path) ;
    jobject statObj = (*env)->NewObject(env, statClass, ctorID) ;
    /* i don't copy the struct into the object here - hope this is right */
    jint ret = (*env)->CallIntMethod(env, fs, getattrID, pathStr, statObj) ;
    /* don't copy back if call failed */
    if (ret == OK) copyStatIn(statObj, stat) ;
    /* don't think we need to release local refs explicitly before detach */
    (*jvm)->DetachCurrentThread(jvm) ;
    return ret ;
}

Does that make sense? This means defining one class per struct, plus one
copy-in method and one copy-out method, as needed. No need to write 35
different classes!

I've assumed that, despite what you said, the const char* parameter isn't
'returned' in any sense.

tom