<!DOCTYPE HTML>
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (11.0.18) on Wed Mar 01 02:01:42 GMT 2023 -->
<title>StreamletImpl (Heron Java API)</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="dc.created" content="2023-03-01">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../jquery/jszip/dist/jszip.min.js"></script>
<script type="text/javascript" src="../../../../../jquery/jszip-utils/dist/jszip-utils.min.js"></script>
<!--[if IE]>
<script type="text/javascript" src="../../../../../jquery/jszip-utils/dist/jszip-utils-ie.min.js"></script>
<![endif]-->
<script type="text/javascript" src="../../../../../jquery/jquery-3.6.0.min.js"></script>
<script type="text/javascript" src="../../../../../jquery/jquery-ui.min.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="StreamletImpl (Heron Java API)";
        }
    }
    catch(err) {
    }
//-->
var data = {"i0":10,"i1":10,"i2":10,"i3":10,"i4":10,"i5":10,"i6":10,"i7":10,"i8":10,"i9":10,"i10":10,"i11":10,"i12":10,"i13":10,"i14":10,"i15":10,"i16":10,"i17":10,"i18":10,"i19":10,"i20":10,"i21":10,"i22":10,"i23":10,"i24":10,"i25":10,"i26":10,"i27":10,"i28":10};
var tabs = {65535:["t0","All Methods"],2:["t2","Instance Methods"],8:["t4","Concrete Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
var pathtoroot = "../../../../../";
var useModuleDirectories = true;
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<header role="banner">
<nav role="navigation">
<div class="fixedNav">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a id="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../../allclasses.html">All&nbsp;Classes</a></li>
</ul>
<ul class="navListSearch">
<li><label for="search">SEARCH:</label>
<input type="text" id="search" value="search" disabled="disabled">
<input type="reset" id="reset" value="reset" disabled="disabled">
</li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li><a href="#nested.class.summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a id="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
</div>
<div class="navPadding">&nbsp;</div>
<script type="text/javascript"><!--
$('.navPadding').css('padding-top', $('.fixedNav').css("height"));
//-->
</script>
</nav>
</header>
<!-- ======== START OF CLASS DATA ======== -->
<main role="main">
<div class="header">
<div class="subTitle"><span class="packageLabelInType">Package</span>&nbsp;<a href="package-summary.html">org.apache.heron.streamlet.impl</a></div>
<h2 title="Class StreamletImpl" class="title">Class StreamletImpl&lt;R&gt;</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li>java.lang.Object</li>
<li>
<ul class="inheritance">
<li><a href="StreamletBaseImpl.html" title="class in org.apache.heron.streamlet.impl">org.apache.heron.streamlet.impl.StreamletBaseImpl</a>&lt;R&gt;</li>
<li>
<ul class="inheritance">
<li>org.apache.heron.streamlet.impl.StreamletImpl&lt;R&gt;</li>
</ul>
</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<dl>
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;R&gt;</code>, <code><a href="../StreamletBase.html" title="interface in org.apache.heron.streamlet">StreamletBase</a>&lt;R&gt;</code></dd>
</dl>
<dl>
<dt>Direct Known Subclasses:</dt>
<dd><code><a href="streamlets/CountByKeyAndWindowStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">CountByKeyAndWindowStreamlet</a></code>, <code><a href="streamlets/CountByKeyStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">CountByKeyStreamlet</a></code>, <code><a href="streamlets/CustomStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">CustomStreamlet</a></code>, <code><a href="streamlets/FilterStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">FilterStreamlet</a></code>, <code><a href="streamlets/FlatMapStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">FlatMapStreamlet</a></code>, <code><a href="streamlets/GeneralReduceByKeyAndWindowStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">GeneralReduceByKeyAndWindowStreamlet</a></code>, <code><a href="streamlets/GeneralReduceByKeyStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">GeneralReduceByKeyStreamlet</a></code>, <code><a href="streamlets/JoinStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">JoinStreamlet</a></code>, <code><a href="streamlets/KeyByStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">KeyByStreamlet</a></code>, <code><a href="streamlets/MapStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">MapStreamlet</a></code>, <code><a href="streamlets/ReduceByKeyAndWindowStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">ReduceByKeyAndWindowStreamlet</a></code>, <code><a href="streamlets/ReduceByKeyStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">ReduceByKeyStreamlet</a></code>, <code><a href="streamlets/RemapStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">RemapStreamlet</a></code>, <code><a href="streamlets/SourceStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">SourceStreamlet</a></code>, <code><a href="streamlets/SplitStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">SplitStreamlet</a></code>, <code><a href="streamlets/SpoutStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">SpoutStreamlet</a></code>, <code><a href="streamlets/StreamletShadow.html" title="class in org.apache.heron.streamlet.impl.streamlets">StreamletShadow</a></code>, <code><a href="streamlets/SupplierStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">SupplierStreamlet</a></code>, <code><a href="streamlets/TransformStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">TransformStreamlet</a></code>, <code><a href="streamlets/UnionStreamlet.html" title="class in org.apache.heron.streamlet.impl.streamlets">UnionStreamlet</a></code></dd>
</dl>
<hr>
<pre>public abstract class <span class="typeNameLabel">StreamletImpl&lt;R&gt;</span>
extends <a href="StreamletBaseImpl.html" title="class in org.apache.heron.streamlet.impl">StreamletBaseImpl</a>&lt;R&gt;
implements <a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;R&gt;</pre>
<div class="block">A Streamlet is a (potentially unbounded) ordered collection of tuples.
 Streamlets originate from pub/sub systems(such Pulsar/Kafka), or from
 static data(such as csv files, HDFS files), or for that matter any other
 source. They are also created by transforming existing Streamlets using
 operations such as map/flatMap, etc.
 Besides the tuples, a Streamlet has the following properties associated with it
 a) name. User assigned or system generated name to refer the streamlet
 b) nPartitions. Number of partitions that the streamlet is composed of. Thus the
    ordering of the tuples in a Streamlet is wrt the tuples within a partition.
    This allows the system to distribute  each partition to different nodes across the cluster.
 A bunch of transformations can be done on Streamlets(like map/flatMap, etc.). Each
 of these transformations operate on every tuple of the Streamlet and produce a new
 Streamlet. One can think of a transformation attaching itself to the stream and processing
 each tuple as they go by. Thus the parallelism of any operator is implicitly determined
 by the number of partitions of the stream that it is operating on. If a particular
 transformation wants to operate at a different parallelism, one can repartition the
 Streamlet before doing the transformation.</div>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<section>
