3884e8cb98
Before this CL, calling overloaded methods on reverse bound Java
classes and interfaces involved confusing and ugly name mangling.
If a set of methods with the same name differed only in argument count,
the mangling was simply adding the argument count to the name:
func F()
func F1(int32)
But if two or more methods had the same number of arguments, the type
had to be appended:
func (...) F() int32
func (...) F1(int32) (int32, error)
func (...) F__I(int32, int32)
func (...) F__JLjava_util_concurrent_TimeUnit_2(int64, concurrent.TimeUnit)
This CL sacrifices a bit of type safety and performance to regain the
convenience and simplicity of Go by resolving overloaded method dispatch
at runtime.
Overloaded Java methods are combined to one Go method that, when invoked,
determines the correct Java method variant at runtime.
The signature of the Go method is compatible with every Java method with
that name. For the example above, the single Go method becomes the most
general
func (...) F(...interface{}) (interface{}, error)
The method is variadic to cover function with a varying number of
arguments, and it returns interface{} to cover int32, int64 and no
argument. Finally, it returns an error to cover the variant that returns
an error. The generator tries to be specific; for example
func G1(int32) int32
func G2(int32, int32) int32
becomes
func G(int32, ...int32) int32
Overriding Java methods in Go is changed to use the Go parameter types to
determine to correct Java method. To avoid name clashes when overriding
multiple overloaded methods, trailing underscores in the method name are
ignored when matching Java methods. See the Get methods of GoFuture in
bind/testpkg/javapkg for an example.
Change-Id: I6ac3e024141daa8fc2c35187865c5d7a63368094
Reviewed-on: https://go-review.googlesource.com/35186
Reviewed-by: David Crawshaw <crawshaw@golang.org>
151 lines
4.0 KiB
Plaintext
151 lines
4.0 KiB
Plaintext
// Java class java.Future is a proxy for talking to a Go program.
|
|
// gobind -lang=java classes
|
|
//
|
|
// File is generated by gobind. Do not edit.
|
|
package java;
|
|
|
|
import go.Seq;
|
|
|
|
public final class Future implements Seq.GoObject, java.util.concurrent.Future {
|
|
static { Java.touch(); }
|
|
|
|
private final Seq.Ref ref;
|
|
|
|
@Override public final int incRefnum() {
|
|
int refnum = ref.refnum;
|
|
Seq.incGoRef(refnum);
|
|
return refnum;
|
|
}
|
|
|
|
Future(Seq.Ref ref) { this.ref = ref; }
|
|
|
|
public Future() { this.ref = __New(); }
|
|
|
|
private static native Seq.Ref __New();
|
|
|
|
public final native java.util.concurrent.Future getFuture();
|
|
public final native void setFuture(java.util.concurrent.Future v);
|
|
|
|
@Override public native java.lang.Object get() throws java.lang.InterruptedException, java.util.concurrent.ExecutionException;
|
|
@Override public native java.lang.Object get(long p0, java.util.concurrent.TimeUnit p1) throws java.lang.InterruptedException, java.util.concurrent.ExecutionException, java.util.concurrent.TimeoutException;
|
|
}
|
|
|
|
// Java class java.InputStream is a proxy for talking to a Go program.
|
|
// gobind -lang=java classes
|
|
//
|
|
// File is generated by gobind. Do not edit.
|
|
package java;
|
|
|
|
import go.Seq;
|
|
|
|
public final class InputStream extends java.io.InputStream implements Seq.GoObject {
|
|
static { Java.touch(); }
|
|
|
|
private final Seq.Ref ref;
|
|
|
|
@Override public final int incRefnum() {
|
|
int refnum = ref.refnum;
|
|
Seq.incGoRef(refnum);
|
|
return refnum;
|
|
}
|
|
|
|
public InputStream() {
|
|
super();
|
|
this.ref = __NewInputStream();
|
|
}
|
|
|
|
private static native Seq.Ref __NewInputStream();
|
|
|
|
public final native java.io.InputStream getInputStream();
|
|
public final native void setInputStream(java.io.InputStream v);
|
|
|
|
@Override public native int read() throws java.io.IOException;
|
|
}
|
|
|
|
// Java class java.Object is a proxy for talking to a Go program.
|
|
// gobind -lang=java classes
|
|
//
|
|
// File is generated by gobind. Do not edit.
|
|
package java;
|
|
|
|
import go.Seq;
|
|
|
|
public final class Object extends java.lang.Object implements Seq.GoObject {
|
|
static { Java.touch(); }
|
|
|
|
private final Seq.Ref ref;
|
|
|
|
@Override public final int incRefnum() {
|
|
int refnum = ref.refnum;
|
|
Seq.incGoRef(refnum);
|
|
return refnum;
|
|
}
|
|
|
|
Object(Seq.Ref ref) { this.ref = ref; }
|
|
|
|
public Object() { this.ref = __New(); }
|
|
|
|
private static native Seq.Ref __New();
|
|
|
|
public final native java.lang.Object getObject();
|
|
public final native void setObject(java.lang.Object v);
|
|
|
|
}
|
|
|
|
// Java class java.Runnable is a proxy for talking to a Go program.
|
|
// gobind -lang=java classes
|
|
//
|
|
// File is generated by gobind. Do not edit.
|
|
package java;
|
|
|
|
import go.Seq;
|
|
|
|
public final class Runnable implements Seq.GoObject, java.lang.Runnable {
|
|
static { Java.touch(); }
|
|
|
|
private final Seq.Ref ref;
|
|
|
|
@Override public final int incRefnum() {
|
|
int refnum = ref.refnum;
|
|
Seq.incGoRef(refnum);
|
|
return refnum;
|
|
}
|
|
|
|
Runnable(Seq.Ref ref) { this.ref = ref; }
|
|
|
|
public Runnable() { this.ref = __New(); }
|
|
|
|
private static native Seq.Ref __New();
|
|
|
|
public final native java.lang.Runnable getRunnable();
|
|
public final native void setRunnable(java.lang.Runnable v);
|
|
|
|
@Override public native void run();
|
|
}
|
|
|
|
// Java class java.Java is a proxy for talking to a Go program.
|
|
// gobind -lang=java classes
|
|
//
|
|
// File is generated by gobind. Do not edit.
|
|
package java;
|
|
|
|
import go.Seq;
|
|
|
|
public abstract class Java {
|
|
static {
|
|
Seq.touch(); // for loading the native library
|
|
_init();
|
|
}
|
|
|
|
private Java() {} // uninstantiable
|
|
|
|
// touch is called from other bound packages to initialize this package
|
|
public static void touch() {}
|
|
|
|
private static native void _init();
|
|
|
|
|
|
|
|
public static native InputStream newInputStream();
|
|
}
|