http://git-wip-us.apache.org/repos/asf/storm-site/blob/a7a19afb/content/releases/1.0.3/Trident-API-Overview.html
----------------------------------------------------------------------
diff --git a/content/releases/1.0.3/Trident-API-Overview.html 
b/content/releases/1.0.3/Trident-API-Overview.html
index a744aef..ebc3d6b 100644
--- a/content/releases/1.0.3/Trident-API-Overview.html
+++ b/content/releases/1.0.3/Trident-API-Overview.html
@@ -82,18 +82,16 @@
                         
                       
                         
-                          <li><a 
href="/releases/1.1.0/index.html">1.1.0</a></li>
-                        
                       
                         
+                          <li><a 
href="/releases/1.1.0/index.html">1.1.0</a></li>
+                        
                       
                         
                           <li><a 
href="/releases/1.0.4/index.html">1.0.4</a></li>
                         
                       
                         
-                      
-                        
                           <li><a 
href="/releases/1.0.3/index.html">1.0.3</a></li>
                         
                       
@@ -104,6 +102,8 @@
                         
                       
                         
+                      
+                        
                           <li><a 
href="/releases/0.10.2/index.html">0.10.2</a></li>
                         
                       
@@ -144,7 +144,7 @@
                         <li><a href="/contribute/BYLAWS.html">ByLaws</a></li>
                     </ul>
                 </li>
-                <li><a href="/2017/09/15/storm105-released.html" 
id="news">News</a></li>
+                <li><a href="/2018/02/14/storm106-released.html" 
id="news">News</a></li>
             </ul>
         </nav>
     </div>
@@ -180,7 +180,7 @@
 
 <p>A function takes in a set of input fields and emits zero or more tuples as 
output. The fields of the output tuple are appended to the original input tuple 
in the stream. If a function emits no tuples, the original input tuple is 
filtered out. Otherwise, the input tuple is duplicated for each output tuple. 
Suppose you have this function:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">MyFunction</span> <span class="kd">extends</span> <span 
class="n">BaseFunction</span> <span class="o">{</span>
-    <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">,</span> <span class="n">TridentCollector</span> <span 
class="n">collector</span><span class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">,</span> <span class="n">TridentCollector</span> <span 
class="n">collector</span><span class="o">)</span> <span class="o">{</span>
         <span class="k">for</span><span class="o">(</span><span 
class="kt">int</span> <span class="n">i</span><span class="o">=</span><span 
class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span 
class="o">&lt;</span> <span class="n">tuple</span><span class="o">.</span><span 
class="na">getInteger</span><span class="o">(</span><span 
class="mi">0</span><span class="o">);</span> <span class="n">i</span><span 
class="o">++)</span> <span class="o">{</span>
             <span class="n">collector</span><span class="o">.</span><span 
class="na">emit</span><span class="o">(</span><span class="k">new</span> <span 
class="n">Values</span><span class="o">(</span><span class="n">i</span><span 
class="o">));</span>
         <span class="o">}</span>
@@ -204,7 +204,7 @@
 
 <p>Filters take in a tuple as input and decide whether or not to keep that 
tuple or not. Suppose you had this filter:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">MyFilter</span> <span class="kd">extends</span> <span 
class="n">BaseFilter</span> <span class="o">{</span>
-    <span class="kd">public</span> <span class="kt">boolean</span> <span 
class="n">isKeep</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="kt">boolean</span> <span 
class="nf">isKeep</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">)</span> <span class="o">{</span>
         <span class="k">return</span> <span class="n">tuple</span><span 
class="o">.</span><span class="na">getInteger</span><span 
class="o">(</span><span class="mi">0</span><span class="o">)</span> <span 
class="o">==</span> <span class="mi">1</span> <span class="o">&amp;&amp;</span> 
<span class="n">tuple</span><span class="o">.</span><span 
class="na">getInteger</span><span class="o">(</span><span 
class="mi">1</span><span class="o">)</span> <span class="o">==</span> <span 
class="mi">2</span><span class="o">;</span>
     <span class="o">}</span>
 <span class="o">}</span>
@@ -229,8 +229,8 @@ can be used to apply a one-one transformation to the 
tuples.</p>
 you could define a mapping function as follows,</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">UpperCase</span> <span class="kd">extends</span> <span 
class="n">MapFunction</span> <span class="o">{</span>
  <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="n">Values</span> <span 
class="n">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">input</span><span 
class="o">)</span> <span class="o">{</span>
-   <span class="k">return</span> <span class="k">new</span> <span 
class="n">Values</span><span class="o">(</span><span 
class="n">input</span><span class="o">.</span><span 
class="na">getString</span><span class="o">(</span><span 
class="mi">0</span><span class="o">).</span><span 
class="na">toUpperCase</span><span class="o">());</span>
+ <span class="kd">public</span> <span class="n">Values</span> <span 
class="nf">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">input</span><span 
class="o">)</span> <span class="o">{</span>
+   <span class="k">return</span> <span class="k">new</span> <span 
class="nf">Values</span><span class="o">(</span><span 
class="n">input</span><span class="o">.</span><span 
class="na">getString</span><span class="o">(</span><span 
class="mi">0</span><span class="o">).</span><span 
class="na">toUpperCase</span><span class="o">());</span>
  <span class="o">}</span>
 <span class="o">}</span>
 </code></pre></div>
@@ -244,7 +244,7 @@ and then flattening the resulting elements into a new 
stream.</p>
 you could define a flatMap function as follows,</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">Split</span> <span class="kd">extends</span> <span 
class="n">FlatMapFunction</span> <span class="o">{</span>
   <span class="nd">@Override</span>
-  <span class="kd">public</span> <span class="n">Iterable</span><span 
class="o">&lt;</span><span class="n">Values</span><span class="o">&gt;</span> 
<span class="n">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">input</span><span 
class="o">)</span> <span class="o">{</span>
+  <span class="kd">public</span> <span class="n">Iterable</span><span 
class="o">&lt;</span><span class="n">Values</span><span class="o">&gt;</span> 
<span class="nf">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">input</span><span 
class="o">)</span> <span class="o">{</span>
     <span class="n">List</span><span class="o">&lt;</span><span 
class="n">Values</span><span class="o">&gt;</span> <span 
class="n">valuesList</span> <span class="o">=</span> <span class="k">new</span> 
<span class="n">ArrayList</span><span class="o">&lt;&gt;();</span>
     <span class="k">for</span> <span class="o">(</span><span 
class="n">String</span> <span class="n">word</span> <span class="o">:</span> 
<span class="n">input</span><span class="o">.</span><span 
class="na">getString</span><span class="o">(</span><span 
class="mi">0</span><span class="o">).</span><span class="na">split</span><span 
class="o">(</span><span class="s">" "</span><span class="o">))</span> <span 
class="o">{</span>
       <span class="n">valuesList</span><span class="o">.</span><span 
class="na">add</span><span class="o">(</span><span class="k">new</span> <span 
class="n">Values</span><span class="o">(</span><span class="n">word</span><span 
class="o">));</span>
@@ -376,8 +376,8 @@ Partition 2:
 </code></pre></div>
 <p>You can look at other <code>max</code> and <code>maxBy</code> functions on 
Stream</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java">
-      <span class="kd">public</span> <span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span class="n">Stream</span> 
<span class="n">maxBy</span><span class="o">(</span><span 
class="n">String</span> <span class="n">inputFieldName</span><span 
class="o">,</span> <span class="n">Comparator</span><span 
class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span> <span 
class="n">comparator</span><span class="o">)</span> 
-      <span class="kd">public</span> <span class="n">Stream</span> <span 
class="n">max</span><span class="o">(</span><span 
class="n">Comparator</span><span class="o">&lt;</span><span 
class="n">TridentTuple</span><span class="o">&gt;</span> <span 
class="n">comparator</span><span class="o">)</span> 
+      <span class="kd">public</span> <span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span class="n">Stream</span> 
<span class="nf">maxBy</span><span class="o">(</span><span 
class="n">String</span> <span class="n">inputFieldName</span><span 
class="o">,</span> <span class="n">Comparator</span><span 
class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span> <span 
class="n">comparator</span><span class="o">)</span> 
+      <span class="kd">public</span> <span class="n">Stream</span> <span 
class="nf">max</span><span class="o">(</span><span 
class="n">Comparator</span><span class="o">&lt;</span><span 
class="n">TridentTuple</span><span class="o">&gt;</span> <span 
class="n">comparator</span><span class="o">)</span> 
 