<ul class="blockList">
<li class="blockList"><a id="nested.class.summary">
<!--   -->
</a>
<h3>Nested Class Summary</h3>
<ul class="blockList">
<li class="blockList"><a id="nested.classes.inherited.from.class.org.apache.heron.streamlet.impl.StreamletBaseImpl">
<!--   -->
</a>
<h3>Nested classes/interfaces inherited from class&nbsp;org.apache.heron.streamlet.impl.<a href="StreamletBaseImpl.html" title="class in org.apache.heron.streamlet.impl">StreamletBaseImpl</a></h3>
<code><a href="StreamletBaseImpl.StreamletNamePrefix.html" title="enum in org.apache.heron.streamlet.impl">StreamletBaseImpl.StreamletNamePrefix</a></code></li>
</ul>
</li>
</ul>
</section>
<!-- =========== FIELD SUMMARY =========== -->
<section>
<ul class="blockList">
<li class="blockList"><a id="field.summary">
<!--   -->
</a>
<h3>Field Summary</h3>
<ul class="blockList">
<li class="blockList"><a id="fields.inherited.from.class.org.apache.heron.streamlet.impl.StreamletBaseImpl">
<!--   -->
</a>
<h3>Fields inherited from class&nbsp;org.apache.heron.streamlet.impl.<a href="StreamletBaseImpl.html" title="class in org.apache.heron.streamlet.impl">StreamletBaseImpl</a></h3>
<code><a href="StreamletBaseImpl.html#name">name</a>, <a href="StreamletBaseImpl.html#nPartitions">nPartitions</a></code></li>
</ul>
</li>
</ul>
</section>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<section>
<ul class="blockList">
<li class="blockList"><a id="constructor.summary">
<!--   -->
</a>
<h3>Constructor Summary</h3>
<table class="memberSummary">
<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier</th>
<th class="colSecond" scope="col">Constructor</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected </code></td>
<th class="colConstructorName" scope="row"><code><span class="memberNameLink"><a href="#%3Cinit%3E()">StreamletImpl</a></span>()</code></th>
<td class="colLast">
<div class="block">Only used by the implementors</div>
</td>
</tr>
</table>
</li>
</ul>
</section>
<!-- ========== METHOD SUMMARY =========== -->
<section>
<ul class="blockList">
<li class="blockList"><a id="method.summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="memberSummary">
<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd">&nbsp;</span></span><span id="t2" class="tableTab"><span><a href="javascript:show(2);">Instance Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t4" class="tableTab"><span><a href="javascript:show(8);">Concrete Methods</a></span><span class="tabEnd">&nbsp;</span></span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colSecond" scope="col">Method</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tr id="i0" class="altColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;T&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#applyOperator(org.apache.heron.streamlet.IStreamletOperator)">applyOperator</a></span>&#8203;(<a href="../IStreamletOperator.html" title="interface in org.apache.heron.streamlet">IStreamletOperator</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;T&gt;&nbsp;operator)</code></th>
<td class="colLast">
<div class="block">Returns a new Streamlet by applying the operator on each element of this streamlet.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;T&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#applyOperator(org.apache.heron.streamlet.IStreamletOperator,org.apache.heron.api.grouping.StreamGrouping)">applyOperator</a></span>&#8203;(<a href="../IStreamletOperator.html" title="interface in org.apache.heron.streamlet">IStreamletOperator</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;T&gt;&nbsp;operator,
             <a href="../../api/grouping/StreamGrouping.html" title="interface in org.apache.heron.api.grouping">StreamGrouping</a>&nbsp;grouper)</code></th>
<td class="colLast">
<div class="block">Returns a new Streamlet by applying the operator on each element of this streamlet.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code>java.util.List&lt;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#clone(int)">clone</a></span>&#8203;(int&nbsp;numClones)</code></th>
<td class="colLast">
<div class="block">Clones the current Streamlet.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code><a href="../StreamletBase.html" title="interface in org.apache.heron.streamlet">StreamletBase</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#consume(org.apache.heron.streamlet.SerializableConsumer)">consume</a></span>&#8203;(<a href="../SerializableConsumer.html" title="interface in org.apache.heron.streamlet">SerializableConsumer</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;consumer)</code></th>
<td class="colLast">
<div class="block">Applies the consumer function for every element of this streamlet</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>&lt;K&gt;&nbsp;<a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;K,&#8203;java.lang.Long&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#countByKey(org.apache.heron.streamlet.SerializableFunction)">countByKey</a></span>&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor)</code></th>
<td class="colLast">
<div class="block">Returns a new stream of <key, count> by counting tuples in this stream on each key.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>&lt;K&gt;&nbsp;<a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;<a href="../KeyedWindow.html" title="class in org.apache.heron.streamlet">KeyedWindow</a>&lt;K&gt;,&#8203;java.lang.Long&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#countByKeyAndWindow(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig)">countByKeyAndWindow</a></span>&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor,
                   <a href="../WindowConfig.html" title="interface in org.apache.heron.streamlet">WindowConfig</a>&nbsp;windowCfg)</code></th>
<td class="colLast">
<div class="block">Returns a new stream of <key, count> by counting tuples over a window in this stream on each key.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#filter(org.apache.heron.streamlet.SerializablePredicate)">filter</a></span>&#8203;(<a href="../SerializablePredicate.html" title="interface in org.apache.heron.streamlet">SerializablePredicate</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;filterFn)</code></th>
<td class="colLast">
<div class="block">Return a new Streamlet by applying the filterFn on each element of this streamlet
 and including only those elements that satisfy the filterFn</div>
</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;T&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#flatMap(org.apache.heron.streamlet.SerializableFunction)">flatMap</a></span>&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;? extends java.lang.Iterable&lt;? extends T&gt;&gt;&nbsp;flatMapFn)</code></th>
<td class="colLast">
<div class="block">Return a new Streamlet by applying flatMapFn to each element of this Streamlet and
 flattening the result</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code>protected java.util.Set&lt;java.lang.String&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getAvailableStreamIds()">getAvailableStreamIds</a></span>()</code></th>
