add static field get. added lucene example

Author: joeferner

examples/lucene/example.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+var java = require("../../");
+java.classpath.push("lucene-core-3.5.0.jar");
+
+var idx = java.newInstanceSync("org.apache.lucene.store.RAMDirectory");
+var version = java.getStaticFieldValue("org.apache.lucene.util.Version", "LUCENE_CURRENT");
+var analyzer = java.newInstanceSync("org.apache.lucene.analysis.standard.StandardAnalyzer", version);
+var writerConfig = java.newInstanceSync("org.apache.lucene.index.IndexWriterConfig", version, analyzer);
+var writer = java.newInstanceSync("org.apache.lucene.index.IndexWriter", idx, writerConfig);
+
+writer.addDocumentSync(createDocument("Theodore Roosevelt",
+  "It behooves every man to remember that the work of the " +
+  "critic, is of altogether secondary importance, and that, " +
+  "in the end, progress is accomplished by the man who does " +
+  "things."));
+writer.addDocumentSync(createDocument("Friedrich Hayek",
+  "The case for individual freedom rests largely on the " +
+  "recognition of the inevitable and universal ignorance " +
+  "of all of us concerning a great many of the factors on " +
+  "which the achievements of our ends and welfare depend."));
+writer.addDocumentSync(createDocument("Ayn Rand",
+  "There is nothing to take a man's freedom away from " +
+  "him, save other men. To be free, a man must be free " +
+  "of his brothers."));
+writer.addDocumentSync(createDocument("Mohandas Gandhi",
+  "Freedom is not worth having if it does not connote " +
+  "freedom to err."));
+
+writer.closeSync();
+
+var searcher = java.newInstanceSync("org.apache.lucene.search.IndexSearcher", idx);
+
+search(searcher, "freedom");
+search(searcher, "free");
+search(searcher, "progress or achievements");
+
+searcher.closeSync();
+
+function createDocument(title, content) {
+  var fieldStoreYes = java.callStaticMethodSync("org.apache.lucene.document.Field$Store", "valueOf", "YES");
+  var fieldIndexAnalyzed = java.callStaticMethodSync("org.apache.lucene.document.Field$Index", "valueOf", "ANALYZED");
+  var doc = java.newInstanceSync("org.apache.lucene.document.Document");
+  doc.addSync(java.newInstanceSync("org.apache.lucene.document.Field", "title", title, fieldStoreYes, fieldIndexAnalyzed));
+  doc.addSync(java.newInstanceSync("org.apache.lucene.document.Field", "content", content, fieldStoreYes, fieldIndexAnalyzed));
+  return doc;
+}
+
+function search(searcher, queryString) {
+  var query = java.callStaticMethodSync("org.apache.lucene.queryParser.QueryParser", "parse", queryString);
+  var topDocs = searcher.search(query, 10);
+
+  console.log(topDocs);
+  console.log("Found " + topDocs.totalHits + " hits for query " + queryString + ".")
+  for(var i=0; i<topDocs.totalHits; i++) {
+    var docId = topDocs.scoreDocs[i].doc;
+    var doc = searcher.doc(docId);
+    console.log((i + 1) + ". " + doc.get("title"));
+  }
+}

examples/lucene/lucene-core-3.5.0.jar

@@ -21,6 +21,7 @@
   NODE_SET_PROTOTYPE_METHOD(s_ct, "callStaticMethodSync", callStaticMethodSync);
   NODE_SET_PROTOTYPE_METHOD(s_ct, "newArray", newArray);
   NODE_SET_PROTOTYPE_METHOD(s_ct, "newByte", newByte);
+  NODE_SET_PROTOTYPE_METHOD(s_ct, "getStaticFieldValue", getStaticFieldValue);
 
   target->Set(v8::String::NewSymbol("Java"), s_ct->GetFunction());
 }
@@ -137,6 +138,17 @@ v8::Handle<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
   }
   std::list<jobject> constructors = javaReflectionGetConstructors(env, clazz);
   jobject method = javaFindBestMatchingConstructor(env, constructors, methodArgTypes);
