public TridentTopology() { this(new DefaultDirectedGraph<Node, IndexedEdge>(new ErrorEdgeFactory()), new LinkedHashMap<String, List<Node>>(), new UniqueIdGen()); }
DirectedGraph<PlanFragmentId, DefaultEdge> graph = new DefaultDirectedGraph<>(DefaultEdge.class); fragments.forEach(fragment -> graph.addVertex(fragment.getId())); DirectedGraph<Set<PlanFragmentId>, DefaultEdge> componentGraph = new DefaultDirectedGraph<>(DefaultEdge.class); components.forEach(componentGraph::addVertex); for (DefaultEdge edge : graph.edgeSet()) {
DirectedGraph graph = new DefaultDirectedGraph<BaseFlowStep, FlowGraphEdge>( new EdgeFactory<BaseFlowStep, FlowGraphEdge>() { @Override
declarer.withModelProperty(getXmlExtensionModelProperty(moduleModel, xmlDslModel)); DirectedGraph<String, DefaultEdge> directedGraph = new DefaultDirectedGraph<>(DefaultEdge.class);
public CycleDetectorAggregationState(CycleDetectorAggregationStateFactory factory) { this.factory = factory; graph = new DefaultDirectedGraph<>(EventBean.class); }
@VisibleForTesting ClassFileIndex(JavaClassBuilder classBuilder) { builder = classBuilder; graph = new DefaultDirectedGraph<JavaClass, DefaultEdge>(DefaultEdge.class); }
/** * <p>Constructor for EvoSuiteGraph.</p> * * @param edgeClass a {@link java.lang.Class} object. * @param <V> a V object. * @param <E> a E object. */ protected EvoSuiteGraph(Class<E> edgeClass) { graph = new DefaultDirectedGraph<V, E>(edgeClass); this.edgeClass = edgeClass; setId(); }
private void createGraph() { EdgeFactory<ExecutableMethod, DirectedEdge<ExecutableMethod>> edgeFactory = new DirectedEdgeFactory<ExecutableMethod>(DirectedEdge.class); graph = new DefaultDirectedGraph<ExecutableMethod, DirectedEdge<ExecutableMethod>>(edgeFactory); }
private BaseRunRequirements(AddOn addOn) { this.addOn = addOn; dependencyTree = new DefaultDirectedGraph<>(DefaultEdge.class); dependencyTree.addVertex(addOn); runnable = true; issueDetails = Collections.emptyList(); }
public ModelInfoGraphBuilder(JsonixContext context, MModelInfo<T, C> modelInfo) { Validate.notNull(modelInfo); this.logger = Validate.notNull(context).getLoggerFactory() .getLogger(ModelInfoGraphAnalyzer.class.getName()); this.modelInfo = modelInfo; this.graph = new DefaultDirectedGraph<InfoVertex<T, C>, DependencyEdge>( this.edgeFactory); }
private void processMenu(Menu menu) { graph = new DefaultDirectedGraph<String, DefaultEdge>(DefaultEdge.class); graph.addVertex(rootNode); logger.trace("Added Root: "+rootNode); for(MenuItem mi : menu.getMenuItem()) { processMenuItem(rootNode,mi); } }
static public <V> DiGraphImpl<V> copyOf(DiGraph<V> source) { final DiGraphImpl<V> g = new DiGraphImpl<V>( new DefaultDirectedGraph<V, Edge<V>>(new GraphUtils.SimpleEdgeFactory<V>())); GraphUtils.copyToBetter(source, g); return g; }
protected void initialize() { equivalents = CollectionUtils.makeIdentityMap(); graph = new DefaultDirectedGraph<ATermAppl, DefaultEdge>( DefaultEdge.class ); graph.addVertex( TOP ); for( ATermAppl c : kb.getClasses() ) { graph.addVertex( c ); } }
protected void initialize() { equivalents = CollectionUtils.makeIdentityMap(); graph = new DefaultDirectedGraph<ATermAppl, DefaultEdge>( DefaultEdge.class ); graph.addVertex( TOP ); for( ATermAppl c : kb.getClasses() ) { graph.addVertex( c ); } }
static public <V> DefaultDirectedGraph<V, Edge<V>> getDiGraph(IMatrixBinary<V, V> source) { final SimpleEdgeFactory<V> factory = new SimpleEdgeFactory<V>(); final DefaultDirectedGraph<V, Edge<V>> g = new DefaultDirectedGraph<V, Edge<V>>(factory); for (V v1 : source.getRows()) { for (V v2 : source.getColumns()) { if (source.getBooleanValue(v1, v2)) { g.addEdge(v1, v2); } } } return g; }
static public class SimpleEdgeFactory<V> implements EdgeFactory<V, Edge<V>> { @Override public Edge<V> createEdge(V sourceVertex, V targetVertex) { checkNotNull(sourceVertex); checkNotNull(targetVertex); return new Edge<V>(sourceVertex, targetVertex); } }
static public <V> DefaultDirectedGraph<V, Edge<V>> getDefaultDiGraph(BinaryRelation<V, V> source) { final SimpleEdgeFactory<V> factory = new SimpleEdgeFactory<V>(); final DefaultDirectedGraph<V, Edge<V>> g = new DefaultDirectedGraph<V, Edge<V>>(factory); final Set<Pair<V, V>> pairs = source.asPairs(); for (Pair<V, V> pair : pairs) { g.addVertex(pair.getElt1()); g.addVertex(pair.getElt2()); g.addEdge(pair.getElt1(), pair.getElt2()); } return g; }
public static DirectedGraph<Node, LabeledEdge> asJGraphT(Query query) { QueryUtils utils = new QueryUtils(); Set<Triple> tps = utils.extractTriplePattern(query); DirectedGraph<Node, LabeledEdge> g = new DefaultDirectedGraph<>(LabeledEdge.class); tps.forEach(tp -> { g.addVertex(tp.getSubject()); g.addVertex(tp.getObject()); g.addEdge(tp.getSubject(), tp.getObject(), new LabeledEdge(tp.getSubject(), tp.getObject(), tp.getPredicate())); }); return g; }
public ReleaseGraphManager(final List<UpgradeInfo> upgradeInfos) { _directedGraph = new DefaultDirectedGraph<>( new UpgradeProcessEdgeFactory(upgradeInfos)); for (UpgradeInfo upgradeInfo : upgradeInfos) { _directedGraph.addVertex(upgradeInfo.getFromSchemaVersionString()); _directedGraph.addVertex(upgradeInfo.getToSchemaVersionString()); _directedGraph.addEdge( upgradeInfo.getFromSchemaVersionString(), upgradeInfo.getToSchemaVersionString(), new UpgradeProcessEdge(upgradeInfo)); } }
@Test public void expectExceptionIfNonComparableElementsAreProvidedForSorting() { SortableDependency sp1 = newVertex("sp1"); DirectedGraph<SortableDependency, DefaultEdge> graph = new DefaultDirectedGraph<SortableDependency, DefaultEdge>(DefaultEdge.class); for (SortableDependency vertex : shuffledList(sp1)) { graph.addVertex(vertex); } thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Unsortable graph elements"); sorter.sortChanges(graph); }