<td class="colLast">
<div class="block">Get the available stream ids in the Streamlet.</div>
</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code>java.lang.String</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getStreamId()">getStreamId</a></span>()</code></th>
<td class="colLast">
<div class="block">Gets the stream id of this Streamlet.</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code>&lt;K,&#8203;S,&#8203;T&gt;<br><a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;<a href="../KeyedWindow.html" title="class in org.apache.heron.streamlet">KeyedWindow</a>&lt;K&gt;,&#8203;T&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#join(org.apache.heron.streamlet.Streamlet,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig,org.apache.heron.streamlet.JoinType,org.apache.heron.streamlet.SerializableBiFunction)">join</a></span>&#8203;(<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;S&gt;&nbsp;otherStreamlet,
    <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;thisKeyExtractor,
    <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;S,&#8203;K&gt;&nbsp;otherKeyExtractor,
    <a href="../WindowConfig.html" title="interface in org.apache.heron.streamlet">WindowConfig</a>&nbsp;windowCfg,
    <a href="../JoinType.html" title="enum in org.apache.heron.streamlet">JoinType</a>&nbsp;joinType,
    <a href="../SerializableBiFunction.html" title="interface in org.apache.heron.streamlet">SerializableBiFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;S,&#8203;? extends T&gt;&nbsp;joinFunction)</code></th>
<td class="colLast">
<div class="block">Return a new KVStreamlet by joining 'this streamlet with ‘other’ streamlet.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code>&lt;K,&#8203;S,&#8203;T&gt;<br><a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;<a href="../KeyedWindow.html" title="class in org.apache.heron.streamlet">KeyedWindow</a>&lt;K&gt;,&#8203;T&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#join(org.apache.heron.streamlet.Streamlet,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig,org.apache.heron.streamlet.SerializableBiFunction)">join</a></span>&#8203;(<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;S&gt;&nbsp;otherStreamlet,
    <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;thisKeyExtractor,
    <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;S,&#8203;K&gt;&nbsp;otherKeyExtractor,
    <a href="../WindowConfig.html" title="interface in org.apache.heron.streamlet">WindowConfig</a>&nbsp;windowCfg,
    <a href="../SerializableBiFunction.html" title="interface in org.apache.heron.streamlet">SerializableBiFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;S,&#8203;? extends T&gt;&nbsp;joinFunction)</code></th>
<td class="colLast">
<div class="block">Return a new Streamlet by inner joining 'this streamlet with ‘other’ streamlet.</div>
</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code>&lt;K&gt;&nbsp;<a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;K,&#8203;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#keyBy(org.apache.heron.streamlet.SerializableFunction)">keyBy</a></span>&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor)</code></th>
<td class="colLast">
<div class="block">Return a new KVStreamlet<K, R> by applying key extractor to each element of this Streamlet</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code>&lt;K,&#8203;V&gt;<br><a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;K,&#8203;V&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#keyBy(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction)">keyBy</a></span>&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor,
     <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;V&gt;&nbsp;valueExtractor)</code></th>
<td class="colLast">
<div class="block">Return a new KVStreamlet<K, V> by applying key and value extractor to each element of this
 Streamlet</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code><a href="../StreamletBase.html" title="interface in org.apache.heron.streamlet">StreamletBase</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#log()">log</a></span>()</code></th>
<td class="colLast">
<div class="block">Logs every element of the streamlet using String.valueOf function
 Note that LogStreamlet is an empty streamlet.</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;T&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#map(org.apache.heron.streamlet.SerializableFunction)">map</a></span>&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;? extends T&gt;&nbsp;mapFn)</code></th>
<td class="colLast">
<div class="block">Return a new Streamlet by applying mapFn to each element of this Streamlet</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code>&lt;K,&#8203;T&gt;<br><a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;K,&#8203;T&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#reduceByKey(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableBinaryOperator)">reduceByKey</a></span>&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor,
           <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;T&gt;&nbsp;valueExtractor,
           <a href="../SerializableBinaryOperator.html" title="interface in org.apache.heron.streamlet">SerializableBinaryOperator</a>&lt;T&gt;&nbsp;reduceFn)</code></th>
<td class="colLast">
<div class="block">Return a new Streamlet accumulating tuples of this streamlet and applying reduceFn on those tuples.</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code>&lt;K,&#8203;T&gt;<br><a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;K,&#8203;T&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#reduceByKey(org.apache.heron.streamlet.SerializableFunction,T,org.apache.heron.streamlet.SerializableBiFunction)">reduceByKey</a></span>&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor,
           T&nbsp;identity,
           <a href="../SerializableBiFunction.html" title="interface in org.apache.heron.streamlet">SerializableBiFunction</a>&lt;T,&#8203;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;? extends T&gt;&nbsp;reduceFn)</code></th>
<td class="colLast">
<div class="block">Return a new Streamlet accumulating tuples of this streamlet and applying reduceFn on those tuples.</div>
</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code>&lt;K,&#8203;T&gt;<br><a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;<a href="../KeyedWindow.html" title="class in org.apache.heron.streamlet">KeyedWindow</a>&lt;K&gt;,&#8203;T&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#reduceByKeyAndWindow(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig,org.apache.heron.streamlet.SerializableBinaryOperator)">reduceByKeyAndWindow</a></span>&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor,
                    <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;T&gt;&nbsp;valueExtractor,
                    <a href="../WindowConfig.html" title="interface in org.apache.heron.streamlet">WindowConfig</a>&nbsp;windowCfg,
                    <a href="../SerializableBinaryOperator.html" title="interface in org.apache.heron.streamlet">SerializableBinaryOperator</a>&lt;T&gt;&nbsp;reduceFn)</code></th>
<td class="colLast">
<div class="block">Return a new Streamlet accumulating tuples of this streamlet over a Window defined by
 windowCfg and applying reduceFn on those tuples.</div>
</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code>&lt;K,&#8203;T&gt;<br><a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;<a href="../KeyedWindow.html" title="class in org.apache.heron.streamlet">KeyedWindow</a>&lt;K&gt;,&#8203;T&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#reduceByKeyAndWindow(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig,T,org.apache.heron.streamlet.SerializableBiFunction)">reduceByKeyAndWindow</a></span>&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor,
                    <a href="../WindowConfig.html" title="interface in org.apache.heron.streamlet">WindowConfig</a>&nbsp;windowCfg,
                    T&nbsp;identity,
                    <a href="../SerializableBiFunction.html" title="interface in org.apache.heron.streamlet">SerializableBiFunction</a>&lt;T,&#8203;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;? extends T&gt;&nbsp;reduceFn)</code></th>
