Package org.apache.ignite.compute

## Class ComputeTaskSplitAdapter<T,​R>

- java.lang.Object
- - org.apache.ignite.compute.ComputeTaskAdapter<T,​R>
  - - org.apache.ignite.compute.ComputeTaskSplitAdapter<T,​R>

- Type Parameters:
    `T` - Type of the task execution argument.
    `R` - Type of the task result returning from `ComputeTask.reduce(List)` method.
  All Implemented Interfaces:
    `Serializable`, `ComputeTask<T,​R>`

      public abstract class ComputeTaskSplitAdapter<T,​R>
      extends ComputeTaskAdapter<T,​R>

  This class defines simplified adapter for `ComputeTask`. This adapter can be used when jobs can be randomly assigned to available grid nodes. This adapter is sufficient in most homogeneous environments where all nodes are equally suitable for executing grid job. See `split(int, Object)` method for more details.

  Below is a coding example of how you would use `ComputeTaskSplitAdapter`:

       public class MyFooBarTask extends ComputeTaskSplitAdapter<Object, String> {
           @Override
           protected Collection<? extends ComputeJob> split(int gridSize, Object arg) throws IgniteCheckedException {
               List<MyFooBarJob> jobs = new ArrayList<MyFooBarJob>(gridSize);

               for (int i = 0; i < gridSize; i++) {
                   jobs.add(new MyFooBarJob(arg));
               }

               // Node assignment via load balancer
               // happens automatically.
               return jobs;
           }

           // Aggregate results into one compound result.
           public String reduce(List<ComputeJobResult> results) throws IgniteCheckedException {
               // For the purpose of this example we simply
               // concatenate string representation of every
               // job result
               StringBuilder buf = new StringBuilder();

               for (ComputeJobResult res : results) {
                   // Append string representation of result
                   // returned by every job.
                   buf.append(res.getData().string());
               }

               return buf.string();
           }
       }

  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `ComputeTaskSplitAdapter()` |

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `@NotNull Map<? extends ComputeJob,​ClusterNode>` | `map​(List<ClusterNode> subgrid, T arg)` | This method is called to map or split grid task into multiple grid jobs.
    `protected abstract Collection<? extends ComputeJob>` | `split​(int gridSize, T arg)` | This is a simplified version of `ComputeTask.map(List, Object)` method.

    - ### Methods inherited from class org.apache.ignite.compute.ComputeTaskAdapter

      `result`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface org.apache.ignite.compute.ComputeTask

      `reduce`

- - ### Constructor Detail

    - #### ComputeTaskSplitAdapter

          public ComputeTaskSplitAdapter()

  - ### Method Detail

    - #### split

          protected abstract Collection<? extends ComputeJob> split​(int gridSize,
                                                                    T arg)
                                                             throws IgniteException

      This is a simplified version of `ComputeTask.map(List, Object)` method.

      This method basically takes given argument and splits it into a collection of `ComputeJob` using provided grid size as indication of how many node are available. These jobs will be randomly mapped to available grid nodes. Note that if number of jobs is greater than number of grid nodes (i.e, grid size), the grid nodes will be reused and some jobs will end up on the same grid nodes.

      Parameters:
        `gridSize` - Number of available grid nodes. Note that returned number of jobs can be less, equal or greater than this grid size.
        `arg` - Task execution argument. Can be `null`.
      Returns:
        Collection of grid jobs. These jobs will be randomly mapped to available grid nodes. Note that if number of jobs is greater than number of grid nodes (i.e, grid size), the grid nodes will be reused and some jobs will end up on the same grid nodes.
      Throws:
        `IgniteException` - Thrown in case of any errors.
      See Also:
        `ComputeTask.map(List, Object)`

    - #### map

          @NotNull
          public final @NotNull Map<? extends ComputeJob,​ClusterNode> map​(List<ClusterNode> subgrid,
                                                                                T arg)

      This method is called to map or split grid task into multiple grid jobs. This is the first method that gets called when task execution starts.
      Parameters:
        `subgrid` - Nodes available for this task execution. Note that order of nodes is guaranteed to be randomized by container. This ensures that every time you simply iterate through grid nodes, the order of nodes will be random which over time should result into all nodes being used equally.
        `arg` - Task execution argument. Can be `null`. This is the same argument as the one passed into `Grid#execute(...)` methods.
      Returns:
        Map of grid jobs assigned to subgrid node. Unless `ComputeTaskContinuousMapper` is injected into task, if `null` or empty map is returned, exception will be thrown.