Modified: tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html
URL: 
http://svn.apache.org/viewvc/tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html?rev=1764939&r1=1764938&r2=1764939&view=diff
==============================================================================
--- tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html (original)
+++ tinkerpop/site/docs/3.2.3-SNAPSHOT/reference/index.html Fri Oct 14 16:01:29 
2016
@@ -1125,6 +1125,7 @@ span.line-numbers { border-right: 1px so
 <li><a href="#_bindings">Bindings</a></li>
 <li><a href="#_traversal_strategies">Traversal Strategies</a></li>
 <li><a href="#_the_lambda_solution">The Lambda Solution</a></li>
+<li><a href="#_custom_serialization">Custom Serialization</a></li>
 </ul>
 </li>
 </ul>
@@ -4047,13 +4048,13 @@ gremlin&gt; graph.io(graphml()).readGrap
 gremlin&gt; g = graph.traversal().withoutStrategies(LazyBarrierStrategy) <span 
class="comment">//</span><b>(1)</b>
 ==&gt;graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span 
class="integer">808</span> <span class="key">edges</span>:<span 
class="integer">8049</span>], standard]
 gremlin&gt; clockWithResult(<span 
class="integer">1</span>){g.V().both().both().both().count().next()} <span 
class="comment">//</span><b>(2)</b>
-==&gt;<span class="float">8382.847754</span>
+==&gt;<span class="float">8263.601911</span>
 ==&gt;<span class="integer">126653966</span>
 gremlin&gt; clockWithResult(<span 
class="integer">1</span>){g.V().repeat(both()).times(<span 
class="integer">3</span>).count().next()} <span 
class="comment">//</span><b>(3)</b>
-==&gt;<span class="float">38.959904</span>
+==&gt;<span class="float">33.578151999999996</span>
 ==&gt;<span class="integer">126653966</span>
 gremlin&gt; clockWithResult(<span 
class="integer">1</span>){g.V().both().barrier().both().barrier().both().barrier().count().next()}
 <span class="comment">//</span><b>(4)</b>
-==&gt;<span class="float">14.982242999999999</span>
+==&gt;<span class="float">17.57452</span>
 ==&gt;<span class="integer">126653966</span></code></pre>
 </div>
 </div>
@@ -4090,7 +4091,7 @@ gremlin&gt; graph.io(graphml()).readGrap
 gremlin&gt; g = graph.traversal() <span class="comment">//</span><b>(1)</b>
 ==&gt;graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span 
class="integer">808</span> <span class="key">edges</span>:<span 
class="integer">8049</span>], standard]
 gremlin&gt; clockWithResult(<span 
class="integer">1</span>){g.V().both().both().both().count().next()}
-==&gt;<span class="float">12.814529</span>
+==&gt;<span class="float">7.922727999999999</span>
 ==&gt;<span class="integer">126653966</span>
 gremlin&gt; g.V().both().both().both().count().iterate().toString() <span 