<td class="colLast">
<div class="block">Return a new Streamlet accumulating tuples of this streamlet over a Window defined by
 windowCfg and applying reduceFn on those tuples.</div>
</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#repartition(int)">repartition</a></span>&#8203;(int&nbsp;numPartitions)</code></th>
<td class="colLast">
<div class="block">Same as filter(Identity).setNumPartitions(nPartitions)</div>
</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#repartition(int,org.apache.heron.streamlet.SerializableBiFunction)">repartition</a></span>&#8203;(int&nbsp;numPartitions,
           <a href="../SerializableBiFunction.html" title="interface in org.apache.heron.streamlet">SerializableBiFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;java.lang.Integer,&#8203;java.util.List&lt;java.lang.Integer&gt;&gt;&nbsp;partitionFn)</code></th>
<td class="colLast">
<div class="block">A more generalized version of repartition where a user can determine which partitions
 any particular tuple should go to</div>
</td>
</tr>
<tr id="i22" class="altColor">
<td class="colFirst"><code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#setName(java.lang.String)">setName</a></span>&#8203;(java.lang.String&nbsp;sName)</code></th>
<td class="colLast">
<div class="block">Sets the name of the Streamlet.</div>
</td>
</tr>
<tr id="i23" class="rowColor">
<td class="colFirst"><code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#setNumPartitions(int)">setNumPartitions</a></span>&#8203;(int&nbsp;numPartitions)</code></th>
<td class="colLast">
<div class="block">Sets the number of partitions of the streamlet</div>
</td>
</tr>
<tr id="i24" class="altColor">
<td class="colFirst"><code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#split(java.util.Map)">split</a></span>&#8203;(java.util.Map&lt;java.lang.String,&#8203;<a href="../SerializablePredicate.html" title="interface in org.apache.heron.streamlet">SerializablePredicate</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&gt;&nbsp;splitFns)</code></th>
<td class="colLast">
<div class="block">Returns multiple streams by splitting incoming stream.</div>
</td>
</tr>
<tr id="i25" class="rowColor">
<td class="colFirst"><code><a href="../StreamletBase.html" title="interface in org.apache.heron.streamlet">StreamletBase</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#toSink(org.apache.heron.streamlet.Sink)">toSink</a></span>&#8203;(<a href="../Sink.html" title="interface in org.apache.heron.streamlet">Sink</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;sink)</code></th>
<td class="colLast">
<div class="block">Uses the sink to consume every element of this streamlet</div>
</td>
</tr>
<tr id="i26" class="altColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;T&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#transform(org.apache.heron.streamlet.SerializableTransformer)">transform</a></span>&#8203;(<a href="../SerializableTransformer.html" title="interface in org.apache.heron.streamlet">SerializableTransformer</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;? extends T&gt;&nbsp;serializableTransformer)</code></th>
<td class="colLast">
<div class="block">Returns a new Streamlet by applying the transformFunction on each element of this streamlet.</div>
</td>
</tr>
<tr id="i27" class="rowColor">
<td class="colFirst"><code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#union(org.apache.heron.streamlet.Streamlet)">union</a></span>&#8203;(<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;? extends <a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;otherStreamlet)</code></th>
<td class="colLast">
<div class="block">Returns a new Streamlet that is the union of this and the ‘other’ streamlet.</div>
</td>
</tr>
<tr id="i28" class="altColor">
<td class="colFirst"><code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#withStream(java.lang.String)">withStream</a></span>&#8203;(java.lang.String&nbsp;streamId)</code></th>
<td class="colLast">
<div class="block">Set the id of the stream to be used by the children nodes.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.org.apache.heron.streamlet.impl.StreamletBaseImpl">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;org.apache.heron.streamlet.impl.<a href="StreamletBaseImpl.html" title="class in org.apache.heron.streamlet.impl">StreamletBaseImpl</a></h3>
<code><a href="StreamletBaseImpl.html#addChild(org.apache.heron.streamlet.impl.StreamletBaseImpl)">addChild</a>, <a href="StreamletBaseImpl.html#build(org.apache.heron.api.topology.TopologyBuilder,java.util.Set)">build</a>, <a href="StreamletBaseImpl.html#doBuild(org.apache.heron.api.topology.TopologyBuilder,java.util.Set)">doBuild</a>, <a href="StreamletBaseImpl.html#getChildren()">getChildren</a>, <a href="StreamletBaseImpl.html#getName()">getName</a>, <a href="StreamletBaseImpl.html#getNumPartitions()">getNumPartitions</a>, <a href="StreamletBaseImpl.html#isBuilt()">isBuilt</a>, <a href="StreamletBaseImpl.html#isFullyBuilt()">isFullyBuilt</a>, <a href="StreamletBaseImpl.html#setDefaultNameIfNone(org.apache.heron.streamlet.impl.StreamletBaseImpl.StreamletNamePrefix,java.util.Set)">setDefaultNameIfNone</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.java.lang.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
<code>clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.org.apache.heron.streamlet.Streamlet">
<!--   -->
</a>
<h3>Methods inherited from interface&nbsp;org.apache.heron.streamlet.<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a></h3>
<code><a href="../Streamlet.html#getName()">getName</a>, <a href="../Streamlet.html#getNumPartitions()">getNumPartitions</a></code></li>
</ul>
</li>
</ul>
</section>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<section>
<ul class="blockList">
<li class="blockList"><a id="constructor.detail">
<!--   -->
</a>
<h3>Constructor Detail</h3>
<a id="&lt;init&gt;()">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>StreamletImpl</h4>
<pre>protected&nbsp;StreamletImpl()</pre>
<div class="block">Only used by the implementors</div>
</li>
</ul>
</li>
</ul>
</section>
<!-- ============ METHOD DETAIL ========== -->
<section>
<ul class="blockList">
<li class="blockList"><a id="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a id="setName(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setName</h4>
<pre class="methodSignature">public&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;setName&#8203;(java.lang.String&nbsp;sName)</pre>
<div class="block">Sets the name of the Streamlet.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#setName(java.lang.String)">setName</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../StreamletBase.html#setName(java.lang.String)">setName</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamletBase.html" title="interface in org.apache.heron.streamlet">StreamletBase</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
<dd><code><a href="StreamletBaseImpl.html#setName(java.lang.String)">setName</a></code>&nbsp;in class&nbsp;<code><a href="StreamletBaseImpl.html" title="class in org.apache.heron.streamlet.impl">StreamletBaseImpl</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>sName</code> - The name given by the user for this streamlet</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Returns back the Streamlet with changed name</dd>
</dl>
</li>
</ul>
<a id="setNumPartitions(int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setNumPartitions</h4>
<pre class="methodSignature">public&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;setNumPartitions&#8203;(int&nbsp;numPartitions)</pre>
<div class="block">Sets the number of partitions of the streamlet</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#setNumPartitions(int)">setNumPartitions</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../StreamletBase.html#setNumPartitions(int)">setNumPartitions</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamletBase.html" title="interface in org.apache.heron.streamlet">StreamletBase</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
<dd><code><a href="StreamletBaseImpl.html#setNumPartitions(int)">setNumPartitions</a></code>&nbsp;in class&nbsp;<code><a href="StreamletBaseImpl.html" title="class in org.apache.heron.streamlet.impl">StreamletBaseImpl</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>numPartitions</code> - The user assigned number of partitions</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Returns back the Streamlet with changed number of partitions</dd>
</dl>
</li>
</ul>
<a id="withStream(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>withStream</h4>
<pre class="methodSignature">public&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;withStream&#8203;(java.lang.String&nbsp;streamId)</pre>
<div class="block">Set the id of the stream to be used by the children nodes.
 Usage (assuming source is a Streamlet object with two output streams: stream1 and stream2):
   source.withStream("stream1").filter(...).log();
   source.withStream("stream2").filter(...).log();</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#withStream(java.lang.String)">withStream</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>streamId</code> - The specified stream id</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Returns back the Streamlet with changed stream id</dd>
</dl>
</li>
</ul>
<a id="getAvailableStreamIds()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAvailableStreamIds</h4>
<pre class="methodSignature">protected&nbsp;java.util.Set&lt;java.lang.String&gt;&nbsp;getAvailableStreamIds()</pre>
<div class="block">Get the available stream ids in the Streamlet. For most Streamlets,
 there is only one internal stream id, therefore the function
 returns a set of one single stream id.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Returns a set of one single stream id.</dd>
</dl>
</li>
</ul>
<a id="getStreamId()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getStreamId</h4>
<pre class="methodSignature">public&nbsp;java.lang.String&nbsp;getStreamId()</pre>
<div class="block">Gets the stream id of this Streamlet.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#getStreamId()">getStreamId</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the stream id of this Streamlet`</dd>
</dl>
</li>
</ul>
<a id="map(org.apache.heron.streamlet.SerializableFunction)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>map</h4>
<pre class="methodSignature">public&nbsp;&lt;T&gt;&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;T&gt;&nbsp;map&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;? extends T&gt;&nbsp;mapFn)</pre>
<div class="block">Return a new Streamlet by applying mapFn to each element of this Streamlet</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#map(org.apache.heron.streamlet.SerializableFunction)">map</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>mapFn</code> - The Map Function that should be applied to each element</dd>
</dl>
</li>
</ul>
<a id="flatMap(org.apache.heron.streamlet.SerializableFunction)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>flatMap</h4>
<pre class="methodSignature">public&nbsp;&lt;T&gt;&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;T&gt;&nbsp;flatMap&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;? extends java.lang.Iterable&lt;? extends T&gt;&gt;&nbsp;flatMapFn)</pre>
<div class="block">Return a new Streamlet by applying flatMapFn to each element of this Streamlet and
 flattening the result</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#flatMap(org.apache.heron.streamlet.SerializableFunction)">flatMap</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>flatMapFn</code> - The FlatMap Function that should be applied to each element</dd>
