Merge JavaCall changes from zot branch

Author: mkitti

src/JavaCall.jl

@@ -9,9 +9,10 @@ end
 
 export JavaObject, JavaMetaClass,
        jint, jlong, jbyte, jboolean, jchar, jshort, jfloat, jdouble,
-       JObject, JClass, JMethod, JString,
+       JObject, JClass, JMethod, JConstructor, JField, JString,
        @jimport, jcall, jfield, isnull,
        getname, getclass, listmethods, getreturntype, getparametertypes, classforname,
+       listfields, gettype,
        narrow
 
 # using Compat, Compat.Dates

src/convert.jl

@@ -3,6 +3,26 @@ convert(::Type{Ptr{Nothing}}, obj::JavaObject{T}) where T = Ptr(obj)
 convert(::Type{JString}, str::AbstractString) = JString(str)
 convert(::Type{JObject}, str::AbstractString) = convert(JObject, JString(str))
 
+# From JProxy
+convert(::Type{AbstractString}, str::JString) = unsafe_string(str)
+convert(::Type{JavaObject{Symbol("java.lang.Double")}}, n::Real) = jnew(Symbol("java.lang.Double"), (jdouble,), Float64(n))
+convert(::Type{JavaObject{Symbol("java.lang.Float")}}, n::Real) = jnew(Symbol("java.lang.Float"), (jfloat,), Float32(n))
+convert(::Type{JavaObject{Symbol("java.lang.Long")}}, n::Real) = jnew(Symbol("java.lang.Long"), (jlong,), Int64(n))
+convert(::Type{JavaObject{Symbol("java.lang.Integer")}}, n::Real) = jnew(Symbol("java.lang.Integer"), (jint,), Int32(n))
+convert(::Type{JavaObject{Symbol("java.lang.Short")}}, n::Real) = jnew(Symbol("java.lang.Short"), (jshort,), Int16(n))
+convert(::Type{JavaObject{Symbol("java.lang.Byte")}}, n::Real) = jnew(Symbol("java.lang.Byte"), (jbyte,), Int8(n))
+convert(::Type{JavaObject{Symbol("java.lang.Character")}}, n::Real) = jnew(Symbol("java.lang.Character"), (jchar,), Char(n))
+convert(::Type{JavaObject{:int}}, n) = convert(jint, n)
+convert(::Type{JavaObject{:long}}, n) = convert(jlong, n)
+convert(::Type{JavaObject{:byte}}, n) = convert(jbyte, n)
+convert(::Type{JavaObject{:boolean}}, n) = convert(jboolean, n)
+convert(::Type{JavaObject{:char}}, n) = convert(jchar, n)
+convert(::Type{JavaObject{:short}}, n) = convert(jshort, n)
+convert(::Type{JavaObject{:float}}, n) = convert(jfloat, n)
+convert(::Type{JavaObject{:double}}, n) = convert(jdouble, n)
+convert(::Type{JavaObject{:void}}, n) = convert(jvoid, n)
+convert(::Type{JavaObject{T}}, ::Nothing) where T = jnull
+
 #Cast java object from S to T . Needed for polymorphic calls
 function convert(::Type{JavaObject{T}}, obj::JavaObject{S}) where {T,S}
     if isConvertible(T, S)   #Safe static cast
@@ -91,8 +111,8 @@ end
 function convert_arg(argtype::Type{Array{T,1}}, arg) where T<:JavaObject
     carg = convert(argtype, arg)
     sz = length(carg)
-    init = carg[1]
-    arrayptr = JNI.NewObjectArray(sz, Ptr(metaclass(T)), Ptr(init))
+    init = sz == 0 ? C_NULL : Ptr(carg[1]) 
+    arrayptr = JNI.NewObjectArray(sz, Ptr(metaclass(T)), init)
     arrayptr === C_NULL && geterror()
     for i=2:sz
         JNI.SetObjectArrayElement(arrayptr, i-1, Ptr(carg[i]))
