anchor.diff:  
   NOTE: TinkerPop2 had the notion of "Graph Wrappers" which decorated standard `Graph` implementations with additional features.  A Graph strategy is generally analogous to that capability.
   
  -To use a `GraphStrategy` instance, use the `GraphFactory` to instantiate the `Graph` as follows:
  -
  -[source,groovy]
  -----
  -gremlin> conf = new BaseConfiguration()
  -==>org.apache.commons.configuration.BaseConfiguration@5b40ceb
  -gremlin> conf.setProperty("gremlin.graph","com.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph")
  -==>null
  -gremlin> g = GraphFactory.open(conf, new ReadOnlyStrategy())
  -==>readonlygraphstrategy[tinkergraph[vertices:0 edges:0]]
  -----
  -
  -The above code specifies the creation of a `TinkerGraph` with the use of `ReadOnlyStrategy`.  Note that the `GraphFactory` does not return a `TinkerGraph` instance.  It returns a `StrategyGraph` which is a traverser for the underlying `TinkerGraph` and the `ReadOnlyStrategy`.  Since `StrategyGraph` implements the `Graph` interface, it can be used in the same manner as `TinkerGraph` or any other implementation.
  -
  -[source,groovy]
  -----
  -gremlin> g.addVertex('name','stephen')
  -Graph uses class com.tinkerpop.gremlin.structure.strategy.ReadOnlyStrategy and is therefore unmodifiable
  -----
  -
  -The above code tries to mutate the underlying `TinkerGraph`.  Note that `ReadOnlyStrategy` prevents that and throws an exception.  At any point, the `GraphStrategy` can be bypassed by getting the underlying `TinkerGraph`.
  -
  -[source,groovy]
  -----
  -gremlin> bg = g.getBaseGraph()
  -==>tinkergraph[vertices:0 edges:0]
  -gremlin> bg.addVertex('name','stephen')
  -==>v[0]
  -gremlin> g.V(0l).values('name')
  -==>stephen
  -----
  -
  -By getting the "base graph" (i.e. the underlying `TinkerGraph`) it is possible to mutate the graph.  The above code demonstrates that and also shows that it is then possible to read back that added vertex. The following sections explain details of the specific `GraphStrategy` implementations.
  +To use a `GraphStrategy` instance, use the `Graph.strategy()` method to instantiate the `StrategyGraph` as follows:
  +
  +[source,groovy]
  +----
  +gremlin> g = TinkerFactory.createModern()
  +==>tinkergraph[vertices:6 edges:6]
  +gremlin> sg = g.strategy(IdentityStrategy.instance())
  +==>identitystrategy[tinkergraph[vertices:6 edges:6]]
  +----
  +
  +The above code specifies the creation of a `TinkerGraph` with the use of `IdentityStrategy`.  Note that the `strategy` method returns a `StrategyGraph`, which implements the `Graph` interface. It can be used in the same manner as `TinkerGraph` or any other implementation.  At any point, the `GraphStrategy` can be bypassed by getting the underlying `TinkerGraph`.
  +
  +[source,groovy]
  +----
  +gremlin> sg.getBaseGraph()
  +==>tinkergraph[vertices:6 edges:6]
  +----
   
   IdStrategy
   ~~~~~~~~~~
  
positive.code: `ReadOnlyStrategy` was demonstrated at the start of the `GraphStrategy` section.  It simply prevents write operations that would otherwise mutate the `Graph`.
  
  [source,groovy]
  ----
  gremlin> conf = new BaseConfiguration()
  ==>org.apache.commons.configuration.BaseConfiguration@5b40ceb
  gremlin> conf.setProperty("gremlin.graph","com.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph")
  ==>null
  gremlin> g = GraphFactory.open(conf, new ReadOnlyStrategy())
  ==>readonlygraphstrategy[tinkergraph[vertices:0 edges:0]]
  gremlin> g.addVertex('name','stephen')
  Graph uses class com.tinkerpop.gremlin.structure.strategy.ReadOnlyStrategy and is therefore unmodifiable
  ----
  
  SequenceStrategy
  ~~~~~~~~~~~~~~~~
  
  `SequenceStrategy` provides a way to string together a set of `GraphStrategy` implementations, such that they are executed in order from first to last.  The `GraphFactory` provides a straightforward way to invisibly use `SequenceStrategy`:
  
  [source,groovy]
  gremlin> conf = new BaseConfiguration()
  ==>org.apache.commons.configuration.BaseConfiguration@6048e26a
  gremlin> conf.setProperty("gremlin.graph",TinkerGraph.class.getName())
  ==>null
  gremlin> g = GraphFactory.open(conf, new ReadOnlyStrategy(), new PartitionStrategy("partition","A"))
  ==>sequencegraphstrategy[tinkergraph[vertices:0 edges:0]]
  
  The above code demonstrates a `Graph` that uses a `SequenceStrategy` composed of `ReadOnlyStrategy` and `PartitionhStrategy`.  When the `SequenceStrategy` is invoked, it will first apply the `ReadOnlyStrategy` and then apply the `PartitionStrategy`.  It is important to consider the ordering of the `GraphStrategy` objects when choosing to use `SequenceStrategy` as it makes no attempts to determine if strategies will be in conflict with one another.  Be aware of the nature of the strategies and ensure that applying them in the order assigned will produce the desirable outcome.
  
  SubgraphStrategy
  ~~~~~~~~~~~~~~~~
  
negative.code: ==>null
  gremlin> "in B: " + sg.V().count().next() + ", " + sg.E().count().next()
  ==>in B: 1, 0
  
  Note that there are no edges in the set B, as the only edge added to partition B is incident on a vertex of A.
  
  