</dl>
</li>
</ul>
<a id="filter(org.apache.heron.streamlet.SerializablePredicate)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>filter</h4>
<pre class="methodSignature">public&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;filter&#8203;(<a href="../SerializablePredicate.html" title="interface in org.apache.heron.streamlet">SerializablePredicate</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;filterFn)</pre>
<div class="block">Return a new Streamlet by applying the filterFn on each element of this streamlet
 and including only those elements that satisfy the filterFn</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#filter(org.apache.heron.streamlet.SerializablePredicate)">filter</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>filterFn</code> - The filter Function that should be applied to each element</dd>
</dl>
</li>
</ul>
<a id="repartition(int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>repartition</h4>
<pre class="methodSignature">public&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;repartition&#8203;(int&nbsp;numPartitions)</pre>
<div class="block">Same as filter(Identity).setNumPartitions(nPartitions)</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#repartition(int)">repartition</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
</dl>
</li>
</ul>
<a id="repartition(int,org.apache.heron.streamlet.SerializableBiFunction)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>repartition</h4>
<pre class="methodSignature">public&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;repartition&#8203;(int&nbsp;numPartitions,
                                <a href="../SerializableBiFunction.html" title="interface in org.apache.heron.streamlet">SerializableBiFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;java.lang.Integer,&#8203;java.util.List&lt;java.lang.Integer&gt;&gt;&nbsp;partitionFn)</pre>
<div class="block">A more generalized version of repartition where a user can determine which partitions
 any particular tuple should go to</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#repartition(int,org.apache.heron.streamlet.SerializableBiFunction)">repartition</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
</dl>
</li>
</ul>
<a id="clone(int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>clone</h4>
<pre class="methodSignature">public&nbsp;java.util.List&lt;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&gt;&nbsp;clone&#8203;(int&nbsp;numClones)</pre>
<div class="block">Clones the current Streamlet. It returns an array of numClones Streamlets where each
 Streamlet contains all the tuples of the current Streamlet</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#clone(int)">clone</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>numClones</code> - The number of clones to clone</dd>
</dl>
</li>
</ul>
<a id="join(org.apache.heron.streamlet.Streamlet,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig,org.apache.heron.streamlet.SerializableBiFunction)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>join</h4>
<pre class="methodSignature">public&nbsp;&lt;K,&#8203;S,&#8203;T&gt;&nbsp;<a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;<a href="../KeyedWindow.html" title="class in org.apache.heron.streamlet">KeyedWindow</a>&lt;K&gt;,&#8203;T&gt;&nbsp;join&#8203;(<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;S&gt;&nbsp;otherStreamlet,
                                                                    <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;thisKeyExtractor,
                                                                    <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;S,&#8203;K&gt;&nbsp;otherKeyExtractor,
                                                                    <a href="../WindowConfig.html" title="interface in org.apache.heron.streamlet">WindowConfig</a>&nbsp;windowCfg,
                                                                    <a href="../SerializableBiFunction.html" title="interface in org.apache.heron.streamlet">SerializableBiFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;S,&#8203;? extends T&gt;&nbsp;joinFunction)</pre>
