mirror of
https://github.com/wassname/ray.git
synced 2026-06-29 00:55:31 +08:00
[Java] improve Java API module (#2783)
API module (`ray/java/api` dir) includes all public APIs provided by Ray, it should be the only module that normal Ray users need to face. The purpose of this PR to first improve the code quality of the API module. Subsequent PRs will improve other modules later. The changes of this PR include the following aspects: 1) Only keep interfaces in api module, to hide implementation details from users and fix circular dependencies among modules. 2) Document everything in the api module. 3) Improve naming. 4) Add more tests for API. 5) Also fix/improve related code in other modules. 6) Remove some unused code. (Apologize for posting such a large PR. Java worker code has been lack of maintenance for a while. There're a lot of code quality issues that need to be fixed. We plan to use a couple of large PRs to address them. After that, future changes will come in small PRs.)
This commit is contained in:
Hao Chen
committed by
Robert Nishihara
Robert Nishihara
parent
2691b3a11a
commit
3b0a2c4197
@@ -20,19 +20,11 @@
|
||||
|
||||
<dependencies>
|
||||
|
||||
<dependency>
|
||||
<groupId>org.ray</groupId>
|
||||
<artifactId>ray-common</artifactId>
|
||||
<version>${project.version}</version>
|
||||
</dependency>
|
||||
|
||||
<!-- https://mvnrepository.com/artifact/commons-cli/commons-cli -->
|
||||
<dependency>
|
||||
<groupId>commons-cli</groupId>
|
||||
<artifactId>commons-cli</artifactId>
|
||||
</dependency>
|
||||
|
||||
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
|
||||
<dependency>
|
||||
<groupId>org.apache.commons</groupId>
|
||||
<artifactId>commons-lang3</artifactId>
|
||||
|
||||
@@ -1,99 +1,124 @@
|
||||
package org.ray.api;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import java.util.List;
|
||||
import org.ray.api.internal.RayConnector;
|
||||
import org.ray.util.exception.TaskExecutionException;
|
||||
import org.ray.util.logger.RayLog;
|
||||
import org.ray.api.id.UniqueId;
|
||||
import org.ray.api.runtime.DefaultRayRuntimeFactory;
|
||||
import org.ray.api.runtime.RayRuntime;
|
||||
import org.ray.api.runtime.RayRuntimeFactory;
|
||||
|
||||
/**
|
||||
* Ray API.
|
||||
* This class contains all public APIs of Ray.
|
||||
*/
|
||||
public final class Ray extends Rpc {
|
||||
public final class Ray extends RayCall {
|
||||
|
||||
private static RayApi impl = null;
|
||||
private static RayRuntime runtime = null;
|
||||
|
||||
/**
|
||||
* initialize the current worker or the single-box cluster.
|
||||
* Initialize Ray runtime with the default runtime implementation.
|
||||
*/
|
||||
public static void init() {
|
||||
if (impl == null) {
|
||||
impl = RayConnector.run();
|
||||
init(new DefaultRayRuntimeFactory());
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize Ray runtime with a custom runtime implementation.
|
||||
*
|
||||
* @param factory A factory that produces the runtime instance.
|
||||
*/
|
||||
public static synchronized void init(RayRuntimeFactory factory) {
|
||||
if (runtime == null) {
|
||||
runtime = factory.createRayRuntime();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Put obj into object store.
|
||||
* Shutdown Ray runtime.
|
||||
*/
|
||||
public static void shutdown() {
|
||||
runtime.shutdown();
|
||||
}
|
||||
|
||||
/**
|
||||
* Store an object in the object store.
|
||||
*
|
||||
* @param obj The Java object to be stored.
|
||||
* @return A RayObject instance that represents the in-store object.
|
||||
*/
|
||||
public static <T> RayObject<T> put(T obj) {
|
||||
return impl.put(obj);
|
||||
}
|
||||
|
||||
public static <T, TMT> RayObject<T> put(T obj, TMT metadata) {
|
||||
return impl.put(obj, metadata);
|
||||
return runtime.put(obj);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get obj(s) from object store.
|
||||
*/
|
||||
static <T> T get(UniqueID objectId) throws TaskExecutionException {
|
||||
return impl.get(objectId);
|
||||
}
|
||||
|
||||
static <T> List<T> get(List<UniqueID> objectIds) throws TaskExecutionException {
|
||||
return impl.get(objectIds);
|
||||
}
|
||||
|
||||
static <T> T getMeta(UniqueID objectId) throws TaskExecutionException {
|
||||
return impl.getMeta(objectId);
|
||||
}
|
||||
|
||||
static <T> List<T> getMeta(List<UniqueID> objectIds) throws TaskExecutionException {
|
||||
return impl.getMeta(objectIds);
|
||||
}
|
||||
|
||||
/**
|
||||
* wait until timeout or enough RayObject are ready.
|
||||
* Get an object from the object store.
|
||||
*
|
||||
* @param waitfor wait for who
|
||||
* @param numReturns how many of ready is enough
|
||||
* @param timeoutMilliseconds in millisecond
|
||||
* @param objectId The ID of the object to get.
|
||||
* @return The Java object.
|
||||
*/
|
||||
public static <T> WaitResult<T> wait(List<RayObject<T>> waitfor, int numReturns,
|
||||
int timeoutMilliseconds) {
|
||||
return impl.wait(waitfor, numReturns, timeoutMilliseconds);
|
||||
}
|
||||
|
||||
public static <T> WaitResult<T> wait(List<RayObject<T>> waitfor, int numReturns) {
|
||||
return impl.wait(waitfor, numReturns, Integer.MAX_VALUE);
|
||||
}
|
||||
|
||||
public static <T> WaitResult<T> wait(List<RayObject<T>> waitfor) {
|
||||
return impl.wait(waitfor, waitfor.size(), Integer.MAX_VALUE);
|
||||
public static <T> T get(UniqueId objectId) {
|
||||
return runtime.get(objectId);
|
||||
}
|
||||
|
||||
/**
|
||||
* create actor object.
|
||||
* Get a list of objects from the object store.
|
||||
*
|
||||
* @param objectIds The list of object IDs.
|
||||
* @return A list of Java objects.
|
||||
*/
|
||||
public static <T> RayActor<T> create(Class<T> cls) {
|
||||
try {
|
||||
if (cls.getConstructor() == null) {
|
||||
System.err.println("class " + cls.getName()
|
||||
+ " does not (actors must) have a constructor with no arguments");
|
||||
RayLog.core.error("class {} does not (actors must) have a constructor with no arguments",
|
||||
cls.getName());
|
||||
}
|
||||
} catch (Exception e) {
|
||||
System.exit(1);
|
||||
return null;
|
||||
}
|
||||
return impl.create(cls);
|
||||
public static <T> List<T> get(List<UniqueId> objectIds) {
|
||||
return runtime.get(objectIds);
|
||||
}
|
||||
|
||||
/**
|
||||
* get underlying runtime.
|
||||
* Wait for a list of RayObjects to be locally available,
|
||||
* until specified number of objects are ready, or specified timeout has passed.
|
||||
*
|
||||
* @param waitList A list of RayObject to wait for.
|
||||
* @param numReturns The number of objects that should be returned.
|
||||
* @param timeoutMs The maximum time in milliseconds to wait before returning.
|
||||
* @return Two lists, one containing locally available objects, one containing the rest.
|
||||
*/
|
||||
static RayApi internal() {
|
||||
return impl;
|
||||
public static <T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns,
|
||||
int timeoutMs) {
|
||||
return runtime.wait(waitList, numReturns, timeoutMs);
|
||||
}
|
||||
|
||||
/**
|
||||
* A convenient helper method for Ray.wait. It will wait infinitely until
|
||||
* specified number of objects are locally available.
|
||||
*
|
||||
* @param waitList A list of RayObject to wait for.
|
||||
* @param numReturns The number of objects that should be returned.
|
||||
* @return Two lists, one containing locally available objects, one containing the rest.
|
||||
*/
|
||||
public static <T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns) {
|
||||
return runtime.wait(waitList, numReturns, Integer.MAX_VALUE);
|
||||
}
|
||||
|
||||
/**
|
||||
* A convenient helper method for Ray.wait. It will wait infinitely until
|
||||
* all objects are locally available.
|
||||
*
|
||||
* @param waitList A list of RayObject to wait for.
|
||||
* @return Two lists, one containing locally available objects, one containing the rest.
|
||||
*/
|
||||
public static <T> WaitResult<T> wait(List<RayObject<T>> waitList) {
|
||||
return runtime.wait(waitList, waitList.size(), Integer.MAX_VALUE);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an actor on a remote node.
|
||||
*
|
||||
* @param actorClass the class of the actor to be created.
|
||||
* @return A handle to the newly created actor.
|
||||
*/
|
||||
public static <T> RayActor<T> createActor(Class<T> actorClass) {
|
||||
return runtime.createActor(actorClass);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the underlying runtime instance.
|
||||
*/
|
||||
static RayRuntime internal() {
|
||||
return runtime;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,87 +1,20 @@
|
||||
package org.ray.api;
|
||||
|
||||
import java.io.Externalizable;
|
||||
import java.io.IOException;
|
||||
import java.io.ObjectInput;
|
||||
import java.io.ObjectOutput;
|
||||
import org.ray.util.Sha1Digestor;
|
||||
import org.ray.api.id.UniqueId;
|
||||
|
||||
/**
|
||||
* Ray actor abstraction.
|
||||
* A handle to an actor.
|
||||
* @param <T> The type of the concrete actor class.
|
||||
*/
|
||||
public class RayActor<T> extends RayObject<T> implements Externalizable {
|
||||
public static final RayActor<?> NIL = new RayActor<>(UniqueID.NIL, UniqueID.NIL);
|
||||
private static final long serialVersionUID = 1877485807405645036L;
|
||||
|
||||
private int taskCounter = 0;
|
||||
|
||||
private UniqueID taskCursor = null;
|
||||
|
||||
private UniqueID actorHandleId = UniqueID.NIL;
|
||||
|
||||
private int forksNum = 0;
|
||||
|
||||
public RayActor() {
|
||||
}
|
||||
|
||||
public RayActor(UniqueID id) {
|
||||
super(id);
|
||||
this.taskCounter = 1;
|
||||
}
|
||||
|
||||
public RayActor(UniqueID id, UniqueID actorHandleId) {
|
||||
super(id);
|
||||
this.actorHandleId = actorHandleId;
|
||||
this.taskCounter = 0;
|
||||
}
|
||||
|
||||
public int increaseTaskCounter() {
|
||||
return taskCounter++;
|
||||
}
|
||||
public interface RayActor<T> {
|
||||
|
||||
/**
|
||||
* Getter method for property <tt>taskCursor</tt>.
|
||||
*
|
||||
* @return property value of taskCursor
|
||||
* @return The id of this actor.
|
||||
*/
|
||||
public UniqueID getTaskCursor() {
|
||||
return taskCursor;
|
||||
}
|
||||
UniqueId getId();
|
||||
|
||||
/**
|
||||
* Setter method for property <tt>taskCursor</tt>.
|
||||
*
|
||||
* @param taskCursor value to be assigned to property taskCursor
|
||||
* @return The id of this actor handle.
|
||||
*/
|
||||
public void setTaskCursor(UniqueID taskCursor) {
|
||||
this.taskCursor = taskCursor;
|
||||
}
|
||||
|
||||
public UniqueID getActorHandleId() {
|
||||
return actorHandleId;
|
||||
}
|
||||
|
||||
public void setActorHandleId(UniqueID actorHandleId) {
|
||||
this.actorHandleId = actorHandleId;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeExternal(ObjectOutput out) throws IOException {
|
||||
out.writeObject(this.id);
|
||||
out.writeObject(this.computeNextActorHandleId());
|
||||
out.writeObject(this.taskCursor);
|
||||
}
|
||||
|
||||
public UniqueID computeNextActorHandleId() {
|
||||
byte[] bytes = Sha1Digestor.digest(actorHandleId.getBytes(), ++forksNum);
|
||||
return new UniqueID(bytes);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
|
||||
|
||||
this.id = (UniqueID) in.readObject();
|
||||
this.actorHandleId = (UniqueID) in.readObject();
|
||||
this.taskCursor = (UniqueID) in.readObject();
|
||||
}
|
||||
}
|
||||
UniqueId getHandleId();
|
||||
}
|
||||
|
||||
@@ -1,60 +0,0 @@
|
||||
package org.ray.api;
|
||||
|
||||
import java.util.List;
|
||||
import org.ray.api.funcs.RayFunc;
|
||||
import org.ray.util.exception.TaskExecutionException;
|
||||
|
||||
/**
|
||||
* Ray runtime abstraction.
|
||||
*/
|
||||
public interface RayApi {
|
||||
|
||||
/**
|
||||
* Put obj into object store.
|
||||
*
|
||||
* @return RayObject
|
||||
*/
|
||||
<T> RayObject<T> put(T obj);
|
||||
|
||||
<T, TMT> RayObject<T> put(T obj, TMT metadata);
|
||||
|
||||
/**
|
||||
* Get real obj from object store.
|
||||
*/
|
||||
<T> T get(UniqueID objectId) throws TaskExecutionException;
|
||||
|
||||
/**
|
||||
* Get real objects from object store.
|
||||
*
|
||||
* @param objectIds list of ids of objects to get
|
||||
*/
|
||||
<T> List<T> get(List<UniqueID> objectIds) throws TaskExecutionException;
|
||||
|
||||
<T> T getMeta(UniqueID objectId) throws TaskExecutionException;
|
||||
|
||||
<T> List<T> getMeta(List<UniqueID> objectIds) throws TaskExecutionException;
|
||||
|
||||
/**
|
||||
* wait until timeout or enough RayObjects are ready.
|
||||
*
|
||||
* @param waitfor wait for who
|
||||
* @param numReturns how many of ready is enough
|
||||
* @param timeout in millisecond
|
||||
*/
|
||||
<T> WaitResult<T> wait(List<RayObject<T>> waitfor, int numReturns, int timeout);
|
||||
|
||||
/**
|
||||
* create remote actor.
|
||||
*/
|
||||
<T> RayActor<T> create(Class<T> cls);
|
||||
|
||||
/**
|
||||
* Invoke a remote function.
|
||||
*
|
||||
* @param func the target running function
|
||||
* @param args arguments to this funcRun, can be its original form or RayObject
|
||||
* @return a set of ray objects with their return ids
|
||||
*/
|
||||
RayObject call(RayFunc func, Object... args);
|
||||
|
||||
}
|
||||
@@ -0,0 +1,772 @@
|
||||
// generated automatically, do not modify.
|
||||
|
||||
package org.ray.api;
|
||||
|
||||
import org.ray.api.function.*;
|
||||
|
||||
/**
|
||||
* This class provides type-safe interfaces for Ray.call.
|
||||
**/
|
||||
@SuppressWarnings({"rawtypes", "unchecked"})
|
||||
class RayCall {
|
||||
public static <R> RayObject<R> call(RayFunc0<R> f) {
|
||||
Object[] args = new Object[]{};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, R> RayObject<R> call(RayFunc1<T0, R> f, RayActor<T0> actor) {
|
||||
Object[] args = new Object[]{};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, R> RayObject<R> call(RayFunc1<T0, R> f, T0 t0) {
|
||||
Object[] args = new Object[]{t0};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, R> RayObject<R> call(RayFunc1<T0, R> f, RayObject<T0> t0) {
|
||||
Object[] args = new Object[]{t0};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, RayActor<T0> actor, T1 t1) {
|
||||
Object[] args = new Object[]{t1};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, RayActor<T0> actor, RayObject<T1> t1) {
|
||||
Object[] args = new Object[]{t1};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, T0 t0, T1 t1) {
|
||||
Object[] args = new Object[]{t0, t1};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, T0 t0, RayObject<T1> t1) {
|
||||
Object[] args = new Object[]{t0, t1};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, RayObject<T0> t0, T1 t1) {
|
||||
Object[] args = new Object[]{t0, t1};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, R> RayObject<R> call(RayFunc2<T0, T1, R> f, RayObject<T0> t0, RayObject<T1> t1) {
|
||||
Object[] args = new Object[]{t0, t1};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayActor<T0> actor, T1 t1, T2 t2) {
|
||||
Object[] args = new Object[]{t1, t2};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2) {
|
||||
Object[] args = new Object[]{t1, t2};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2) {
|
||||
Object[] args = new Object[]{t1, t2};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2) {
|
||||
Object[] args = new Object[]{t1, t2};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, T0 t0, T1 t1, T2 t2) {
|
||||
Object[] args = new Object[]{t0, t1, t2};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, T0 t0, T1 t1, RayObject<T2> t2) {
|
||||
Object[] args = new Object[]{t0, t1, t2};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, T0 t0, RayObject<T1> t1, T2 t2) {
|
||||
Object[] args = new Object[]{t0, t1, t2};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2) {
|
||||
Object[] args = new Object[]{t0, t1, t2};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayObject<T0> t0, T1 t1, T2 t2) {
|
||||
Object[] args = new Object[]{t0, t1, t2};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2) {
|
||||
Object[] args = new Object[]{t0, t1, t2};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2) {
|
||||
Object[] args = new Object[]{t0, t1, t2};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, R> RayObject<R> call(RayFunc3<T0, T1, T2, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2) {
|
||||
Object[] args = new Object[]{t0, t1, t2};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayActor<T0> actor, T1 t1, T2 t2, T3 t3) {
|
||||
Object[] args = new Object[]{t1, t2, t3};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayActor<T0> actor, T1 t1, T2 t2, RayObject<T3> t3) {
|
||||
Object[] args = new Object[]{t1, t2, t3};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, T3 t3) {
|
||||
Object[] args = new Object[]{t1, t2, t3};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
|
||||
Object[] args = new Object[]{t1, t2, t3};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, T3 t3) {
|
||||
Object[] args = new Object[]{t1, t2, t3};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
|
||||
Object[] args = new Object[]{t1, t2, t3};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
|
||||
Object[] args = new Object[]{t1, t2, t3};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
|
||||
Object[] args = new Object[]{t1, t2, t3};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, T1 t1, T2 t2, T3 t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, R> RayObject<R> call(RayFunc4<T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, T1 t1, T2 t2, T3 t3, T4 t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc5<T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayActor<T0> actor, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, actor, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
public static <T0, T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc6<T0, T1, T2, T3, T4, T5, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
Object[] args = new Object[]{t0, t1, t2, t3, t4, t5};
|
||||
return Ray.internal().call(f, args);
|
||||
}
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
package org.ray.api;
|
||||
|
||||
public @interface RayDisabled {
|
||||
|
||||
}
|
||||
@@ -1,35 +1,23 @@
|
||||
package org.ray.api;
|
||||
|
||||
import java.io.Serializable;
|
||||
import org.ray.util.exception.TaskExecutionException;
|
||||
import org.ray.api.id.UniqueId;
|
||||
|
||||
/**
|
||||
* RayObject<T> is a handle for T object, which may or may not be available now.
|
||||
* That said, RayObject can be viewed as a Future object with metadata.
|
||||
* Represents an object in the object store.
|
||||
* @param <T> The object type.
|
||||
*/
|
||||
public class RayObject<T> implements Serializable {
|
||||
public interface RayObject<T> {
|
||||
|
||||
private static final long serialVersionUID = 3250003902037418062L;
|
||||
/**
|
||||
* Fetch the object from the object store, this method will block
|
||||
* until the object is locally available.
|
||||
*/
|
||||
T get();
|
||||
|
||||
UniqueID id;
|
||||
|
||||
public RayObject() {
|
||||
}
|
||||
|
||||
public RayObject(UniqueID id) {
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
public T get() throws TaskExecutionException {
|
||||
return Ray.get(id);
|
||||
}
|
||||
|
||||
public <TMT> TMT getMeta() throws TaskExecutionException {
|
||||
return Ray.getMeta(id);
|
||||
}
|
||||
|
||||
public UniqueID getId() {
|
||||
return id;
|
||||
}
|
||||
/**
|
||||
* Get the object id.
|
||||
*/
|
||||
UniqueId getId();
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -1,20 +0,0 @@
|
||||
package org.ray.api;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
import org.ray.util.ResourceItem;
|
||||
|
||||
/**
|
||||
* a ray remote function or class (as an actor).
|
||||
*/
|
||||
@Target({ElementType.METHOD, ElementType.TYPE})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
public @interface RayRemote {
|
||||
/**
|
||||
* This is used for default resources.
|
||||
* @return The resources of the method or actor need.
|
||||
*/
|
||||
ResourceItem[] resources() default {@ResourceItem()};
|
||||
}
|
||||
@@ -1,9 +0,0 @@
|
||||
package org.ray.api;
|
||||
|
||||
/**
|
||||
* a RPC service that represent the data processing services implemented in Ray.
|
||||
* it is programmed in other services but will be shipped and executed on ray machines at runtime
|
||||
*/
|
||||
public @interface RayService {
|
||||
|
||||
}
|
||||
@@ -1,390 +0,0 @@
|
||||
// generated automatically, do not modify.
|
||||
|
||||
package org.ray.api;
|
||||
|
||||
import org.ray.api.funcs.*;
|
||||
|
||||
@SuppressWarnings({"rawtypes", "unchecked"})
|
||||
class Rpc {
|
||||
public static <R> RayObject<R> call(RayFunc0<R> f) {
|
||||
return Ray.internal().call(f);
|
||||
}
|
||||
public static <T1, R> RayObject<R> call(RayFunc1<T1, R> f, T1 t1) {
|
||||
return Ray.internal().call(f, t1);
|
||||
}
|
||||
public static <T1, R> RayObject<R> call(RayFunc1<T1, R> f, RayObject<T1> t1) {
|
||||
return Ray.internal().call(f, t1);
|
||||
}
|
||||
public static <T1, T2, R> RayObject<R> call(RayFunc2<T1, T2, R> f, T1 t1, T2 t2) {
|
||||
return Ray.internal().call(f, t1, t2);
|
||||
}
|
||||
public static <T1, T2, R> RayObject<R> call(RayFunc2<T1, T2, R> f, T1 t1, RayObject<T2> t2) {
|
||||
return Ray.internal().call(f, t1, t2);
|
||||
}
|
||||
public static <T1, T2, R> RayObject<R> call(RayFunc2<T1, T2, R> f, RayObject<T1> t1, T2 t2) {
|
||||
return Ray.internal().call(f, t1, t2);
|
||||
}
|
||||
public static <T1, T2, R> RayObject<R> call(RayFunc2<T1, T2, R> f, RayObject<T1> t1, RayObject<T2> t2) {
|
||||
return Ray.internal().call(f, t1, t2);
|
||||
}
|
||||
public static <T1, T2, T3, R> RayObject<R> call(RayFunc3<T1, T2, T3, R> f, T1 t1, T2 t2, T3 t3) {
|
||||
return Ray.internal().call(f, t1, t2, t3);
|
||||
}
|
||||
public static <T1, T2, T3, R> RayObject<R> call(RayFunc3<T1, T2, T3, R> f, T1 t1, T2 t2, RayObject<T3> t3) {
|
||||
return Ray.internal().call(f, t1, t2, t3);
|
||||
}
|
||||
public static <T1, T2, T3, R> RayObject<R> call(RayFunc3<T1, T2, T3, R> f, T1 t1, RayObject<T2> t2, T3 t3) {
|
||||
return Ray.internal().call(f, t1, t2, t3);
|
||||
}
|
||||
public static <T1, T2, T3, R> RayObject<R> call(RayFunc3<T1, T2, T3, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
|
||||
return Ray.internal().call(f, t1, t2, t3);
|
||||
}
|
||||
public static <T1, T2, T3, R> RayObject<R> call(RayFunc3<T1, T2, T3, R> f, RayObject<T1> t1, T2 t2, T3 t3) {
|
||||
return Ray.internal().call(f, t1, t2, t3);
|
||||
}
|
||||
public static <T1, T2, T3, R> RayObject<R> call(RayFunc3<T1, T2, T3, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
|
||||
return Ray.internal().call(f, t1, t2, t3);
|
||||
}
|
||||
public static <T1, T2, T3, R> RayObject<R> call(RayFunc3<T1, T2, T3, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
|
||||
return Ray.internal().call(f, t1, t2, t3);
|
||||
}
|
||||
public static <T1, T2, T3, R> RayObject<R> call(RayFunc3<T1, T2, T3, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
|
||||
return Ray.internal().call(f, t1, t2, t3);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, T1 t1, T2 t2, T3 t3, T4 t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, R> RayObject<R> call(RayFunc4<T1, T2, T3, T4, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, R> RayObject<R> call(RayFunc5<T1, T2, T3, T4, T5, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, T3 t3, T4 t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, T5 t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, T6 t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
public static <T1, T2, T3, T4, T5, T6, R> RayObject<R> call(RayFunc6<T1, T2, T3, T4, T5, T6, R> f, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4, RayObject<T5> t5, RayObject<T6> t6) {
|
||||
return Ray.internal().call(f, t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
package org.ray.api;
|
||||
|
||||
import java.io.Serializable;
|
||||
|
||||
/**
|
||||
* Represents a status of type T of a task.
|
||||
*/
|
||||
public class TaskStatus<T> implements Serializable {
|
||||
|
||||
private static final long serialVersionUID = -3382082416577683751L;
|
||||
|
||||
public T status;
|
||||
}
|
||||
@@ -4,24 +4,31 @@ package org.ray.api;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* The result of Ray.wait() distinguish the ready ones and the remain ones
|
||||
* Represents the result of a Ray.wait call. It contains 2 lists,
|
||||
* one containing the locally available objects, one containing the rest.
|
||||
*/
|
||||
public class WaitResult<T> {
|
||||
public final class WaitResult<T> {
|
||||
|
||||
private final List<RayObject<T>> readyOnes;
|
||||
private final List<RayObject<T>> remainOnes;
|
||||
private final List<RayObject<T>> ready;
|
||||
private final List<RayObject<T>> unready;
|
||||
|
||||
public WaitResult(List<RayObject<T>> readyOnes, List<RayObject<T>> remainOnes) {
|
||||
this.readyOnes = readyOnes;
|
||||
this.remainOnes = remainOnes;
|
||||
public WaitResult(List<RayObject<T>> ready, List<RayObject<T>> unready) {
|
||||
this.ready = ready;
|
||||
this.unready = unready;
|
||||
}
|
||||
|
||||
public List<RayObject<T>> getReadyOnes() {
|
||||
return readyOnes;
|
||||
/**
|
||||
* Get the list of ready objects.
|
||||
*/
|
||||
public List<RayObject<T>> getReady() {
|
||||
return ready;
|
||||
}
|
||||
|
||||
public List<RayObject<T>> getRemainOnes() {
|
||||
return remainOnes;
|
||||
/**
|
||||
* Get the list of unready objects.
|
||||
*/
|
||||
public List<RayObject<T>> getUnready() {
|
||||
return unready;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
package org.ray.api.annotation;
|
||||
|
||||
import java.lang.annotation.Documented;
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Defines a remote function (when used on a method),
|
||||
* or an actor (when used on a class).
|
||||
*/
|
||||
@Documented
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Target({ElementType.METHOD, ElementType.TYPE})
|
||||
public @interface RayRemote {
|
||||
|
||||
/**
|
||||
* Defines the quantity of various custom resources to reserve
|
||||
* for this task or for the lifetime of the actor.
|
||||
* @return an array of custom resource items.
|
||||
*/
|
||||
ResourceItem[] resources() default {};
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
package org.ray.api.annotation;
|
||||
|
||||
|
||||
import java.lang.annotation.Documented;
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Represents a custom resource, including its name and quantity.
|
||||
*/
|
||||
@Documented
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Target(ElementType.ANNOTATION_TYPE)
|
||||
public @interface ResourceItem {
|
||||
|
||||
/**
|
||||
* Name of this resource, must not be null or empty.
|
||||
*/
|
||||
String name();
|
||||
|
||||
/**
|
||||
* Quantity of this resource.
|
||||
*/
|
||||
double value() default 0;
|
||||
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
package org.ray.api.exception;
|
||||
|
||||
/**
|
||||
* Base class of all ray exceptions.
|
||||
*/
|
||||
public class RayException extends RuntimeException {
|
||||
|
||||
public RayException(String message) {
|
||||
super(message);
|
||||
}
|
||||
|
||||
public RayException(String message, Throwable cause) {
|
||||
super(message, cause);
|
||||
}
|
||||
}
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
package org.ray.api.funcs;
|
||||
package org.ray.api.function;
|
||||
|
||||
import java.io.Serializable;
|
||||
|
||||
+4
-1
@@ -1,7 +1,10 @@
|
||||
// generated automatically, do not modify.
|
||||
|
||||
package org.ray.api.funcs;
|
||||
package org.ray.api.function;
|
||||
|
||||
/**
|
||||
* Functional interface for a remote function that has 0 parameter.
|
||||
*/
|
||||
@FunctionalInterface
|
||||
public interface RayFunc0<R> extends RayFunc {
|
||||
R apply();
|
||||
+4
-1
@@ -1,7 +1,10 @@
|
||||
// generated automatically, do not modify.
|
||||
|
||||
package org.ray.api.funcs;
|
||||
package org.ray.api.function;
|
||||
|
||||
/**
|
||||
* Functional interface for a remote function that has 1 parameter.
|
||||
*/
|
||||
@FunctionalInterface
|
||||
public interface RayFunc1<T0, R> extends RayFunc {
|
||||
R apply(T0 t0);
|
||||
+4
-1
@@ -1,7 +1,10 @@
|
||||
// generated automatically, do not modify.
|
||||
|
||||
package org.ray.api.funcs;
|
||||
package org.ray.api.function;
|
||||
|
||||
/**
|
||||
* Functional interface for a remote function that has 2 parameters.
|
||||
*/
|
||||
@FunctionalInterface
|
||||
public interface RayFunc2<T0, T1, R> extends RayFunc {
|
||||
R apply(T0 t0, T1 t1);
|
||||
+4
-1
@@ -1,7 +1,10 @@
|
||||
// generated automatically, do not modify.
|
||||
|
||||
package org.ray.api.funcs;
|
||||
package org.ray.api.function;
|
||||
|
||||
/**
|
||||
* Functional interface for a remote function that has 3 parameters.
|
||||
*/
|
||||
@FunctionalInterface
|
||||
public interface RayFunc3<T0, T1, T2, R> extends RayFunc {
|
||||
R apply(T0 t0, T1 t1, T2 t2);
|
||||
+4
-1
@@ -1,7 +1,10 @@
|
||||
// generated automatically, do not modify.
|
||||
|
||||
package org.ray.api.funcs;
|
||||
package org.ray.api.function;
|
||||
|
||||
/**
|
||||
* Functional interface for a remote function that has 4 parameters.
|
||||
*/
|
||||
@FunctionalInterface
|
||||
public interface RayFunc4<T0, T1, T2, T3, R> extends RayFunc {
|
||||
R apply(T0 t0, T1 t1, T2 t2, T3 t3);
|
||||
+4
-1
@@ -1,7 +1,10 @@
|
||||
// generated automatically, do not modify.
|
||||
|
||||
package org.ray.api.funcs;
|
||||
package org.ray.api.function;
|
||||
|
||||
/**
|
||||
* Functional interface for a remote function that has 5 parameters.
|
||||
*/
|
||||
@FunctionalInterface
|
||||
public interface RayFunc5<T0, T1, T2, T3, T4, R> extends RayFunc {
|
||||
R apply(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4);
|
||||
+4
-1
@@ -1,7 +1,10 @@
|
||||
// generated automatically, do not modify.
|
||||
|
||||
package org.ray.api.funcs;
|
||||
package org.ray.api.function;
|
||||
|
||||
/**
|
||||
* Functional interface for a remote function that has 6 parameters.
|
||||
*/
|
||||
@FunctionalInterface
|
||||
public interface RayFunc6<T0, T1, T2, T3, T4, T5, R> extends RayFunc {
|
||||
R apply(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5);
|
||||
+47
-22
@@ -1,4 +1,4 @@
|
||||
package org.ray.api;
|
||||
package org.ray.api.id;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.nio.ByteBuffer;
|
||||
@@ -7,59 +7,88 @@ import java.util.Random;
|
||||
import javax.xml.bind.DatatypeConverter;
|
||||
|
||||
/**
|
||||
* Unique ID for task, worker, function.
|
||||
* Represents a unique id of all Ray concepts, including
|
||||
* objects, tasks, workers, actors, etc.
|
||||
*/
|
||||
public class UniqueID implements Serializable {
|
||||
public class UniqueId implements Serializable {
|
||||
|
||||
public static final int LENGTH = 20;
|
||||
public static final UniqueID NIL = genNil();
|
||||
public static final UniqueId NIL = genNil();
|
||||
private static final long serialVersionUID = 8588849129675565761L;
|
||||
private final byte[] id;
|
||||
|
||||
public static UniqueID fromHexString(String hex) {
|
||||
/**
|
||||
* Create a UniqueId from a hex string.
|
||||
*/
|
||||
public static UniqueId fromHexString(String hex) {
|
||||
byte[] bytes = DatatypeConverter.parseHexBinary(hex);
|
||||
return new UniqueID(bytes);
|
||||
return new UniqueId(bytes);
|
||||
}
|
||||
|
||||
public static UniqueID fromByteBuffer(ByteBuffer bb) {
|
||||
/**
|
||||
* Creates a UniqueId from a ByteBuffer.
|
||||
*/
|
||||
public static UniqueId fromByteBuffer(ByteBuffer bb) {
|
||||
byte[] id = new byte[bb.remaining()];
|
||||
bb.get(id);
|
||||
|
||||
return new UniqueID(id);
|
||||
return new UniqueId(id);
|
||||
}
|
||||
|
||||
public static UniqueID genNil() {
|
||||
/**
|
||||
* Generate a nil UniqueId.
|
||||
*/
|
||||
public static UniqueId genNil() {
|
||||
byte[] b = new byte[LENGTH];
|
||||
Arrays.fill(b, (byte) 0xFF);
|
||||
return new UniqueID(b);
|
||||
return new UniqueId(b);
|
||||
}
|
||||
|
||||
public static UniqueID randomId() {
|
||||
/**
|
||||
* Generate an UniqueId with random value.
|
||||
*/
|
||||
public static UniqueId randomId() {
|
||||
byte[] b = new byte[LENGTH];
|
||||
new Random().nextBytes(b);
|
||||
return new UniqueID(b);
|
||||
return new UniqueId(b);
|
||||
}
|
||||
|
||||
public UniqueID(byte[] id) {
|
||||
public UniqueId(byte[] id) {
|
||||
if (id.length != LENGTH) {
|
||||
throw new IllegalArgumentException("Illegal argument for UniqueID, expect " + LENGTH
|
||||
throw new IllegalArgumentException("Illegal argument for UniqueId, expect " + LENGTH
|
||||
+ " bytes, but got " + id.length + " bytes.");
|
||||
}
|
||||
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the byte data of this UniqueId.
|
||||
*/
|
||||
public byte[] getBytes() {
|
||||
return id;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert the byte data to a ByteBuffer.
|
||||
*/
|
||||
public ByteBuffer toByteBuffer() {
|
||||
return ByteBuffer.wrap(id);
|
||||
}
|
||||
|
||||
public UniqueID copy() {
|
||||
/**
|
||||
* Create a copy of this UniqueId.
|
||||
*/
|
||||
public UniqueId copy() {
|
||||
byte[] nid = Arrays.copyOf(id, id.length);
|
||||
return new UniqueID(nid);
|
||||
return new UniqueId(nid);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if this id is nil.
|
||||
*/
|
||||
public boolean isNil() {
|
||||
return this.equals(NIL);
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -73,11 +102,11 @@ public class UniqueID implements Serializable {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!(obj instanceof UniqueID)) {
|
||||
if (!(obj instanceof UniqueId)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
UniqueID r = (UniqueID) obj;
|
||||
UniqueId r = (UniqueId) obj;
|
||||
return Arrays.equals(id, r.id);
|
||||
}
|
||||
|
||||
@@ -85,8 +114,4 @@ public class UniqueID implements Serializable {
|
||||
public String toString() {
|
||||
return DatatypeConverter.printHexBinary(id);
|
||||
}
|
||||
|
||||
public boolean isNil() {
|
||||
return this.equals(NIL);
|
||||
}
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
package org.ray.api.internal;
|
||||
|
||||
import java.lang.reflect.Method;
|
||||
import org.ray.api.RayApi;
|
||||
import org.ray.util.logger.RayLog;
|
||||
|
||||
/**
|
||||
* Mediator, which pulls the {@code org.ray.api.RayApi} up to run.
|
||||
*/
|
||||
public class RayConnector {
|
||||
|
||||
private static final String className = "org.ray.core.RayRuntime";
|
||||
|
||||
public static RayApi run() {
|
||||
try {
|
||||
Method m = Class.forName(className).getDeclaredMethod("init");
|
||||
m.setAccessible(true);
|
||||
RayApi api = (RayApi) m.invoke(null);
|
||||
m.setAccessible(false);
|
||||
return api;
|
||||
} catch (ReflectiveOperationException | IllegalArgumentException | SecurityException e) {
|
||||
RayLog.core.error("Load {} class failed.", className, e);
|
||||
throw new Error("RayApi is not successfully initiated.");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
package org.ray.api.runtime;
|
||||
|
||||
import java.lang.reflect.Method;
|
||||
|
||||
/**
|
||||
* The default Ray runtime factory. It produces an instance of AbstractRayRuntime.
|
||||
*/
|
||||
public class DefaultRayRuntimeFactory implements RayRuntimeFactory {
|
||||
|
||||
@Override
|
||||
public RayRuntime createRayRuntime() {
|
||||
try {
|
||||
Method m = Class.forName("org.ray.core.AbstractRayRuntime").getDeclaredMethod("init");
|
||||
m.setAccessible(true);
|
||||
RayRuntime runtime = (RayRuntime) m.invoke(null);
|
||||
m.setAccessible(false);
|
||||
return runtime;
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException("Failed to initialize ray runtime", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
package org.ray.api.runtime;
|
||||
|
||||
import java.util.List;
|
||||
import org.ray.api.RayActor;
|
||||
import org.ray.api.RayObject;
|
||||
import org.ray.api.WaitResult;
|
||||
import org.ray.api.function.RayFunc;
|
||||
import org.ray.api.id.UniqueId;
|
||||
|
||||
/**
|
||||
* Base interface of a Ray runtime.
|
||||
*/
|
||||
public interface RayRuntime {
|
||||
|
||||
/**
|
||||
* Shutdown the runtime.
|
||||
*/
|
||||
void shutdown();
|
||||
|
||||
/**
|
||||
* Store an object in the object store.
|
||||
*
|
||||
* @param obj The Java object to be stored.
|
||||
* @return A RayObject instance that represents the in-store object.
|
||||
*/
|
||||
<T> RayObject<T> put(T obj);
|
||||
|
||||
/**
|
||||
* Get an object from the object store.
|
||||
*
|
||||
* @param objectId The ID of the object to get.
|
||||
* @return The Java object.
|
||||
*/
|
||||
<T> T get(UniqueId objectId);
|
||||
|
||||
/**
|
||||
* Get a list of objects from the object store.
|
||||
*
|
||||
* @param objectIds The list of object IDs.
|
||||
* @return A list of Java objects.
|
||||
*/
|
||||
<T> List<T> get(List<UniqueId> objectIds);
|
||||
|
||||
/**
|
||||
* Wait for a list of RayObjects to be locally available,
|
||||
* until specified number of objects are ready, or specified timeout has passed.
|
||||
*
|
||||
* @param waitList A list of RayObject to wait for.
|
||||
* @param numReturns The number of objects that should be returned.
|
||||
* @param timeoutMs The maximum time in milliseconds to wait before returning.
|
||||
* @return Two lists, one containing locally available objects, one containing the rest.
|
||||
*/
|
||||
<T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns, int timeoutMs);
|
||||
|
||||
/**
|
||||
* Create an actor on a remote node.
|
||||
*
|
||||
* @param actorClass the class of the actor to be created.
|
||||
* @return A handle to the newly created actor.
|
||||
*/
|
||||
<T> RayActor<T> createActor(Class<T> actorClass);
|
||||
|
||||
/**
|
||||
* Invoke a remote function.
|
||||
*
|
||||
* @param func The remote function to run.
|
||||
* @param args The arguments of the remote function.
|
||||
* @return The result object.
|
||||
*/
|
||||
RayObject call(RayFunc func, Object[] args);
|
||||
|
||||
/**
|
||||
* Invoke a remote function on an actor.
|
||||
*
|
||||
* @param func The remote function to run, it must be a method of the given actor.
|
||||
* @param actor A handle to the actor.
|
||||
* @param args The arguments of the remote function.
|
||||
* @return The result object.
|
||||
*/
|
||||
RayObject call(RayFunc func, RayActor actor, Object[] args);
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
package org.ray.api.runtime;
|
||||
|
||||
/**
|
||||
* A factory that produces a RayRuntime instance.
|
||||
*/
|
||||
public interface RayRuntimeFactory {
|
||||
|
||||
RayRuntime createRayRuntime();
|
||||
}
|
||||
Reference in New Issue
Block a user