+  if(method == NULL) {
+    std::ostringstream errStr;
+    errStr << "Could not find constructor";
+    v8::Handle<v8::Value> error = javaExceptionToV8(env, errStr.str());
+
+    v8::Handle<v8::Value> argv[2];
+    argv[0] = error;
+    argv[1] = v8::Undefined();
+    v8::Function::Cast(*callback)->Call(v8::Context::GetCurrent()->Global(), 2, argv);
+    return v8::Undefined();
+  }
 
   // run
   NewInstanceBaton* baton = new NewInstanceBaton(self, clazz, method, methodArgs, callback);
@@ -155,6 +167,7 @@ v8::Handle<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
   JNIEnv* env = self->getJavaEnv();
 
   int argsEnd = args.Length();
+  int argsStart = 0;
 
   // argument - className
   if(args.Length() < 1 || !args[0]->IsString()) {
@@ -163,9 +176,10 @@ v8::Handle<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
   v8::Local<v8::String> classNameObj = v8::Local<v8::String>::Cast(args[0]);
   v8::String::AsciiValue classNameVal(classNameObj);
   std::string className = *classNameVal;
+  argsStart++;
 
 	std::list<int> methodArgTypes;
-  jarray methodArgs = v8ToJava(env, args, 1, argsEnd, &methodArgTypes);
+  jarray methodArgs = v8ToJava(env, args, argsStart, argsEnd, &methodArgTypes);
 
   jclass clazz = javaFindClass(env, className);
   if(clazz == NULL) {
@@ -175,6 +189,11 @@ v8::Handle<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
   }
   std::list<jobject> constructors = javaReflectionGetConstructors(env, clazz);
   jobject method = javaFindBestMatchingConstructor(env, constructors, methodArgTypes);
+  if(method == NULL) {
+    std::ostringstream errStr;
+    errStr << "Could not find constructor";
+    return ThrowException(javaExceptionToV8(env, errStr.str()));
+  }
 
   // run
   v8::Handle<v8::Value> callback = v8::Object::New();
@@ -412,3 +431,53 @@ v8::Handle<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
 
   return scope.Close(JavaObject::New(self, newObj));
 }