<div class="block">Return a new Streamlet by inner joining 'this streamlet with ‘other’ streamlet.
 The join is done over elements accumulated over a time window defined by windowCfg.
 The elements are compared using the thisKeyExtractor for this streamlet with the
 otherKeyExtractor for the other streamlet. On each matching pair, the joinFunction is applied.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#join(org.apache.heron.streamlet.Streamlet,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig,org.apache.heron.streamlet.SerializableBiFunction)">join</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>otherStreamlet</code> - The Streamlet that we are joining with.</dd>
<dd><code>thisKeyExtractor</code> - The function applied to a tuple of this streamlet to get the key</dd>
<dd><code>otherKeyExtractor</code> - The function applied to a tuple of the other streamlet to get the key</dd>
<dd><code>windowCfg</code> - This is a specification of what kind of windowing strategy you like to
 have. Typical windowing strategies are sliding windows and tumbling windows</dd>
<dd><code>joinFunction</code> - The join function that needs to be applied</dd>
</dl>
</li>
</ul>
<a id="join(org.apache.heron.streamlet.Streamlet,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig,org.apache.heron.streamlet.JoinType,org.apache.heron.streamlet.SerializableBiFunction)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>join</h4>
<pre class="methodSignature">public&nbsp;&lt;K,&#8203;S,&#8203;T&gt;&nbsp;<a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;<a href="../KeyedWindow.html" title="class in org.apache.heron.streamlet">KeyedWindow</a>&lt;K&gt;,&#8203;T&gt;&nbsp;join&#8203;(<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;S&gt;&nbsp;otherStreamlet,
                                                                    <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;thisKeyExtractor,
                                                                    <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;S,&#8203;K&gt;&nbsp;otherKeyExtractor,
                                                                    <a href="../WindowConfig.html" title="interface in org.apache.heron.streamlet">WindowConfig</a>&nbsp;windowCfg,
                                                                    <a href="../JoinType.html" title="enum in org.apache.heron.streamlet">JoinType</a>&nbsp;joinType,
                                                                    <a href="../SerializableBiFunction.html" title="interface in org.apache.heron.streamlet">SerializableBiFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;S,&#8203;? extends T&gt;&nbsp;joinFunction)</pre>
<div class="block">Return a new KVStreamlet by joining 'this streamlet with ‘other’ streamlet. The type of joining
 is declared by the joinType parameter.
 The join is done over elements accumulated over a time window defined by windowCfg.
 The elements are compared using the thisKeyExtractor for this streamlet with the
 otherKeyExtractor for the other streamlet. On each matching pair, the joinFunction is applied.
 Types of joins <a href="../JoinType.html" title="enum in org.apache.heron.streamlet"><code>JoinType</code></a></div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#join(org.apache.heron.streamlet.Streamlet,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig,org.apache.heron.streamlet.JoinType,org.apache.heron.streamlet.SerializableBiFunction)">join</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>otherStreamlet</code> - The Streamlet that we are joining with.</dd>
<dd><code>thisKeyExtractor</code> - The function applied to a tuple of this streamlet to get the key</dd>
<dd><code>otherKeyExtractor</code> - The function applied to a tuple of the other streamlet to get the key</dd>
<dd><code>windowCfg</code> - This is a specification of what kind of windowing strategy you like to
 have. Typical windowing strategies are sliding windows and tumbling windows</dd>
<dd><code>joinType</code> - Type of Join. Options <a href="../JoinType.html" title="enum in org.apache.heron.streamlet"><code>JoinType</code></a></dd>
<dd><code>joinFunction</code> - The join function that needs to be applied</dd>
</dl>
</li>
</ul>
<a id="reduceByKey(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableBinaryOperator)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>reduceByKey</h4>
<pre class="methodSignature">public&nbsp;&lt;K,&#8203;T&gt;&nbsp;<a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;K,&#8203;T&gt;&nbsp;reduceByKey&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor,
                                                      <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;T&gt;&nbsp;valueExtractor,
                                                      <a href="../SerializableBinaryOperator.html" title="interface in org.apache.heron.streamlet">SerializableBinaryOperator</a>&lt;T&gt;&nbsp;reduceFn)</pre>
<div class="block">Return a new Streamlet accumulating tuples of this streamlet and applying reduceFn on those tuples.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#reduceByKey(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableBinaryOperator)">reduceByKey</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>keyExtractor</code> - The function applied to a tuple of this streamlet to get the key</dd>
<dd><code>valueExtractor</code> - The function applied to a tuple of this streamlet to extract the value
 to be reduced on</dd>
<dd><code>reduceFn</code> - The reduce function that you want to apply to all the values of a key.</dd>
</dl>
</li>
</ul>
<a id="reduceByKey(org.apache.heron.streamlet.SerializableFunction,java.lang.Object,org.apache.heron.streamlet.SerializableBiFunction)">
<!--   -->
</a><a id="reduceByKey(org.apache.heron.streamlet.SerializableFunction,T,org.apache.heron.streamlet.SerializableBiFunction)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>reduceByKey</h4>
<pre class="methodSignature">public&nbsp;&lt;K,&#8203;T&gt;&nbsp;<a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;K,&#8203;T&gt;&nbsp;reduceByKey&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor,
                                                      T&nbsp;identity,
                                                      <a href="../SerializableBiFunction.html" title="interface in org.apache.heron.streamlet">SerializableBiFunction</a>&lt;T,&#8203;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;? extends T&gt;&nbsp;reduceFn)</pre>
<div class="block">Return a new Streamlet accumulating tuples of this streamlet and applying reduceFn on those tuples.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#reduceByKey(org.apache.heron.streamlet.SerializableFunction,T,org.apache.heron.streamlet.SerializableBiFunction)">reduceByKey</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>keyExtractor</code> - The function applied to a tuple of this streamlet to get the key</dd>
<dd><code>identity</code> - The identity element is the initial value for each key</dd>
<dd><code>reduceFn</code> - The reduce function that you want to apply to all the values of a key.</dd>
</dl>
</li>
</ul>
<a id="reduceByKeyAndWindow(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig,org.apache.heron.streamlet.SerializableBinaryOperator)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>reduceByKeyAndWindow</h4>
<pre class="methodSignature">public&nbsp;&lt;K,&#8203;T&gt;&nbsp;<a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;<a href="../KeyedWindow.html" title="class in org.apache.heron.streamlet">KeyedWindow</a>&lt;K&gt;,&#8203;T&gt;&nbsp;reduceByKeyAndWindow&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor,
                                                                            <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;T&gt;&nbsp;valueExtractor,
                                                                            <a href="../WindowConfig.html" title="interface in org.apache.heron.streamlet">WindowConfig</a>&nbsp;windowCfg,
                                                                            <a href="../SerializableBinaryOperator.html" title="interface in org.apache.heron.streamlet">SerializableBinaryOperator</a>&lt;T&gt;&nbsp;reduceFn)</pre>
