Fragment (Grakn 0.16.0 API)

```
public interface Fragment
```
represents a graph traversal, with one start point and optionally an end point
A fragment is composed of four things:
- A gremlin traversal function, that takes a gremlin traversal and appends some new gremlin steps
- A starting variable name, where the gremlin traversal must start from
- An optional ending variable name, if the gremlin traversal navigates to a new Graql variable
- A priority, that describes how efficient this traversal is to help with ordering the traversals
Variable names refer to Graql variables. Some of these variable names may be randomly-generated UUIDs, such as for castings.
A Fragment is usually contained in a EquivalentFragmentSet, which contains multiple fragments describing the different directions the traversal can be followed in, with different starts and ends.
A gremlin traversal is created from a Query by appending together fragments in order of priority, one from each EquivalentFragmentSet describing the Query.
Author:

Felix Chapman

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<org.apache.tinkerpop.gremlin.structure.Element,? extends org.apache.tinkerpop.gremlin.structure.Element>`	`applyTraversal(org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<org.apache.tinkerpop.gremlin.structure.Element,? extends org.apache.tinkerpop.gremlin.structure.Element> traversal, GraknGraph graph)`
`default boolean`	`canOperateOnEdges()` Indicates whether the fragment can be used on an `Edge` as well as a `Vertex`.
`double`	`fragmentCost()` Get the cost for executing the fragment.
`Set<Var>`	`getDependencies()`
`Set<Weighted<DirectedEdge<Node>>>`	`getDirectedEdges(Map<NodeId,Node> nodes, Map<Node,Map<Node,Fragment>> edgeToFragment)` Convert the fragment to a set of weighted edges for query planning
`Optional<Var>`	`getEnd()`
`EquivalentFragmentSet`	`getEquivalentFragmentSet()`
`String`	`getName()` The name of the fragment
`Var`	`getStart()`
`Set<Var>`	`getVariableNames()` Get all variable names in the fragment - the start and end (if present)
`VarProperty`	`getVarProperty()` Get the corresponding property
`default boolean`	`hasFixedFragmentCost()` If a fragment has fixed cost, the traversal is done using index.
`default boolean`	`isStartingFragment()` A starting fragment is a fragment that can start a traversal.
`void`	`setEquivalentFragmentSet(EquivalentFragmentSet equivalentFragmentSet)`

- Method Detail
  - getEquivalentFragmentSet
```
EquivalentFragmentSet getEquivalentFragmentSet()
```
    Returns:
    
    the EquivalentFragmentSet that contains this Fragment
  - setEquivalentFragmentSet
```
void setEquivalentFragmentSet(EquivalentFragmentSet equivalentFragmentSet)
```
    Parameters:
    
    equivalentFragmentSet - the EquivalentFragmentSet that contains this Fragment
  - applyTraversal
```
org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<org.apache.tinkerpop.gremlin.structure.Element,? extends org.apache.tinkerpop.gremlin.structure.Element> applyTraversal(org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<org.apache.tinkerpop.gremlin.structure.Element,? extends org.apache.tinkerpop.gremlin.structure.Element> traversal,
                                                                                                                                                                                                GraknGraph graph)
```
    Parameters:
    
    traversal - the traversal to extend with this Fragment
    
    graph - the graph to execute the traversal on
  - getName
```
String getName()
```
    The name of the fragment
  - getStart
```
Var getStart()
```
    Returns:
    
    the variable name that this fragment starts from in the query
  - getEnd
```
Optional<Var> getEnd()
```
    Returns:
    
    the variable name that this fragment ends at in the query, if this query has an end variable
  - getDependencies
```
Set<Var> getDependencies()
```
    Returns:
    
    the variable names that this fragment requires to have already been visited
  - getVariableNames
```
Set<Var> getVariableNames()
```
    Get all variable names in the fragment - the start and end (if present)
  - getVarProperty
```
VarProperty getVarProperty()
```
    Get the corresponding property
  - isStartingFragment
```
default boolean isStartingFragment()
```
    A starting fragment is a fragment that can start a traversal. If any other fragment is present that refers to the same variable, the starting fragment can be omitted.
  - fragmentCost
```
double fragmentCost()
```
    Get the cost for executing the fragment.
  - hasFixedFragmentCost
```
default boolean hasFixedFragmentCost()
```
    If a fragment has fixed cost, the traversal is done using index. This makes the fragment a good starting point. A plan should always start with these fragments when possible.
  - getDirectedEdges
```
Set<Weighted<DirectedEdge<Node>>> getDirectedEdges(Map<NodeId,Node> nodes,
                                                   Map<Node,Map<Node,Fragment>> edgeToFragment)
```
    Convert the fragment to a set of weighted edges for query planning
    
    Parameters:
    
    nodes - all nodes in the query
    
    edgeToFragment - a mapping from edge(child, parent) to its corresponding fragment
    
    Returns:
    
    a set of edges
  - canOperateOnEdges
```
default boolean canOperateOnEdges()
```
    Indicates whether the fragment can be used on an Edge as well as a Vertex.

Interface Fragment

Method Summary

Method Detail

getEquivalentFragmentSet

setEquivalentFragmentSet

applyTraversal

getName

getStart

getEnd

getDependencies

getVariableNames

getVarProperty

isStartingFragment

fragmentCost

hasFixedFragmentCost

getDirectedEdges

canOperateOnEdges