How to use

com.tinkerpop.gremlin.java.GremlinPipeline

constructor

/**
 * Start a gremlin pipeline
 * 
 * @param starts
 * @return Start a gremlin pipeline at an element
 */
public <E> GremlinPipeline<C, E> gremlin(Object starts) {
  return new GremlinPipeline<C, E>(starts);
}

/**
 * Start a gremlin pipeline
 * 
 * @param starts
 * @return Start a gremlin pipeline at an element
 */
public <E> GremlinPipeline<C, E> gremlin(Object starts) {
  return new GremlinPipeline<C, E>(starts);
}

/**
 * @return A gremlin pipeline at the context element
 */
public <E> GremlinPipeline<C, E> gremlin() {
  return new GremlinPipeline<C, E>(it());
}

  @Override
  protected Pipe getQueryPipe() {
    return new GremlinPipeline().has("__typeName", "Taxonomy");
  }
}

/**
 * @return A gremlin pipeline at the context element
 */
public <E> GremlinPipeline<C, E> gremlin() {
  return new GremlinPipeline<C, E>(it());
}

protected GremlinPipeline getRootVertexPipeline() {
  return new GremlinPipeline(unWrapVertices());
}

public double getNodeInDegree(Vertex vertex)
{
  GremlinPipeline<String, Vertex> pipe = new GremlinPipeline<String, Vertex>(vertex).in(SIMILAR);
  return (double) pipe.count();
}

@Override
public int getNodeCount()
{
  long nodeCount = new GremlinPipeline<Object, Object>(titanGraph).V().count();
  return (int) nodeCount;
}

public double getNodeOutDegree(Vertex vertex)
{
  GremlinPipeline<String, Vertex> pipe = new GremlinPipeline<String, Vertex>(vertex).out(SIMILAR);
  return (double) pipe.count();
}

@Override
public Set<Integer> getNeighborsIds(int nodeId)
{
  Set<Integer> neighbors = new HashSet<Integer>();
  Vertex vertex = titanGraph.getVertices(NODE_ID, nodeId).iterator().next();
  GremlinPipeline<String, Vertex> pipe = new GremlinPipeline<String, Vertex>(vertex).out(SIMILAR);
  Iterator<Vertex> iter = pipe.iterator();
  while (iter.hasNext())
  {
    Integer neighborId = iter.next().getProperty(NODE_ID);
    neighbors.add(neighborId);
  }
  return neighbors;
}

  @Override
  public Boolean compute(Object vertices) {
    GremlinPipeline p = new GremlinPipeline(Collections.singleton(vertices));
    p.add(excludePipeline);
    return p.gather().toList().isEmpty();
  }
}

  protected Pipe getQueryPipe() {
    return new GremlinPipeline().has(Constants.ENTITY_TEXT_PROPERTY_KEY).
        hasNot(Constants.ENTITY_TYPE_PROPERTY_KEY, "Taxonomy");
  }
}

@Override
public Set<Integer> getCommunitiesConnectedToNodeCommunities(int nodeCommunities)
{
  Set<Integer> communities = new HashSet<Integer>();
  Iterable<Vertex> vertices = titanGraph.getVertices(NODE_COMMUNITY, nodeCommunities);
  for (Vertex vertex : vertices)
  {
    GremlinPipeline<String, Vertex> pipe = new GremlinPipeline<String, Vertex>(vertex).out(SIMILAR);
    Iterator<Vertex> iter = pipe.iterator();
    while (iter.hasNext())
    {
      int community = iter.next().getProperty(COMMUNITY);
      communities.add(community);
    }
  }
  return communities;
}

  @Override
  public void run() {
    for (int t = 1; t <= trials; t++) {
      TitanTransaction tx = graph.newTransaction();
      TitanVertex v = tx.getVertex(vids[random.nextInt(numV)]);
      for (int r = 0; r < repetitions; r++) {
        assertEquals((int) Math.pow(numE, 2), Iterables.size(new GremlinPipeline<Vertex, Vertex>(v)
            .out(label).out(label)
        ));
      }
      tx.commit();
    }
  }
});

  @Override
  protected Pipe getQueryPipe() {
    GremlinPipeline p;
    if (termPath.getTaxonomyName().equals("*")) {
      p = new GremlinPipeline().has("Taxonomy.name").out();
    } else {
      p = new GremlinPipeline().has("Taxonomy.name", termPath.getTaxonomyName()).out().
          has(Constants.ENTITY_TYPE_PROPERTY_KEY, Text.PREFIX, termPath.getFullyQualifiedName());
    }
    return p;
  }
}

@Override
public void shortestPath(final Vertex fromNode, Integer node)
{
  final Vertex v2 = titanGraph.getVertices(NODE_ID, node).iterator().next();
  @SuppressWarnings("rawtypes")
  final GremlinPipeline<String, List> pathPipe = new GremlinPipeline<String, List>(fromNode).as(SIMILAR)
    .out(SIMILAR).loop(SIMILAR, new PipeFunction<LoopBundle<Vertex>, Boolean>() {
      // @Override
      public Boolean compute(LoopBundle<Vertex> bundle)
      {
        return bundle.getLoops() < 5 && !bundle.getObject().equals(v2);
      }
    }).path();
}

public boolean isMavenConfiguration(XmlFileModel resource)
{
  return (new GremlinPipeline<Vertex, Vertex>(resource.asVertex())).in("xmlFacet").as("facet")
        .has(WindupVertexFrame.TYPE_PROP, this.getTypeValueForSearch()).back("facet")
        .iterator().hasNext();
}

public MavenProjectModel getMavenConfigurationFromResource(XmlFileModel resource)
{
  @SuppressWarnings("unchecked")
  Iterator<Vertex> v = (Iterator<Vertex>) (new GremlinPipeline<Vertex, Vertex>(resource.asVertex()))
        .in("xmlFacet").as("facet")
        .has(WindupVertexFrame.TYPE_PROP, this.getTypeValueForSearch()).back("facet")
        .iterator();
  if (v.hasNext())
  {
    return getGraphContext().getFramed().frame(v.next(), this.getType());
  }
  return null;
}

  @Override
  public void query(GraphRewrite event, GremlinPipeline<Vertex, Vertex> pipeline)
  {
    pipeline.has(DoctypeMetaModel.PROPERTY_PUBLIC_ID, Text.REGEX, hibernateRegex);
    FramedGraphQuery systemIDQuery = event.getGraphContext().getQuery().type(DoctypeMetaModel.class)
          .has(DoctypeMetaModel.PROPERTY_SYSTEM_ID, Text.REGEX, hibernateRegex);
    GremlinPipeline<Vertex, Vertex> systemIdPipeline = new GremlinPipeline<>(systemIDQuery.vertices());
    pipeline.add(systemIdPipeline);
    pipeline.dedup();
  }
};

  @Override
  public void query(GraphRewrite event, GremlinPipeline<Vertex, Vertex> pipeline)
  {
    pipeline.has(DoctypeMetaModel.PROPERTY_PUBLIC_ID, Text.REGEX, hibernateRegex);
    FramedGraphQuery systemIDQuery = event.getGraphContext().getQuery().type(DoctypeMetaModel.class)
          .has(DoctypeMetaModel.PROPERTY_SYSTEM_ID, Text.REGEX, hibernateRegex);
    GremlinPipeline<Vertex, Vertex> systemIdPipeline = new GremlinPipeline<>(systemIDQuery.vertices());
    pipeline.add(systemIdPipeline);
    pipeline.dedup();
  }
};