<div class="block">Return a new Streamlet accumulating tuples of this streamlet over a Window defined by
 windowCfg and applying reduceFn on those tuples.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#reduceByKeyAndWindow(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig,org.apache.heron.streamlet.SerializableBinaryOperator)">reduceByKeyAndWindow</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>keyExtractor</code> - The function applied to a tuple of this streamlet to get the key</dd>
<dd><code>valueExtractor</code> - The function applied to a tuple of this streamlet to extract the value
 to be reduced on</dd>
<dd><code>windowCfg</code> - This is a specification of what kind of windowing strategy you like to have.
 Typical windowing strategies are sliding windows and tumbling windows</dd>
<dd><code>reduceFn</code> - The reduce function that you want to apply to all the values of a key.</dd>
</dl>
</li>
</ul>
<a id="reduceByKeyAndWindow(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig,java.lang.Object,org.apache.heron.streamlet.SerializableBiFunction)">
<!--   -->
</a><a id="reduceByKeyAndWindow(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig,T,org.apache.heron.streamlet.SerializableBiFunction)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>reduceByKeyAndWindow</h4>
<pre class="methodSignature">public&nbsp;&lt;K,&#8203;T&gt;&nbsp;<a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;<a href="../KeyedWindow.html" title="class in org.apache.heron.streamlet">KeyedWindow</a>&lt;K&gt;,&#8203;T&gt;&nbsp;reduceByKeyAndWindow&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor,
                                                                            <a href="../WindowConfig.html" title="interface in org.apache.heron.streamlet">WindowConfig</a>&nbsp;windowCfg,
                                                                            T&nbsp;identity,
                                                                            <a href="../SerializableBiFunction.html" title="interface in org.apache.heron.streamlet">SerializableBiFunction</a>&lt;T,&#8203;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;? extends T&gt;&nbsp;reduceFn)</pre>
<div class="block">Return a new Streamlet accumulating tuples of this streamlet over a Window defined by
 windowCfg and applying reduceFn on those tuples. For each window, the value identity is used
 as a initial value. All the matching tuples are reduced using reduceFn starting from this
 initial value.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#reduceByKeyAndWindow(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig,T,org.apache.heron.streamlet.SerializableBiFunction)">reduceByKeyAndWindow</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>keyExtractor</code> - The function applied to a tuple of this streamlet to get the key</dd>
<dd><code>windowCfg</code> - This is a specification of what kind of windowing strategy you like to have.
 Typical windowing strategies are sliding windows and tumbling windows</dd>
<dd><code>identity</code> - The identity element is both the initial value inside the reduction window
 and the default result if there are no elements in the window</dd>
<dd><code>reduceFn</code> - The reduce function takes two parameters: a partial result of the reduction
 and the next element of the stream. It returns a new partial result.</dd>
</dl>
</li>
</ul>
<a id="union(org.apache.heron.streamlet.Streamlet)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>union</h4>
<pre class="methodSignature">public&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;union&#8203;(<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;? extends <a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;otherStreamlet)</pre>
<div class="block">Returns a new Streamlet that is the union of this and the ‘other’ streamlet. Essentially
 the new streamlet will contain tuples belonging to both Streamlets</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#union(org.apache.heron.streamlet.Streamlet)">union</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
</dl>
</li>
</ul>
<a id="log()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>log</h4>
<pre class="methodSignature">public&nbsp;<a href="../StreamletBase.html" title="interface in org.apache.heron.streamlet">StreamletBase</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;log()</pre>
<div class="block">Logs every element of the streamlet using String.valueOf function
 Note that LogStreamlet is an empty streamlet. That is its a streamlet
 that does not contain any tuple. Thus this function returns void.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#log()">log</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
</dl>
</li>
</ul>
<a id="consume(org.apache.heron.streamlet.SerializableConsumer)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>consume</h4>
<pre class="methodSignature">public&nbsp;<a href="../StreamletBase.html" title="interface in org.apache.heron.streamlet">StreamletBase</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;consume&#8203;(<a href="../SerializableConsumer.html" title="interface in org.apache.heron.streamlet">SerializableConsumer</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;consumer)</pre>
<div class="block">Applies the consumer function for every element of this streamlet</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#consume(org.apache.heron.streamlet.SerializableConsumer)">consume</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>consumer</code> - The user supplied consumer function that is invoked for each element</dd>
</dl>
</li>
</ul>
<a id="toSink(org.apache.heron.streamlet.Sink)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toSink</h4>
<pre class="methodSignature">public&nbsp;<a href="../StreamletBase.html" title="interface in org.apache.heron.streamlet">StreamletBase</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;toSink&#8203;(<a href="../Sink.html" title="interface in org.apache.heron.streamlet">Sink</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;sink)</pre>
<div class="block">Uses the sink to consume every element of this streamlet</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#toSink(org.apache.heron.streamlet.Sink)">toSink</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>sink</code> - The Sink that consumes</dd>
</dl>
</li>
</ul>
<a id="transform(org.apache.heron.streamlet.SerializableTransformer)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>transform</h4>
<pre class="methodSignature">public&nbsp;&lt;T&gt;&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;T&gt;&nbsp;transform&#8203;(<a href="../SerializableTransformer.html" title="interface in org.apache.heron.streamlet">SerializableTransformer</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;? extends T&gt;&nbsp;serializableTransformer)</pre>
<div class="block">Returns a new Streamlet by applying the transformFunction on each element of this streamlet.
 Before starting to cycle the transformFunction over the Streamlet, the open function is called.
 This allows the transform Function to do any kind of initialization/loading, etc.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#transform(org.apache.heron.streamlet.SerializableTransformer)">transform</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>T</code> - The return type of the transform</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>serializableTransformer</code> - The transformation function to be applied</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Streamlet containing the output of the transformFunction</dd>