 </code></pre></div>
 <p>Below example shows how these APIs can be used to find maximum using 
respective Comparators on a tuple.</p>
@@ -415,13 +415,13 @@ There are two kinds of windowing supported which are 
based on processing time or
     <span class="cm">/**
      * Returns a stream of tuples which are aggregated results of a tumbling 
window with every {@code windowCount} of tuples.
      */</span>
-    <span class="kd">public</span> <span class="n">Stream</span> <span 
class="n">tumblingWindow</span><span class="o">(</span><span 
class="kt">int</span> <span class="n">windowCount</span><span 
class="o">,</span> <span class="n">WindowsStoreFactory</span> <span 
class="n">windowStoreFactory</span><span class="o">,</span>
+    <span class="kd">public</span> <span class="n">Stream</span> <span 
class="nf">tumblingWindow</span><span class="o">(</span><span 
class="kt">int</span> <span class="n">windowCount</span><span 
class="o">,</span> <span class="n">WindowsStoreFactory</span> <span 
class="n">windowStoreFactory</span><span class="o">,</span>
                                       <span class="n">Fields</span> <span 
class="n">inputFields</span><span class="o">,</span> <span 
class="n">Aggregator</span> <span class="n">aggregator</span><span 
class="o">,</span> <span class="n">Fields</span> <span 
class="n">functionFields</span><span class="o">);</span>
 
     <span class="cm">/**
      * Returns a stream of tuples which are aggregated results of a window 
that tumbles at duration of {@code windowDuration}
      */</span>
-    <span class="kd">public</span> <span class="n">Stream</span> <span 
class="n">tumblingWindow</span><span class="o">(</span><span 
class="n">BaseWindowedBolt</span><span class="o">.</span><span 
class="na">Duration</span> <span class="n">windowDuration</span><span 
class="o">,</span> <span class="n">WindowsStoreFactory</span> <span 
class="n">windowStoreFactory</span><span class="o">,</span>
+    <span class="kd">public</span> <span class="n">Stream</span> <span 
class="nf">tumblingWindow</span><span class="o">(</span><span 
class="n">BaseWindowedBolt</span><span class="o">.</span><span 
class="na">Duration</span> <span class="n">windowDuration</span><span 
class="o">,</span> <span class="n">WindowsStoreFactory</span> <span 
class="n">windowStoreFactory</span><span class="o">,</span>
                                      <span class="n">Fields</span> <span 
class="n">inputFields</span><span class="o">,</span> <span 
class="n">Aggregator</span> <span class="n">aggregator</span><span 
class="o">,</span> <span class="n">Fields</span> <span 
class="n">functionFields</span><span class="o">);</span>
 
 </code></pre></div>
@@ -433,14 +433,14 @@ There are two kinds of windowing supported which are 
based on processing time or
      * Returns a stream of tuples which are aggregated results of a sliding 
window with every {@code windowCount} of tuples
      * and slides the window after {@code slideCount}.
      */</span>
-    <span class="kd">public</span> <span class="n">Stream</span> <span 
class="n">slidingWindow</span><span class="o">(</span><span 
class="kt">int</span> <span class="n">windowCount</span><span 
class="o">,</span> <span class="kt">int</span> <span 
class="n">slideCount</span><span class="o">,</span> <span 
class="n">WindowsStoreFactory</span> <span 
class="n">windowStoreFactory</span><span class="o">,</span>
+    <span class="kd">public</span> <span class="n">Stream</span> <span 
class="nf">slidingWindow</span><span class="o">(</span><span 
class="kt">int</span> <span class="n">windowCount</span><span 
class="o">,</span> <span class="kt">int</span> <span 
class="n">slideCount</span><span class="o">,</span> <span 
class="n">WindowsStoreFactory</span> <span 
class="n">windowStoreFactory</span><span class="o">,</span>
                                       <span class="n">Fields</span> <span 
class="n">inputFields</span><span class="o">,</span> <span 
class="n">Aggregator</span> <span class="n">aggregator</span><span 
class="o">,</span> <span class="n">Fields</span> <span 
class="n">functionFields</span><span class="o">);</span>
 
     <span class="cm">/**
      * Returns a stream of tuples which are aggregated results of a window 
which slides at duration of {@code slidingInterval}
      * and completes a window at {@code windowDuration}
      */</span>
-    <span class="kd">public</span> <span class="n">Stream</span> <span 
class="n">slidingWindow</span><span class="o">(</span><span 
class="n">BaseWindowedBolt</span><span class="o">.</span><span 
class="na">Duration</span> <span class="n">windowDuration</span><span 
class="o">,</span> <span class="n">BaseWindowedBolt</span><span 
class="o">.</span><span class="na">Duration</span> <span 
class="n">slidingInterval</span><span class="o">,</span>
+    <span class="kd">public</span> <span class="n">Stream</span> <span 
class="nf">slidingWindow</span><span class="o">(</span><span 
class="n">BaseWindowedBolt</span><span class="o">.</span><span 
class="na">Duration</span> <span class="n">windowDuration</span><span 
class="o">,</span> <span class="n">BaseWindowedBolt</span><span 
class="o">.</span><span class="na">Duration</span> <span 
class="n">slidingInterval</span><span class="o">,</span>
                                     <span class="n">WindowsStoreFactory</span> 
<span class="n">windowStoreFactory</span><span class="o">,</span> <span 
class="n">Fields</span> <span class="n">inputFields</span><span 
class="o">,</span> <span class="n">Aggregator</span> <span 
class="n">aggregator</span><span class="o">,</span> <span 
class="n">Fields</span> <span class="n">functionFields</span><span 
class="o">);</span>
 </code></pre></div>
 <p>Examples of tumbling and sliding windows can be found <a 
href="Windowing.html">here</a></p>
@@ -449,7 +449,7 @@ There are two kinds of windowing supported which are based 
on processing time or
 
 <p>Below is the common windowing API which takes <code>WindowConfig</code> for 
any supported windowing configurations. </p>
 <div class="highlight"><pre><code class="language-java" data-lang="java">
-    <span class="kd">public</span> <span class="n">Stream</span> <span 
class="nf">window</span><span class="p">(</span><span 
class="n">WindowConfig</span> <span class="n">windowConfig</span><span 
class="o">,</span> <span class="n">WindowsStoreFactory</span> <span 
class="n">windowStoreFactory</span><span class="o">,</span> <span 
class="n">Fields</span> <span class="n">inputFields</span><span 
class="o">,</span>
+    <span class="kd">public</span> <span class="n">Stream</span> <span 
class="nf">window</span><span class="o">(</span><span 
class="n">WindowConfig</span> <span class="n">windowConfig</span><span 
class="o">,</span> <span class="n">WindowsStoreFactory</span> <span 
class="n">windowStoreFactory</span><span class="o">,</span> <span 
class="n">Fields</span> <span class="n">inputFields</span><span 
class="o">,</span>
                          <span class="n">Aggregator</span> <span 
class="n">aggregator</span><span class="o">,</span> <span 
class="n">Fields</span> <span class="n">functionFields</span><span 
class="o">)</span>
 
 </code></pre></div>
@@ -466,18 +466,18 @@ Example of using <code>HBaseWindowStoreFactory</code> for 
windowing can be seen
     <span class="c1">// window-state table should already be created with 
cf:tuples column</span>
     <span class="n">HBaseWindowsStoreFactory</span> <span 
class="n">windowStoreFactory</span> <span class="o">=</span> <span 
class="k">new</span> <span class="n">HBaseWindowsStoreFactory</span><span 
class="o">(</span><span class="k">new</span> <span 
class="n">HashMap</span><span class="o">&lt;</span><span 
class="n">String</span><span class="o">,</span> <span 
class="n">Object</span><span class="o">&gt;(),</span> <span 
class="s">"window-state"</span><span class="o">,</span> <span 
class="s">"cf"</span><span class="o">.</span><span 
class="na">getBytes</span><span class="o">(</span><span 
class="s">"UTF-8"</span><span class="o">),</span> <span 
class="s">"tuples"</span><span class="o">.</span><span 
class="na">getBytes</span><span class="o">(</span><span 
class="s">"UTF-8"</span><span class="o">));</span>
     <span class="n">FixedBatchSpout</span> <span class="n">spout</span> <span 
class="o">=</span> <span class="k">new</span> <span 
class="n">FixedBatchSpout</span><span class="o">(</span><span 
class="k">new</span> <span class="n">Fields</span><span class="o">(</span><span 
class="s">"sentence"</span><span class="o">),</span> <span 
class="mi">3</span><span class="o">,</span> <span class="k">new</span> <span 
class="n">Values</span><span class="o">(</span><span class="s">"the cow jumped 
over the moon"</span><span class="o">),</span>
-            <span class="k">new</span> <span class="n">Values</span><span 
class="o">(</span><span class="s">"the man went to the store and bought some 
candy"</span><span class="o">),</span> <span class="k">new</span> <span 
class="n">Values</span><span class="o">(</span><span class="s">"four score and 
seven years ago"</span><span class="o">),</span>
-            <span class="k">new</span> <span class="n">Values</span><span 
class="o">(</span><span class="s">"how many apples can you eat"</span><span 
class="o">),</span> <span class="k">new</span> <span 
class="n">Values</span><span class="o">(</span><span class="s">"to be or not to 
be the person"</span><span class="o">));</span>
+            <span class="k">new</span> <span class="nf">Values</span><span 
class="o">(</span><span class="s">"the man went to the store and bought some 
candy"</span><span class="o">),</span> <span class="k">new</span> <span 
class="n">Values</span><span class="o">(</span><span class="s">"four score and 
seven years ago"</span><span class="o">),</span>
+            <span class="k">new</span> <span class="nf">Values</span><span 
class="o">(</span><span class="s">"how many apples can you eat"</span><span 
class="o">),</span> <span class="k">new</span> <span 
class="n">Values</span><span class="o">(</span><span class="s">"to be or not to 
be the person"</span><span class="o">));</span>
     <span class="n">spout</span><span class="o">.</span><span 
class="na">setCycle</span><span class="o">(</span><span 
class="kc">true</span><span class="o">);</span>
 
     <span class="n">TridentTopology</span> <span class="n">topology</span> 
<span class="o">=</span> <span class="k">new</span> <span 
class="n">TridentTopology</span><span class="o">();</span>
 
     <span class="n">Stream</span> <span class="n">stream</span> <span 
class="o">=</span> <span class="n">topology</span><span class="o">.</span><span 
class="na">newStream</span><span class="o">(</span><span 
class="s">"spout1"</span><span class="o">,</span> <span 
class="n">spout</span><span class="o">).</span><span 
class="na">parallelismHint</span><span class="o">(</span><span 
class="mi">16</span><span class="o">).</span><span class="na">each</span><span 
class="o">(</span><span class="k">new</span> <span class="n">Fields</span><span 
class="o">(</span><span class="s">"sentence"</span><span class="o">),</span>
-            <span class="k">new</span> <span class="n">Split</span><span 
class="o">(),</span> <span class="k">new</span> <span 
class="n">Fields</span><span class="o">(</span><span 
class="s">"word"</span><span class="o">))</span>
+            <span class="k">new</span> <span class="nf">Split</span><span 
class="o">(),</span> <span class="k">new</span> <span 
class="n">Fields</span><span class="o">(</span><span 
class="s">"word"</span><span class="o">))</span>
             <span class="o">.</span><span class="na">window</span><span 
class="o">(</span><span class="n">TumblingCountWindow</span><span 
class="o">.</span><span class="na">of</span><span class="o">(</span><span 
class="mi">1000</span><span class="o">),</span> <span 
class="n">windowStoreFactory</span><span class="o">,</span> <span 
class="k">new</span> <span class="n">Fields</span><span class="o">(</span><span 
class="s">"word"</span><span class="o">),</span> <span class="k">new</span> 
<span class="n">CountAsAggregator</span><span class="o">(),</span> <span 
class="k">new</span> <span class="n">Fields</span><span class="o">(</span><span 
class="s">"count"</span><span class="o">))</span>
             <span class="o">.</span><span class="na">peek</span><span 
class="o">(</span><span class="k">new</span> <span 
class="n">Consumer</span><span class="o">()</span> <span class="o">{</span>
                 <span class="nd">@Override</span>
-                <span class="kd">public</span> <span class="kt">void</span> 
<span class="n">accept</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">input</span><span 
class="o">)</span> <span class="o">{</span>
+                <span class="kd">public</span> <span class="kt">void</span> 
<span class="nf">accept</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">input</span><span 
class="o">)</span> <span class="o">{</span>
                     <span class="n">LOG</span><span class="o">.</span><span 
class="na">info</span><span class="o">(</span><span class="s">"Received tuple: 
[{}]"</span><span class="o">,</span> <span class="n">input</span><span 
class="o">);</span>
                 <span class="o">}</span>
             <span class="o">});</span>
@@ -525,22 +525,22 @@ Partition 2:
 
 <p>Here&#39;s the interface for CombinerAggregator:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">interface</span> <span 
class="nc">CombinerAggregator</span><span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span class="kd">extends</span> 
<span class="n">Serializable</span> <span class="o">{</span>
-    <span class="n">T</span> <span class="n">init</span><span 
class="o">(</span><span class="n">TridentTuple</span> <span 
class="n">tuple</span><span class="o">);</span>
-    <span class="n">T</span> <span class="n">combine</span><span 
class="o">(</span><span class="n">T</span> <span class="n">val1</span><span 
class="o">,</span> <span class="n">T</span> <span class="n">val2</span><span 
class="o">);</span>
-    <span class="n">T</span> <span class="n">zero</span><span 
class="o">();</span>
+    <span class="n">T</span> <span class="nf">init</span><span 
class="o">(</span><span class="n">TridentTuple</span> <span 
class="n">tuple</span><span class="o">);</span>
+    <span class="n">T</span> <span class="nf">combine</span><span 
class="o">(</span><span class="n">T</span> <span class="n">val1</span><span 
class="o">,</span> <span class="n">T</span> <span class="n">val2</span><span 
class="o">);</span>
+    <span class="n">T</span> <span class="nf">zero</span><span 
class="o">();</span>
 <span class="o">}</span>
 </code></pre></div>
 <p>A CombinerAggregator returns a single tuple with a single field as output. 
CombinerAggregators run the init function on each input tuple and use the 
combine function to combine values until there&#39;s only one value left. If 
there&#39;s no tuples in the partition, the CombinerAggregator emits the output 
of the zero function. For example, here&#39;s the implementation of Count:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">Count</span> <span class="kd">implements</span> <span 
class="n">CombinerAggregator</span><span class="o">&lt;</span><span 
class="n">Long</span><span class="o">&gt;</span> <span class="o">{</span>
-    <span class="kd">public</span> <span class="n">Long</span> <span 
class="n">init</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="n">Long</span> <span 
class="nf">init</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">)</span> <span class="o">{</span>
         <span class="k">return</span> <span class="mi">1L</span><span 
class="o">;</span>
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="n">Long</span> <span 
class="n">combine</span><span class="o">(</span><span class="n">Long</span> 
<span class="n">val1</span><span class="o">,</span> <span class="n">Long</span> 
<span class="n">val2</span><span class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="n">Long</span> <span 
class="nf">combine</span><span class="o">(</span><span class="n">Long</span> 
<span class="n">val1</span><span class="o">,</span> <span class="n">Long</span> 
<span class="n">val2</span><span class="o">)</span> <span class="o">{</span>
         <span class="k">return</span> <span class="n">val1</span> <span 
class="o">+</span> <span class="n">val2</span><span class="o">;</span>
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="n">Long</span> <span 
class="n">zero</span><span class="o">()</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="n">Long</span> <span 
class="nf">zero</span><span class="o">()</span> <span class="o">{</span>
         <span class="k">return</span> <span class="mi">0L</span><span 
class="o">;</span>
     <span class="o">}</span>
 <span class="o">}</span>
@@ -549,17 +549,17 @@ Partition 2:
 
 <p>A ReducerAggregator has the following interface:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">interface</span> <span 
class="nc">ReducerAggregator</span><span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span class="kd">extends</span> 
<span class="n">Serializable</span> <span class="o">{</span>
-    <span class="n">T</span> <span class="n">init</span><span 
class="o">();</span>
-    <span class="n">T</span> <span class="n">reduce</span><span 
class="o">(</span><span class="n">T</span> <span class="n">curr</span><span 
class="o">,</span> <span class="n">TridentTuple</span> <span 
class="n">tuple</span><span class="o">);</span>
+    <span class="n">T</span> <span class="nf">init</span><span 
class="o">();</span>
+    <span class="n">T</span> <span class="nf">reduce</span><span 
class="o">(</span><span class="n">T</span> <span class="n">curr</span><span 
class="o">,</span> <span class="n">TridentTuple</span> <span 
class="n">tuple</span><span class="o">);</span>
 <span class="o">}</span>
 </code></pre></div>
 <p>A ReducerAggregator produces an initial value with init, and then it 
iterates on that value for each input tuple to produce a single tuple with a 
single value as output. For example, here&#39;s how you would define Count as a 
ReducerAggregator:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">Count</span> <span class="kd">implements</span> <span 
class="n">ReducerAggregator</span><span class="o">&lt;</span><span 
class="n">Long</span><span class="o">&gt;</span> <span class="o">{</span>
-    <span class="kd">public</span> <span class="n">Long</span> <span 
class="n">init</span><span class="o">()</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="n">Long</span> <span 
class="nf">init</span><span class="o">()</span> <span class="o">{</span>
         <span class="k">return</span> <span class="mi">0L</span><span 
class="o">;</span>
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="n">Long</span> <span 
class="n">reduce</span><span class="o">(</span><span class="n">Long</span> 
<span class="n">curr</span><span class="o">,</span> <span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="n">Long</span> <span 
class="nf">reduce</span><span class="o">(</span><span class="n">Long</span> 
<span class="n">curr</span><span class="o">,</span> <span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">)</span> <span class="o">{</span>
         <span class="k">return</span> <span class="n">curr</span> <span 
class="o">+</span> <span class="mi">1</span><span class="o">;</span>
     <span class="o">}</span>
 <span class="o">}</span>
@@ -568,9 +568,9 @@ Partition 2:
 
 <p>The most general interface for performing aggregations is Aggregator, which 
looks like this:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">interface</span> <span 
class="nc">Aggregator</span><span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span class="kd">extends</span> 
<span class="n">Operation</span> <span class="o">{</span>
-    <span class="n">T</span> <span class="n">init</span><span 
class="o">(</span><span class="n">Object</span> <span 
class="n">batchId</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">);</span>
-    <span class="kt">void</span> <span class="n">aggregate</span><span 
class="o">(</span><span class="n">T</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">TridentTuple</span> <span 
class="n">tuple</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">);</span>
-    <span class="kt">void</span> <span class="n">complete</span><span 
class="o">(</span><span class="n">T</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">TridentCollector</span> <span 
class="n">collector</span><span class="o">);</span>
+    <span class="n">T</span> <span class="nf">init</span><span 
class="o">(</span><span class="n">Object</span> <span 
class="n">batchId</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">);</span>
+    <span class="kt">void</span> <span class="nf">aggregate</span><span 
class="o">(</span><span class="n">T</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">TridentTuple</span> <span 
class="n">tuple</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">);</span>
+    <span class="kt">void</span> <span class="nf">complete</span><span 
class="o">(</span><span class="n">T</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">TridentCollector</span> <span 
class="n">collector</span><span class="o">);</span>
 <span class="o">}</span>
 </code></pre></div>
 <p>Aggregators can emit any number of tuples with any number of fields. They 
can emit tuples at any point during execution. Aggregators execute in the 
following way:</p>
@@ -587,15 +587,15 @@ Partition 2:
         <span class="kt">long</span> <span class="n">count</span> <span 
class="o">=</span> <span class="mi">0</span><span class="o">;</span>
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="n">CountState</span> <span 
class="n">init</span><span class="o">(</span><span class="n">Object</span> 
<span class="n">batchId</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">)</span> <span class="o">{</span>
-        <span class="k">return</span> <span class="k">new</span> <span 
class="n">CountState</span><span class="o">();</span>
+    <span class="kd">public</span> <span class="n">CountState</span> <span 
class="nf">init</span><span class="o">(</span><span class="n">Object</span> 
<span class="n">batchId</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">)</span> <span class="o">{</span>
+        <span class="k">return</span> <span class="k">new</span> <span 
class="nf">CountState</span><span class="o">();</span>
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">aggregate</span><span class="o">(</span><span 
class="n">CountState</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">TridentTuple</span> <span 
class="n">tuple</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">aggregate</span><span class="o">(</span><span 
class="n">CountState</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">TridentTuple</span> <span 
class="n">tuple</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">)</span> <span class="o">{</span>
         <span class="n">state</span><span class="o">.</span><span 
class="na">count</span><span class="o">+=</span><span class="mi">1</span><span 
class="o">;</span>
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">complete</span><span class="o">(</span><span 
class="n">CountState</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">TridentCollector</span> <span 
class="n">collector</span><span class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">complete</span><span class="o">(</span><span 
class="n">CountState</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">TridentCollector</span> <span 
class="n">collector</span><span class="o">)</span> <span class="o">{</span>
         <span class="n">collector</span><span class="o">.</span><span 
class="na">emit</span><span class="o">(</span><span class="k">new</span> <span 
class="n">Values</span><span class="o">(</span><span 
class="n">state</span><span class="o">.</span><span 
class="na">count</span><span class="o">));</span>
     <span class="o">}</span>
 <span class="o">}</span>

http://git-wip-us.apache.org/repos/asf/storm-site/blob/a7a19afb/content/releases/1.0.3/Trident-RAS-API.html
----------------------------------------------------------------------
diff --git a/content/releases/1.0.3/Trident-RAS-API.html 
b/content/releases/1.0.3/Trident-RAS-API.html
index a8c42cc..50f1c40 100644
--- a/content/releases/1.0.3/Trident-RAS-API.html
+++ b/content/releases/1.0.3/Trident-RAS-API.html
@@ -82,18 +82,16 @@
                         
                       
                         
-                          <li><a 
href="/releases/1.1.0/index.html">1.1.0</a></li>
-                        
                       
                         
+                          <li><a 
href="/releases/1.1.0/index.html">1.1.0</a></li>
+                        
                       
                         
                           <li><a 
href="/releases/1.0.4/index.html">1.0.4</a></li>
                         
                       
                         
-                      
-                        
                           <li><a 
href="/releases/1.0.3/index.html">1.0.3</a></li>
                         
                       
@@ -104,6 +102,8 @@
                         
                       
                         
+                      
+                        
                           <li><a 
href="/releases/0.10.2/index.html">0.10.2</a></li>
                         
                       
@@ -144,7 +144,7 @@
                         <li><a href="/contribute/BYLAWS.html">ByLaws</a></li>
                     </ul>
                 </li>
-                <li><a href="/2017/09/15/storm105-released.html" 
id="news">News</a></li>
+                <li><a href="/2018/02/14/storm106-released.html" 
id="news">News</a></li>
             </ul>
         </nav>
     </div>

http://git-wip-us.apache.org/repos/asf/storm-site/blob/a7a19afb/content/releases/1.0.3/Trident-spouts.html
----------------------------------------------------------------------
diff --git a/content/releases/1.0.3/Trident-spouts.html 
b/content/releases/1.0.3/Trident-spouts.html
index d1dd439..7d812e5 100644
--- a/content/releases/1.0.3/Trident-spouts.html
+++ b/content/releases/1.0.3/Trident-spouts.html
@@ -82,18 +82,16 @@
                         
                       
                         
-                          <li><a 
href="/releases/1.1.0/index.html">1.1.0</a></li>
-                        
                       
                         
+                          <li><a 
href="/releases/1.1.0/index.html">1.1.0</a></li>
+                        
                       
                         
                           <li><a 
href="/releases/1.0.4/index.html">1.0.4</a></li>
                         
                       
                         
-                      
-                        
                           <li><a 
href="/releases/1.0.3/index.html">1.0.3</a></li>
                         
                       
@@ -104,6 +102,8 @@
                         
                       
                         
+                      
+                        
                           <li><a 
href="/releases/0.10.2/index.html">0.10.2</a></li>
                         
                       
@@ -144,7 +144,7 @@
                         <li><a href="/contribute/BYLAWS.html">ByLaws</a></li>
                     </ul>
                 </li>
-                <li><a href="/2017/09/15/storm105-released.html" 
id="news">News</a></li>
+                <li><a href="/2018/02/14/storm106-released.html" 
id="news">News</a></li>
             </ul>
         </nav>
     </div>

http://git-wip-us.apache.org/repos/asf/storm-site/blob/a7a19afb/content/releases/1.0.3/Trident-state.html
----------------------------------------------------------------------
diff --git a/content/releases/1.0.3/Trident-state.html 
b/content/releases/1.0.3/Trident-state.html
index 4071eb7..3a7ae22 100644
--- a/content/releases/1.0.3/Trident-state.html
+++ b/content/releases/1.0.3/Trident-state.html
@@ -82,18 +82,16 @@
                         
                       
                         
-                          <li><a 
href="/releases/1.1.0/index.html">1.1.0</a></li>
-                        
                       
                         
+                          <li><a 
href="/releases/1.1.0/index.html">1.1.0</a></li>
+                        
                       
                         
                           <li><a 
href="/releases/1.0.4/index.html">1.0.4</a></li>
                         
                       
                         
-                      
-                        
                           <li><a 
href="/releases/1.0.3/index.html">1.0.3</a></li>
                         
                       
@@ -104,6 +102,8 @@
                         
                       
                         
+                      
+                        
                           <li><a 
href="/releases/0.10.2/index.html">0.10.2</a></li>
                         
                       
@@ -144,7 +144,7 @@
                         <li><a href="/contribute/BYLAWS.html">ByLaws</a></li>
                     </ul>
                 </li>
-                <li><a href="/2017/09/15/storm105-released.html" 
id="news">News</a></li>
+                <li><a href="/2018/02/14/storm106-released.html" 
id="news">News</a></li>
             </ul>
         </nav>
     </div>
@@ -230,23 +230,23 @@ apple =&gt; [count=10, txid=2]
 <p>With opaque transactional spouts, it&#39;s no longer possible to use the 
trick of skipping state updates if the transaction id in the database is the 
same as the transaction id for the current batch. This is because the batch may 
have changed between state updates.</p>
 
 <p>What you can do is store more state in the database. Rather than store a 
value and transaction id in the database, you instead store a value, 
transaction id, and the previous value in the database. Let&#39;s again use the 
example of storing a count in the database. Suppose the partial count for your 
batch is &quot;2&quot; and it&#39;s time to apply a state update. Suppose the 
value in the database looks like this:</p>
-<div class="highlight"><pre><code class="language-" data-lang=""><span 
class="p">{</span><span class="w"> </span><span class="err">value</span><span 
class="w"> </span><span class="err">=</span><span class="w"> </span><span 
class="err">4,</span><span class="w">
-  </span><span class="err">prevValue</span><span class="w"> </span><span 
class="err">=</span><span class="w"> </span><span class="err">1,</span><span 
class="w">
-  </span><span class="err">txid</span><span class="w"> </span><span 
class="err">=</span><span class="w"> </span><span class="err">2</span><span 
class="w">
-</span><span class="p">}</span><span class="w">
-</span></code></pre></div>
+<div class="highlight"><pre><code class="language-" data-lang="">{ value = 4,
+  prevValue = 1,
+  txid = 2
+}
+</code></pre></div>
 <p>Suppose your current txid is 3, different than what&#39;s in the database. 
In this case, you set &quot;prevValue&quot; equal to &quot;value&quot;, 
increment &quot;value&quot; by your partial count, and update the txid. The new 
database value will look like this:</p>
-<div class="highlight"><pre><code class="language-" data-lang=""><span 
class="p">{</span><span class="w"> </span><span class="err">value</span><span 
class="w"> </span><span class="err">=</span><span class="w"> </span><span 
class="err">6,</span><span class="w">
-  </span><span class="err">prevValue</span><span class="w"> </span><span 
class="err">=</span><span class="w"> </span><span class="err">4,</span><span 
class="w">
-  </span><span class="err">txid</span><span class="w"> </span><span 
class="err">=</span><span class="w"> </span><span class="err">3</span><span 
class="w">
-</span><span class="p">}</span><span class="w">
-</span></code></pre></div>
+<div class="highlight"><pre><code class="language-" data-lang="">{ value = 6,
+  prevValue = 4,
+  txid = 3
+}
+</code></pre></div>
 <p>Now suppose your current txid is 2, equal to what&#39;s in the database. 
Now you know that the &quot;value&quot; in the database contains an update from 
a previous batch for your current txid, but that batch may have been different 
so you have to ignore it. What you do in this case is increment 
&quot;prevValue&quot; by your partial count to compute the new 
&quot;value&quot;. You then set the value in the database to this:</p>
-<div class="highlight"><pre><code class="language-" data-lang=""><span 
class="p">{</span><span class="w"> </span><span class="err">value</span><span 
class="w"> </span><span class="err">=</span><span class="w"> </span><span 
class="err">3,</span><span class="w">
-  </span><span class="err">prevValue</span><span class="w"> </span><span 
class="err">=</span><span class="w"> </span><span class="err">1,</span><span 
class="w">
-  </span><span class="err">txid</span><span class="w"> </span><span 
class="err">=</span><span class="w"> </span><span class="err">2</span><span 
class="w">
-</span><span class="p">}</span><span class="w">
-</span></code></pre></div>
+<div class="highlight"><pre><code class="language-" data-lang="">{ value = 3,
+  prevValue = 1,
+  txid = 2
+}
+</code></pre></div>
 <p>This works because of the strong ordering of batches provided by Trident. 
Once Trident moves onto a new batch for state updates, it will never go back to 
a previous batch. And since opaque transactional spouts guarantee no overlap 
between batches – that each tuple is successfully processed by one batch – 
you can safely update based on the previous value.</p>
 
 <h2 id="non-transactional-spouts">Non-transactional spouts</h2>
@@ -278,33 +278,33 @@ apple =&gt; [count=10, txid=2]
 
 <p>The base State interface just has two methods:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">interface</span> <span 
class="nc">State</span> <span class="o">{</span>
-    <span class="kt">void</span> <span class="n">beginCommit</span><span 
class="o">(</span><span class="n">Long</span> <span class="n">txid</span><span 
class="o">);</span> <span class="c1">// can be null for things like 
partitionPersist occurring off a DRPC stream</span>
-    <span class="kt">void</span> <span class="n">commit</span><span 
class="o">(</span><span class="n">Long</span> <span class="n">txid</span><span 
class="o">);</span>
+    <span class="kt">void</span> <span class="nf">beginCommit</span><span 
class="o">(</span><span class="n">Long</span> <span class="n">txid</span><span 
class="o">);</span> <span class="c1">// can be null for things like 
partitionPersist occurring off a DRPC stream</span>
+    <span class="kt">void</span> <span class="nf">commit</span><span 
class="o">(</span><span class="n">Long</span> <span class="n">txid</span><span 
class="o">);</span>
 <span class="o">}</span>
 </code></pre></div>
 <p>You&#39;re told when a state update is beginning, when a state update is 
ending, and you&#39;re given the txid in each case. Trident assumes nothing 
about how your state works, what kind of methods there are to update it, and 
what kind of methods there are to read from it.</p>
 
 <p>Suppose you have a home-grown database that contains user location 
information and you want to be able to access it from Trident. Your State 
implementation would have methods for getting and setting user information:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">LocationDB</span> <span class="kd">implements</span> <span 
class="n">State</span> <span class="o">{</span>
-    <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">beginCommit</span><span class="o">(</span><span class="n">Long</span> 
<span class="n">txid</span><span class="o">)</span> <span class="o">{</span>    
+    <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">beginCommit</span><span class="o">(</span><span 
class="n">Long</span> <span class="n">txid</span><span class="o">)</span> <span 
class="o">{</span>    
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">commit</span><span class="o">(</span><span class="n">Long</span> 
<span class="n">txid</span><span class="o">)</span> <span class="o">{</span>    
+    <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">commit</span><span class="o">(</span><span class="n">Long</span> 
<span class="n">txid</span><span class="o">)</span> <span class="o">{</span>    
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">setLocation</span><span class="o">(</span><span 
class="kt">long</span> <span class="n">userId</span><span class="o">,</span> 
<span class="n">String</span> <span class="n">location</span><span 
class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">setLocation</span><span class="o">(</span><span 
class="kt">long</span> <span class="n">userId</span><span class="o">,</span> 
<span class="n">String</span> <span class="n">location</span><span 
class="o">)</span> <span class="o">{</span>
       <span class="c1">// code to access database and set location</span>
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="n">String</span> <span 
class="n">getLocation</span><span class="o">(</span><span 
class="kt">long</span> <span class="n">userId</span><span class="o">)</span> 
<span class="o">{</span>
+    <span class="kd">public</span> <span class="n">String</span> <span 
class="nf">getLocation</span><span class="o">(</span><span 
class="kt">long</span> <span class="n">userId</span><span class="o">)</span> 
<span class="o">{</span>
       <span class="c1">// code to get location from database</span>
     <span class="o">}</span>
 <span class="o">}</span>
 </code></pre></div>
 <p>You then provide Trident a StateFactory that can create instances of your 
State object within Trident tasks. The StateFactory for your LocationDB might 
look something like this:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">LocationDBFactory</span> <span class="kd">implements</span> <span 
class="n">StateFactory</span> <span class="o">{</span>
-   <span class="kd">public</span> <span class="n">State</span> <span 
class="n">makeState</span><span class="o">(</span><span class="n">Map</span> 
<span class="n">conf</span><span class="o">,</span> <span class="kt">int</span> 
<span class="n">partitionIndex</span><span class="o">,</span> <span 
class="kt">int</span> <span class="n">numPartitions</span><span 
class="o">)</span> <span class="o">{</span>
-      <span class="k">return</span> <span class="k">new</span> <span 
class="n">LocationDB</span><span class="o">();</span>
+   <span class="kd">public</span> <span class="n">State</span> <span 
class="nf">makeState</span><span class="o">(</span><span class="n">Map</span> 
<span class="n">conf</span><span class="o">,</span> <span class="kt">int</span> 
<span class="n">partitionIndex</span><span class="o">,</span> <span 
class="kt">int</span> <span class="n">numPartitions</span><span 
class="o">)</span> <span class="o">{</span>
+      <span class="k">return</span> <span class="k">new</span> <span 
class="nf">LocationDB</span><span class="o">();</span>
    <span class="o">}</span> 
 <span class="o">}</span>
 </code></pre></div>
@@ -316,7 +316,7 @@ apple =&gt; [count=10, txid=2]
 </code></pre></div>
 <p>Now let&#39;s take a look at what the implementation of QueryLocation would 
look like:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">QueryLocation</span> <span class="kd">extends</span> <span 
class="n">BaseQueryFunction</span><span class="o">&lt;</span><span 
class="n">LocationDB</span><span class="o">,</span> <span 
class="n">String</span><span class="o">&gt;</span> <span class="o">{</span>
-    <span class="kd">public</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> 
<span class="n">batchRetrieve</span><span class="o">(</span><span 
class="n">LocationDB</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">List</span><span class="o">&lt;</span><span 
class="n">TridentTuple</span><span class="o">&gt;</span> <span 
class="n">inputs</span><span class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> 
<span class="nf">batchRetrieve</span><span class="o">(</span><span 
class="n">LocationDB</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">List</span><span class="o">&lt;</span><span 
class="n">TridentTuple</span><span class="o">&gt;</span> <span 
class="n">inputs</span><span class="o">)</span> <span class="o">{</span>
         <span class="n">List</span><span class="o">&lt;</span><span 
class="n">String</span><span class="o">&gt;</span> <span class="n">ret</span> 
<span class="o">=</span> <span class="k">new</span> <span 
class="n">ArrayList</span><span class="o">();</span>
         <span class="k">for</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="nl">input:</span> <span 
class="n">inputs</span><span class="o">)</span> <span class="o">{</span>
             <span class="n">ret</span><span class="o">.</span><span 
class="na">add</span><span class="o">(</span><span class="n">state</span><span 
class="o">.</span><span class="na">getLocation</span><span 
class="o">(</span><span class="n">input</span><span class="o">.</span><span 
class="na">getLong</span><span class="o">(</span><span class="mi">0</span><span 
class="o">)));</span>
@@ -324,7 +324,7 @@ apple =&gt; [count=10, txid=2]
         <span class="k">return</span> <span class="n">ret</span><span 
class="o">;</span>
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">,</span> <span class="n">String</span> <span 
class="n">location</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">,</span> <span class="n">String</span> <span 
class="n">location</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">)</span> <span class="o">{</span>
         <span class="n">collector</span><span class="o">.</span><span 
class="na">emit</span><span class="o">(</span><span class="k">new</span> <span 
class="n">Values</span><span class="o">(</span><span 
class="n">location</span><span class="o">));</span>
     <span class="o">}</span>    
 <span class="o">}</span>
@@ -333,24 +333,24 @@ apple =&gt; [count=10, txid=2]
 
 <p>You can see that this code doesn&#39;t take advantage of the batching that 
Trident does, since it just queries the LocationDB one at a time. So a better 
way to write the LocationDB would be like this:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">LocationDB</span> <span class="kd">implements</span> <span 
class="n">State</span> <span class="o">{</span>
-    <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">beginCommit</span><span class="o">(</span><span class="n">Long</span> 
<span class="n">txid</span><span class="o">)</span> <span class="o">{</span>    
+    <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">beginCommit</span><span class="o">(</span><span 
class="n">Long</span> <span class="n">txid</span><span class="o">)</span> <span 
class="o">{</span>    
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">commit</span><span class="o">(</span><span class="n">Long</span> 
<span class="n">txid</span><span class="o">)</span> <span class="o">{</span>    
+    <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">commit</span><span class="o">(</span><span class="n">Long</span> 
<span class="n">txid</span><span class="o">)</span> <span class="o">{</span>    
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">setLocationsBulk</span><span class="o">(</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Long</span><span class="o">&gt;</span> <span 
class="n">userIds</span><span class="o">,</span> <span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">String</span><span class="o">&gt;</span> <span 
class="n">locations</span><span class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">setLocationsBulk</span><span class="o">(</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Long</span><span class="o">&gt;</span> <span 
class="n">userIds</span><span class="o">,</span> <span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">String</span><span class="o">&gt;</span> <span 
class="n">locations</span><span class="o">)</span> <span class="o">{</span>
       <span class="c1">// set locations in bulk</span>
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> 
<span class="n">bulkGetLocations</span><span class="o">(</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Long</span><span class="o">&gt;</span> <span 
class="n">userIds</span><span class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> 
<span class="nf">bulkGetLocations</span><span class="o">(</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Long</span><span class="o">&gt;</span> <span 
class="n">userIds</span><span class="o">)</span> <span class="o">{</span>
       <span class="c1">// get locations in bulk</span>
     <span class="o">}</span>
 <span class="o">}</span>
 </code></pre></div>
 <p>Then, you can write the QueryLocation function like this:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">QueryLocation</span> <span class="kd">extends</span> <span 
class="n">BaseQueryFunction</span><span class="o">&lt;</span><span 
class="n">LocationDB</span><span class="o">,</span> <span 
class="n">String</span><span class="o">&gt;</span> <span class="o">{</span>
-    <span class="kd">public</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> 
<span class="n">batchRetrieve</span><span class="o">(</span><span 
class="n">LocationDB</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">List</span><span class="o">&lt;</span><span 
class="n">TridentTuple</span><span class="o">&gt;</span> <span 
class="n">inputs</span><span class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> 
<span class="nf">batchRetrieve</span><span class="o">(</span><span 
class="n">LocationDB</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">List</span><span class="o">&lt;</span><span 
class="n">TridentTuple</span><span class="o">&gt;</span> <span 
class="n">inputs</span><span class="o">)</span> <span class="o">{</span>
         <span class="n">List</span><span class="o">&lt;</span><span 
class="n">Long</span><span class="o">&gt;</span> <span class="n">userIds</span> 
<span class="o">=</span> <span class="k">new</span> <span 
class="n">ArrayList</span><span class="o">&lt;</span><span 
class="n">Long</span><span class="o">&gt;();</span>
         <span class="k">for</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="nl">input:</span> <span 
class="n">inputs</span><span class="o">)</span> <span class="o">{</span>
             <span class="n">userIds</span><span class="o">.</span><span 
class="na">add</span><span class="o">(</span><span class="n">input</span><span 
class="o">.</span><span class="na">getLong</span><span class="o">(</span><span 
class="mi">0</span><span class="o">));</span>
@@ -358,7 +358,7 @@ apple =&gt; [count=10, txid=2]
         <span class="k">return</span> <span class="n">state</span><span 
class="o">.</span><span class="na">bulkGetLocations</span><span 
class="o">(</span><span class="n">userIds</span><span class="o">);</span>
     <span class="o">}</span>
 
-    <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">,</span> <span class="n">String</span> <span 
class="n">location</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">,</span> <span class="n">String</span> <span 
class="n">location</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">)</span> <span class="o">{</span>
         <span class="n">collector</span><span class="o">.</span><span 
class="na">emit</span><span class="o">(</span><span class="k">new</span> <span 
class="n">Values</span><span class="o">(</span><span 
class="n">location</span><span class="o">));</span>
     <span class="o">}</span>    
 <span class="o">}</span>
@@ -367,7 +367,7 @@ apple =&gt; [count=10, txid=2]
 
 <p>To update state, you make use of the StateUpdater interface. Here&#39;s a 
StateUpdater that updates a LocationDB with new location information:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">LocationUpdater</span> <span class="kd">extends</span> <span 
class="n">BaseStateUpdater</span><span class="o">&lt;</span><span 
class="n">LocationDB</span><span class="o">&gt;</span> <span class="o">{</span>
-    <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">updateState</span><span class="o">(</span><span 
class="n">LocationDB</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">List</span><span class="o">&lt;</span><span 
class="n">TridentTuple</span><span class="o">&gt;</span> <span 
class="n">tuples</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">)</span> <span class="o">{</span>
+    <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">updateState</span><span class="o">(</span><span 
class="n">LocationDB</span> <span class="n">state</span><span 
class="o">,</span> <span class="n">List</span><span class="o">&lt;</span><span 
class="n">TridentTuple</span><span class="o">&gt;</span> <span 
class="n">tuples</span><span class="o">,</span> <span 
class="n">TridentCollector</span> <span class="n">collector</span><span 
class="o">)</span> <span class="o">{</span>
         <span class="n">List</span><span class="o">&lt;</span><span 
class="n">Long</span><span class="o">&gt;</span> <span class="n">ids</span> 
<span class="o">=</span> <span class="k">new</span> <span 
class="n">ArrayList</span><span class="o">&lt;</span><span 
class="n">Long</span><span class="o">&gt;();</span>
         <span class="n">List</span><span class="o">&lt;</span><span 
class="n">String</span><span class="o">&gt;</span> <span 
class="n">locations</span> <span class="o">=</span> <span class="k">new</span> 
<span class="n">ArrayList</span><span class="o">&lt;</span><span 
class="n">String</span><span class="o">&gt;();</span>
         <span class="k">for</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="nl">t:</span> <span 
class="n">tuples</span><span class="o">)</span> <span class="o">{</span>
@@ -402,16 +402,16 @@ apple =&gt; [count=10, txid=2]
 </code></pre></div>
 <p>persistentAggregate is an additional abstraction built on top of 
partitionPersist that knows how to take a Trident aggregator and use it to 
apply updates to the source of state. In this case, since this is a grouped 
stream, Trident expects the state you provide to implement the 
&quot;MapState&quot; interface. The grouping fields will be the keys in the 
state, and the aggregation result will be the values in the state. The 
&quot;MapState&quot; interface looks like this:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">interface</span> <span 
class="nc">MapState</span><span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span class="kd">extends</span> 
<span class="n">State</span> <span class="o">{</span>
-    <span class="n">List</span><span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span 
class="n">multiGet</span><span class="o">(</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Object</span><span class="o">&gt;&gt;</span> <span 
class="n">keys</span><span class="o">);</span>
-    <span class="n">List</span><span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span 
class="n">multiUpdate</span><span class="o">(</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Object</span><span class="o">&gt;&gt;</span> <span 
class="n">keys</span><span class="o">,</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">ValueUpdater</span><span 
class="o">&gt;</span> <span class="n">updaters</span><span class="o">);</span>
-    <span class="kt">void</span> <span class="n">multiPut</span><span 
class="o">(</span><span class="n">List</span><span class="o">&lt;</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Object</span><span class="o">&gt;&gt;</span> <span 
class="n">keys</span><span class="o">,</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span> <span 
class="n">vals</span><span class="o">);</span>
+    <span class="n">List</span><span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span 
class="nf">multiGet</span><span class="o">(</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Object</span><span class="o">&gt;&gt;</span> <span 
class="n">keys</span><span class="o">);</span>
+    <span class="n">List</span><span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span 
class="nf">multiUpdate</span><span class="o">(</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Object</span><span class="o">&gt;&gt;</span> <span 
class="n">keys</span><span class="o">,</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">ValueUpdater</span><span 
class="o">&gt;</span> <span class="n">updaters</span><span class="o">);</span>
+    <span class="kt">void</span> <span class="nf">multiPut</span><span 
class="o">(</span><span class="n">List</span><span class="o">&lt;</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Object</span><span class="o">&gt;&gt;</span> <span 
class="n">keys</span><span class="o">,</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span> <span 
class="n">vals</span><span class="o">);</span>
 <span class="o">}</span>
 </code></pre></div>
 <p>When you do aggregations on non-grouped streams (a global aggregation), 
Trident expects your State object to implement the &quot;Snapshottable&quot; 
interface:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">interface</span> <span 
class="nc">Snapshottable</span><span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span class="kd">extends</span> 
<span class="n">State</span> <span class="o">{</span>
-    <span class="n">T</span> <span class="n">get</span><span 
class="o">();</span>
-    <span class="n">T</span> <span class="n">update</span><span 
class="o">(</span><span class="n">ValueUpdater</span> <span 
class="n">updater</span><span class="o">);</span>
-    <span class="kt">void</span> <span class="n">set</span><span 
class="o">(</span><span class="n">T</span> <span class="n">o</span><span 
class="o">);</span>
+    <span class="n">T</span> <span class="nf">get</span><span 
class="o">();</span>
+    <span class="n">T</span> <span class="nf">update</span><span 
class="o">(</span><span class="n">ValueUpdater</span> <span 
class="n">updater</span><span class="o">);</span>
+    <span class="kt">void</span> <span class="nf">set</span><span 
class="o">(</span><span class="n">T</span> <span class="n">o</span><span 
class="o">);</span>
 <span class="o">}</span>
 </code></pre></div>
 <p><a 
href="http://github.com/apache/storm/blob/v1.0.3/storm-core/src/jvm/org/apache/storm/trident/testing/MemoryMapState.java";>MemoryMapState</a>
 and <a 
href="https://github.com/nathanmarz/trident-memcached/blob/1.0.3/src/jvm/trident/memcached/MemcachedState.java";>MemcachedState</a>
 each implement both of these interfaces.</p>
@@ -420,8 +420,8 @@ apple =&gt; [count=10, txid=2]
 
 <p>Trident makes it easy to implement MapState&#39;s, doing almost all the 
work for you. The OpaqueMap, TransactionalMap, and NonTransactionalMap classes 
implement all the logic for doing the respective fault-tolerance logic. You 
simply provide these classes with an IBackingMap implementation that knows how 
to do multiGets and multiPuts of the respective key/values. IBackingMap looks 
like this:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">interface</span> <span 
class="nc">IBackingMap</span><span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span class="o">{</span>
-    <span class="n">List</span><span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span 
class="n">multiGet</span><span class="o">(</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Object</span><span class="o">&gt;&gt;</span> <span 
class="n">keys</span><span class="o">);</span> 
-    <span class="kt">void</span> <span class="n">multiPut</span><span 
class="o">(</span><span class="n">List</span><span class="o">&lt;</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Object</span><span class="o">&gt;&gt;</span> <span 
class="n">keys</span><span class="o">,</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span> <span 
class="n">vals</span><span class="o">);</span> 
+    <span class="n">List</span><span class="o">&lt;</span><span 
class="n">T</span><span class="o">&gt;</span> <span 
class="nf">multiGet</span><span class="o">(</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Object</span><span class="o">&gt;&gt;</span> <span 
class="n">keys</span><span class="o">);</span> 
+    <span class="kt">void</span> <span class="nf">multiPut</span><span 
class="o">(</span><span class="n">List</span><span class="o">&lt;</span><span 
class="n">List</span><span class="o">&lt;</span><span 
class="n">Object</span><span class="o">&gt;&gt;</span> <span 
class="n">keys</span><span class="o">,</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span> <span 
class="n">vals</span><span class="o">);</span> 
 <span class="o">}</span>
 </code></pre></div>
 <p>OpaqueMap&#39;s will call multiPut with <a 
href="http://github.com/apache/storm/blob/v1.0.3/storm-core/src/jvm/org/apache/storm/trident/state/OpaqueValue.java";>OpaqueValue</a>&#39;s
 for the vals, TransactionalMap&#39;s will give <a 
href="http://github.com/apache/storm/blob/v1.0.3/storm-core/src/jvm/org/apache/storm/trident/state/TransactionalValue.java";>TransactionalValue</a>&#39;s
 for the vals, and NonTransactionalMaps will just pass the objects from the 
topology through.</p>

http://git-wip-us.apache.org/repos/asf/storm-site/blob/a7a19afb/content/releases/1.0.3/Trident-tutorial.html
----------------------------------------------------------------------
diff --git a/content/releases/1.0.3/Trident-tutorial.html 
b/content/releases/1.0.3/Trident-tutorial.html
index 0f8a8f3..3f82161 100644
--- a/content/releases/1.0.3/Trident-tutorial.html
+++ b/content/releases/1.0.3/Trident-tutorial.html
@@ -82,18 +82,16 @@
                         
                       
                         
-                          <li><a 
href="/releases/1.1.0/index.html">1.1.0</a></li>
-                        
                       
                         
+                          <li><a 
href="/releases/1.1.0/index.html">1.1.0</a></li>
+                        
                       
                         
                           <li><a 
href="/releases/1.0.4/index.html">1.0.4</a></li>
                         
                       
                         
-                      
-                        
                           <li><a 
href="/releases/1.0.3/index.html">1.0.3</a></li>
                         
                       
@@ -104,6 +102,8 @@
                         
                       
                         
+                      
+                        
                           <li><a 
href="/releases/0.10.2/index.html">0.10.2</a></li>
                         
                       
@@ -144,7 +144,7 @@
                         <li><a href="/contribute/BYLAWS.html">ByLaws</a></li>
                     </ul>
                 </li>
-                <li><a href="/2017/09/15/storm105-released.html" 
id="news">News</a></li>
+                <li><a href="/2018/02/14/storm106-released.html" 
id="news">News</a></li>
             </ul>
         </nav>
     </div>
@@ -173,10 +173,10 @@
 
 <p>For the purposes of illustration, this example will read an infinite stream 
of sentences from the following source:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="n">FixedBatchSpout</span> <span class="n">spout</span> <span 
class="o">=</span> <span class="k">new</span> <span 
class="n">FixedBatchSpout</span><span class="o">(</span><span 
class="k">new</span> <span class="n">Fields</span><span class="o">(</span><span 
class="s">"sentence"</span><span class="o">),</span> <span 
class="mi">3</span><span class="o">,</span>
-               <span class="k">new</span> <span class="n">Values</span><span 
class="o">(</span><span class="s">"the cow jumped over the moon"</span><span 
class="o">),</span>
-               <span class="k">new</span> <span class="n">Values</span><span 
class="o">(</span><span class="s">"the man went to the store and bought some 
candy"</span><span class="o">),</span>
-               <span class="k">new</span> <span class="n">Values</span><span 
class="o">(</span><span class="s">"four score and seven years ago"</span><span 
class="o">),</span>
-               <span class="k">new</span> <span class="n">Values</span><span 
class="o">(</span><span class="s">"how many apples can you eat"</span><span 
class="o">));</span>
+               <span class="k">new</span> <span class="nf">Values</span><span 
class="o">(</span><span class="s">"the cow jumped over the moon"</span><span 
class="o">),</span>
+               <span class="k">new</span> <span class="nf">Values</span><span 
class="o">(</span><span class="s">"the man went to the store and bought some 
candy"</span><span class="o">),</span>
+               <span class="k">new</span> <span class="nf">Values</span><span 
class="o">(</span><span class="s">"four score and seven years ago"</span><span 
class="o">),</span>
+               <span class="k">new</span> <span class="nf">Values</span><span 
class="o">(</span><span class="s">"how many apples can you eat"</span><span 
class="o">));</span>
 <span class="n">spout</span><span class="o">.</span><span 
class="na">setCycle</span><span class="o">(</span><span 
class="kc">true</span><span class="o">);</span>
 </code></pre></div>
 <p>This spout cycles through that set of sentences over and over to produce 
the sentence stream. Here&#39;s the code to do the streaming word count part of 
the computation:</p>
@@ -200,7 +200,7 @@
 
 <p>Back to the example, the spout emits a stream containing one field called 
&quot;sentence&quot;. The next line of the topology definition applies the 
Split function to each tuple in the stream, taking the &quot;sentence&quot; 
field and splitting it into words. Each sentence tuple creates potentially many 
word tuples – for instance, the sentence &quot;the cow jumped over the 
moon&quot; creates six &quot;word&quot; tuples. Here&#39;s the definition of 
Split:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">Split</span> <span class="kd">extends</span> <span 
class="n">BaseFunction</span> <span class="o">{</span>
-   <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">,</span> <span class="n">TridentCollector</span> <span 
class="n">collector</span><span class="o">)</span> <span class="o">{</span>
+   <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">,</span> <span class="n">TridentCollector</span> <span 
class="n">collector</span><span class="o">)</span> <span class="o">{</span>
        <span class="n">String</span> <span class="n">sentence</span> <span 
class="o">=</span> <span class="n">tuple</span><span class="o">.</span><span 
class="na">getString</span><span class="o">(</span><span 
class="mi">0</span><span class="o">);</span>
        <span class="k">for</span><span class="o">(</span><span 
class="n">String</span> <span class="nl">word:</span> <span 
class="n">sentence</span><span class="o">.</span><span 
class="na">split</span><span class="o">(</span><span class="s">" "</span><span 
class="o">))</span> <span class="o">{</span>
            <span class="n">collector</span><span class="o">.</span><span 
class="na">emit</span><span class="o">(</span><span class="k">new</span> <span 
class="n">Values</span><span class="o">(</span><span class="n">word</span><span 
class="o">));</span>                
@@ -282,15 +282,15 @@
 
 <p>Next, the set of followers is uniqued and counted. This is done in two 
steps. First a &quot;group by&quot; is done on the batch by 
&quot;follower&quot;, running the &quot;One&quot; aggregator on each group. The 
&quot;One&quot; aggregator simply emits a single tuple containing the number 
one for each group. Then, the ones are summed together to get the unique count 
of the followers set. Here&#39;s the definition of the &quot;One&quot; 
aggregator:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">One</span> <span class="kd">implements</span> <span 
class="n">CombinerAggregator</span><span class="o">&lt;</span><span 
class="n">Integer</span><span class="o">&gt;</span> <span class="o">{</span>
-   <span class="kd">public</span> <span class="n">Integer</span> <span 
class="n">init</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">)</span> <span class="o">{</span>
+   <span class="kd">public</span> <span class="n">Integer</span> <span 
class="nf">init</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">)</span> <span class="o">{</span>
        <span class="k">return</span> <span class="mi">1</span><span 
class="o">;</span>
    <span class="o">}</span>
 
-   <span class="kd">public</span> <span class="n">Integer</span> <span 
class="n">combine</span><span class="o">(</span><span class="n">Integer</span> 
<span class="n">val1</span><span class="o">,</span> <span 
class="n">Integer</span> <span class="n">val2</span><span class="o">)</span> 
<span class="o">{</span>
+   <span class="kd">public</span> <span class="n">Integer</span> <span 
class="nf">combine</span><span class="o">(</span><span class="n">Integer</span> 
<span class="n">val1</span><span class="o">,</span> <span 
class="n">Integer</span> <span class="n">val2</span><span class="o">)</span> 
<span class="o">{</span>
        <span class="k">return</span> <span class="mi">1</span><span 
class="o">;</span>
    <span class="o">}</span>
 
-   <span class="kd">public</span> <span class="n">Integer</span> <span 
class="n">zero</span><span class="o">()</span> <span class="o">{</span>
+   <span class="kd">public</span> <span class="n">Integer</span> <span 
class="nf">zero</span><span class="o">()</span> <span class="o">{</span>
        <span class="k">return</span> <span class="mi">1</span><span 
class="o">;</span>
    <span class="o">}</span>        
 <span class="o">}</span>
@@ -308,7 +308,7 @@
 </code></pre></div>
 <p>Suppose the implementation of MyFilter is this:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">MyFilter</span> <span class="kd">extends</span> <span 
class="n">BaseFilter</span> <span class="o">{</span>
-   <span class="kd">public</span> <span class="kt">boolean</span> <span 
class="n">isKeep</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">)</span> <span class="o">{</span>
+   <span class="kd">public</span> <span class="kt">boolean</span> <span 
class="nf">isKeep</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">)</span> <span class="o">{</span>
        <span class="k">return</span> <span class="n">tuple</span><span 
class="o">.</span><span class="na">getInteger</span><span 
class="o">(</span><span class="mi">0</span><span class="o">)</span> <span 
class="o">&lt;</span> <span class="mi">10</span><span class="o">;</span>
    <span class="o">}</span>
 <span class="o">}</span>
@@ -317,7 +317,7 @@
 
 <p>Let&#39;s now look at how &quot;function fields&quot; work. Suppose you had 
this function:</p>
 <div class="highlight"><pre><code class="language-java" data-lang="java"><span 
class="kd">public</span> <span class="kd">class</span> <span 
class="nc">AddAndMultiply</span> <span class="kd">extends</span> <span 
class="n">BaseFunction</span> <span class="o">{</span>
-   <span class="kd">public</span> <span class="kt">void</span> <span 
class="n">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">,</span> <span class="n">TridentCollector</span> <span 
class="n">collector</span><span class="o">)</span> <span class="o">{</span>
+   <span class="kd">public</span> <span class="kt">void</span> <span 
class="nf">execute</span><span class="o">(</span><span 
class="n">TridentTuple</span> <span class="n">tuple</span><span 
class="o">,</span> <span class="n">TridentCollector</span> <span 
class="n">collector</span><span class="o">)</span> <span class="o">{</span>
        <span class="kt">int</span> <span class="n">i1</span> <span 
class="o">=</span> <span class="n">tuple</span><span class="o">.</span><span 
class="na">getInteger</span><span class="o">(</span><span 
class="mi">0</span><span class="o">);</span>
        <span class="kt">int</span> <span class="n">i2</span> <span 
class="o">=</span> <span class="n">tuple</span><span class="o">.</span><span 
class="na">getInteger</span><span class="o">(</span><span 
class="mi">1</span><span class="o">);</span>
        <span class="n">collector</span><span class="o">.</span><span 
class="na">emit</span><span class="o">(</span><span class="k">new</span> <span 
class="n">Values</span><span class="o">(</span><span class="n">i1</span> <span 
class="o">+</span> <span class="n">i2</span><span class="o">,</span> <span 
class="n">i1</span> <span class="o">*</span> <span class="n">i2</span><span 
class="o">));</span>

http://git-wip-us.apache.org/repos/asf/storm-site/blob/a7a19afb/content/releases/1.0.3/Troubleshooting.html
----------------------------------------------------------------------
diff --git a/content/releases/1.0.3/Troubleshooting.html 
b/content/releases/1.0.3/Troubleshooting.html
index 7d3f852..b0a5752 100644
--- a/content/releases/1.0.3/Troubleshooting.html
+++ b/content/releases/1.0.3/Troubleshooting.html
@@ -82,18 +82,16 @@
                         
                       
                         
-                          <li><a 
href="/releases/1.1.0/index.html">1.1.0</a></li>
-                        
                       
                         
+                          <li><a 
href="/releases/1.1.0/index.html">1.1.0</a></li>
+                        
                       
                         
                           <li><a 
href="/releases/1.0.4/index.html">1.0.4</a></li>
                         
                       
                         
-                      
-                        
                           <li><a 
href="/releases/1.0.3/index.html">1.0.3</a></li>
                         
                       
@@ -104,6 +102,8 @@
                         
                       
                         
+                      
+                        
                           <li><a 
href="/releases/0.10.2/index.html">0.10.2</a></li>
                         
                       
@@ -144,7 +144,7 @@
                         <li><a href="/contribute/BYLAWS.html">ByLaws</a></li>
                     </ul>
                 </li>
-                <li><a href="/2017/09/15/storm105-released.html" 
id="news">News</a></li>
+                <li><a href="/2018/02/14/storm106-released.html" 
id="news">News</a></li>
             </ul>
         </nav>
     </div>
@@ -227,7 +227,7 @@
 <li>Try deleting the local dirs for the supervisors and restarting the 
daemons. Supervisors create a unique id for themselves and store it locally. 
When that id is copied to other nodes, Storm gets confused. </li>
 </ul>
 
-<h3 id="quot-multiple-defaults-yaml-found-quot-error">&quot;Multiple 
defaults.yaml found&quot; error</h3>
+<h3 id="multiple-defaults-yaml-found-error">&quot;Multiple defaults.yaml 
found&quot; error</h3>
 
 <p>Symptoms:</p>
 
@@ -241,7 +241,7 @@
 <li>You&#39;re most likely including the Storm jars inside your topology jar. 
When packaging your topology jar, don&#39;t include the Storm jars as Storm 
will put those on the classpath for you.</li>
 </ul>
 
-<h3 
id="quot-nosuchmethoderror-quot-when-running-storm-jar">&quot;NoSuchMethodError&quot;
 when running storm jar</h3>
+<h3 
id="nosuchmethoderror-when-running-storm-jar">&quot;NoSuchMethodError&quot; 
when running storm jar</h3>
 
 <p>Symptoms:</p>
 

Reply via email to