class="comment">//</span><b>(2)</b>
 ==&gt;[TinkerGraphStep(vertex,<span class="type">[]</span>), 
VertexStep(BOTH,vertex), NoOpBarrierStep(<span class="integer">10000</span>), 
VertexStep(BOTH,vertex), NoOpBarrierStep(<span class="integer">10000</span>), 
VertexStep(BOTH,edge), CountGlobalStep]</code></pre>
@@ -4314,9 +4315,9 @@ gremlin&gt; g.V().hasLabel(<span class="
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().coin(<span class="float">0.5</span>)
-==&gt;v[<span class="integer">2</span>]
 ==&gt;v[<span class="integer">3</span>]
-==&gt;v[<span class="integer">6</span>]
+==&gt;v[<span class="integer">4</span>]
+==&gt;v[<span class="integer">5</span>]
 gremlin&gt; g.V().coin(<span class="float">0.0</span>)
 gremlin&gt; g.V().coin(<span class="float">1.0</span>)
 ==&gt;v[<span class="integer">1</span>]
@@ -4435,12 +4436,12 @@ has been seen or not.</p>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().valueMap(<span class="predefined-constant">true</span>, <span 
class="string"><span class="delimiter">'</span><span 
class="content">name</span><span class="delimiter">'</span></span>)
-==&gt;[<span class="key">id</span>:<span class="integer">1</span>,<span 
class="key">name</span>:[marko],<span class="key">label</span>:person]
-==&gt;[<span class="key">id</span>:<span class="integer">2</span>,<span 
class="key">name</span>:[vadas],<span class="key">label</span>:person]
-==&gt;[<span class="key">id</span>:<span class="integer">3</span>,<span 
class="key">name</span>:[lop],<span class="key">label</span>:software]
-==&gt;[<span class="key">id</span>:<span class="integer">4</span>,<span 
class="key">name</span>:[josh],<span class="key">label</span>:person]
-==&gt;[<span class="key">id</span>:<span class="integer">5</span>,<span 
class="key">name</span>:[ripple],<span class="key">label</span>:software]
-==&gt;[<span class="key">id</span>:<span class="integer">6</span>,<span 
class="key">name</span>:[peter],<span class="key">label</span>:person]
+==&gt;[<span class="key">name</span>:[marko],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">1</span>]
+==&gt;[<span class="key">name</span>:[vadas],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">2</span>]
+==&gt;[<span class="key">name</span>:[lop],<span 
class="key">label</span>:software,<span class="key">id</span>:<span 
class="integer">3</span>]
+==&gt;[<span class="key">name</span>:[josh],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">4</span>]
+==&gt;[<span class="key">name</span>:[ripple],<span 
class="key">label</span>:software,<span class="key">id</span>:<span 
class="integer">5</span>]
+==&gt;[<span class="key">name</span>:[peter],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">6</span>]
 gremlin&gt; g.V().dedup().by(label).values(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>)
 ==&gt;marko
 ==&gt;lop</code></pre>
@@ -4521,12 +4522,12 @@ Original Traversal                 [Grap
 ConnectiveStrategy           [D]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
 InlineFilterStrategy         [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
 MatchPredicateStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
-FilterRankingStrategy        [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
 IncidentToAdjacentStrategy   [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
 AdjacentToIncidentStrategy   [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
+RepeatUnrollStrategy         [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
+FilterRankingStrategy        [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
+PathRetractionStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), CountGlobalStep, IsStep(gt(<span 
class="integer">5</span>))]
 RangeByIsCountStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span 
class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, 
IsStep(gt(<span class="integer">5</span>))]
-RepeatUnrollStrategy         [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span 
class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, 
IsStep(gt(<span class="integer">5</span>))]
-PathRetractionStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span 
class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, 
IsStep(gt(<span class="integer">5</span>))]
 LazyBarrierStrategy          [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span 
class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, 
IsStep(gt(<span class="integer">5</span>))]
 TinkerGraphStepStrategy      [P]   
[TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span 
class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, 
IsStep(gt(<span class="integer">5</span>))]
 ProfileStrategy              [F]   
[TinkerGraphStep(vertex,[~label.eq(person)]), VertexStep(OUT,edge), 
IdentityStep, EdgeVertexStep(IN), RangeGlobalStep(<span 
class="integer">0</span>,<span class="integer">6</span>), CountGlobalStep, 
IsStep(gt(<span class="integer">5</span>))]
@@ -5653,14 +5654,14 @@ gremlin&gt; g.V().hasLabel(<span class="
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span 
class="content">person</span><span 
class="delimiter">'</span></span>).order().by(shuffle)
 ==&gt;v[<span class="integer">2</span>]
-==&gt;v[<span class="integer">6</span>]
-==&gt;v[<span class="integer">1</span>]
 ==&gt;v[<span class="integer">4</span>]
-gremlin&gt; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).order().by(shuffle)
 ==&gt;v[<span class="integer">1</span>]
-==&gt;v[<span class="integer">2</span>]
 ==&gt;v[<span class="integer">6</span>]
-==&gt;v[<span class="integer">4</span>]</code></pre>
+gremlin&gt; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).order().by(shuffle)
+==&gt;v[<span class="integer">2</span>]
+==&gt;v[<span class="integer">1</span>]
+==&gt;v[<span class="integer">4</span>]
+==&gt;v[<span class="integer">6</span>]</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -5733,12 +5734,12 @@ The <code>pageRank()</code>-step is a <c
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; g = 
graph.traversal().withComputer()
 ==&gt;graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span 
class="integer">6</span> <span class="key">edges</span>:<span 
class="integer">6</span>], graphcomputer]
 gremlin&gt; g.V().pageRank().by(<span class="string"><span 
class="delimiter">'</span><span class="content">pageRank</span><span 
class="delimiter">'</span></span>).values(<span class="string"><span 
class="delimiter">'</span><span class="content">pageRank</span><span 
class="delimiter">'</span></span>)
+==&gt;<span class="float">0.19250000000000003</span>
+==&gt;<span class="float">0.19250000000000003</span>
 ==&gt;<span class="float">0.4018125</span>
 ==&gt;<span class="float">0.23181250000000003</span>
 ==&gt;<span class="float">0.15000000000000002</span>
 ==&gt;<span class="float">0.15000000000000002</span>
-==&gt;<span class="float">0.19250000000000003</span>
-==&gt;<span class="float">0.19250000000000003</span>
 gremlin&gt; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).
            pageRank().
              by(outE(<span class="string"><span 
class="delimiter">'</span><span class="content">knows</span><span 
class="delimiter">'</span></span>)).
@@ -5775,23 +5776,23 @@ InlineFilterStrategy         [O]   [Trav
                                       
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
 MatchPredicateStrategy       [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
                                       
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-FilterRankingStrategy        [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
+OrderLimitStrategy           [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
                                       
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
 IncidentToAdjacentStrategy   [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
                                       
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
 AdjacentToIncidentStrategy   [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
                                       
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-RangeByIsCountStrategy       [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
-                                      
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
 RepeatUnrollStrategy         [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
                                       
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
+FilterRankingStrategy        [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
+                                      
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
 PathProcessorStrategy        [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
                                       
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
 PathRetractionStrategy       [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
                                       
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-LazyBarrierStrategy          [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
+RangeByIsCountStrategy       [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
                                       
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
-OrderLimitStrategy           [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
+LazyBarrierStrategy          [O]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
                                       
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
 TinkerGraphStepStrategy      [P]   
[TraversalVertexProgramStep([GraphStep(vertex,<span class="type">[]</span>), 
HasStep([~label.eq(person)])],graphfilter[none]), 
PageRankVertexProgramStep([VertexStep(OUT,[knows],edge)],friendRank,<span 
class="integer">30</span>,graphfilter[none]), TraversalV
                                       
ertexProgramStep([OrderGlobalStep([[value(friendRank), decr]]), 
PropertyMapStep([name, friendRank],value)],graphfilter[none]), 
ComputerResultStep]
@@ -5955,7 +5956,7 @@ gremlin&gt; g.V().peerPressure().by(<spa
 gremlin&gt; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).
            peerPressure().by(<span class="string"><span 
class="delimiter">'</span><span class="content">cluster</span><span 
class="delimiter">'</span></span>).
            group().by(<span class="string"><span 
class="delimiter">'</span><span class="content">cluster</span><span 
class="delimiter">'</span></span>).by(<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>)
-==&gt;[<span class="integer">1</span>:[marko,josh,vadas],<span 
class="integer">6</span>:[peter]]</code></pre>
+==&gt;[<span class="integer">1</span>:[marko,vadas,josh],<span 
class="integer">6</span>:[peter]]</code></pre>
 </div>
 </div>
 </div>
@@ -5984,18 +5985,18 @@ profile results, but durations are not e
 ==&gt;Traversal Metrics
 Step                                                               Count  
Traversers       <span class="predefined-type">Time</span> (ms)    % Dur
 
=============================================================================================================
-TinkerGraphStep(vertex,<span class="type">[]</span>)                           
                  <span class="integer">6</span>           <span 
class="integer">6</span>           <span class="float">0.086</span>    <span 
class="float">12.77</span>
-VertexStep(OUT,[created],vertex)                                       <span 
class="integer">4</span>           <span class="integer">4</span>           
<span class="float">0.110</span>    <span class="float">16.20</span>
-VertexStep(BOTH,vertex)                                               <span 
class="integer">10</span>          <span class="integer">10</span>           
<span class="float">0.132</span>    <span class="float">19.50</span>
-NoOpBarrierStep(<span class="integer">5000</span>)                             
                    <span class="integer">10</span>           <span 
class="integer">3</span>           <span class="float">0.062</span>     <span 
class="float">9.19</span>
-VertexStep(BOTH,vertex)                                               <span 
class="integer">24</span>           <span class="integer">7</span>           
<span class="float">0.030</span>     <span class="float">4.48</span>
-NoOpBarrierStep(<span class="integer">5000</span>)                             
                    <span class="integer">24</span>           <span 
class="integer">5</span>           <span class="float">0.029</span>     <span 
class="float">4.33</span>
-VertexStep(BOTH,vertex)                                               <span 
class="integer">58</span>          <span class="integer">11</span>           
<span class="float">0.037</span>     <span class="float">5.55</span>
-NoOpBarrierStep(<span class="integer">5000</span>)                             
                    <span class="integer">58</span>           <span 
class="integer">6</span>           <span class="float">0.045</span>     <span 
class="float">6.65</span>
-HasStep([~label.eq(person)])                                          <span 
class="integer">48</span>           <span class="integer">4</span>           
<span class="float">0.029</span>     <span class="float">4.30</span>
-PropertiesStep([age],value)                                           <span 
class="integer">48</span>           <span class="integer">4</span>           
<span class="float">0.034</span>     <span class="float">5.04</span>
-SumGlobalStep                                                          <span 
class="integer">1</span>           <span class="integer">1</span>           
<span class="float">0.081</span>    <span class="float">11.99</span>
-                                            &gt;TOTAL                     -    
       -           <span class="float">0.681</span>        -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>)                           
                  <span class="integer">6</span>           <span 
class="integer">6</span>           <span class="float">0.072</span>    <span 
class="float">12.13</span>
+VertexStep(OUT,[created],vertex)                                       <span 
class="integer">4</span>           <span class="integer">4</span>           
<span class="float">0.101</span>    <span class="float">17.04</span>
+VertexStep(BOTH,vertex)                                               <span 
class="integer">10</span>          <span class="integer">10</span>           
<span class="float">0.063</span>    <span class="float">10.72</span>
+NoOpBarrierStep(<span class="integer">5000</span>)                             
                    <span class="integer">10</span>           <span 
class="integer">3</span>           <span class="float">0.057</span>     <span 
class="float">9.57</span>
+VertexStep(BOTH,vertex)                                               <span 
class="integer">24</span>           <span class="integer">7</span>           
<span class="float">0.030</span>     <span class="float">5.04</span>
+NoOpBarrierStep(<span class="integer">5000</span>)                             
                    <span class="integer">24</span>           <span 
class="integer">5</span>           <span class="float">0.028</span>     <span 
class="float">4.82</span>
+VertexStep(BOTH,vertex)                                               <span 
class="integer">58</span>          <span class="integer">11</span>           
<span class="float">0.040</span>     <span class="float">6.75</span>
+NoOpBarrierStep(<span class="integer">5000</span>)                             
                    <span class="integer">58</span>           <span 
class="integer">6</span>           <span class="float">0.057</span>     <span 
class="float">9.60</span>
+HasStep([~label.eq(person)])                                          <span 
class="integer">48</span>           <span class="integer">4</span>           
<span class="float">0.029</span>     <span class="float">4.98</span>
+PropertiesStep([age],value)                                           <span 
class="integer">48</span>           <span class="integer">4</span>           
<span class="float">0.034</span>     <span class="float">5.84</span>
+SumGlobalStep                                                          <span 
class="integer">1</span>           <span class="integer">1</span>           
<span class="float">0.080</span>    <span class="float">13.51</span>
+                                            &gt;TOTAL                     -    
       -           <span class="float">0.596</span>        -</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6043,9 +6044,9 @@ gremlin&gt; metrics = t.getSideEffects()
 ==&gt;Traversal Metrics
 Step                                                               Count  
Traversers       <span class="predefined-type">Time</span> (ms)    % Dur
 
=============================================================================================================
-TinkerGraphStep(vertex,<span class="type">[]</span>)                           
                  <span class="integer">6</span>           <span 
class="integer">6</span>           <span class="float">0.100</span>  -<span 
class="float">115.95</span>
-VertexStep(OUT,[created],vertex)                                       <span 
class="integer">4</span>           <span class="integer">4</span>          
-<span class="float">0.186</span>   <span class="float">215.95</span>
-                                            &gt;TOTAL                     -    
       -          -<span class="float">0.086</span>        -</code></pre>
+TinkerGraphStep(vertex,<span class="type">[]</span>)                           
                  <span class="integer">6</span>           <span 
class="integer">6</span>           <span class="float">0.144</span>   -<span 
class="float">90.76</span>
+VertexStep(OUT,[created],vertex)                                       <span 
class="integer">4</span>           <span class="integer">4</span>          
-<span class="float">0.303</span>   <span class="float">190.76</span>
+                                            &gt;TOTAL                     -    
       -          -<span class="float">0.159</span>        -</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6199,8 +6200,8 @@ gremlin&gt; g.V().hasLabel(<span class="
            valueMap(<span class="string"><span class="delimiter">'</span><span 
class="content">name</span><span class="delimiter">'</span></span>, <span 
class="string"><span class="delimiter">'</span><span 
class="content">rank</span><span class="delimiter">'</span></span>)
 ==&gt;[<span class="key">name</span>:[marko],<span 
class="key">rank</span>:[<span class="float">0.15000000000000002</span>]]
 ==&gt;[<span class="key">name</span>:[peter],<span 
class="key">rank</span>:[<span class="float">0.15000000000000002</span>]]
-==&gt;[<span class="key">name</span>:[josh],<span 
class="key">rank</span>:[<span class="float">0.19250000000000003</span>]]
-==&gt;[<span class="key">name</span>:[vadas],<span 
class="key">rank</span>:[<span 
class="float">0.19250000000000003</span>]]</code></pre>
+==&gt;[<span class="key">name</span>:[vadas],<span 
class="key">rank</span>:[<span class="float">0.19250000000000003</span>]]
+==&gt;[<span class="key">name</span>:[josh],<span 
class="key">rank</span>:[<span 
class="float">0.19250000000000003</span>]]</code></pre>
 </div>
 </div>
 </div>
@@ -6466,14 +6467,14 @@ value is accessed (<code>sack()</code>).
 ==&gt;<span class="float">1.0</span>
 ==&gt;<span class="float">1.0</span>
 gremlin&gt; rand = <span class="keyword">new</span> <span 
class="predefined-type">Random</span>()
-==&gt;java.util.Random<span class="error">@</span><span 
class="float">2f</span><span class="integer">98859</span>a
+==&gt;java.util.Random<span class="error">@</span><span 
class="float">6e95</span>c023
 gremlin&gt; g.withSack {rand.nextFloat()}.V().sack()
-==&gt;<span class="float">0.5964332</span>
-==&gt;<span class="float">0.88723356</span>
-==&gt;<span class="float">0.4387771</span>
-==&gt;<span class="float">0.82640034</span>
-==&gt;<span class="float">0.62456286</span>
-==&gt;<span class="float">0.5871389</span></code></pre>
+==&gt;<span class="float">0.98372227</span>
+==&gt;<span class="float">0.25891244</span>
+==&gt;<span class="float">0.84362406</span>
+==&gt;<span class="float">0.9044096</span>
+==&gt;<span class="float">0.9889438</span>
+==&gt;<span class="float">0.54450595</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6586,10 +6587,10 @@ gremlin&gt; g.withBulk(<span class="pred
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().outE().sample(<span class="integer">1</span>).values(<span 
class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span class="delimiter">'</span></span>)
 ==&gt;<span class="float">0.5</span>
 gremlin&gt; g.V().outE().sample(<span class="integer">1</span>).by(<span 
class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span 
class="delimiter">'</span></span>).values(<span class="string"><span 
class="delimiter">'</span><span class="content">weight</span><span 
class="delimiter">'</span></span>)
-==&gt;<span class="float">0.4</span>
-gremlin&gt; g.V().outE().sample(<span class="integer">2</span>).by(<span 
class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span 
class="delimiter">'</span></span>).values(<span class="string"><span 
class="delimiter">'</span><span class="content">weight</span><span 
class="delimiter">'</span></span>)
 ==&gt;<span class="float">1.0</span>
-==&gt;<span class="float">1.0</span></code></pre>
+gremlin&gt; g.V().outE().sample(<span class="integer">2</span>).by(<span 
class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span 
class="delimiter">'</span></span>).values(<span class="string"><span 
class="delimiter">'</span><span class="content">weight</span><span 
class="delimiter">'</span></span>)
+==&gt;<span class="float">0.5</span>
+==&gt;<span class="float">0.4</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -6604,15 +6605,15 @@ the traverser never splits and continues
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V(<span class="integer">1</span>).repeat(local(
                   bothE().sample(<span class="integer">1</span>).by(<span 
class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span class="delimiter">'</span></span>).otherV()
                 )).times(<span class="integer">5</span>)
-==&gt;v[<span class="integer">3</span>]
+==&gt;v[<span class="integer">4</span>]
 gremlin&gt; g.V(<span class="integer">1</span>).repeat(local(
                   bothE().sample(<span class="integer">1</span>).by(<span 
class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span class="delimiter">'</span></span>).otherV()
                 )).times(<span class="integer">5</span>).path()
-==&gt;[v[<span class="integer">1</span>],e[<span 
class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">4</span>],v[<span class="integer">4</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">3</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">4</span>],e[<span 
class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">5</span>],v[<span class="integer">5</span>],e[<span 
class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">5</span>],v[<span class="integer">4</span>]]
+==&gt;[v[<span class="integer">1</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</span>],v[<span class="integer">2</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</span>],v[<span class="integer">1</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</span>],v[<span class="integer">2</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</span>],v[<span class="integer">1</span>],e[<span 
class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">3</span>]]
 gremlin&gt; g.V(<span class="integer">1</span>).repeat(local(
                   bothE().sample(<span class="integer">1</span>).by(<span 
class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span class="delimiter">'</span></span>).otherV()
                 )).times(<span class="integer">10</span>).path()
-==&gt;[v[<span class="integer">1</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</span>],v[<span class="integer">2</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</span>],v[<span class="integer">1</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</span>],v[<span class="integer">2</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</span>],v[<span class="integer">1</span>],e[<span 
class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">3</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">4</span>],e[<span 
class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">4</span>
 ],v[<span class="integer">1</span>],e[<span class="integer">8</span>][<span 
class="integer">1</span>-knows-&gt;<span class="integer">4</span>],v[<span 
class="integer">4</span>],e[<span class="integer">8</span>][<span 
class="integer">1</span>-knows-&gt;<span class="integer">4</span>],v[<span 
class="integer">1</span>],e[<span class="integer">7</span>][<span 
class="integer">1</span>-knows-&gt;<span class="integer">2</span>],v[<span 
class="integer">2</span>]]</code></pre>
+==&gt;[v[<span class="integer">1</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</span>],v[<span class="integer">2</span>],e[<span 
class="integer">7</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">2</span>],v[<span class="integer">1</span>],e[<span 
class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">3</span>],e[<span 
class="integer">9</span>][<span class="integer">1</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">1</span>],e[<span 
class="integer">8</span>][<span class="integer">1</span>-knows-&gt;<span 
class="integer">4</span>],v[<span class="integer">4</span>],e[<span 
class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">5</span>],v[<span class="integer">5</span>],e[<span 
class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">5</
 span>],v[<span class="integer">4</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">3</span>],e[<span 
class="integer">11</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">3</span>],v[<span class="integer">4</span>],e[<span 
class="integer">10</span>][<span class="integer">4</span>-created-&gt;<span 
class="integer">5</span>],v[<span class="integer">5</span>]]</code></pre>
 </div>
 </div>
 </div>
@@ -7121,7 +7122,7 @@ that can be used to time execution of a
 ==&gt;v[<span class="integer">5</span>]=<span class="integer">1136688</span>
 ==&gt;v[<span class="integer">6</span>]=<span class="integer">1136688</span>
 gremlin&gt; clock(<span class="integer">1</span>) 
{g.V().repeat(both().groupCount(<span class="string"><span 
class="delimiter">'</span><span class="content">m</span><span 
class="delimiter">'</span></span>)).times(<span 
class="integer">16</span>).cap(<span class="string"><span 
class="delimiter">'</span><span class="content">m</span><span 
class="delimiter">'</span></span>).order(local).by(values,decr).next()}
-==&gt;<span class="float">1.890463</span>
+==&gt;<span class="float">1.703647</span>
 gremlin&gt; g.V().repeat(timeLimit(<span 
class="integer">2</span>).both().groupCount(<span class="string"><span 
class="delimiter">'</span><span class="content">m</span><span 
class="delimiter">'</span></span>)).times(<span 
class="integer">16</span>).cap(<span class="string"><span 
class="delimiter">'</span><span class="content">m</span><span 
class="delimiter">'</span></span>).order(local).by(values,decr).next()
 ==&gt;v[<span class="integer">1</span>]=<span class="integer">2744208</span>
 ==&gt;v[<span class="integer">3</span>]=<span class="integer">2744208</span>
@@ -7130,7 +7131,7 @@ gremlin&gt; g.V().repeat(timeLimit(<span
 ==&gt;v[<span class="integer">5</span>]=<span class="integer">1136688</span>
 ==&gt;v[<span class="integer">6</span>]=<span class="integer">1136688</span>
 gremlin&gt; clock(<span class="integer">1</span>) 
{g.V().repeat(timeLimit(<span class="integer">2</span>).both().groupCount(<span 
class="string"><span class="delimiter">'</span><span 
class="content">m</span><span class="delimiter">'</span></span>)).times(<span 
class="integer">16</span>).cap(<span class="string"><span 
class="delimiter">'</span><span class="content">m</span><span 
class="delimiter">'</span></span>).order(local).by(values,decr).next()}
-==&gt;<span class="float">2.36301</span></code></pre>
+==&gt;<span class="float">1.461136</span></code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -7328,30 +7329,30 @@ returned map.</p>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="groovy language-groovy">gremlin&gt; 
g.V().hasLabel(<span class="string"><span class="delimiter">'</span><span 
class="content">person</span><span 
class="delimiter">'</span></span>).valueMap(<span 
class="predefined-constant">true</span>)
-==&gt;[<span class="key">id</span>:<span class="integer">1</span>,<span 
class="key">name</span>:[marko],<span class="key">label</span>:person,<span 
class="key">location</span>:[san diego,santa cruz,brussels,santa fe]]
-==&gt;[<span class="key">id</span>:<span class="integer">7</span>,<span 
class="key">name</span>:[stephen],<span class="key">label</span>:person,<span 
class="key">location</span>:[centreville,dulles,purcellville]]
-==&gt;[<span class="key">id</span>:<span class="integer">8</span>,<span 
class="key">name</span>:[matthias],<span class="key">label</span>:person,<span 
class="key">location</span>:[bremen,baltimore,oakland,seattle]]
-==&gt;[<span class="key">id</span>:<span class="integer">9</span>,<span 
class="key">name</span>:[daniel],<span class="key">label</span>:person,<span 
class="key">location</span>:[spremberg,kaiserslautern,aachen]]
+==&gt;[<span class="key">name</span>:[marko],<span 
class="key">location</span>:[san diego,santa cruz,brussels,santa fe],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">1</span>]
+==&gt;[<span class="key">name</span>:[stephen],<span 
class="key">location</span>:[centreville,dulles,purcellville],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">7</span>]
+==&gt;[<span class="key">name</span>:[matthias],<span 
class="key">location</span>:[bremen,baltimore,oakland,seattle],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">8</span>]
+==&gt;[<span class="key">name</span>:[daniel],<span 
class="key">location</span>:[spremberg,kaiserslautern,aachen],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">9</span>]
 gremlin&gt; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).valueMap(<span 
class="predefined-constant">true</span>,<span class="string"><span 
class="delimiter">'</span><span class="content">name</span><span 
class="delimiter">'</span></span>)
-==&gt;[<span class="key">id</span>:<span class="integer">1</span>,<span 
class="key">name</span>:[marko],<span class="key">label</span>:person]
-==&gt;[<span class="key">id</span>:<span class="integer">7</span>,<span 
class="key">name</span>:[stephen],<span class="key">label</span>:person]
-==&gt;[<span class="key">id</span>:<span class="integer">8</span>,<span 
class="key">name</span>:[matthias],<span class="key">label</span>:person]
-==&gt;[<span class="key">id</span>:<span class="integer">9</span>,<span 
class="key">name</span>:[daniel],<span class="key">label</span>:person]
+==&gt;[<span class="key">name</span>:[marko],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">1</span>]
+==&gt;[<span class="key">name</span>:[stephen],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">7</span>]
+==&gt;[<span class="key">name</span>:[matthias],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">8</span>]
+==&gt;[<span class="key">name</span>:[daniel],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">9</span>]
 gremlin&gt; g.V().hasLabel(<span class="string"><span 
class="delimiter">'</span><span class="content">person</span><span 
class="delimiter">'</span></span>).properties(<span class="string"><span 
class="delimiter">'</span><span class="content">location</span><span 
class="delimiter">'</span></span>).valueMap(<span 
class="predefined-constant">true</span>)
-==&gt;[<span class="key">id</span>:<span class="integer">6</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">1997</span>,<span class="key">endTime</span>:<span 
class="integer">2001</span>,<span class="key">value</span>:san diego]
-==&gt;[<span class="key">id</span>:<span class="integer">7</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">2001</span>,<span class="key">endTime</span>:<span 
class="integer">2004</span>,<span class="key">value</span>:santa cruz]
-==&gt;[<span class="key">id</span>:<span class="integer">8</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">2004</span>,<span class="key">endTime</span>:<span 
class="integer">2005</span>,<span class="key">value</span>:brussels]
-==&gt;[<span class="key">id</span>:<span class="integer">9</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">2005</span>,<span class="key">value</span>:santa fe]
-==&gt;[<span class="key">id</span>:<span class="integer">10</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">1990</span>,<span class="key">endTime</span>:<span 
class="integer">2000</span>,<span class="key">value</span>:centreville]
-==&gt;[<span class="key">id</span>:<span class="integer">11</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">2000</span>,<span class="key">endTime</span>:<span 
class="integer">2006</span>,<span class="key">value</span>:dulles]
-==&gt;[<span class="key">id</span>:<span class="integer">12</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">2006</span>,<span class="key">value</span>:purcellville]
-==&gt;[<span class="key">id</span>:<span class="integer">13</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">2004</span>,<span class="key">endTime</span>:<span 
class="integer">2007</span>,<span class="key">value</span>:bremen]
-==&gt;[<span class="key">id</span>:<span class="integer">14</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">2007</span>,<span class="key">endTime</span>:<span 
class="integer">2011</span>,<span class="key">value</span>:baltimore]
-==&gt;[<span class="key">id</span>:<span class="integer">15</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">2011</span>,<span class="key">endTime</span>:<span 
class="integer">2014</span>,<span class="key">value</span>:oakland]
-==&gt;[<span class="key">id</span>:<span class="integer">16</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">2014</span>,<span class="key">value</span>:seattle]
-==&gt;[<span class="key">id</span>:<span class="integer">17</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">1982</span>,<span class="key">endTime</span>:<span 
class="integer">2005</span>,<span class="key">value</span>:spremberg]
-==&gt;[<span class="key">id</span>:<span class="integer">18</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">2005</span>,<span class="key">endTime</span>:<span 
class="integer">2009</span>,<span class="key">value</span>:kaiserslautern]
-==&gt;[<span class="key">id</span>:<span class="integer">19</span>,<span 
class="key">key</span>:location,<span class="key">startTime</span>:<span 
class="integer">2009</span>,<span class="key">value</span>:aachen]</code></pre>
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">1997</span>,<span class="key">endTime</span>:<span 
class="integer">2001</span>,<span class="key">value</span>:san diego,<span 
class="key">id</span>:<span class="integer">6</span>,<span 
class="key">key</span>:location]
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">2001</span>,<span class="key">endTime</span>:<span 
class="integer">2004</span>,<span class="key">value</span>:santa cruz,<span 
class="key">id</span>:<span class="integer">7</span>,<span 
class="key">key</span>:location]
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">2004</span>,<span class="key">endTime</span>:<span 
class="integer">2005</span>,<span class="key">value</span>:brussels,<span 
class="key">id</span>:<span class="integer">8</span>,<span 
class="key">key</span>:location]
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">2005</span>,<span class="key">value</span>:santa fe,<span 
class="key">id</span>:<span class="integer">9</span>,<span 
class="key">key</span>:location]
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">1990</span>,<span class="key">endTime</span>:<span 
class="integer">2000</span>,<span class="key">value</span>:centreville,<span 
class="key">id</span>:<span class="integer">10</span>,<span 
class="key">key</span>:location]
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">2000</span>,<span class="key">endTime</span>:<span 
class="integer">2006</span>,<span class="key">value</span>:dulles,<span 
class="key">id</span>:<span class="integer">11</span>,<span 
class="key">key</span>:location]
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">2006</span>,<span class="key">value</span>:purcellville,<span 
class="key">id</span>:<span class="integer">12</span>,<span 
class="key">key</span>:location]
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">2004</span>,<span class="key">endTime</span>:<span 
class="integer">2007</span>,<span class="key">value</span>:bremen,<span 
class="key">id</span>:<span class="integer">13</span>,<span 
class="key">key</span>:location]
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">2007</span>,<span class="key">endTime</span>:<span 
class="integer">2011</span>,<span class="key">value</span>:baltimore,<span 
class="key">id</span>:<span class="integer">14</span>,<span 
class="key">key</span>:location]
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">2011</span>,<span class="key">endTime</span>:<span 
class="integer">2014</span>,<span class="key">value</span>:oakland,<span 
class="key">id</span>:<span class="integer">15</span>,<span 
class="key">key</span>:location]
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">2014</span>,<span class="key">value</span>:seattle,<span 
class="key">id</span>:<span class="integer">16</span>,<span 
class="key">key</span>:location]
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">1982</span>,<span class="key">endTime</span>:<span 
class="integer">2005</span>,<span class="key">value</span>:spremberg,<span 
class="key">id</span>:<span class="integer">17</span>,<span 
class="key">key</span>:location]
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">2005</span>,<span class="key">endTime</span>:<span 
class="integer">2009</span>,<span class="key">value</span>:kaiserslautern,<span 
class="key">id</span>:<span class="integer">18</span>,<span 
class="key">key</span>:location]
+==&gt;[<span class="key">startTime</span>:<span 
class="integer">2009</span>,<span class="key">value</span>:aachen,<span 
class="key">id</span>:<span class="integer">19</span>,<span 
class="key">key</span>:location]</code></pre>
 </div>
 </div>
 </div>
@@ -7967,13 +7968,15 @@ depending on whether there is or is not
             <span class="directive">final</span> TinkerGraphStep&lt;?, ?&gt; 
tinkerGraphStep = <span class="keyword">new</span> 
TinkerGraphStep&lt;&gt;(originalGraphStep);
             TraversalHelper.replaceStep(originalGraphStep, tinkerGraphStep, 
traversal);
             Step&lt;?, ?&gt; currentStep = tinkerGraphStep.getNextStep();
-            <span class="keyword">while</span> (currentStep <span 
class="keyword">instanceof</span> HasStep) {
-                <span class="keyword">for</span> (<span 
class="directive">final</span> HasContainer hasContainer : 
((HasContainerHolder) currentStep).getHasContainers()) {
-                    <span class="keyword">if</span> 
(!GraphStep.processHasContainerIds(tinkerGraphStep, hasContainer))
-                        tinkerGraphStep.addHasContainer(hasContainer);
+            <span class="keyword">while</span> (currentStep <span 
class="keyword">instanceof</span> HasStep || currentStep <span 
class="keyword">instanceof</span> NoOpBarrierStep) {
+                <span class="keyword">if</span> (currentStep <span 
class="keyword">instanceof</span> HasStep) {
+                    <span class="keyword">for</span> (<span 
class="directive">final</span> HasContainer hasContainer : 
((HasContainerHolder) currentStep).getHasContainers()) {
+                        <span class="keyword">if</span> 
(!GraphStep.processHasContainerIds(tinkerGraphStep, hasContainer))
+                            tinkerGraphStep.addHasContainer(hasContainer);
+                    }
+                    TraversalHelper.copyLabels(currentStep, 
currentStep.getPreviousStep(), <span class="predefined-constant">false</span>);
+                    traversal.removeStep(currentStep);
                 }
-                TraversalHelper.copyLabels(currentStep, tinkerGraphStep, <span 
class="predefined-constant">false</span>);
-                traversal.removeStep(currentStep);
                 currentStep = currentStep.getNextStep();
             }
         }
@@ -7987,11 +7990,9 @@ depending on whether there is or is not
 </div>
 <div class="paragraph">
 <p>The traversal is redefined by simply taking a chain of 
<code>has()</code>-steps after <code>g.V()</code> 
(<code>TinkerGraphStep</code>) and providing
-their <code>HasContainers</code> to <code>TinkerGraphStep</code>. Then its up 
to <code>TinkerGraphStep</code> to determine if an appropriate index exists. In 
the code
-below, review the <code>vertices()</code> method and note how if an index 
exists, for a particular <code>HasContainer</code>, then that
-index is first queried before the remaining <code>HasContainer</code> filters 
are serially applied. Given that the strategy
-uses non-TinkerPop3 provided steps, it should go into the 
<code>ProviderOptimizationStrategy</code> category to ensure the
-added step does not interfere with the assumptions of the 
<code>OptimizationStrategy</code> strategies.</p>
+their <code>HasContainers</code> to <code>TinkerGraphStep</code>. Then its up 
to <code>TinkerGraphStep</code> to determine if an appropriate index exists.
+Given that the strategy uses non-TinkerPop3 provided steps, it should go into 
the <code>ProviderOptimizationStrategy</code> category
+to ensure the added step does not interfere with the assumptions of the 
<code>OptimizationStrategy</code> strategies.</p>
 </div>
 <div class="listingblock">
 <div class="content">
@@ -8056,23 +8057,23 @@ InlineFilterStrategy         [O]   [Grap
 MatchPredicateStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), 
TraversalFilterStep([PropertiesStep([name],value)]), HasStep([name.eq(marko), 
age.gt(<span class="integer">20</span>), age.lt(<span 
class="integer">32</span>)])<span class="error">@</span>[a], 
MatchStep(AND,[[MatchStartStep(a), Repeat
                                       Step([VertexStep(OUT,edge), 
EdgeVertexStep(IN), RepeatEndStep],until(loops(<span 
class="integer">2</span>)),emit(<span 
class="predefined-constant">false</span>)), MatchEndStep(b)], 
[MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], 
[MatchStartStep(b), WhereTra
                                       versalStep([WhereStartStep, 
VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span 
class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), 
GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
-FilterRankingStrategy        [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), 
age.gt(<span class="integer">20</span>), age.lt(<span 
class="integer">32</span>)]), 
TraversalFilterStep([PropertiesStep([name],value)])<span 
class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Repeat
-                                      Step([VertexStep(OUT,edge), 
EdgeVertexStep(IN), RepeatEndStep],until(loops(<span 
class="integer">2</span>)),emit(<span 
class="predefined-constant">false</span>)), MatchEndStep(b)], 
[MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], 
[MatchStartStep(b), WhereTra
-                                      versalStep([WhereStartStep, 
VertexStep(BOTH,vertex), CountGlobalStep, IsStep(gt(<span 
class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), 
GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
-IncidentToAdjacentStrategy   [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), 
age.gt(<span class="integer">20</span>), age.lt(<span 
class="integer">32</span>)]), 
TraversalFilterStep([PropertiesStep([name],value)])<span 
class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Repeat
+IncidentToAdjacentStrategy   [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), 
TraversalFilterStep([PropertiesStep([name],value)]), HasStep([name.eq(marko), 
age.gt(<span class="integer">20</span>), age.lt(<span 
class="integer">32</span>)])<span class="error">@</span>[a], 
MatchStep(AND,[[MatchStartStep(a), Repeat
                                       Step([VertexStep(OUT,vertex), 
RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span 
class="predefined-constant">false</span>)), MatchEndStep(b)], 
[MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], 
[MatchStartStep(b), WhereTraversalStep([WhereS
                                       tartStep, VertexStep(BOTH,vertex), 
CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), 
SelectOneStep(b), GroupCountStep([VertexStep(OUT,vertex), CountGlobalStep])]
-AdjacentToIncidentStrategy   [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), 
age.gt(<span class="integer">20</span>), age.lt(<span 
class="integer">32</span>)]), 
TraversalFilterStep([PropertiesStep([name],property)])<span 
class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Rep
+AdjacentToIncidentStrategy   [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), 
TraversalFilterStep([PropertiesStep([name],property)]), 
HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span 
class="integer">32</span>)])<span class="error">@</span>[a], 
MatchStep(AND,[[MatchStartStep(a), Rep
                                       eatStep([VertexStep(OUT,vertex), 
RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span 
class="predefined-constant">false</span>)), MatchEndStep(b)], 
[MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], 
[MatchStartStep(b), WhereTraversalStep([Whe
                                       reStartStep, VertexStep(BOTH,edge), 
CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), 
SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
-RangeByIsCountStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), 
age.gt(<span class="integer">20</span>), age.lt(<span 
class="integer">32</span>)]), 
TraversalFilterStep([PropertiesStep([name],property)])<span 
class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Rep
-                                      eatStep([VertexStep(OUT,vertex), 
RepeatEndStep],until(loops(<span class="integer">2</span>)),emit(<span 
class="predefined-constant">false</span>)), MatchEndStep(b)], 
[MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], 
[MatchStartStep(b), WhereTraversalStep([Whe
-                                      reStartStep, VertexStep(BOTH,edge), 
RangeGlobalStep(<span class="integer">0</span>,<span class="integer">2</span>), 
CountGlobalStep, IsStep(gt(<span class="integer">1</span>))]), MatchEndStep]]), 
SelectOneStep(b), GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
-RepeatUnrollStrategy         [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), 
age.gt(<span class="integer">20</span>), age.lt(<span 
class="integer">32</span>)]), 
TraversalFilterStep([PropertiesStep([name],property)])<span 
class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Ver
+RepeatUnrollStrategy         [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), 
TraversalFilterStep([PropertiesStep([name],property)]), 
HasStep([name.eq(marko), age.gt(<span class="integer">20</span>), age.lt(<span 
class="integer">32</span>)])<span class="error">@</span>[a], 
MatchStep(AND,[[MatchStartStep(a), Ver
                                       texStep(OUT,vertex), 
NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex), 
NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], 
[MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], 
[MatchStartStep(b), WhereTrave
-                                      rsalStep([WhereStartStep, 
VertexStep(BOTH,edge), RangeGlobalStep(<span class="integer">0</span>,<span 
class="integer">2</span>), CountGlobalStep, IsStep(gt(<span 
class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), 
GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+                                      rsalStep([WhereStartStep, 
VertexStep(BOTH,edge), CountGlobalStep, IsStep(gt(<span 
class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), 
GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+FilterRankingStrategy        [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), 
age.gt(<span class="integer">20</span>), age.lt(<span 
class="integer">32</span>)]), 
TraversalFilterStep([PropertiesStep([name],property)])<span 
class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Ver
+                                      texStep(OUT,vertex), 
NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex), 
NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], 
[MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], 
[MatchStartStep(b), WhereTrave
+                                      rsalStep([WhereStartStep, 
VertexStep(BOTH,edge), CountGlobalStep, IsStep(gt(<span 
class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), 
GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
 PathRetractionStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), 
age.gt(<span class="integer">20</span>), age.lt(<span 
class="integer">32</span>)]), 
TraversalFilterStep([PropertiesStep([name],property)])<span 
class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Ver
                                       texStep(OUT,vertex), 
NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex), 
NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], 
[MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], 
[MatchStartStep(b), WhereTrave
+                                      rsalStep([WhereStartStep, 
VertexStep(BOTH,edge), CountGlobalStep, IsStep(gt(<span 
class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), 
GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
+RangeByIsCountStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), 
age.gt(<span class="integer">20</span>), age.lt(<span 
class="integer">32</span>)]), 
TraversalFilterStep([PropertiesStep([name],property)])<span 
class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Ver
+                                      texStep(OUT,vertex), 
NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex), 
NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], 
[MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], 
[MatchStartStep(b), WhereTrave
                                       rsalStep([WhereStartStep, 
VertexStep(BOTH,edge), RangeGlobalStep(<span class="integer">0</span>,<span 
class="integer">2</span>), CountGlobalStep, IsStep(gt(<span 
class="integer">1</span>))]), MatchEndStep]]), SelectOneStep(b), 
GroupCountStep([VertexStep(OUT,edge), CountGlobalStep])]
 LazyBarrierStrategy          [O]   [GraphStep(vertex,<span 
class="type">[]</span>), HasStep([~label.eq(person)]), HasStep([name.eq(marko), 
age.gt(<span class="integer">20</span>), age.lt(<span 
class="integer">32</span>)]), 
TraversalFilterStep([PropertiesStep([name],property)])<span 
class="error">@</span>[a], MatchStep(AND,[[MatchStartStep(a), Ver
                                       texStep(OUT,vertex), 
NoOpBarrierStep(<span class="integer">5000</span>), VertexStep(OUT,vertex), 
NoOpBarrierStep(<span class="integer">5000</span>), MatchEndStep(b)], 
[MatchStartStep(a), WherePredicateStep(neq(b)), MatchEndStep], 
[MatchStartStep(b), WhereTrave
@@ -8382,12 +8383,12 @@ SubgraphStrategy             [D]   [Grap
 ConnectiveStrategy           [D]   [GraphStep(vertex,<span 
class="type">[]</span>)<span class="error">@</span>[a], 
PropertiesStep([location],property), 
TraversalFilterStep([NotStep([PropertiesStep([endTime],value)])]), 
PropertyValueStep<span class="error">@</span>[b], SelectStep([a, 
b],[value(name), identity])]
 InlineFilterStrategy         [O]   [GraphStep(vertex,<span 
class="type">[]</span>)<span class="error">@</span>[a], 
PropertiesStep([location],property), 
NotStep([PropertiesStep([endTime],value)]), PropertyValueStep<span 
class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
 MatchPredicateStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>)<span class="error">@</span>[a], 
PropertiesStep([location],property), 
NotStep([PropertiesStep([endTime],value)]), PropertyValueStep<span 
class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
-FilterRankingStrategy        [O]   [GraphStep(vertex,<span 
class="type">[]</span>)<span class="error">@</span>[a], 
PropertiesStep([location],property), 
NotStep([PropertiesStep([endTime],value)]), PropertyValueStep<span 
class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
 IncidentToAdjacentStrategy   [O]   [GraphStep(vertex,<span 
class="type">[]</span>)<span class="error">@</span>[a], 
PropertiesStep([location],property), 
NotStep([PropertiesStep([endTime],value)]), PropertyValueStep<span 
class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
 AdjacentToIncidentStrategy   [O]   [GraphStep(vertex,<span 
class="type">[]</span>)<span class="error">@</span>[a], 
PropertiesStep([location],property), 
NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span 
class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
-RangeByIsCountStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>)<span class="error">@</span>[a], 
PropertiesStep([location],property), 
NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span 
class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
 RepeatUnrollStrategy         [O]   [GraphStep(vertex,<span 
class="type">[]</span>)<span class="error">@</span>[a], 
PropertiesStep([location],property), 
NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span 
class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
+FilterRankingStrategy        [O]   [GraphStep(vertex,<span 
class="type">[]</span>)<span class="error">@</span>[a], 
PropertiesStep([location],property), 
NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span 
class="error">@</span>[b], SelectStep([a, b],[value(name), identity])]
 PathRetractionStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>)<span class="error">@</span>[a], 
PropertiesStep([location],property), 
NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span 
class="error">@</span>[b], SelectStep([a, b],[value(name), identity]), 
NoOpBarrierStep(<span class="integer">2500</span>)]
+RangeByIsCountStrategy       [O]   [GraphStep(vertex,<span 
class="type">[]</span>)<span class="error">@</span>[a], 
PropertiesStep([location],property), 
NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span 
class="error">@</span>[b], SelectStep([a, b],[value(name), identity]), 
NoOpBarrierStep(<span class="integer">2500</span>)]
 LazyBarrierStrategy          [O]   [GraphStep(vertex,<span 
class="type">[]</span>)<span class="error">@</span>[a], 
PropertiesStep([location],property), 
NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span 
class="error">@</span>[b], SelectStep([a, b],[value(name), identity]), 
NoOpBarrierStep(<span class="integer">2500</span>)]
 TinkerGraphStepStrategy      [P]   [TinkerGraphStep(vertex,<span 
class="type">[]</span>)<span class="error">@</span>[a], 
PropertiesStep([location],property), 
NotStep([PropertiesStep([endTime],property)]), PropertyValueStep<span 
class="error">@</span>[b], SelectStep([a, b],[value(name), identity]), 
NoOpBarrierStep(<span class="integer">25</span>
                                       <span class="octal">00</span>)]
@@ -8440,14 +8441,14 @@ gremlin&gt; g = graph.traversal().withSt
            vertexProperties(or(hasLabel(neq(<span class="string"><span 
class="delimiter">'</span><span class="content">location</span><span 
class="delimiter">'</span></span>)),hasNot(<span class="string"><span 
class="delimiter">'</span><span class="content">endTime</span><span 
class="delimiter">'</span></span>))).create())
 ==&gt;graphtraversalsource[tinkergraph[<span class="key">vertices</span>:<span 
class="integer">6</span> <span class="key">edges</span>:<span 
class="integer">14</span>], standard]
 gremlin&gt; g.V().valueMap(<span class="predefined-constant">true</span>)
-==&gt;[<span class="key">id</span>:<span class="integer">1</span>,<span 
class="key">name</span>:[marko],<span class="key">label</span>:person,<span 
class="key">location</span>:[santa fe]]
-==&gt;[<span class="key">id</span>:<span class="integer">8</span>,<span 
class="key">name</span>:[matthias],<span class="key">label</span>:person,<span 
class="key">location</span>:[seattle]]
-==&gt;[<span class="key">id</span>:<span class="integer">10</span>,<span 
class="key">name</span>:[gremlin],<span class="key">label</span>:software]
-==&gt;[<span class="key">id</span>:<span class="integer">11</span>,<span 
class="key">name</span>:[tinkergraph],<span class="key">label</span>:software]
+==&gt;[<span class="key">name</span>:[marko],<span 
class="key">location</span>:[santa fe],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">1</span>]
+==&gt;[<span class="key">name</span>:[matthias],<span 
class="key">location</span>:[seattle],<span 
class="key">label</span>:person,<span class="key">id</span>:<span 
class="integer">8</span>]
+==&gt;[<span class="key">name</span>:[gremlin],<span 
class="key">label</span>:software,<span class="key">id</span>:<span 
class="integer">10</span>]
+==&gt;[<span class="key">name</span>:[tinkergraph],<span 
class="key">label</span>:software,<span class="key">id</span>:<span 
class="integer">11</span>]
 gremlin&gt; g.E().valueMap(<span class="predefined-constant">true</span>)
-==&gt;[<span class="key">id</span>:<span class="integer">13</span>,<span 
class="key">label</span>:develops,<span class="key">since</span>:<span 
class="integer">2009</span>]
-==&gt;[<span class="key">id</span>:<span class="integer">14</span>,<span 
class="key">label</span>:develops,<span class="key">since</span>:<span 
class="integer">2010</span>]
-==&gt;[<span class="key">id</span>:<span class="integer">21</span>,<span 
class="key">label</span>:develops,<span class="key">since</span>:<span 
class="integer">2012</span>]
+==&gt;[<span class="key">label</span>:develops,<span 
class="key">id</span>:<span class="integer">13</span>,<span 
class="key">since</span>:<span class="integer">2009</span>]
+==&gt;[<span class="key">label</span>:develops,<span 
class="key">id</span>:<span class="integer">14</span>,<span 
class="key">since</span>:<span class="integer">2010</span>]
+==&gt;[<span class="key">label</span>:develops,<span 
class="key">id</span>:<span class="integer">21</span>,<span 
class="key">since</span>:<span class="integer">2012</span>]
 gremlin&gt; g.V().outE().inV().
            path().
              by(<span class="string"><span class="delimiter">'</span><span 
class="content">name</span><span class="delimiter">'</span></span>).
@@ -15857,7 +15858,7 @@ it is possible to use the <code>withBind
 <h3 id="_traversal_strategies">Traversal Strategies</h3>
 <div class="paragraph">
 <p>In order to add and remove <a href="#traversalstrategy">traversal 
strategies</a> from a traversal source, Gremlin-Python has a
-<code>TraversalStrategy</code> class along with numerous subclasses that 
mirror the standard, distributed strategies.</p>
+<code>TraversalStrategy</code> class along with a collection of subclasses 
that mirror the standard Gremlin-Java strategies.</p>
 </div>
 <div class="listingblock">
 <div class="content">
@@ -15888,7 +15889,7 @@ null
 <div class="title">Note</div>
 </td>
 <td class="content">
-Many of the <code>TraversalStrategy</code> classes in Gremlin-Python are 
proxies to the respective strategy on the
+Many of the <code>TraversalStrategy</code> classes in Gremlin-Python are 
proxies to the respective strategy on
 Apache TinkerPop&#8217;s JVM-based Gremlin traversal machine. As such, their 
<code>apply(Traversal)</code> method does nothing. However,
 the strategy is encoded in the Gremlin-Python bytecode and transmitted to the 
Gremlin traversal machine for
 re-construction machine-side.
@@ -15956,6 +15957,43 @@ null
 </ol>
 </div>
 </div>
+<div class="sect2">
+<h3 id="_custom_serialization">Custom Serialization</h3>
+<div class="paragraph">
+<p>Gremlin-Python provides a GraphSON 2.0 serialization package with the 
standard Apache TinkerPop <code>g</code>-types registered
+(see <a 
href="http://tinkerpop.apache.org/docs/3.2.3-SNAPSHOT/dev/io/#graphson-2d0";>GraphSON
 2.0</a>). It is possible for users to add
+new types by creating serializers and deserializers in Python and registering 
them with the <code>RemoteConnection</code>.</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="python language-python"><span 
class="keyword">class</span> <span class="class">MyType</span>(<span 
class="predefined">object</span>):
+  GRAPHSON_PREFIX = <span class="string"><span 
class="delimiter">&quot;</span><span class="content">providerx</span><span 
class="delimiter">&quot;</span></span>
+  GRAPHSON_BASE_TYPE = <span class="string"><span 
class="delimiter">&quot;</span><span class="content">MyType</span><span 
class="delimiter">&quot;</span></span>
+  GRAPHSON_TYPE = GraphSONUtil.formatType(GRAPHSON_PREFIX, GRAPHSON_BASE_TYPE)
+
+  <span class="keyword">def</span> <span 
class="function">__init__</span>(<span class="predefined-constant">self</span>, 
x, y):
+    <span class="predefined-constant">self</span>.x = x
+    <span class="predefined-constant">self</span>.y = y
+
+  <span class="decorator">@classmethod</span>
+  <span class="keyword">def</span> <span 
class="function">objectify</span>(cls, value, reader):
+    <span class="keyword">return</span> cls(value[<span class="string"><span 
class="delimiter">'</span><span class="content">x</span><span 
class="delimiter">'</span></span>], value[<span class="string"><span 
class="delimiter">'</span><span class="content">y</span><span 
class="delimiter">'</span></span>])
+
+  <span class="decorator">@classmethod</span>
+  <span class="keyword">def</span> <span class="function">dictify</span>(cls, 
value, writer):
+    <span class="keyword">return</span> 
GraphSONUtil.typedValue(cls.GRAPHSON_BASE_TYPE,
+                                  {<span class="string"><span 
class="delimiter">'</span><span class="content">x</span><span 
class="delimiter">'</span></span>: value.x, <span class="string"><span 
class="delimiter">'</span><span class="content">y</span><span 
class="delimiter">'</span></span>: value.y},
+                                  cls.GRAPHSON_PREFIX)
+
+graphson_reader = GraphSONReader({MyType.GRAPHSON_TYPE: MyType})
+graphson_writer = GraphSONWriter({MyType: MyType})
+
+connection = DriverRemoteConnection(<span class="string"><span 
class="delimiter">'</span><span 
class="content">ws://localhost:8182/gremlin</span><span 
class="delimiter">'</span></span>, <span class="string"><span 
class="delimiter">'</span><span class="content">g</span><span 
class="delimiter">'</span></span>,
+                                     graphson_reader=graphson_reader,
+                                     
graphson_writer=graphson_writer)</code></pre>
+</div>
+</div>
+</div>
 </div>
 </div>
 <h1 id="conclusion" class="sect0">Conclusion</h1>
@@ -15986,7 +16024,7 @@ cheerfully greet visitors to the TinkerP
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2016-10-13 11:25:26 -04:00
+Last updated 2016-10-14 11:58:59 -04:00
 </div>
 </div>
 </body>

Modified: tinkerpop/site/docs/3.2.3-SNAPSHOT/upgrade/index.html
URL: 
http://svn.apache.org/viewvc/tinkerpop/site/docs/3.2.3-SNAPSHOT/upgrade/index.html?rev=1764939&r1=1764938&r2=1764939&view=diff
==============================================================================
--- tinkerpop/site/docs/3.2.3-SNAPSHOT/upgrade/index.html (original)
+++ tinkerpop/site/docs/3.2.3-SNAPSHOT/upgrade/index.html Fri Oct 14 16:01:29 
2016
@@ -1043,14 +1043,39 @@ formats: GraphML, GraphSON and Gryo.</p>
 <div class="sect3">
 <h4 id="_graph_system_providers">Graph System Providers</h4>
 <div class="sect4">
-<h5 id="_configurable_strategies">Configurable Strategies</h5>
+<h5 id="_default_lazybarrierstrategy">Default LazyBarrierStrategy</h5>
+<div class="paragraph">
+<p><code>LazyBarrierStrategy</code> has been included as a default strategy. 
<code>LazyBarrierStrategy</code> walks a traversal and looks for
+"flatMaps" (<code>out()</code>, <code>in()</code>, <code>both()</code>, 
<code>values()</code>, <code>V()</code>, etc.) and adds "lazy barriers" to dam 
up the stream so to
+increase the probability of bulking the traversers. One of the side-effects is 
that:</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="java 
language-java">g.V().out().V().has(a)</code></pre>
+</div>
+</div>
+<div class="paragraph">
+<p>is compiled to:</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="CodeRay"><code class="java 
language-java">g.V().out().barrier().V().barrier().has(a)</code></pre>
+</div>
+</div>
 <div class="paragraph">
-<p><code>TraversalSource.withStrategies()</code> and 
<code>TraversalSource.withoutStrategies()</code> use Java objects. In order to 
make strategy
-manipulation possible from Gremlin language variants like Gremlin-Python, it 
is important to support non-JVM-based versions
-of these methods. As such, 
<code>TraversalSource.withStrategies(Map&lt;String,Object&gt;...)</code> and 
<code>TraversalSource.withoutStrategies(String...)</code>
-were added.</p>
+<p>Given that <code>LazyBarrierStrategy</code> is an 
<code>OptimizationStrategy</code>, it comes before 
<code>ProviderOptimizationStrategies</code>.
+Thus, if the provider&#8217;s <code>XXXGraphStepStrategy</code> simply walks 
from the second <code>V()</code> looking for <code>has()</code>-only, it will 
not
+be able to pull in the <code>has()</code> cause the <code>barrier()</code> 
blocks it. Please see the updates to <code>TinkerGraphStepStrategy</code> and
+how it acknowledges <code>NoOpBarrierSteps</code> (i.e. 
<code>barrier()`</code>) skipping over them and “left”-propagating labels 
to the
+previous step.</p>
 </div>
 <div class="paragraph">
+<p>See: <a 
href="https://issues.apache.org/jira/browse/TINKERPOP-1488";>TINKERPOP-1488</a></p>
+</div>
+</div>
+<div class="sect4">
+<h5 id="_configurable_strategies">Configurable Strategies</h5>
+<div class="paragraph">
 <p>If the provider has non-configurable <code>TraversalStrategy</code> 
classes, those classes should expose a static <code>instance()</code>-method.
 This is typical and thus, backwards compatible. However, if the provider has a 
<code>TraversalStrategy</code> that can be configured
 (e.g. via a <code>Builder</code>), then it should expose a static 
<code>create(Configuration)</code>-method, where the keys of the configuration
@@ -1060,9 +1085,7 @@ a <code>SubgraphStrategy</code>, it does
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay"><code class="python language-python">g = 
Graph().traversal().withRemote(connection).
-        withStrategy({<span class="string"><span 
class="delimiter">'</span><span class="content">strategy</span><span 
class="delimiter">'</span></span>:<span class="string"><span 
class="delimiter">'</span><span 
class="content">org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SubgraphStrategy</span><span
 class="delimiter">'</span></span>,
-            <span class="string"><span class="delimiter">'</span><span 
class="content">vertices</span><span class="delimiter">'</span></span>: 
__.hasLabel(<span class="string"><span class="delimiter">'</span><span 
class="content">person</span><span class="delimiter">'</span></span>),
-            <span class="string"><span class="delimiter">'</span><span 
class="content">edges</span><span class="delimiter">'</span></span>: 
__.has(<span class="string"><span class="delimiter">'</span><span 
class="content">weight</span><span class="delimiter">'</span></span>,gt(<span 
class="float">0.5</span>))})
+        withStrategies(SubgraphStrategy(vertices=__.hasLabel(<span 
class="string"><span class="delimiter">'</span><span 
class="content">person</span><span 
class="delimiter">'</span></span>),edges=__.has(<span class="string"><span 
class="delimiter">'</span><span class="content">weight</span><span 
class="delimiter">'</span></span>,gt(<span class="float">0.5</span>))))
 ---
 
 The `SubgraphStrategy.create(Configuration)`-method <span 
class="keyword">is</span> defined <span class="keyword">as</span>:
@@ -1118,7 +1141,7 @@ The default implementation of `Traversal
 </div>
 <div class="paragraph">
 <p>public default Configuration getConfiguration() {
-    return new MapConfiguration(Collections.singletonMap(STRATEGY, 
this.getClass().getCanonicalName()));
+    return new BaseConfiguration();
 }</p>
 </div>
 <div class="listingblock">
@@ -2900,7 +2923,7 @@ See: link:http://tinkerpop.apache.org/do
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2016-10-12 14:45:07 -04:00
+Last updated 2016-10-14 11:59:00 -04:00
 </div>
 </div>
 </body>

Modified: 
tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/computer/package-tree.html
URL: 
http://svn.apache.org/viewvc/tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/computer/package-tree.html?rev=1764939&r1=1764938&r2=1764939&view=diff
==============================================================================
--- 
tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/computer/package-tree.html
 (original)
+++ 
tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/computer/package-tree.html
 Fri Oct 14 16:01:29 2016
@@ -2,10 +2,10 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (1.8.0_101) on Wed Oct 12 14:46:14 EDT 2016 -->
+<!-- Generated by javadoc (1.8.0_101) on Fri Oct 14 12:00:08 EDT 2016 -->
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>org.apache.tinkerpop.gremlin.process.computer Class Hierarchy (Apache 
TinkerPop 3.2.3-SNAPSHOT API)</title>
-<meta name="date" content="2016-10-12">
+<meta name="date" content="2016-10-14">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" 
title="Style">
 <script type="text/javascript" src="../../../../../../script.js"></script>
 </head>
@@ -137,11 +137,11 @@
 <ul>
 <li type="circle">java.lang.<a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Enum.html?is-external=true";
 title="class or interface in java.lang"><span 
class="typeNameLink">Enum</span></a>&lt;E&gt; (implements java.lang.<a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html?is-external=true";
 title="class or interface in java.lang">Comparable</a>&lt;T&gt;, java.io.<a 
href="http://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html?is-external=true";
 title="class or interface in java.io">Serializable</a>)
 <ul>
-<li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a 
href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/GraphComputer.ResultGraph.html"
 title="enum in org.apache.tinkerpop.gremlin.process.computer"><span 
class="typeNameLink">GraphComputer.ResultGraph</span></a></li>
 <li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a 
href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/MapReduce.Stage.html"
 title="enum in org.apache.tinkerpop.gremlin.process.computer"><span 
class="typeNameLink">MapReduce.Stage</span></a></li>
 <li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a 
href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/GraphComputer.Persist.html"
 title="enum in org.apache.tinkerpop.gremlin.process.computer"><span 
class="typeNameLink">GraphComputer.Persist</span></a></li>
-<li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a 
href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/GraphFilter.Legal.html"
 title="enum in org.apache.tinkerpop.gremlin.process.computer"><span 
class="typeNameLink">GraphFilter.Legal</span></a></li>
 <li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a 
href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/ProgramPhase.html"
 title="enum in org.apache.tinkerpop.gremlin.process.computer"><span 
class="typeNameLink">ProgramPhase</span></a></li>
+<li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a 
href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/GraphComputer.ResultGraph.html"
 title="enum in org.apache.tinkerpop.gremlin.process.computer"><span 
class="typeNameLink">GraphComputer.ResultGraph</span></a></li>
+<li type="circle">org.apache.tinkerpop.gremlin.process.computer.<a 
href="../../../../../../org/apache/tinkerpop/gremlin/process/computer/GraphFilter.Legal.html"
 title="enum in org.apache.tinkerpop.gremlin.process.computer"><span 
class="typeNameLink">GraphFilter.Legal</span></a></li>
 </ul>
 </li>
 </ul>

Modified: 
tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/Order.html
URL: 
http://svn.apache.org/viewvc/tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/Order.html?rev=1764939&r1=1764938&r2=1764939&view=diff
==============================================================================
--- 
tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/Order.html
 (original)
+++ 
tinkerpop/site/javadocs/3.2.3-SNAPSHOT/core/org/apache/tinkerpop/gremlin/process/traversal/Order.html
 Fri Oct 14 16:01:29 2016
@@ -2,10 +2,10 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (1.8.0_101) on Tue Oct 04 15:40:52 EDT 2016 -->
+<!-- Generated by javadoc (1.8.0_101) on Fri Oct 14 12:00:06 EDT 2016 -->
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Order (Apache TinkerPop 3.2.3-SNAPSHOT API)</title>
-<meta name="date" content="2016-10-04">
+<meta name="date" content="2016-10-14">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" 
title="Style">
 <script type="text/javascript" src="../../../../../../script.js"></script>
 </head>
@@ -232,7 +232,7 @@ the order they are declared.</div>
 <!--   -->
 </a>
 <h3>Methods inherited from class&nbsp;java.lang.<a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true";
 title="class or interface in java.lang">Object</a></h3>
-<code><a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#equals-java.lang.Object-";
 title="class or interface in java.lang">equals</a>, <a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#getClass--";
 title="class or interface in java.lang">getClass</a>, <a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notify--";
 title="class or interface in java.lang">notify</a>, <a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notifyAll--";
 title="class or interface in java.lang">notifyAll</a>, <a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait--";
 title="class or interface in java.lang">wait</a>, <a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-";
 title="class or interface in java.lang">wait</a>, <a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Obj
 ect.html?is-external=true#wait-long-int-" title="class or interface in 
java.lang">wait</a></code></li>
+<code><a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#getClass--";
 title="class or interface in java.lang">getClass</a>, <a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notify--";
 title="class or interface in java.lang">notify</a>, <a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notifyAll--";
 title="class or interface in java.lang">notifyAll</a>, <a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait--";
 title="class or interface in java.lang">wait</a>, <a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-";
 title="class or interface in java.lang">wait</a>, <a 
href="http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-int-";
 title="class or interface in java.lang">wait</a></code></li>
 </ul>
 <ul class="blockList">
 <li class="blockList"><a 
name="methods.inherited.from.class.java.util.Comparator">



Reply via email to