</dl>
</li>
</ul>
<a id="applyOperator(org.apache.heron.streamlet.IStreamletOperator)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>applyOperator</h4>
<pre class="methodSignature">public&nbsp;&lt;T&gt;&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;T&gt;&nbsp;applyOperator&#8203;(<a href="../IStreamletOperator.html" title="interface in org.apache.heron.streamlet">IStreamletOperator</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;T&gt;&nbsp;operator)</pre>
<div class="block">Returns a new Streamlet by applying the operator on each element of this streamlet.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#applyOperator(org.apache.heron.streamlet.IStreamletOperator)">applyOperator</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>T</code> - The return type of the transform</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>operator</code> - The operator to be applied</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Streamlet containing the output of the operation</dd>
</dl>
</li>
</ul>
<a id="applyOperator(org.apache.heron.streamlet.IStreamletOperator,org.apache.heron.api.grouping.StreamGrouping)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>applyOperator</h4>
<pre class="methodSignature">public&nbsp;&lt;T&gt;&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;T&gt;&nbsp;applyOperator&#8203;(<a href="../IStreamletOperator.html" title="interface in org.apache.heron.streamlet">IStreamletOperator</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;T&gt;&nbsp;operator,
                                      <a href="../../api/grouping/StreamGrouping.html" title="interface in org.apache.heron.api.grouping">StreamGrouping</a>&nbsp;grouper)</pre>
<div class="block">Returns a new Streamlet by applying the operator on each element of this streamlet.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#applyOperator(org.apache.heron.streamlet.IStreamletOperator,org.apache.heron.api.grouping.StreamGrouping)">applyOperator</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>T</code> - The return type of the transform</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>operator</code> - The operator to be applied</dd>
<dd><code>grouper</code> - The grouper to be applied with the operator</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Streamlet containing the output of the operation</dd>
</dl>
</li>
</ul>
<a id="split(java.util.Map)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>split</h4>
<pre class="methodSignature">public&nbsp;<a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;split&#8203;(java.util.Map&lt;java.lang.String,&#8203;<a href="../SerializablePredicate.html" title="interface in org.apache.heron.streamlet">SerializablePredicate</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&gt;&nbsp;splitFns)</pre>
<div class="block">Returns multiple streams by splitting incoming stream.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#split(java.util.Map)">split</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>splitFns</code> - The Split Functions that test if the tuple should be emitted into each stream
 Note that there could be 0 or multiple target stream ids</dd>
</dl>
</li>
</ul>
<a id="keyBy(org.apache.heron.streamlet.SerializableFunction)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>keyBy</h4>
<pre class="methodSignature">public&nbsp;&lt;K&gt;&nbsp;<a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;K,&#8203;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;&nbsp;keyBy&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor)</pre>
<div class="block">Return a new KVStreamlet<K, R> by applying key extractor to each element of this Streamlet</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#keyBy(org.apache.heron.streamlet.SerializableFunction)">keyBy</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>keyExtractor</code> - The function applied to a tuple of this streamlet to get the key</dd>
</dl>
</li>
</ul>
<a id="keyBy(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>keyBy</h4>
<pre class="methodSignature">public&nbsp;&lt;K,&#8203;V&gt;&nbsp;<a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;K,&#8203;V&gt;&nbsp;keyBy&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor,
                                                <a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;V&gt;&nbsp;valueExtractor)</pre>
<div class="block">Return a new KVStreamlet<K, V> by applying key and value extractor to each element of this
 Streamlet</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#keyBy(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.SerializableFunction)">keyBy</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>keyExtractor</code> - The function applied to a tuple of this streamlet to get the key</dd>
<dd><code>valueExtractor</code> - The function applied to a tuple of this streamlet to extract the value</dd>
</dl>
</li>
</ul>
<a id="countByKey(org.apache.heron.streamlet.SerializableFunction)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>countByKey</h4>
<pre class="methodSignature">public&nbsp;&lt;K&gt;&nbsp;<a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;K,&#8203;java.lang.Long&gt;&nbsp;countByKey&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor)</pre>
<div class="block">Returns a new stream of <key, count> by counting tuples in this stream on each key.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#countByKey(org.apache.heron.streamlet.SerializableFunction)">countByKey</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>keyExtractor</code> - The function applied to a tuple of this streamlet to get the key</dd>
</dl>
</li>
</ul>
<a id="countByKeyAndWindow(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig)">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>countByKeyAndWindow</h4>
<pre class="methodSignature">public&nbsp;&lt;K&gt;&nbsp;<a href="../KVStreamlet.html" title="interface in org.apache.heron.streamlet">KVStreamlet</a>&lt;<a href="../KeyedWindow.html" title="class in org.apache.heron.streamlet">KeyedWindow</a>&lt;K&gt;,&#8203;java.lang.Long&gt;&nbsp;countByKeyAndWindow&#8203;(<a href="../SerializableFunction.html" title="interface in org.apache.heron.streamlet">SerializableFunction</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>,&#8203;K&gt;&nbsp;keyExtractor,
                                                                                <a href="../WindowConfig.html" title="interface in org.apache.heron.streamlet">WindowConfig</a>&nbsp;windowCfg)</pre>
<div class="block">Returns a new stream of <key, count> by counting tuples over a window in this stream on each key.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../Streamlet.html#countByKeyAndWindow(org.apache.heron.streamlet.SerializableFunction,org.apache.heron.streamlet.WindowConfig)">countByKeyAndWindow</a></code>&nbsp;in interface&nbsp;<code><a href="../Streamlet.html" title="interface in org.apache.heron.streamlet">Streamlet</a>&lt;<a href="StreamletImpl.html" title="type parameter in StreamletImpl">R</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>keyExtractor</code> - The function applied to a tuple of this streamlet to get the key</dd>
<dd><code>windowCfg</code> - This is a specification of what kind of windowing strategy you like to have.
 Typical windowing strategies are sliding windows and tumbling windows
 Note that there could be 0 or multiple target stream ids</dd>
</dl>
</li>
</ul>
</li>
</ul>
</section>
</li>
</ul>
</div>
</div>
</main>
<!-- ========= END OF CLASS DATA ========= -->
<footer role="contentinfo">
<nav role="navigation">
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a id="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../../allclasses.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li><a href="#nested.class.summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a id="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
</nav>
</footer>
</body>
</html>
