/// <summary>
/// Executes provided closure job on a node in this grid projection.
/// </summary>
/// <param name="clo">Job to run.</param>
/// <param name="arg">Job argument.</param>
/// <returns>Job result for this execution.</returns>
public Future <TJobRes> Apply <TArg, TJobRes>(IComputeFunc <TArg, TJobRes> clo, TArg arg)
{
IgniteArgumentCheck.NotNull(clo, "clo");
return(ExecuteClosures0(new ComputeSingleClosureTask <TArg, TJobRes, TJobRes>(),
new ComputeFuncJob(clo.ToNonGeneric(), arg), null, false));
}
/// <summary>
/// Broadcasts given closure job with passed in argument to all nodes in grid projection.
/// Every participating node will return a job result.
/// </summary>
/// <param name="clo">Job to broadcast to all projection nodes.</param>
/// <param name="arg">Job closure argument.</param>
/// <returns>Collection of results for this execution.</returns>
public Future <ICollection <TJobRes> > Broadcast <TArg, TJobRes>(IComputeFunc <TArg, TJobRes> clo, TArg arg)
{
IgniteArgumentCheck.NotNull(clo, "clo");
return(ExecuteClosures0(new ComputeMultiClosureTask <object, TJobRes, ICollection <TJobRes> >(1),
new ComputeFuncJob(clo.ToNonGeneric(), arg), null, true));
}
/// <summary>
/// Executes provided job on a node in this grid projection. The result of the
/// job execution is returned from the result closure.
/// </summary>
/// <param name="clo">Job to execute.</param>
/// <returns>Job result for this execution.</returns>
public Future <TJobRes> Execute <TJobRes>(IComputeFunc <TJobRes> clo)
{
IgniteArgumentCheck.NotNull(clo, "clo");
return(ExecuteClosures0(new ComputeSingleClosureTask <object, TJobRes, TJobRes>(),
new ComputeOutFuncJob(clo.ToNonGeneric()), null, false));
}
/// <summary>
/// Broadcasts given job to all nodes in grid projection. Every participating node will return a job result.
/// </summary>
/// <param name="clo">Job to broadcast to all projection nodes.</param>
/// <returns>Collection of results for this execution.</returns>
public IFuture <ICollection <TR> > Broadcast <TR>(IComputeFunc <TR> clo)
{
IgniteArgumentCheck.NotNull(clo, "clo");
return(ExecuteClosures0(new ComputeMultiClosureTask <object, TR, ICollection <TR> >(1),
new ComputeOutFuncJob(clo.ToNonGeneric()), null, true));
}
/// <summary>
/// Executes given job on the node where data for provided affinity key is located
/// (a.k.a. affinity co-location).
/// </summary>
/// <param name="cacheName">Name of the cache to use for affinity co-location.</param>
/// <param name="affinityKey">Affinity key.</param>
/// <param name="clo">Job to execute.</param>
/// <returns>Job result for this execution.</returns>
/// <typeparam name="TJobRes">Type of job result.</typeparam>
public Future <TJobRes> AffinityCall <TJobRes>(string cacheName, object affinityKey, IComputeFunc <TJobRes> clo)
{
IgniteArgumentCheck.NotNull(clo, "clo");
return(ExecuteClosures0(new ComputeSingleClosureTask <object, TJobRes, TJobRes>(),
new ComputeOutFuncJob(clo.ToNonGeneric()), opId: OpAffinity,
writeAction: w => WriteAffinity(w, cacheName, affinityKey)));
}
/// <summary>
/// Executes provided closure job on nodes within this grid projection. A new job is executed for
/// every argument in the passed in collection. The number of actual job executions will be
/// equal to size of the job arguments collection.
/// </summary>
/// <param name="clo">Job to run.</param>
/// <param name="args">Job arguments.</param>
/// <returns>Collection of job results.</returns>
public IFuture <ICollection <TR> > Apply <T, TR>(IComputeFunc <T, TR> clo, IEnumerable <T> args)
{
IgniteArgumentCheck.NotNull(clo, "clo");
IgniteArgumentCheck.NotNull(clo, "clo");
var jobs = new List <IComputeJob>(GetCountOrZero(args));
var func = clo.ToNonGeneric();
foreach (T arg in args)
{
jobs.Add(new ComputeFuncJob(func, arg));
}
return(ExecuteClosures0(new ComputeMultiClosureTask <T, TR, ICollection <TR> >(jobs.Count),
null, jobs, false));
}
/// <summary>
/// Executes provided closure job on nodes within this grid projection. A new job is executed for
/// every argument in the passed in collection. The number of actual job executions will be
/// equal to size of the job arguments collection. The returned job results will be reduced
/// into an individual result by provided reducer.
/// </summary>
/// <param name="clo">Job to run.</param>
/// <param name="args">Job arguments.</param>
/// <param name="rdc">Reducer to reduce all job results into one individual return value.</param>
/// <returns>Reduced job result for this execution.</returns>
public Future <TReduceRes> Apply <TArg, TJobRes, TReduceRes>(IComputeFunc <TArg, TJobRes> clo,
IEnumerable <TArg> args, IComputeReducer <TJobRes, TReduceRes> rdc)
{
IgniteArgumentCheck.NotNull(clo, "clo");
IgniteArgumentCheck.NotNull(clo, "clo");
IgniteArgumentCheck.NotNull(clo, "clo");
ICollection <IComputeJob> jobs = new List <IComputeJob>(GetCountOrZero(args));
var func = clo.ToNonGeneric();
foreach (TArg arg in args)
{
jobs.Add(new ComputeFuncJob(func, arg));
}
return(ExecuteClosures0(new ComputeReducingClosureTask <TArg, TJobRes, TReduceRes>(rdc),
null, jobs, false));
}