@@ -259,13 +279,15 @@ function convert(::Type{@jimport(java.util.List)}, x::Vector, V::Type{JavaObject
 end
 
 # Convert a reference to a java.lang.String into a Julia string. Copies the underlying byte buffer
-function unsafe_string(jstr::JString)  #jstr must be a jstring obtained via a JNI call
-    if isnull(jstr); return ""; end #Return empty string to keep type stability. But this is questionable
+unsafe_string(jstr::JString) = unsafe_string(Ptr(jstr))  #jstr must be a jstring obtained via a JNI call
+
+function unsafe_string(jstr::Ptr{Nothing})  #jstr must be a jstring obtained via a JNI call
+    if jstr == C_NULL; return ""; end #Return empty string to keep type stability. But this is questionable
     pIsCopy = Array{jboolean}(undef, 1)
     #buf::Ptr{UInt8} = JNI.GetStringUTFChars(Ptr(jstr), pIsCopy)
-    buf = JNI.GetStringUTFChars(Ptr(jstr), pIsCopy)
+    buf = JNI.GetStringUTFChars(jstr, pIsCopy)
     s = unsafe_string(buf)
-    JNI.ReleaseStringUTFChars(Ptr(jstr), buf)
+    JNI.ReleaseStringUTFChars(jstr, buf)
     return s
 end
 

src/core.jl

@@ -157,10 +157,14 @@ isnull(obj::JavaMetaClass) = Ptr(obj) == C_NULL
 const JClass = JavaObject{Symbol("java.lang.Class")}
 const JObject = JavaObject{Symbol("java.lang.Object")}
 const JMethod = JavaObject{Symbol("java.lang.reflect.Method")}
+const JConstructor = JavaObject{Symbol("java.lang.reflect.Constructor")}
+const JField = JavaObject{Symbol("java.lang.reflect.Field")}
 const JThread = JavaObject{Symbol("java.lang.Thread")}
 const JClassLoader = JavaObject{Symbol("java.lang.ClassLoader")}
 const JString = JavaObject{Symbol("java.lang.String")}
 
+#JavaObject(ptr::Ptr{Nothing}) = ptr == C_NULL ? JavaObject(ptr) : JavaObject{Symbol(getclassname(getclass(ptr)))}(ptr)
+
 function JString(str::AbstractString)
     jstring = JNI.NewStringUTF(String(str))
     if jstring == C_NULL
@@ -345,6 +349,7 @@ metaclass(::Type{JavaObject{T}}) where {T} = metaclass(T)
 metaclass(::JavaObject{T}) where {T} = metaclass(T)
 
 javaclassname(class::Symbol) = replace(string(class), "."=>"/")
+javaclassname(class::AbstractString) = replace(class, "."=>"/")
 
 function geterror(allow=false)
     isexception = JNI.ExceptionCheck()

src/reflect.jl

@@ -62,6 +62,10 @@ function getname(method::JMethod)
     jcall(method, "getName", JString, ())
 end
 
+"""
+"""
+getname(field::JField) = jcall(field, "getName", JString, ())
+
 """
 ```
 listmethods(obj::JavaObject)
@@ -123,6 +127,29 @@ function getreturntype(method::JMethod)
     jcall(method, "getReturnType", JClass, ())
 end
 
+"""
+gettype(field::JField)
+
+Get type of field
+"""
+gettype(field::JField) = jcall(field, "getType", JClass, ())
+
+"""
+```
+listfields(obj::JavaObject)
+```
+List the fields that are available on the java object passed.
+"""
+listfields(cls::AbstractString) = listfields(classforname(cls))
+listfields(cls::Type{JavaObject{C}}) where C = listfields(classforname(string(C)))
+listfields(cls::JClass) = jcall(cls, "getFields", Vector{JField}, ())
+listfields(obj::JavaObject) = listfields(getclass(obj))
+
+function listfields(cls::Union{JavaObject{C}, Type{JavaObject{C}}}, name::AbstractString) where C
+    allfields = listfields(cls)
+    filter(f -> getname(f) == name, allfields)
+end
+
 """
 ```
 getparametertypes(method::JMethod)
@@ -135,7 +162,7 @@ Returns the parameter types of the java method
 ### Returns
 Vector the parametertypes
 """
-function getparametertypes(method::JMethod)
+function getparametertypes(method::Union{JMethod,JConstructor})
     jcall(method, "getParameterTypes", Vector{JClass}, ())
 end
 
@@ -147,6 +174,12 @@ function Base.show(io::IO, method::JMethod)
     print(io, "$rettype $name($argtypestr)")
 end
 
+function Base.show(io::IO, field::JField)
+    name = getname(field)
+    fieldtype = getname(gettype(field))
+    print(io, "$fieldtype $name")
+end
+
 
 """
 ```