<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<META NAME="ROBOTS" CONTENT="NOINDEX">
<link rel="canonical" href="https://ignite.apache.org/releases/1.7.0/javadoc/org/apache/ignite/compute/package-frame.html" />
<!-- Generated by javadoc (version 1.7.0_80) on Mon Aug 01 20:32:34 MSK 2016 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>org.apache.ignite.compute (Ignite 1.7.0)</title>
<meta name="date" content="2016-08-01">
<link rel="stylesheet" type="text/css" href="../../../../javadoc.css" title="Style">

<script>
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

  ga('create', 'UA-61232409-1', 'auto');
  ga('send', 'pageview');

</script></head>
<body>
<h1 class="bar"><a href="../../../../org/apache/ignite/compute/package-summary.html" target="classFrame">org.apache.ignite.compute</a></h1>
<div class="indexContainer">
<h2 title="Interfaces">Interfaces</h2>
<ul title="Interfaces">
<li><a href="ComputeJob.html" title="interface in org.apache.ignite.compute" target="classFrame"><i>ComputeJob</i></a></li>
<li><a href="ComputeJobContext.html" title="interface in org.apache.ignite.compute" target="classFrame"><i>ComputeJobContext</i></a></li>
<li><a href="ComputeJobContinuation.html" title="interface in org.apache.ignite.compute" target="classFrame"><i>ComputeJobContinuation</i></a></li>
<li><a href="ComputeJobMasterLeaveAware.html" title="interface in org.apache.ignite.compute" target="classFrame"><i>ComputeJobMasterLeaveAware</i></a></li>
<li><a href="ComputeJobResult.html" title="interface in org.apache.ignite.compute" target="classFrame"><i>ComputeJobResult</i></a></li>
<li><a href="ComputeJobSibling.html" title="interface in org.apache.ignite.compute" target="classFrame"><i>ComputeJobSibling</i></a></li>
<li><a href="ComputeLoadBalancer.html" title="interface in org.apache.ignite.compute" target="classFrame"><i>ComputeLoadBalancer</i></a></li>
<li><a href="ComputeTask.html" title="interface in org.apache.ignite.compute" target="classFrame"><i>ComputeTask</i></a></li>
<li><a href="ComputeTaskContinuousMapper.html" title="interface in org.apache.ignite.compute" target="classFrame"><i>ComputeTaskContinuousMapper</i></a></li>
<li><a href="ComputeTaskFuture.html" title="interface in org.apache.ignite.compute" target="classFrame"><i>ComputeTaskFuture</i></a></li>
<li><a href="ComputeTaskSession.html" title="interface in org.apache.ignite.compute" target="classFrame"><i>ComputeTaskSession</i></a></li>
<li><a href="ComputeTaskSessionAttributeListener.html" title="interface in org.apache.ignite.compute" target="classFrame"><i>ComputeTaskSessionAttributeListener</i></a></li>
</ul>
<h2 title="Classes">Classes</h2>
<ul title="Classes">
<li><a href="ComputeJobAdapter.html" title="class in org.apache.ignite.compute" target="classFrame">ComputeJobAdapter</a></li>
<li><a href="ComputeJobContinuationAdapter.html" title="class in org.apache.ignite.compute" target="classFrame">ComputeJobContinuationAdapter</a></li>
<li><a href="ComputeTaskAdapter.html" title="class in org.apache.ignite.compute" target="classFrame">ComputeTaskAdapter</a></li>
<li><a href="ComputeTaskSplitAdapter.html" title="class in org.apache.ignite.compute" target="classFrame">ComputeTaskSplitAdapter</a></li>
</ul>
<h2 title="Enums">Enums</h2>
<ul title="Enums">
<li><a href="ComputeJobResultPolicy.html" title="enum in org.apache.ignite.compute" target="classFrame">ComputeJobResultPolicy</a></li>
<li><a href="ComputeTaskSessionScope.html" title="enum in org.apache.ignite.compute" target="classFrame">ComputeTaskSessionScope</a></li>
</ul>
<h2 title="Exceptions">Exceptions</h2>
<ul title="Exceptions">
<li><a href="ComputeExecutionRejectedException.html" title="class in org.apache.ignite.compute" target="classFrame">ComputeExecutionRejectedException</a></li>
<li><a href="ComputeJobFailoverException.html" title="class in org.apache.ignite.compute" target="classFrame">ComputeJobFailoverException</a></li>
<li><a href="ComputeTaskCancelledException.html" title="class in org.apache.ignite.compute" target="classFrame">ComputeTaskCancelledException</a></li>
<li><a href="ComputeTaskTimeoutException.html" title="class in org.apache.ignite.compute" target="classFrame">ComputeTaskTimeoutException</a></li>
<li><a href="ComputeUserUndeclaredException.html" title="class in org.apache.ignite.compute" target="classFrame">ComputeUserUndeclaredException</a></li>
</ul>
<h2 title="Annotation Types">Annotation Types</h2>
<ul title="Annotation Types">
<li><a href="ComputeJobAfterSend.html" title="annotation in org.apache.ignite.compute" target="classFrame">ComputeJobAfterSend</a></li>
<li><a href="ComputeJobBeforeFailover.html" title="annotation in org.apache.ignite.compute" target="classFrame">ComputeJobBeforeFailover</a></li>
<li><a href="ComputeTaskMapAsync.html" title="annotation in org.apache.ignite.compute" target="classFrame">ComputeTaskMapAsync</a></li>
<li><a href="ComputeTaskName.html" title="annotation in org.apache.ignite.compute" target="classFrame">ComputeTaskName</a></li>
<li><a href="ComputeTaskNoResultCache.html" title="annotation in org.apache.ignite.compute" target="classFrame">ComputeTaskNoResultCache</a></li>
<li><a href="ComputeTaskSessionFullSupport.html" title="annotation in org.apache.ignite.compute" target="classFrame">ComputeTaskSessionFullSupport</a></li>
<li><a href="ComputeTaskSpis.html" title="annotation in org.apache.ignite.compute" target="classFrame">ComputeTaskSpis</a></li>
</ul>
</div>
</body>
</html>
