Explicit types + ClosureRunnable

johnno1962 · johnno1962 · commit 3a48760a5528 · 2017-09-17T22:25:08.000+01:00
diff --git a/Sources/JNICore.swift b/Sources/JNICore.swift
@@ -17,7 +17,7 @@ import Dispatch
 @_silgen_name("JNI_OnLoad")
 public func JNI_OnLoad( jvm: UnsafeMutablePointer<JavaVM?>, ptr: UnsafeRawPointer ) -> jint {
     JNI.jvm = jvm
-    let env = JNI.GetEnv()
+    let env: UnsafeMutablePointer<JNIEnv?>? = JNI.GetEnv()
     JNI.api = env!.pointee!.pointee
     JNI.envCache[JNI.threadKey] = env
 #if os(Android)
@@ -84,10 +84,10 @@ open class JNICore {
             return true
         }
 
-        var options = options
+        var options: [String]? = options
         if options == nil {
-            var classpath = String( cString: getenv("HOME") )+"/.swiftjava.jar"
-            if let CLASSPATH = getenv( "CLASSPATH" ) {
+            var classpath: String = String( cString: getenv("HOME") )+"/.swiftjava.jar"
+            if let CLASSPATH: UnsafeMutablePointer<Int8> = getenv( "CLASSPATH" ) {
                 classpath += ":"+String( cString: CLASSPATH )
             }
             options = ["-Djava.class.path="+classpath,
@@ -105,7 +105,7 @@ open class JNICore {
             vmArgs.nOptions = jint(options?.count ?? 0)
             vmArgs.options = vmOptionsPtr
 
-            if let options = options {
+            if let options: [String] = options {
                 for i in 0..<options.count {
                     options[i].withCString {
                         (cString) in
@@ -169,7 +169,7 @@ open class JNICore {
     open func FindClass( _ name: UnsafePointer<Int8>, _ file: StaticString = #file, _ line: Int = #line ) -> jclass? {
         autoInit()
         ExceptionReset()
-        let clazz = api.FindClass( env, name )
+        let clazz: jclass? = api.FindClass( env, name )
         if clazz == nil {
             report( "Could not find class \(String( cString: name ))", file, line )
             if strncmp( name, "org/swiftjava/", 14 ) == 0 {
@@ -183,7 +183,7 @@ open class JNICore {
 
     open func CachedFindClass( _ name: UnsafePointer<Int8>, _ classCache: UnsafeMutablePointer<jclass?>,
                                _ file: StaticString = #file, _ line: Int = #line ) {
-        if classCache.pointee == nil, let clazz = FindClass( name, file, line ) {
+        if classCache.pointee == nil, let clazz: jclass = FindClass( name, file, line ) {
             classCache.pointee = api.NewGlobalRef( env, clazz )
             api.DeleteLocalRef( env, clazz )
         }
@@ -195,7 +195,7 @@ open class JNICore {
         if object == nil {
             report( "GetObjectClass with nil object", file, line )
         }
-        let clazz = api.GetObjectClass( env, object )
+        let clazz: jclass? = api.GetObjectClass( env, object )
         if clazz == nil {
             report( "GetObjectClass returns nil class", file, line )
         }
@@ -207,9 +207,9 @@ open class JNICore {
 
     private static var java_lang_ObjectClass: jclass?
 
-    open func NewObjectArray( _ count: Int, _ array: [jobject?]?, _ locals: UnsafeMutablePointer<[jobject]>, _ file: StaticString = #file, _ line: Int = #line  ) -> jobject? {
+    open func NewObjectArray( _ count: Int, _ array: [jobject?]?, _ locals: UnsafeMutablePointer<[jobject]>, _ file: StaticString = #file, _ line: Int = #line  ) -> jobjectArray? {
         CachedFindClass( "java/lang/Object", &JNICore.java_lang_ObjectClass, file, line )
-        var arrayClass = JNICore.java_lang_ObjectClass
+        var arrayClass: jclass? = JNICore.java_lang_ObjectClass
         if array?.count != 0 {
             arrayClass = JNI.GetObjectClass(array![0], locals)
         }
@@ -218,7 +218,7 @@ open class JNICore {
             return nil
 #endif
         }
-        let array = api.NewObjectArray( env, jsize(count), arrayClass, nil )
+        let array: jobjectArray? = api.NewObjectArray( env, jsize(count), arrayClass, nil )
         if array == nil {
             report( "Could not create array", file, line )
         }
@@ -231,7 +231,7 @@ open class JNICore {
         }
     }
 
-    private var thrownCache = [pthread_t:jthrowable]()
+    private var thrownCache = [pthread_t: jthrowable]()
     private let thrownLock = NSLock()
 
     open func check<T>( _ result: T, _ locals: UnsafeMutablePointer<[jobject]>, removeLast: Bool = false, _ file: StaticString = #file, _ line: Int = #line ) -> T {
@@ -241,7 +241,7 @@ open class JNICore {
         for local in locals.pointee {
             DeleteLocalRef( local )
         }
-        if api.ExceptionCheck( env ) != 0, let throwable = api.ExceptionOccurred( env ) {
+        if api.ExceptionCheck( env ) != 0, let throwable: jthrowable = api.ExceptionOccurred( env ) {
             report( "Exception occured", file, line )
             thrownLock.lock()
             thrownCache[threadKey] = throwable
@@ -252,8 +252,8 @@ open class JNICore {
     }
 
     open func ExceptionCheck() -> jthrowable? {
-        let currentThread = threadKey
-        if let throwable = thrownCache[currentThread] {
+        let currentThread: pthread_t = threadKey
+        if let throwable: jthrowable = thrownCache[currentThread] {
             thrownLock.lock()
             thrownCache.removeValue(forKey: currentThread)
             thrownLock.unlock()
@@ -263,7 +263,7 @@ open class JNICore {
     }
 
     open func ExceptionReset() {
-        if let throwable = ExceptionCheck() {
+        if let throwable: jthrowable = ExceptionCheck() {
             report( "Left over exception" )
             Throwable( javaObject: throwable ).printStackTrace()
         }
diff --git a/Sources/JNIMethod.swift b/Sources/JNIMethod.swift
@@ -25,7 +25,7 @@ public class JNIMethod {
                              _ methodCache: UnsafeMutablePointer<jmethodID?>, _ object: jobject?,
                              _ locals: UnsafeMutablePointer<[jobject]>,
                              _ file: StaticString = #file, _ line: Int = #line ) {
-        let clazz = JNI.GetObjectClass( object, locals, file, line )
+        let clazz: jclass? = JNI.GetObjectClass( object, locals, file, line )
         methodCache.pointee = JNI.api.GetMethodID( JNI.env, clazz, methodName, methodSig )
         if methodCache.pointee == nil {
             JNI.report( "Failed to lookup method \(String(describing: object)).\(String(describing: clazz)).\(String(cString: methodName))( \(String(cString: methodSig)) )", file, line )
diff --git a/Sources/JNIObject.swift b/Sources/JNIObject.swift
@@ -28,7 +28,7 @@ extension JNIObjectProtocol {
 
     public func withJavaObject<Result>( _ body: @escaping (jobject?) throws -> Result ) rethrows -> Result {
         var locals = [jobject]()
-        let javaObject = localJavaObject( &locals )
+        let javaObject: jobject? = localJavaObject( &locals )
         defer {
             for local in locals {
                 JNI.DeleteLocalRef( local )
@@ -66,7 +66,7 @@ open class JNIObject: JNIObjectProtocol, JNIObjectInit {
         }
         set(newValue) {
             if newValue != _javaObject {
-                let oldValue = _javaObject
+                let oldValue: jobject? = _javaObject
                 if newValue != nil {
                     _javaObject = JNI.api.NewGlobalRef( JNI.env, newValue )
                 }
@@ -93,7 +93,7 @@ open class JNIObject: JNIObjectProtocol, JNIObjectInit {
     }
 
     open func localJavaObject( _ locals: UnsafeMutablePointer<[jobject]> ) -> jobject? {
-        if let local = _javaObject != nil ? JNI.api.NewLocalRef( JNI.env, _javaObject ) : nil {
+        if let local: jobject = _javaObject != nil ? JNI.api.NewLocalRef( JNI.env, _javaObject ) : nil {
             locals.pointee.append( local )
             return local
         }
@@ -114,7 +114,7 @@ open class JNIObjectForward: JNIObject {
 extension String: JNIObjectProtocol {
 
     public func localJavaObject( _ locals: UnsafeMutablePointer<[jobject]> ) -> jobject? {
-        if let javaObject =  Array(utf16).withUnsafeBufferPointer( {
+        if let javaObject: jstring =  Array(utf16).withUnsafeBufferPointer( {
             JNI.env?.pointee?.pointee.NewString( JNI.env, $0.baseAddress, jsize($0.count) )
         } ) {
             locals.pointee.append( javaObject )
@@ -128,7 +128,7 @@ extension String: JNIObjectInit {
 
     public init( javaObject: jobject? ) {
         var isCopy: jboolean = 0
-        if let javaObject = javaObject, let value = JNI.api.GetStringChars( JNI.env, javaObject, &isCopy ) {
+        if let javaObject: jobject = javaObject, let value: UnsafePointer<jchar> = JNI.api.GetStringChars( JNI.env, javaObject, &isCopy ) {
             self.init( utf16CodeUnits: value, count: Int(JNI.api.GetStringLength( JNI.env, javaObject )) )
             if isCopy != 0 || true {
                 JNI.api.ReleaseStringChars( JNI.env, javaObject, value ) ////
@@ -144,7 +144,7 @@ extension jobject {
 
     public func arrayMap<T>( block: ( _ javaObject: jobject? ) -> T ) -> [T] {
         return (0 ..< JNI.api.GetArrayLength( JNI.env, self )).map {
-            let element = JNI.api.GetObjectArrayElement( JNI.env, self, $0 )
+            let element: jobject? = JNI.api.GetObjectArrayElement( JNI.env, self, $0 )
             defer { JNI.DeleteLocalRef( element ) }
             return block( element )
         }
@@ -167,15 +167,15 @@ extension JNIType {
     public static func toJavaArray<T>( value: [T]?, locals: UnsafeMutablePointer<[jobject]> ,
                                        block: (_ value: T, _ locals: UnsafeMutablePointer<[jobject]> ) -> jvalue ) -> jvalue {
         var array: jarray?
-        if let value = value {
+        if let value: [T] = value {
             for i in 0 ..< value.count {
                 var sublocals = [jobject]()
-                let element = block( value[i], &sublocals ).l
+                let element: jobject? = block( value[i], &sublocals ).l
                 if array == nil {
                     if element == nil {
                         break
                     }
-                    let elementClass = JNI.GetObjectClass( element, &sublocals )
+                    let elementClass: jclass? = JNI.GetObjectClass( element, &sublocals )
                     array = JNI.api.NewObjectArray( JNI.env, jsize(value.count), elementClass, nil )
                 }
                 JNI.api.SetObjectArrayElement( JNI.env, array, jsize(i), element )
@@ -210,19 +210,19 @@ extension JNIType {
     }
 
     public static func toSwift<T: JNIObjectInit>( type: T.Type, from: jobject?, consume: Bool = true ) -> T? {
-        guard let from = from else { return nil }
+        guard let from: jobject = from else { return nil }
         defer { if consume { JNI.DeleteLocalRef( from ) } }
         return T( javaObject: from )
     }
 
     public static func toSwift<T: JNIObjectInit>( type: [T].Type, from: jobject?, consume: Bool = true ) -> [T]? {
-        guard let from = from else { return nil }
+        guard let from: jobject = from else { return nil }
         defer { if consume { JNI.DeleteLocalRef( from ) } }
         return from.arrayMap { T( javaObject: $0 ) }
     }
 
     public static func toSwift<T: JNIObjectInit>( type: [[T]].Type, from: jobject?, consume: Bool = true ) -> [[T]]? {
-        guard let from = from else { return nil }
+        guard let from: jobject = from else { return nil }
         defer { if consume { JNI.DeleteLocalRef( from ) } }
         return from.arrayMap { toSwift( type: [T].self, from: $0, consume: false ) ?? [T]() }
     }
@@ -231,14 +231,14 @@ extension JNIType {
         return jvalue( l: value?.localJavaObject( locals ) )
     }
 
-    public static func toJava( value: [String:JNIObjectProtocol]?, mapClass: String, locals: UnsafeMutablePointer<[jobject]> ) -> jvalue {
-        guard let value = value else { return jvalue( l: nil ) }
+    public static func toJava( value: [String: JNIObjectProtocol]?, mapClass: String, locals: UnsafeMutablePointer<[jobject]> ) -> jvalue {
+        guard let value: [String: JNIObjectProtocol] = value else { return jvalue( l: nil ) }
 
         var classCache: jclass?
         var methodID: jmethodID?
         var __locals = [jobject]()
         var __args = [jvalue]( repeating: jvalue(), count: 1 )
-        guard let __object = JNIMethod.NewObject( className: mapClass, classCache: &classCache,
+        guard let __object: jobject = JNIMethod.NewObject( className: mapClass, classCache: &classCache,
                   methodSig: "()V", methodCache: &methodID, args: &__args, locals: &__locals ) else {
             JNI.report( "Unable to create HashMap of class \(mapClass)" )
             return jvalue( l: nil )
@@ -261,22 +261,22 @@ extension JNIType {
         return jvalue( l: __object )
     }
 
-    public static func toJava( value: [String:[JNIObjectProtocol]]?, mapClass: String, locals: UnsafeMutablePointer<[jobject]> ) -> jvalue {
-        guard let value = value else { return jvalue( l: nil ) }
+    public static func toJava( value: [String: [JNIObjectProtocol]]?, mapClass: String, locals: UnsafeMutablePointer<[jobject]> ) -> jvalue {
+        guard let value: [String: [JNIObjectProtocol]] = value else { return jvalue( l: nil ) }
 
         var classCache: jclass?
         var methodID: jmethodID?
         var __args = [jvalue]( repeating: jvalue(), count: 1 )
         var __locals = [jobject]()
-        guard let __object = JNIMethod.NewObject( className: mapClass, classCache: &classCache,
+        guard let __object: jobject = JNIMethod.NewObject( className: mapClass, classCache: &classCache,
                   methodSig: "()V", methodCache: &methodID, args: &__args, locals: &__locals ) else {
             JNI.report( "Unable to create HashMap of class \(mapClass)" )
             return jvalue( l: nil )
         }
 
         JNI.api.DeleteGlobalRef( JNI.env, classCache )
 
-        let map = HashMap( javaObject: __object )
+        let map: HashMap = HashMap( javaObject: __object )
         for (key, item) in value {
             var sublocals = [jobject]()
             let javaKey = JavaObject( javaObject: toJava( value: key, locals: &sublocals ).l )
@@ -291,8 +291,8 @@ extension JNIType {
         return jvalue( l: __object )
     }
 
-    public static func toSwift<T: JNIObjectInit>( type: [String:T].Type, from: jobject?, consume: Bool = true ) -> [String:T]? {
-        guard let from = from else { return nil }
+    public static func toSwift<T: JNIObjectInit>( type: [String: T].Type, from: jobject?, consume: Bool = true ) -> [String: T]? {
+        guard let from: jobject = from else { return nil }
         defer { if consume { JNI.DeleteLocalRef( from ) } }
         let map = HashMap( javaObject: from )
         var out = [String:T]()
@@ -301,7 +301,7 @@ extension JNIType {
                 keyObject in
                 map.get(key).withJavaObject {
                     itemObject in
-                    if let keystr = JNIType.toSwift( type: String.self, from: keyObject, consume: false ) {
+                    if let keystr: String = JNIType.toSwift( type: String.self, from: keyObject, consume: false ) {
                         out[keystr] = T( javaObject: itemObject )
                     }
                 }
@@ -310,8 +310,8 @@ extension JNIType {
         return out
     }
 
-    public static func toSwift<T: JNIObjectInit>( type: [String:[T]].Type, from: jobject?, consume: Bool = true ) -> [String:[T]]? {
-        guard let from = from else { return nil }
+    public static func toSwift<T: JNIObjectInit>( type: [String: [T]].Type, from: jobject?, consume: Bool = true ) -> [String: [T]]? {
+        guard let from: jobject = from else { return nil }
         defer { if consume { JNI.DeleteLocalRef( from ) } }
         let map = HashMap( javaObject: from )
         var out = [String:[T]]()
@@ -320,8 +320,8 @@ extension JNIType {
                 keyObject in
                 map.get(key).withJavaObject {
                     itemObject in
-                    if let keystr = JNIType.toSwift( type: String.self, from: keyObject, consume: false ),
-                        let value = JNIType.toSwift( type: [T].self, from: itemObject, consume: false ) {
+                    if let keystr: String = JNIType.toSwift( type: String.self, from: keyObject, consume: false ),
+                        let value: [T] = JNIType.toSwift( type: [T].self, from: itemObject, consume: false ) {
                         out[keystr] = value
                     }
                 }
diff --git a/Sources/JNIProxy.swift b/Sources/JNIProxy.swift
@@ -29,7 +29,7 @@ open class JNIReleasableProxy {
     }
 
     static public func canrelease( swiftObject: jlong ) {
-        let toRelease = unsafeBitCast( recoverPointer( swiftObject ), to: JNIReleasableProxy.self )
+        let toRelease: JNIReleasableProxy = unsafeBitCast( recoverPointer( swiftObject ), to: JNIReleasableProxy.self )
         toRelease.clearLocal()
         Unmanaged.passUnretained(toRelease).release()
     }
@@ -51,8 +51,8 @@ public let JNIReleasableProxy__finalize_thunk: JNIReleasableProxy__finalize_type
 open class JNILocalProxy<Owned, OwnedType>: JNIReleasableProxy, JNIObjectProtocol {
 
     public func localJavaObject( _ locals: UnsafeMutablePointer<[jobject]> ) -> jobject? {
-        let proxy = createProxy( className: type(of: self).proxyClassName(),
-                                 classObject: type(of: self).proxyClass() )
+        let proxy: jobject? = createProxy( className: type(of: self).proxyClassName(),
+                                           classObject: type(of: self).proxyClass() )
         locals.pointee.append( proxy! )
         return proxy
     }
@@ -78,8 +78,8 @@ open class JNILocalProxy<Owned, OwnedType>: JNIReleasableProxy, JNIObjectProtoco
         guard javaObject != nil else { return }
         var locals = [jobject]()
         var fieldID: jfieldID?
-        let existing = JNIField.GetLongField( fieldName: "__swiftObject", fieldType: "J", fieldCache: &fieldID,
-                                              object: javaObject, file, line )
+        let existing: jlong = JNIField.GetLongField( fieldName: "__swiftObject", fieldType: "J", fieldCache: &fieldID,
+                                                     object: javaObject, file, line )
         JNIField.SetLongField( fieldName: "__swiftObject", fieldType: "J", fieldCache: &fieldID,
                                object: javaObject, value: swiftValue().j, locals: &locals, file, line )
         if existing != 0 {
@@ -95,9 +95,9 @@ open class JNILocalProxy<Owned, OwnedType>: JNIReleasableProxy, JNIObjectProtoco
         var locals = [jobject]()
         var methodID: jmethodID?
         var args: [jvalue] = [swiftValue()]
-        if let newObject = JNIMethod.NewObject( className: className, classObject: classObject,
-                                                methodSig: "(J)V", methodCache: &methodID,
-                                                args: &args, locals: &locals ) {
+        if let newObject: jobject = JNIMethod.NewObject( className: className, classObject: classObject,
+                                                         methodSig: "(J)V", methodCache: &methodID,
+                                                         args: &args, locals: &locals ) {
             return newObject
         }
         else {
@@ -111,7 +111,7 @@ open class JNILocalProxy<Owned, OwnedType>: JNIReleasableProxy, JNIObjectProtoco
 open class JNIObjectProxy<ObjectOwned> : JNILocalProxy<ObjectOwned, JNIObject> where ObjectOwned: JNIObject {
 
     override public func localJavaObject(_ locals: UnsafeMutablePointer<[jobject]>) -> jobject? {
-        let local = JNI.api.NewLocalRef( JNI.env, owned.javaObject )
+        let local: jobject? = JNI.api.NewLocalRef( JNI.env, owned.javaObject )
         if local != nil {
             locals.pointee.append( local! )
         }
@@ -123,3 +123,18 @@ open class JNIObjectProxy<ObjectOwned> : JNILocalProxy<ObjectOwned, JNIObject> w
     }
 
 }
+
+public class ClosureRunnable: Runnable {
+
+    let closure: () -> ()
+
+    public init( _ closure: @escaping () -> () ) {
+        self.closure = closure
+    }
+
+    public func run() {
+        closure()
+        JNI.envCache[JNI.threadKey] = nil
+    }
+
+}
diff --git a/Sources/JNIType.swift b/Sources/JNIType.swift
