Skip to content

Commit aeb2699

Browse files
ephemerephemer
committed
Remove named parameters in CJNI (but not SwiftJNI)
1 parent 8e4de1b commit aeb2699

9 files changed

+63
-63
lines changed

‎JNI.swift

+4-4
Original file line numberDiff line numberDiff line change
@@ -45,14 +45,14 @@ public extension JNI {
4545
return env.memory.memory.GetJavaVM(env, vm)
4646
}
4747

48-
public func RegisterNatives(clazz: jclass, methods: UnsafePointer<JNINativeMethod>, nMethods: jint) -> jint {
48+
public func RegisterNatives(targetClass: jclass, _ methods: UnsafePointer<JNINativeMethod>, _ nMethods: jint) -> jint {
4949
let env = self._env
50-
return env.memory.memory.RegisterNatives(env, clazz, methods, nMethods)
50+
return env.memory.memory.RegisterNatives(env, targetClass, methods, nMethods)
5151
}
5252

53-
public func UnregisterNatives(clazz: jclass) -> jint {
53+
public func UnregisterNatives(targetClass: jclass) -> jint {
5454
let env = self._env
55-
return env.memory.memory.UnregisterNatives(env, clazz)
55+
return env.memory.memory.UnregisterNatives(env, targetClass)
5656
}
5757

5858
public func MonitorEnter(obj: jobject) -> jint {

‎JNIArrays.swift.gyb

+10-10
Original file line numberDiff line numberDiff line change
@@ -26,17 +26,17 @@ public extension JNI {
2626
}
2727

2828
% # You can only set / get one object element at a time
29-
public func NewObjectArray(length: jsize, elementClass: jclass, initialElement: jobject) -> jobjectArray {
29+
public func NewObjectArray(length: jsize, _ elementClass: jclass, _ initialElement: jobject) -> jobjectArray {
3030
let env = self._env
3131
return env.memory.memory.NewObjectArray(env, length, elementClass, initialElement)
3232
}
3333

34-
public func GetObjectArrayElement(array: jobjectArray, index: jsize) -> jobject {
34+
public func GetObjectArrayElement(array: jobjectArray, _ index: jsize) -> jobject {
3535
let env = self._env
3636
return env.memory.memory.GetObjectArrayElement(env, array, index)
3737
}
3838

39-
public func SetObjectArrayElement(array: jobjectArray, index: jsize, value: jobject) {
39+
public func SetObjectArrayElement(array: jobjectArray, _ index: jsize, _ value: jobject) {
4040
let env = self._env
4141
env.memory.memory.SetObjectArrayElement(env, array, index, value)
4242
}
@@ -50,22 +50,22 @@ public extension JNI {
5050
return env.memory.memory.New${TypeName}Array(env, length)
5151
}
5252

53-
public func Get${TypeName}ArrayElements(array: ${type}Array, isCopy: UnsafeMutablePointer<jboolean>) -> UnsafeMutablePointer<${type}> {
53+
public func Get${TypeName}ArrayElements(array: ${type}Array, _ isCopy: UnsafeMutablePointer<jboolean>) -> UnsafeMutablePointer<${type}> {
5454
let env = self._env
5555
return env.memory.memory.Get${TypeName}ArrayElements(env, array, isCopy)
5656
}
5757

58-
public func Release${TypeName}ArrayElements(array: ${type}Array, elems: UnsafeMutablePointer<${type}>, mode: jint) {
58+
public func Release${TypeName}ArrayElements(array: ${type}Array, _ elems: UnsafeMutablePointer<${type}>, _ mode: jint) {
5959
let env = self._env
6060
env.memory.memory.Release${TypeName}ArrayElements(env, array, elems, mode)
6161
}
6262

63-
public func Get${TypeName}ArrayRegion(array: ${type}Array, start: jsize, len: jsize, buf: UnsafeMutablePointer<${type}>) {
63+
public func Get${TypeName}ArrayRegion(array: ${type}Array, _ start: jsize, _ len: jsize, _ buf: UnsafeMutablePointer<${type}>) {
6464
let env = self._env
6565
env.memory.memory.Get${TypeName}ArrayRegion(env, array, start, len, buf)
6666
}
6767

68-
public func Set${TypeName}ArrayRegion(array: ${type}Array, start: jsize, len: jsize, buf: UnsafePointer<${type}>) {
68+
public func Set${TypeName}ArrayRegion(array: ${type}Array, _ start: jsize, _ len: jsize, _ buf: UnsafePointer<${type}>) {
6969
let env = self._env
7070
env.memory.memory.Set${TypeName}ArrayRegion(env, array, start, len, buf)
7171
}
@@ -75,17 +75,17 @@ public extension JNI {
7575

7676
/// High performance JNI extensions
7777
public extension JNI {
78-
public func GetPrimitiveArrayCritical(array: jarray, isCopy: UnsafeMutablePointer<jboolean>) -> UnsafeMutablePointer<Void> {
78+
public func GetPrimitiveArrayCritical(array: jarray, _ isCopy: UnsafeMutablePointer<jboolean>) -> UnsafeMutablePointer<Void> {
7979
let env = self._env
8080
return env.memory.memory.GetPrimitiveArrayCritical(env, array, isCopy)
8181
}
8282

83-
public func ReleasePrimitiveArrayCritical(array: jarray, carray: UnsafeMutablePointer<Void>, mode: jint) {
83+
public func ReleasePrimitiveArrayCritical(array: jarray, _ carray: UnsafeMutablePointer<Void>, _ mode: jint) {
8484
let env = self._env
8585
env.memory.memory.ReleasePrimitiveArrayCritical(env, array, carray, mode)
8686
}
8787

88-
public func NewDirectByteBuffer(address: UnsafeMutablePointer<Void>, capacity: jlong) -> jobject {
88+
public func NewDirectByteBuffer(address: UnsafeMutablePointer<Void>, _ capacity: jlong) -> jobject {
8989
let env = self._env
9090
return env.memory.memory.NewDirectByteBuffer(env, address, capacity)
9191
}

‎JNIClassManipulation.swift

+8-8
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,9 @@
11
import CJNI
22

33
public extension JNI {
4-
public func DefineClass(name: String, loader: jobject, buf: UnsafePointer<jbyte>, bufLen: jsize) -> jclass {
4+
public func DefineClass(name: String, _ loader: jobject, _ buffer: UnsafePointer<jbyte>, _ bufferLength: jsize) -> jclass {
55
let env = self._env
6-
return env.memory.memory.DefineClass(env, name, loader, buf, bufLen)
6+
return env.memory.memory.DefineClass(env, name, loader, buffer, bufferLength)
77
}
88

99
public func FindClass(name: String) -> jclass {
@@ -21,22 +21,22 @@ public extension JNI {
2121
return env.memory.memory.FromReflectedField(env, field)
2222
}
2323

24-
public func ToReflectedMethod(cls: jclass, methodID: jmethodID, isStatic: jboolean) -> jobject {
24+
public func ToReflectedMethod(targetClass: jclass, _ methodID: jmethodID, _ isStatic: jboolean) -> jobject {
2525
let env = self._env
2626
return env.memory.memory.ToReflectedMethod(env, cls, methodID, isStatic)
2727
}
2828

29-
public func GetSuperclass(clazz: jclass) -> jclass {
29+
public func GetSuperclass(targetClass: jclass) -> jclass {
3030
let env = self._env
31-
return env.memory.memory.GetSuperclass(env, clazz)
31+
return env.memory.memory.GetSuperclass(env, targetClass)
3232
}
3333

34-
public func IsAssignableFrom(clazz1: jclass, clazz2: jclass) -> jboolean {
34+
public func IsAssignableFrom(classA: jclass, _ classB: jclass) -> jboolean {
3535
let env = self._env
36-
return env.memory.memory.IsAssignableFrom(env, clazz1, clazz2)
36+
return env.memory.memory.IsAssignableFrom(env, classA, classB)
3737
}
3838

39-
public func ToReflectedField(cls: jclass, fieldID: jfieldID, isStatic: jboolean) -> jobject {
39+
public func ToReflectedField(targetClass: jclass, _ fieldID: jfieldID, _ isStatic: jboolean) -> jobject {
4040
let env = self._env
4141
return env.memory.memory.ToReflectedField(env, cls, fieldID, isStatic)
4242
}

‎JNIExceptions.swift

+2-2
Original file line numberDiff line numberDiff line change
@@ -26,9 +26,9 @@ public extension JNI {
2626
return env.memory.memory.Throw(env, obj)
2727
}
2828

29-
public func ThrowNew(clazz: jclass, message: String) -> jint {
29+
public func ThrowNew(targetClass: jclass, _ message: String) -> jint {
3030
let env = self._env
31-
return env.memory.memory.ThrowNew(env, clazz, message)
31+
return env.memory.memory.ThrowNew(env, targetClass, message)
3232
}
3333

3434
public func FatalError(msg: String) {

‎JNIFields.swift.gyb

+10-10
Original file line numberDiff line numberDiff line change
@@ -18,35 +18,35 @@ import CJNI
1818

1919
public extension JNI {
2020

21-
public func GetFieldID(clazz: jclass, name: String, sig: String) -> jfieldID {
21+
public func GetFieldID(targetClass: jclass, _ name: String, _ sig: String) -> jfieldID {
2222
let env = self._env
23-
return env.memory.memory.GetFieldID(env, clazz, name, sig)
23+
return env.memory.memory.GetFieldID(env, targetClass, name, sig)
2424
}
2525

26-
public func GetStaticFieldID(clazz: jclass, name: String, sig: String) -> jfieldID {
26+
public func GetStaticFieldID(targetClass: jclass, _ name: String, _ sig: String) -> jfieldID {
2727
let env = self._env
28-
return env.memory.memory.GetStaticFieldID(env, clazz, name, sig)
28+
return env.memory.memory.GetStaticFieldID(env, targetClass, name, sig)
2929
}
3030

3131
% for (TypeName, Type) in jTypes:
32-
public func Get${TypeName}Field(obj: jobject, fieldID: jfieldID) -> ${Type} {
32+
public func Get${TypeName}Field(obj: jobject, _ fieldID: jfieldID) -> ${Type} {
3333
let env = self._env
3434
return env.memory.memory.Get${TypeName}Field(env, obj, fieldID)
3535
}
3636

37-
public func Set${TypeName}Field(obj: jobject, fieldID: jfieldID, value: ${Type}) {
37+
public func Set${TypeName}Field(obj: jobject, _ fieldID: jfieldID, _ value: ${Type}) {
3838
let env = self._env
3939
env.memory.memory.Set${TypeName}Field(env, obj, fieldID, value)
4040
}
4141

42-
public func GetStatic${TypeName}Field(clazz: jclass, fieldID: jfieldID) -> ${Type} {
42+
public func GetStatic${TypeName}Field(targetClass: jclass, _ fieldID: jfieldID) -> ${Type} {
4343
let env = self._env
44-
return env.memory.memory.GetStatic${TypeName}Field(env, clazz, fieldID)
44+
return env.memory.memory.GetStatic${TypeName}Field(env, targetClass, fieldID)
4545
}
4646

47-
public func SetStatic${TypeName}Field(clazz: jclass, fieldID: jfieldID, value: ${Type}) {
47+
public func SetStatic${TypeName}Field(targetClass: jclass, _ fieldID: jfieldID, _ value: ${Type}) {
4848
let env = self._env
49-
env.memory.memory.SetStatic${TypeName}Field(env, clazz, fieldID, value)
49+
env.memory.memory.SetStatic${TypeName}Field(env, targetClass, fieldID, value)
5050
}
5151
% end
5252
}

‎JNIMethods.swift.gyb

+13-13
Original file line numberDiff line numberDiff line change
@@ -40,18 +40,18 @@ public extension JNI {
4040

4141
%for (TypeName, type) in jTypes:
4242

43-
public func Call${TypeName}Method(obj: jobject, methodID: jmethodID, args: jvalue...) -> ${type} {
44-
return Call${TypeName}MethodA(obj, methodID: methodID, args: args)
43+
public func Call${TypeName}Method(obj: jobject, _ methodID: jmethodID, _ args: jvalue...) -> ${type} {
44+
return Call${TypeName}MethodA(obj, _ methodID: methodID, _ args: args)
4545
}
4646

4747
@available(*, unavailable, message="CVaListPointers are not supported, use `Call${TypeName}Method` or `Call${TypeName}MethodA` instead")
48-
public func Call${TypeName}MethodV(obj: jobject, methodID: jmethodID, args: CVaListPointer) -> ${type} {
48+
public func Call${TypeName}MethodV(obj: jobject, _ methodID: jmethodID, _ args: CVaListPointer) -> ${type} {
4949
// let env = self._env
5050
// return env.memory.memory.Call${TypeName}MethodV(env, obj, methodID, args)
5151
return ${type}()
5252
}
5353

54-
public func Call${TypeName}MethodA(obj: jobject, methodID: jmethodID, args: [jvalue]) -> ${type} {
54+
public func Call${TypeName}MethodA(obj: jobject, _ methodID: jmethodID, _ args: [jvalue]) -> ${type} {
5555
let env = self._env
5656
var mutableArgs = args
5757
return env.memory.memory.Call${TypeName}MethodA(env, obj, methodID, &mutableArgs)
@@ -64,18 +64,18 @@ public extension JNI {
6464
% # Nonvirtual Java method calls
6565
%for (TypeName, type) in jTypes:
6666

67-
public func CallNonvirtual${TypeName}Method(obj: jobject, targetClass: jclass, methodID: jmethodID, args: jvalue...) -> ${type} {
68-
return self.CallNonvirtual${TypeName}MethodA(obj, targetClass: targetClass, methodID: methodID, args: args)
67+
public func CallNonvirtual${TypeName}Method(obj: jobject, _ targetClass: jclass, _ methodID: jmethodID, _ args: jvalue...) -> ${type} {
68+
return self.CallNonvirtual${TypeName}MethodA(obj, _ targetClass: targetClass, _ methodID: methodID, _ args: args)
6969
}
7070

7171
@available(*, unavailable, message="CVaListPointers are not supported, use `CallNonvirtual${TypeName}Method` or `CallNonvirtual${TypeName}MethodA` instead")
72-
public func CallNonvirtual${TypeName}MethodV(obj: jobject, targetClass: jclass, methodID: jmethodID, args: CVaListPointer) -> ${type} {
72+
public func CallNonvirtual${TypeName}MethodV(obj: jobject, _ targetClass: jclass, _ methodID: jmethodID, _ args: CVaListPointer) -> ${type} {
7373
// let env = self._env
7474
// return env.memory.memory.CallNonvirtual${TypeName}MethodV(env, obj, methodID, args)
7575
return ${type}()
7676
}
7777

78-
public func CallNonvirtual${TypeName}MethodA(obj: jobject, targetClass: jclass, methodID: jmethodID, args: [jvalue]) -> ${type} {
78+
public func CallNonvirtual${TypeName}MethodA(obj: jobject, _ targetClass: jclass, _ methodID: jmethodID, _ args: [jvalue]) -> ${type} {
7979
let env = self._env
8080
var mutableArgs = args
8181
return env.memory.memory.CallNonvirtual${TypeName}MethodA(env, obj, targetClass, methodID, &mutableArgs)
@@ -87,25 +87,25 @@ public extension JNI {
8787

8888
%# Static Java method calls
8989

90-
public func GetStaticMethodID(targetClass: jclass, name: String, sig: String) -> jmethodID {
90+
public func GetStaticMethodID(targetClass: jclass, _ name: String, _ sig: String) -> jmethodID {
9191
let env = self._env
9292
return env.memory.memory.GetStaticMethodID(env, targetClass, name, sig)
9393
}
9494

9595
%for (TypeName, type) in jTypes:
9696

97-
public func CallStatic${TypeName}Method(targetClass: jclass, methodID: jmethodID, args: jvalue...) -> ${type} {
98-
return CallStatic${TypeName}MethodA(targetClass, methodID: methodID, args: args)
97+
public func CallStatic${TypeName}Method(targetClass: jclass, _ methodID: jmethodID, _ args: jvalue...) -> ${type} {
98+
return CallStatic${TypeName}MethodA(targetClass, _ methodID: methodID, _ args: args)
9999
}
100100

101101
@available(*, unavailable, message="CVaListPointers are not supported, use `CallStatic${TypeName}Method` or `CallStatic${TypeName}MethodA` instead")
102-
public func CallStatic${TypeName}MethodV(targetClass: jclass, methodID: jmethodID, args: CVaListPointer) -> ${type} {
102+
public func CallStatic${TypeName}MethodV(targetClass: jclass, _ methodID: jmethodID, _ args: CVaListPointer) -> ${type} {
103103
// let env = self._env
104104
// return env.memory.memory.CallStatic${TypeName}MethodV(env, class, methodID, args)
105105
return ${type}()
106106
}
107107

108-
public func CallStatic${TypeName}MethodA(targetClass: jclass, methodID: jmethodID, args: [jvalue]) -> ${type} {
108+
public func CallStatic${TypeName}MethodA(targetClass: jclass, _ methodID: jmethodID, _ args: [jvalue]) -> ${type} {
109109
let env = self._env
110110
var mutableArgs = args
111111
return env.memory.memory.CallStatic${TypeName}MethodA(env, targetClass, methodID, &mutableArgs)

‎JNIObjects.swift

+4-4
Original file line numberDiff line numberDiff line change
@@ -7,18 +7,18 @@ public extension JNI {
77
return env.memory.memory.AllocObject(env, targetClass)
88
}
99

10-
public func NewObject(targetClass: jclass, methodID: jmethodID, args: jvalue...) -> jobject {
11-
return self.NewObjectA(targetClass, methodID: methodID, args: args)
10+
public func NewObject(targetClass: jclass, _ methodID: jmethodID, _ args: jvalue...) -> jobject {
11+
return self.NewObjectA(targetClass, _ methodID: methodID, _ args: args)
1212
}
1313

1414
@available(*, unavailable, message="CVaListPointer unavailable, use NewObject or NewObjectA")
15-
public func NewObjectV(targetClass: jclass, methodID: jmethodID, args: CVaListPointer) -> jobject {
15+
public func NewObjectV(targetClass: jclass, _ methodID: jmethodID, _ args: CVaListPointer) -> jobject {
1616
// let env = self._env
1717
// return env.memory.memory.NewObjectV(env, targetClass, methodID, args)
1818
return jobject()
1919
}
2020

21-
public func NewObjectA(targetClass: jclass, methodID: jmethodID, args: [jvalue]) -> jobject {
21+
public func NewObjectA(targetClass: jclass, _ methodID: jmethodID, _ args: [jvalue]) -> jobject {
2222
let env = self._env
2323
var mutableArgs = args
2424
return env.memory.memory.NewObjectA(env, targetClass, methodID, &mutableArgs)

‎JNIRefs.swift

+3-3
Original file line numberDiff line numberDiff line change
@@ -36,14 +36,14 @@ public extension JNI {
3636
return env.memory.memory.EnsureLocalCapacity(env, capacity)
3737
}
3838

39-
public func IsSameObject(ref1: jobject, ref2: jobject) -> jboolean {
39+
public func IsSameObject(ref1: jobject, _ ref2: jobject) -> jboolean {
4040
let env = self._env
4141
return env.memory.memory.IsSameObject(env, ref1, ref2)
4242
}
4343

44-
public func IsInstanceOf(obj: jobject, clazz: jclass) -> jboolean {
44+
public func IsInstanceOf(obj: jobject, _ targetClass: jclass) -> jboolean {
4545
let env = self._env
46-
return env.memory.memory.IsInstanceOf(env, obj, clazz)
46+
return env.memory.memory.IsInstanceOf(env, obj, targetClass)
4747
}
4848

4949
public func NewWeakGlobalRef(obj: jobject) -> jweak {

‎JNIStrings.swift

+9-9
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
import CJNI
22

33
public extension JNI {
4-
public func NewString(unicodeChars: UnsafePointer<jchar>, len: jsize) -> jstring {
4+
public func NewString(unicodeChars: UnsafePointer<jchar>, _ len: jsize) -> jstring {
55
let env = self._env
66
return env.memory.memory.NewString(env, unicodeChars, len)
77
}
@@ -11,12 +11,12 @@ public extension JNI {
1111
return env.memory.memory.GetStringLength(env, string)
1212
}
1313

14-
public func GetStringChars(string: jstring, isCopy: UnsafeMutablePointer<jboolean>) -> UnsafePointer<jchar> {
14+
public func GetStringChars(string: jstring, _ isCopy: UnsafeMutablePointer<jboolean>) -> UnsafePointer<jchar> {
1515
let env = self._env
1616
return env.memory.memory.GetStringChars(env, string, isCopy)
1717
}
1818

19-
public func ReleaseStringChars(string: jstring, chars: UnsafePointer<jchar>) {
19+
public func ReleaseStringChars(string: jstring, _ chars: UnsafePointer<jchar>) {
2020
let env = self._env
2121
env.memory.memory.ReleaseStringChars(env, string, chars)
2222
}
@@ -31,32 +31,32 @@ public extension JNI {
3131
return env.memory.memory.GetStringUTFLength(env, string)
3232
}
3333

34-
public func GetStringUTFChars(string: jstring, isCopy: UnsafeMutablePointer<jboolean>) -> String {
34+
public func GetStringUTFChars(string: jstring, _ isCopy: UnsafeMutablePointer<jboolean>) -> String {
3535
let env = self._env
3636
return String(env.memory.memory.GetStringUTFChars(env, string, isCopy))
3737
}
3838

39-
public func ReleaseStringUTFChars(string: jstring, utf: String) {
39+
public func ReleaseStringUTFChars(string: jstring, _ utf: String) {
4040
let env = self._env
4141
env.memory.memory.ReleaseStringUTFChars(env, string, utf)
4242
}
4343

44-
public func GetStringRegion(str: jstring, start: jsize, len: jsize, buf: UnsafeMutablePointer<jchar>) {
44+
public func GetStringRegion(str: jstring, _ start: jsize, _ len: jsize, _ buf: UnsafeMutablePointer<jchar>) {
4545
let env = self._env
4646
env.memory.memory.GetStringRegion(env, str, start, len, buf)
4747
}
4848

49-
public func GetStringUTFRegion(str: jstring, start: jsize, len: jsize, buf: UnsafeMutablePointer<CChar>) {
49+
public func GetStringUTFRegion(str: jstring, _ start: jsize, _ len: jsize, _ buf: UnsafeMutablePointer<CChar>) {
5050
let env = self._env
5151
env.memory.memory.GetStringUTFRegion(env, str, start, len, buf)
5252
}
5353

54-
public func GetStringCritical(string: jstring, isCopy: UnsafeMutablePointer<jboolean>) -> UnsafePointer<jchar> {
54+
public func GetStringCritical(string: jstring, _ isCopy: UnsafeMutablePointer<jboolean>) -> UnsafePointer<jchar> {
5555
let env = self._env
5656
return env.memory.memory.GetStringCritical(env, string, isCopy)
5757
}
5858

59-
public func ReleaseStringCritical(string: jstring, carray: UnsafePointer<jchar>) {
59+
public func ReleaseStringCritical(string: jstring, _ carray: UnsafePointer<jchar>) {
6060
let env = self._env
6161
env.memory.memory.ReleaseStringCritical(env, string, carray)
6262
}

0 commit comments

Comments
 (0)