+
+/*static*/ v8::Handle<v8::Value> Java::getStaticFieldValue(const v8::Arguments& args) {
+  v8::HandleScope scope;
+  Java* self = node::ObjectWrap::Unwrap<Java>(args.This());
+  v8::Handle<v8::Value> ensureJvmResults = self->ensureJvm();
+  if(!ensureJvmResults->IsUndefined()) {
+    return ensureJvmResults;
+  }
+  JNIEnv* env = self->getJavaEnv();
+
+  // argument - className
+  if(args.Length() < 1 || !args[0]->IsString()) {
+    return ThrowException(v8::Exception::TypeError(v8::String::New("Argument 0 must be a string")));
+  }
+  v8::Local<v8::String> classNameObj = v8::Local<v8::String>::Cast(args[0]);
+  v8::String::AsciiValue classNameVal(classNameObj);
+  std::string className = *classNameVal;
+
+  // argument - field name
+  if(args.Length() < 2 || !args[1]->IsString()) {
+    return ThrowException(v8::Exception::TypeError(v8::String::New("Argument 1 must be a string")));
+  }
+  v8::Local<v8::String> fieldNameObj = v8::Local<v8::String>::Cast(args[1]);
+  v8::String::AsciiValue fieldNameVal(fieldNameObj);
+  std::string fieldName = *fieldNameVal;
+
+  // find the class
+  jclass clazz = javaFindClass(env, className);
+  if(clazz == NULL) {
+    std::ostringstream errStr;
+    errStr << "Could not create class " << className.c_str();
+    return ThrowException(javaExceptionToV8(env, errStr.str()));
+  }
+
+  // get the field
+  jobject field = javaFindField(env, clazz, fieldName);
+  if(field == NULL) {
+    std::ostringstream errStr;
+    errStr << "Could not find field " << fieldName.c_str() << " on class " << className.c_str();
+    return ThrowException(javaExceptionToV8(env, errStr.str()));
+  }
+
+  // get field value
+  jclass fieldClazz = env->FindClass("java/lang/reflect/Field");
+  jmethodID field_get = env->GetMethodID(fieldClazz, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
+  jobject val = env->CallObjectMethod(field, field_get, NULL);
+
+  return scope.Close(JavaObject::New(self, val));
+}
+

src/java.cpp

@@ -25,6 +25,7 @@ class Java : public node::ObjectWrap {
   static v8::Handle<v8::Value> callStaticMethodSync(const v8::Arguments& args);
   static v8::Handle<v8::Value> newArray(const v8::Arguments& args);
   static v8::Handle<v8::Value> newByte(const v8::Arguments& args);
+  static v8::Handle<v8::Value> getStaticFieldValue(const v8::Arguments& args);
   v8::Handle<v8::Value> ensureJvm();
 
   static v8::Persistent<v8::FunctionTemplate> s_ct;

src/java.h

@@ -109,6 +109,8 @@ void NewInstanceBaton::execute(JNIEnv *env) {
   jclass constructorClazz = env->FindClass("java/lang/reflect/Constructor");
   jmethodID constructor_newInstance = env->GetMethodID(constructorClazz, "newInstance", "([Ljava/lang/Object;)Ljava/lang/Object;");
 
+  //printf("invoke: %s\n", javaObjectToString(env, m_method).c_str());
+
   jobject result = env->CallObjectMethod(m_method, constructor_newInstance, m_args);
   m_resultType = TYPE_OBJECT;
   m_result = env->NewGlobalRef(result);
@@ -124,6 +126,14 @@ void StaticMethodCallBaton::execute(JNIEnv *env) {
 
   jclass returnType = (jclass)env->CallObjectMethod(m_method, method_getReturnType);
 
+  /*
+  printf("calling %s\n", javaObjectToString(env, m_method).c_str());
+  printf("arguments\n");
+  for(int i=0; i<env->GetArrayLength(m_args); i++) {
+    printf("  %s\n", javaObjectToString(env, env->GetObjectArrayElement((jobjectArray)m_args, i)).c_str());
+  }
+  */
+
   m_resultType = javaGetType(env, returnType);
   jobject result = env->CallObjectMethod(m_method, method_invoke, NULL, m_args);
   m_result = env->NewGlobalRef(result);

src/methodCallBaton.cpp

@@ -74,6 +74,7 @@ jobject javaFindBestMatchingMethod(
   const char *methodName,
   std::list<int>& argTypes) {
 
+  std::list<jobject> possibleMatches;
   jclass methodClazz = env->FindClass("java/lang/reflect/Method");
   jmethodID method_getNameMethod = env->GetMethodID(methodClazz, "getName", "()Ljava/lang/String;");
   jmethodID method_getParameterTypes = env->GetMethodID(methodClazz, "getParameterTypes", "()[Ljava/lang/Class;");
@@ -83,10 +84,25 @@ jobject javaFindBestMatchingMethod(
     if(itMethodName == methodName) {
       jarray parameters = (jarray)env->CallObjectMethod(*it, method_getParameterTypes);
       if(env->GetArrayLength(parameters) == (jsize)argTypes.size()) {
-        return *it; // TODO: check parameters
+        possibleMatches.push_back(*it);
       }
     }
   }
+
+  if(possibleMatches.size() == 0) {
+    return NULL;
+  }
+  if(possibleMatches.size() == 1) {
+    return possibleMatches.front();
+  } else {
+    // TODO: argument match
+    printf("javaFindBestMatchingMethod: multiple matches (choosing the first)\n");
+    for(std::list<jobject>::iterator it = possibleMatches.begin(); it != possibleMatches.end(); it++) {
+      printf("  %s\n", javaObjectToString(env, *it).c_str());
+    }
+    return possibleMatches.front();
+  }
+
   return NULL;
 }
 
@@ -95,15 +111,31 @@ jobject javaFindBestMatchingConstructor(
   std::list<jobject>& constructors,
   std::list<int>& argTypes) {
 
+  std::list<jobject> possibleMatches;
   jclass constructorClazz = env->FindClass("java/lang/reflect/Constructor");
   jmethodID constructor_getParameterTypes = env->GetMethodID(constructorClazz, "getParameterTypes", "()[Ljava/lang/Class;");
 
   for(std::list<jobject>::iterator it = constructors.begin(); it != constructors.end(); it++) {
     jarray parameters = (jarray)env->CallObjectMethod(*it, constructor_getParameterTypes);
     if(env->GetArrayLength(parameters) == (jsize)argTypes.size()) {
-      return *it; // TODO: check parameters
+      possibleMatches.push_back(*it);
+    }
+  }
+
+  if(possibleMatches.size() == 0) {
+    return NULL;
+  }
+  if(possibleMatches.size() == 1) {
+    return possibleMatches.front();
+  } else {
+    // TODO: argument match
+    printf("javaFindBestMatchingConstructor: multiple matches (choosing the first)\n");
+    for(std::list<jobject>::iterator it = possibleMatches.begin(); it != possibleMatches.end(); it++) {
+      printf("  %s\n", javaObjectToString(env, *it).c_str());
     }
+    return possibleMatches.front();
   }
+
   return NULL;
 }
 
@@ -148,18 +180,53 @@ jclass javaFindClass(JNIEnv* env, std::string className) {
   return clazz;
 }
 
+jobject javaFindField(JNIEnv* env, jclass clazz, std::string fieldName) {
+  jclass clazzclazz = env->GetObjectClass(clazz);
+  jclass fieldClazz = env->FindClass("java/lang/reflect/Field");
+  jmethodID field_getName = env->GetMethodID(fieldClazz, "getName", "()Ljava/lang/String;");
+  jmethodID class_getFields = env->GetMethodID(clazzclazz, "getFields", "()[Ljava/lang/reflect/Field;");
+  jobjectArray fieldObjects = (jobjectArray)env->CallObjectMethod(clazz, class_getFields);
+
+  jsize fieldCount = env->GetArrayLength(fieldObjects);
+  for(jsize i=0; i<fieldCount; i++) {
+    jobject field = env->GetObjectArrayElement(fieldObjects, i);
+    std::string fieldName = javaToString(env, (jstring)env->CallObjectMethod(field, field_getName));
+    if(strcmp(fieldName.c_str(), fieldName.c_str()) == 0) {
+      return field;
+    }
+  }
+
+  return NULL;
+}
+
 jobject v8ToJava(JNIEnv* env, v8::Local<v8::Value> arg, int *methodArgType) {
+  if(arg->IsNull()) {
+    return NULL;
+  }
+
   if(arg->IsString()) {
     *methodArgType = TYPE_STRING;
     v8::String::AsciiValue val(arg->ToString());
     return env->NewStringUTF(*val);
-  } else if(arg->IsInt32()) {
+  }
+
+  if(arg->IsInt32()) {
     jint val = arg->ToInt32()->Value();
     *methodArgType = TYPE_INT;
     jclass clazz = env->FindClass("java/lang/Integer");
     jmethodID constructor = env->GetMethodID(clazz, "<init>", "(I)V");
     return env->NewObject(clazz, constructor, val);
-  } else if(arg->IsObject()) {
+  }
+
+  if(arg->IsBoolean()) {
+    jboolean val = arg->ToBoolean()->Value();
+    *methodArgType = TYPE_BOOLEAN;
+    jclass clazz = env->FindClass("java/lang/Boolean");
+    jmethodID constructor = env->GetMethodID(clazz, "<init>", "(Z)V");
+    return env->NewObject(clazz, constructor, val);
+  }
+
+  if(arg->IsObject()) {
     v8::Local<v8::Object> obj = v8::Object::Cast(*arg);
     v8::String::AsciiValue constructorName(obj->GetConstructorName());
     if(strcmp(*constructorName, "JavaObject") == 0) {

src/utils.cpp

@@ -35,6 +35,7 @@ JNIEnv* javaAttachCurrentThread(JavaVM* jvm);
 void javaDetachCurrentThread(JavaVM* jvm);
 jvalueType javaGetType(JNIEnv *env, jclass type);
 jclass javaFindClass(JNIEnv* env, std::string className);
+jobject javaFindField(JNIEnv* env, jclass clazz, std::string fieldName);
 jarray v8ToJava(JNIEnv* env, const v8::Arguments& args, int start, int end, std::list<int> *methodArgTypes);
 jobject v8ToJava(JNIEnv* env, v8::Local<v8::Value> arg, int *methodArgType);
 v8::Handle<v8::Value> javaExceptionToV8(JNIEnv* env, const std::string& alternateMessage);