import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
public static List<Long> get_all_reaches_edges_with_member_access(Joern_db joern_db)
   {
   List<Long> edges = Pipeline.Vs().outE("REACHES").filter(
new PipeFunction<Neo4j2Edge,Boolean>()
 {
  public Boolean compute(Neo4j2Edge it)
   {
    String var = (String)(it.getProperty("var"));
    return var.indexOf('.') != -1;
   }
 }
).id().toList();
    return edges;

//   List<Long> ids = new ArrayList<Long>();
//    for(Neo4j2Edge e : edges)
//     {
//Long it = e.getId();
//      ids.add(it);
//     }
//    return ids;

//    edges = joern_db.runGremlinQuery("g.V.outE(DATA_FLOW_EDGE).has('var').filter{it.var.contains('.')}.id")
//    return edges
   }
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
public Pipeline functionToStatements()
{
 return (Pipeline)(this.transform(
          new PipeFunction<Neo4j2Vertex,List<Neo4j2Vertex>>()
           {
            public List<Neo4j2Vertex> compute(Neo4j2Vertex it)
             {
             List<Node> tmp = Joern_db.queryNodeIndex("isCFGNode:True AND functionId:" + it.getId().toString());
             List<Neo4j2Vertex> ret = new ArrayList<>();
               for(Node n : tmp)
                {
                 ret.add(new Neo4j2Vertex(n, Joern_db.g) );
                }
              return ret;
             }
           }
        ).scatter());
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
@Override
protected Pipe getQueryPipe() {
    GremlinPipeline p;
    if (guid.equals("*")) {
        p = new GremlinPipeline().has(Constants.ENTITY_TEXT_PROPERTY_KEY).
                hasNot(Constants.ENTITY_TYPE_PROPERTY_KEY, "Taxonomy").outE();
    } else {
        p = new GremlinPipeline().has(Constants.GUID_PROPERTY_KEY, guid).outE();
    }
    //todo: this is basically the same pipeline used in TagRelation.asPipe()
    p.add(new FilterFunctionPipe<>(new PipeFunction<Edge, Boolean>() {
        @Override
        public Boolean compute(Edge edge) {
            String type = edge.getVertex(Direction.OUT).getProperty(Constants.ENTITY_TYPE_PROPERTY_KEY);
            VertexWrapper v = new TermVertexWrapper(edge.getVertex(Direction.IN));
            return edge.getLabel().startsWith(type) && v.getPropertyKeys().contains("available_as_tag");
        }
    }));

    return p.inV();
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
private RelationProjection getTagProjection() {
    Relation traitRelation = new TagRelation();
    RelationProjection tagProjection = new RelationProjection("tags", Collections.singleton("name"),
            traitRelation, Projection.Cardinality.MULTIPLE);
    tagProjection.addPipe(new TransformFunctionPipe<>(
            new PipeFunction<Collection<ProjectionResult>, Collection<ProjectionResult>>() {
                @Override
                public Collection<ProjectionResult> compute(Collection<ProjectionResult> results) {
                    for (ProjectionResult result : results) {
                        for (Map<String, Object> properties : result.getPropertyMaps()) {
                            properties.put("href", String.format("v1/entities/%s/tags/%s",
                                    result.getStartingVertex().getProperty("id"), properties.get("name")));
                        }
                    }
                    return results;
                }
            }));
    return tagProjection;
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
private RelationProjection getDefaultRelationProjection() {
    Relation genericRelation = new GenericRelation(this);
    RelationProjection relationProjection = new RelationProjection(
            "relations",
            Arrays.asList("type", "id", "name"),
            genericRelation, Projection.Cardinality.MULTIPLE);

    relationProjection.addPipe(new TransformFunctionPipe<>(
            new PipeFunction<Collection<ProjectionResult>, Collection<ProjectionResult>>() {
                @Override
                public Collection<ProjectionResult> compute(Collection<ProjectionResult> results) {
                    for (ProjectionResult result : results) {
                        for (Map<String, Object> properties : result.getPropertyMaps()) {
                            properties.put("href", String.format("v1/entities/%s", properties.get("id")));
                        }
                    }
                    return results;
                }
            }));
    return relationProjection;
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
private Projection getHierarchyProjection() {
    final String projectionName = "hierarchy";
    return new Projection(projectionName, Projection.Cardinality.SINGLE,
            new TransformFunctionPipe<>(new PipeFunction<VertexWrapper, Collection<ProjectionResult>>() {
                @Override
                public Collection<ProjectionResult> compute(VertexWrapper start) {
                    Map<String, Object> map = new TreeMap<>(new ResourceComparator());

                    TermPath termPath = new TermPath(start.getVertex().<String>getProperty(
                            Constants.ENTITY_TYPE_PROPERTY_KEY));

                    map.put("path", termPath.getPath());
                    map.put("short_name", termPath.getShortName());
                    map.put("taxonomy", termPath.getTaxonomyName());

                    return Collections.singleton(new ProjectionResult(projectionName, start,
                            Collections.singleton(map)));
                }
            }));

}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
@Test
public void testBulkLoading() throws Exception {
    bulkLoadGraphOfTheGods(f1);
    clopen();
    assertEquals(12, new GremlinPipeline(g).V().count());
    assertEquals(17, new GremlinPipeline(g).E().count());
    new GremlinPipeline(g).V().sideEffect(new PipeFunction<Vertex, Vertex>() {
        @Override
        public Vertex compute(Vertex vertex) {
            assertEquals(2, vertex.getPropertyKeys().size());
            assertNotNull(vertex.getProperty("name"));
            return vertex;
        }
    }).iterate();
    assertEquals("saturn", new GremlinPipeline(g).V("name", "hercules").out("father").out("father").property("name").next());
    List names = new GremlinPipeline(g).V("name", "hercules").outE("battled").sideEffect(new PipeFunction<Edge, Edge>() {
        @Override
        public Edge compute(Edge edge) {
            assertNotNull(edge.getProperty("time"));
            return edge;
        }
    }).inV().property("name").toList();
    assertTrue(names.contains("nemean"));
    assertTrue(names.contains("hydra"));
    assertTrue(names.contains("cerberus"));
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
@Test
public void testBulkVertexPropertyDeletions() throws Exception {
    bulkLoadGraphOfTheGods(f1);
    new HadoopPipeline(f2).V().sideEffect("{it.removeProperty('name')}").submit();
    clopen();
    assertEquals(12, new GremlinPipeline(g).V().count());
    assertEquals(17, new GremlinPipeline(g).E().count());

    for (Vertex v : g.getVertices()) {
        assertNull(v.getProperty("name"));
        assertEquals(1, v.getPropertyKeys().size());
    }
    new GremlinPipeline(g).V("name", "hercules").outE("battled").sideEffect(new PipeFunction<Edge, Edge>() {
        @Override
        public Edge compute(Edge edge) {
            assertNotNull(edge.getProperty("time"));
            return edge;
        }
    }).iterate();
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
/**
 * Add sideEffect step to the traversal engine
 *
 * @param sideEffectFunction
 *            the function of the pipe
 * @return the extended Stream
 */
public CachedTraversalEngine sideEffect(final PipeFunction sideEffectFunction) {
	if (isPathEnabled) {
		List intermediate = (List) stream.map(e -> {
			sideEffectFunction.compute(e);
			return e;
		}).collect(Collectors.toList());
		if (isParallel) {
			stream = intermediate.parallelStream();
		} else {
			stream = intermediate.stream();
		}
	} else {
		stream = stream.map(e -> {
			sideEffectFunction.compute(e);
			return e;
		});
	}
	// Step Update
	final Class[] args = new Class[1];
	args[0] = PipeFunction.class;
	final Step step = new Step(this.getClass().getName(), "sideEffect", args, sideEffectFunction);
	stepList.add(step);
	return this;
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
public SelectPipe(final Collection<String> stepNames, final List<AsPipe> allPreviousAsPipes, final PipeFunction... stepFunctions) {
    this.stepFunctions = stepFunctions;
    this.stepNames = stepNames;

    if (this.doFunctions = this.stepFunctions.length > 0)
        currentFunction = 0;

    final List<String> tempNames = new ArrayList<String>();
    for (final AsPipe asPipe : allPreviousAsPipes) {
        final String columnName = asPipe.getName();
        if (null == this.stepNames || this.stepNames.contains(columnName)) {
            tempNames.add(columnName);
            this.asPipes.add(asPipe);
        }
    }

    if (tempNames.size() > 0)
        this.columnNames = tempNames;
    else
        this.columnNames = null;

}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
public TablePipe(final Table table, final Collection<String> stepNames, final List<AsPipe> allPreviousAsPipes, final PipeFunction... columnFunctions) {
    this.table = table;
    this.columnFunctions = columnFunctions;
    this.stepNames = stepNames;

    if (this.doFunctions = this.columnFunctions.length > 0)
        currentFunction = 0;

    final List<String> tempNames = new ArrayList<String>();
    for (final AsPipe asPipe : allPreviousAsPipes) {
        final String columnName = asPipe.getName();
        if (null == this.stepNames || this.stepNames.contains(columnName)) {
            tempNames.add(columnName);
            this.asPipes.add(asPipe);
        }
    }

    if (tempNames.size() > 0)
        table.setColumnNames(tempNames.toArray(new String[tempNames.size()]));

}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
@Override
public Pipe asPipe() {
    return new FilterFunctionPipe<>(new PipeFunction<Edge, Boolean>() {
        @Override
        public Boolean compute(Edge edge) {
            String name = edge.getVertex(Direction.OUT).getProperty(Constants.ENTITY_TYPE_PROPERTY_KEY);
            if (edge.getLabel().startsWith(name)) {
                VertexWrapper v = new TermVertexWrapper(edge.getVertex(Direction.IN));
                return ! v.getPropertyKeys().contains("available_as_tag") && ! isDeleted(v.getVertex());
            } else {
                return false;
            }
        }
    });
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
@Override
public Pipe asPipe() {
    return new FilterFunctionPipe<>(new PipeFunction<Edge, Boolean>() {
        @Override
        public Boolean compute(Edge edge) {
            String name = edge.getVertex(Direction.OUT).getProperty(Constants.ENTITY_TYPE_PROPERTY_KEY);
            if (edge.getLabel().startsWith(name)) {
                VertexWrapper v = new TermVertexWrapper(edge.getVertex(Direction.IN));
                return v.getPropertyKeys().contains("available_as_tag") && ! isDeleted(v.getVertex());
            } else {
                return false;
            }
        }
    });
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
public Pipe asPipe() {
    return new FilterFunctionPipe(new PipeFunction<Vertex, Boolean>() {
        @Override
        public Boolean compute(Vertex vertex) {
            return evaluate(new VertexWrapper(vertex, resourceDefinition));
        }
    });
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
private Projection getTermProjection() {
    return new Projection("term", Projection.Cardinality.SINGLE,
            new TransformFunctionPipe<>(new PipeFunction<VertexWrapper, Collection<ProjectionResult>>() {
                @Override
                public Collection<ProjectionResult> compute(VertexWrapper start) {
                    Map<String, Object> map = new TreeMap<>(new ResourceComparator());

                    StringBuilder sb = new StringBuilder();
                    sb.append("v1/taxonomies/");

                    String fullyQualifiedName = start.getVertex().getProperty(Constants.ENTITY_TYPE_PROPERTY_KEY);
                    String[] paths = fullyQualifiedName.split("\\.");
                    // first path segment is the taxonomy
                    sb.append(paths[0]);

                    for (int i = 1; i < paths.length; ++i) {
                        String path = paths[i];
                        if (path != null && !path.isEmpty()) {
                            sb.append("/terms/");
                            sb.append(path);
                        }
                    }

                    map.put("href", sb.toString());
                    return Collections.singleton(new ProjectionResult("term", start,
                            Collections.singleton(map)));
                }
            }));
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
private Projection getSubTermProjection() {
    //todo: combine with other term projections
    final String termsProjectionName = "terms";
    return new Projection(termsProjectionName, Projection.Cardinality.SINGLE,
            new TransformFunctionPipe<>(new PipeFunction<VertexWrapper, Collection<ProjectionResult>>() {
                @Override
                public Collection<ProjectionResult> compute(VertexWrapper start) {
                    Map<String, Object> map = new TreeMap<>(new ResourceComparator());

                    StringBuilder sb = new StringBuilder();
                    sb.append("v1/taxonomies/");

                    TermPath termPath = new TermPath(start.getVertex().<String>getProperty(Constants.ENTITY_TYPE_PROPERTY_KEY));
                    String[] paths = termPath.getPathSegments();
                    sb.append(termPath.getTaxonomyName());

                    for (String path : paths) {
                        //todo: shouldn't need to check for null or empty after TermPath addition
                        if (path != null && !path.isEmpty()) {
                            sb.append("/terms/");
                            sb.append(path);
                        }
                    }
                    sb.append("/terms");

                    map.put("href", sb.toString());
                    return Collections.singleton(new ProjectionResult(termsProjectionName, start,
                            Collections.singleton(map)));
                }
            }));
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
private Projection getTermsProjection() {
    final String termsProjectionName = "terms";
    return new Projection(termsProjectionName, Projection.Cardinality.SINGLE,
            new TransformFunctionPipe<>(new PipeFunction<VertexWrapper, Collection<ProjectionResult>>() {
                private String baseHref = "v1/taxonomies/";
                @Override
                public Collection<ProjectionResult> compute(VertexWrapper v) {
                    Map<String, Object> map = new HashMap<>();
                    map.put("href", baseHref + v.getProperty("name") + "/terms");
                    return Collections.singleton(new ProjectionResult(termsProjectionName, v,
                            Collections.singleton(map)));
                }
            }));
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
public static List<Vertex> getInputSteps( Graph g ) {
  GremlinPipeline<Vertex, Vertex> pipe = new GremlinPipeline<>( g );
  return pipe.V().filter( new PipeFunction<Vertex, Boolean>() {
    @Override
    public Boolean compute( Vertex vertex ) {
      return Iterables.isEmpty( vertex.getEdges( Direction.IN ) );
    }
  } ).toList();
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
private PipeFunction<Pair<Vertex, Vertex>, Integer> compareProperty( final String key ) {
  return new PipeFunction<Pair<Vertex, Vertex>, Integer>() {
    @Override public Integer compute( Pair<Vertex, Vertex> argument ) {
      return Integer.compare(
        argument.getA().<Integer>getProperty( key ),
        argument.getB().<Integer>getProperty( key )
      );
    }
  };
}
 

import com.tinkerpop.pipes.PipeFunction; //导入依赖的package包/类
public static List<Vertex> getVertexesForSubject(
		NerdleFact questionExtraction, TinkerGraph graph) {
	final List<NerdleArg> questionsArguments = questionExtraction
			.getArguments();
	final NerdlePredicate questionPredicate = questionExtraction
			.getPredicate();

	GremlinPipeline<Iterable<Vertex>, Vertex> pipeline = new GremlinPipeline<Iterable<Vertex>, Vertex>();
	pipeline.filter(new PipeFunction<Vertex, Boolean>() {

		@Override
		public Boolean compute(Vertex vertex) {

			NerdleFact transform = NerdleGraphTransformer.transform(vertex);

			for (NerdleArg arg : transform.getArguments()) {

				boolean match = FuzzyStringMatcher.fuzzyArgumentMatcher(
						questionsArguments, arg.getText());

				if (match)
					return true;

			}

			return false;

		}

	});

	pipeline.start(graph.getVertices(NerdleGraphTransformer.PROPERTY_LEMMA,
			questionPredicate.getLemma()));
	List<Vertex> list = pipeline.toList();
	return list;
}