mirror of https://github.com/apache/openjpa.git
OPENJPA-235
git-svn-id: https://svn.apache.org/repos/asf/openjpa/trunk@544918 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Patrick Linskey
parent
4d23f445c6
commit
5463700d6c
|
|
@ -214,9 +214,11 @@ public class JDBCConfigurationImpl
|
||||||
updateManagerPlugin = addPlugin("jdbc.UpdateManager", true);
|
updateManagerPlugin = addPlugin("jdbc.UpdateManager", true);
|
||||||
aliases = new String[]{
|
aliases = new String[]{
|
||||||
"default",
|
"default",
|
||||||
"org.apache.openjpa.jdbc.kernel.OperationOrderUpdateManager",
|
"org.apache.openjpa.jdbc.kernel.ConstraintUpdateManager",
|
||||||
"operation-order",
|
"operation-order",
|
||||||
"org.apache.openjpa.jdbc.kernel.OperationOrderUpdateManager",
|
"org.apache.openjpa.jdbc.kernel.OperationOrderUpdateManager",
|
||||||
|
"constraint",
|
||||||
|
"org.apache.openjpa.jdbc.kernel.ConstraintUpdateManager",
|
||||||
};
|
};
|
||||||
updateManagerPlugin.setAliases(aliases);
|
updateManagerPlugin.setAliases(aliases);
|
||||||
updateManagerPlugin.setDefault(aliases[0]);
|
updateManagerPlugin.setDefault(aliases[0]);
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,419 @@
|
||||||
|
/*
|
||||||
|
* Licensed to the Apache Software Foundation (ASF) under one
|
||||||
|
* or more contributor license agreements. See the NOTICE file
|
||||||
|
* distributed with this work for additional information
|
||||||
|
* regarding copyright ownership. The ASF licenses this file
|
||||||
|
* to you under the Apache License, Version 2.0 (the
|
||||||
|
* "License"); you may not use this file except in compliance
|
||||||
|
* with the License. You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing,
|
||||||
|
* software distributed under the License is distributed on an
|
||||||
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||||
|
* KIND, either express or implied. See the License for the
|
||||||
|
* specific language governing permissions and limitations
|
||||||
|
* under the License.
|
||||||
|
*/
|
||||||
|
package org.apache.openjpa.jdbc.kernel;
|
||||||
|
|
||||||
|
import java.sql.Connection;
|
||||||
|
import java.sql.SQLException;
|
||||||
|
import java.util.Collection;
|
||||||
|
import java.util.HashMap;
|
||||||
|
import java.util.Iterator;
|
||||||
|
import java.util.LinkedList;
|
||||||
|
import java.util.Map;
|
||||||
|
|
||||||
|
import org.apache.openjpa.jdbc.meta.ClassMapping;
|
||||||
|
import org.apache.openjpa.jdbc.schema.Column;
|
||||||
|
import org.apache.openjpa.jdbc.schema.ForeignKey;
|
||||||
|
import org.apache.openjpa.jdbc.schema.Table;
|
||||||
|
import org.apache.openjpa.jdbc.sql.PrimaryRow;
|
||||||
|
import org.apache.openjpa.jdbc.sql.Row;
|
||||||
|
import org.apache.openjpa.jdbc.sql.RowImpl;
|
||||||
|
import org.apache.openjpa.jdbc.sql.RowManager;
|
||||||
|
import org.apache.openjpa.jdbc.sql.RowManagerImpl;
|
||||||
|
import org.apache.openjpa.jdbc.sql.SQLExceptions;
|
||||||
|
import org.apache.openjpa.kernel.OpenJPAStateManager;
|
||||||
|
import org.apache.openjpa.lib.graph.DepthFirstAnalysis;
|
||||||
|
import org.apache.openjpa.lib.graph.Edge;
|
||||||
|
import org.apache.openjpa.lib.graph.Graph;
|
||||||
|
import org.apache.openjpa.lib.util.Localizer;
|
||||||
|
import org.apache.openjpa.util.InternalException;
|
||||||
|
import org.apache.openjpa.util.OpenJPAException;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* <p>Standard update manager, capable of foreign key constraint evaluation.</p>
|
||||||
|
*
|
||||||
|
* @since 1.0.0
|
||||||
|
*/
|
||||||
|
public class ConstraintUpdateManager
|
||||||
|
extends AbstractUpdateManager {
|
||||||
|
|
||||||
|
private static final Localizer _loc = Localizer.forPackage
|
||||||
|
(ConstraintUpdateManager.class);
|
||||||
|
|
||||||
|
public boolean orderDirty() {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
protected PreparedStatementManager newPreparedStatementManager
|
||||||
|
(JDBCStore store, Connection conn) {
|
||||||
|
return new PreparedStatementManagerImpl(store, conn);
|
||||||
|
}
|
||||||
|
|
||||||
|
protected RowManager newRowManager() {
|
||||||
|
return new RowManagerImpl(false);
|
||||||
|
}
|
||||||
|
|
||||||
|
protected Collection flush(RowManager rowMgr,
|
||||||
|
PreparedStatementManager psMgr, Collection exceps) {
|
||||||
|
RowManagerImpl rmimpl = (RowManagerImpl) rowMgr;
|
||||||
|
|
||||||
|
// first take care of all secondary table deletes and 'all row' deletes
|
||||||
|
// (which are probably secondary table deletes), since no foreign
|
||||||
|
// keys ever rely on secondary table pks
|
||||||
|
flush(rmimpl.getAllRowDeletes(), psMgr);
|
||||||
|
flush(rmimpl.getSecondaryDeletes(), psMgr);
|
||||||
|
|
||||||
|
// now do any 'all row' updates
|
||||||
|
flush(rmimpl.getAllRowUpdates(), psMgr);
|
||||||
|
|
||||||
|
// analyze foreign keys
|
||||||
|
Collection inserts = rmimpl.getInserts();
|
||||||
|
Collection updates = rmimpl.getUpdates();
|
||||||
|
Collection deletes = rmimpl.getDeletes();
|
||||||
|
Graph[] graphs = new Graph[2]; // insert graph, delete graph
|
||||||
|
analyzeForeignKeys(inserts, updates, deletes, rmimpl, graphs);
|
||||||
|
|
||||||
|
// flush insert graph, if any
|
||||||
|
boolean autoAssign = rmimpl.hasAutoAssignConstraints();
|
||||||
|
try {
|
||||||
|
flushGraph(graphs[0], psMgr, autoAssign);
|
||||||
|
} catch (SQLException se) {
|
||||||
|
exceps = addException(exceps, SQLExceptions.getStore(se, dict));
|
||||||
|
} catch (OpenJPAException ke) {
|
||||||
|
exceps = addException(exceps, ke);
|
||||||
|
}
|
||||||
|
|
||||||
|
// flush the rest of the inserts and updates; inserts before updates
|
||||||
|
// because some update fks might reference pks that have to be inserted
|
||||||
|
flush(inserts, psMgr);
|
||||||
|
flush(updates, psMgr);
|
||||||
|
|
||||||
|
// flush the delete graph, if any
|
||||||
|
try {
|
||||||
|
flushGraph(graphs[1], psMgr, autoAssign);
|
||||||
|
} catch (SQLException se) {
|
||||||
|
exceps = addException(exceps, SQLExceptions.getStore(se, dict));
|
||||||
|
} catch (OpenJPAException ke) {
|
||||||
|
exceps = addException(exceps, ke);
|
||||||
|
}
|
||||||
|
|
||||||
|
// put the remainder of the deletes after updates because some updates
|
||||||
|
// may be nulling fks to rows that are going to be deleted
|
||||||
|
flush(deletes, psMgr);
|
||||||
|
|
||||||
|
// take care of all secondary table inserts and updates last, since
|
||||||
|
// they may rely on previous inserts or updates, but nothing relies
|
||||||
|
// on them
|
||||||
|
flush(rmimpl.getSecondaryUpdates(), psMgr);
|
||||||
|
|
||||||
|
// flush any left over prepared statements
|
||||||
|
psMgr.flush();
|
||||||
|
return exceps;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Analyze foreign key dependencies on the given rows
|
||||||
|
* and create an insert and a delete graph to execute. The insert
|
||||||
|
* graph will be flushed before all other rows, and the delete graph will
|
||||||
|
* be flushed after them.
|
||||||
|
*/
|
||||||
|
private void analyzeForeignKeys(Collection inserts, Collection updates,
|
||||||
|
Collection deletes, RowManagerImpl rowMgr, Graph[] graphs) {
|
||||||
|
// if there are any deletes, we have to map the insert objects on their
|
||||||
|
// oids so we'll be able to detect delete-then-insert-same-pk cases
|
||||||
|
Map insertMap = null;
|
||||||
|
OpenJPAStateManager sm;
|
||||||
|
if (!deletes.isEmpty() && !inserts.isEmpty()) {
|
||||||
|
insertMap = new HashMap((int) (inserts.size() * 1.33 + 1));
|
||||||
|
for (Iterator itr = inserts.iterator(); itr.hasNext();) {
|
||||||
|
sm = ((Row) itr.next()).getPrimaryKey();
|
||||||
|
if (sm != null && sm.getObjectId() != null)
|
||||||
|
insertMap.put(sm.getObjectId(), sm);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// first construct the graph for deletes; this may expand to include
|
||||||
|
// inserts and updates as well if there are any inserts that rely on
|
||||||
|
// deletes (delete-then-insert-same-pk cases)
|
||||||
|
PrimaryRow row;
|
||||||
|
Row row2;
|
||||||
|
ForeignKey[] fks;
|
||||||
|
OpenJPAStateManager fkVal;
|
||||||
|
boolean ignoreUpdates = true;
|
||||||
|
for (Iterator itr = deletes.iterator(); itr.hasNext();) {
|
||||||
|
row = (PrimaryRow) itr.next();
|
||||||
|
if (!row.isValid())
|
||||||
|
continue;
|
||||||
|
|
||||||
|
row2 = getInsertRow(insertMap, rowMgr, row);
|
||||||
|
if (row2 != null) {
|
||||||
|
ignoreUpdates = false;
|
||||||
|
graphs[1] = addEdge(graphs[1], row, (PrimaryRow) row2, null);
|
||||||
|
}
|
||||||
|
|
||||||
|
// now check this row's fks against other deletes
|
||||||
|
fks = row.getTable().getForeignKeys();
|
||||||
|
for (int j = 0; j < fks.length; j++) {
|
||||||
|
// when deleting ref fks they'll just set a where value, so
|
||||||
|
// check both for fk updates (relation fks) and wheres (ref fks)
|
||||||
|
fkVal = row.getForeignKeySet(fks[j]);
|
||||||
|
if (fkVal == null)
|
||||||
|
fkVal = row.getForeignKeyWhere(fks[j]);
|
||||||
|
if (fkVal == null)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
row2 = rowMgr.getRow(fks[j].getPrimaryKeyTable(),
|
||||||
|
Row.ACTION_DELETE, fkVal, false);
|
||||||
|
if (row2 != null && row2.isValid() && row2 != row)
|
||||||
|
graphs[1] = addEdge(graphs[1], row, (PrimaryRow) row2,
|
||||||
|
fks[j]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ignoreUpdates)
|
||||||
|
graphs[0] = analyzeAgainstInserts(inserts, rowMgr, graphs[0]);
|
||||||
|
else {
|
||||||
|
// put inserts *and updates* in the delete graph; they all rely
|
||||||
|
// on each other
|
||||||
|
graphs[1] = analyzeAgainstInserts(updates, rowMgr, graphs[1]);
|
||||||
|
graphs[1] = analyzeAgainstInserts(inserts, rowMgr, graphs[1]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Check to see if there is an insert for for the same table and primary
|
||||||
|
* key values as the given delete row.
|
||||||
|
*/
|
||||||
|
private Row getInsertRow(Map insertMap, RowManagerImpl rowMgr, Row row) {
|
||||||
|
if (insertMap == null)
|
||||||
|
return null;
|
||||||
|
|
||||||
|
OpenJPAStateManager sm = row.getPrimaryKey();
|
||||||
|
if (sm == null)
|
||||||
|
return null;
|
||||||
|
|
||||||
|
// look for a new object whose insert id is the same as this delete one
|
||||||
|
Object oid = sm.getObjectId();
|
||||||
|
OpenJPAStateManager nsm = (OpenJPAStateManager) insertMap.get(oid);
|
||||||
|
if (nsm == null)
|
||||||
|
return null;
|
||||||
|
|
||||||
|
// found new object; get its row
|
||||||
|
row = rowMgr.getRow(row.getTable(), Row.ACTION_INSERT, nsm, false);
|
||||||
|
return (row == null || row.isValid()) ? row : null;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Analyze the given rows against the inserts, placing dependencies
|
||||||
|
* in the given graph.
|
||||||
|
*/
|
||||||
|
private Graph analyzeAgainstInserts(Collection rows, RowManagerImpl rowMgr,
|
||||||
|
Graph graph) {
|
||||||
|
PrimaryRow row;
|
||||||
|
Row row2;
|
||||||
|
ForeignKey[] fks;
|
||||||
|
Column[] cols;
|
||||||
|
for (Iterator itr = rows.iterator(); itr.hasNext();) {
|
||||||
|
row = (PrimaryRow) itr.next();
|
||||||
|
if (!row.isValid())
|
||||||
|
continue;
|
||||||
|
|
||||||
|
// check this row's fks against inserts; a logical fk to an auto-inc
|
||||||
|
// column is treated just as actual database fk because the result
|
||||||
|
// is the same: the pk row has to be inserted before the fk row
|
||||||
|
fks = row.getTable().getForeignKeys();
|
||||||
|
for (int j = 0; j < fks.length; j++) {
|
||||||
|
if (row.getForeignKeySet(fks[j]) == null)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
// see if this row is dependent on another. if it's only
|
||||||
|
// depenent on itself, see if the fk is logical or deferred, in
|
||||||
|
// which case it must be an auto-inc because otherwise we
|
||||||
|
// wouldn't have recorded it
|
||||||
|
row2 = rowMgr.getRow(fks[j].getPrimaryKeyTable(),
|
||||||
|
Row.ACTION_INSERT, row.getForeignKeySet(fks[j]), false);
|
||||||
|
if (row2 != null && row2.isValid() && (row2 != row
|
||||||
|
|| fks[j].isDeferred() || fks[j].isLogical()))
|
||||||
|
graph = addEdge(graph, (PrimaryRow) row2, row, fks[j]);
|
||||||
|
}
|
||||||
|
|
||||||
|
// see if there are any relation id columns dependent on
|
||||||
|
// auto-inc objects
|
||||||
|
cols = row.getTable().getRelationIdColumns();
|
||||||
|
for (int j = 0; j < cols.length; j++) {
|
||||||
|
OpenJPAStateManager sm = row.getRelationIdSet(cols[j]);
|
||||||
|
if (sm == null)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
row2 = rowMgr.getRow(getBaseTable(sm), Row.ACTION_INSERT,
|
||||||
|
sm, false);
|
||||||
|
if (row2 != null && row2.isValid())
|
||||||
|
graph = addEdge(graph, (PrimaryRow) row2, row, cols[j]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return graph;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return the base table for the given instance.
|
||||||
|
*/
|
||||||
|
private static Table getBaseTable(OpenJPAStateManager sm) {
|
||||||
|
ClassMapping cls = (ClassMapping) sm.getMetaData();
|
||||||
|
while (cls.getJoinablePCSuperclassMapping() != null)
|
||||||
|
cls = cls.getJoinablePCSuperclassMapping();
|
||||||
|
return cls.getTable();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Add an edge between the given rows in the given foreign key graph.
|
||||||
|
*/
|
||||||
|
private Graph addEdge(Graph graph, PrimaryRow row1, PrimaryRow row2,
|
||||||
|
Object fk) {
|
||||||
|
// delay creation of the graph
|
||||||
|
if (graph == null)
|
||||||
|
graph = new Graph();
|
||||||
|
|
||||||
|
row1.setDependent(true);
|
||||||
|
row2.setDependent(true);
|
||||||
|
graph.addNode(row1);
|
||||||
|
graph.addNode(row2);
|
||||||
|
|
||||||
|
// add an edge from row1 to row2, and set the fk causing the
|
||||||
|
// dependency as the user object so we can retrieve it when resolving
|
||||||
|
// circular constraints
|
||||||
|
Edge edge = new Edge(row1, row2, true);
|
||||||
|
edge.setUserObject(fk);
|
||||||
|
graph.addEdge(edge);
|
||||||
|
|
||||||
|
return graph;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Flush the given graph of rows in the proper order.
|
||||||
|
* @param graph The graph of statements to be walked
|
||||||
|
* @param psMgr The prepared statement manager to use to issue the
|
||||||
|
* statements
|
||||||
|
* @param autoAssign Whether any of the rows in the graph have any
|
||||||
|
* auto-assign constraints
|
||||||
|
*/
|
||||||
|
protected void flushGraph(Graph graph, PreparedStatementManager psMgr,
|
||||||
|
boolean autoAssign)
|
||||||
|
throws SQLException {
|
||||||
|
if (graph == null)
|
||||||
|
return;
|
||||||
|
|
||||||
|
DepthFirstAnalysis dfa = newDepthFirstAnalysis(graph, autoAssign);
|
||||||
|
Collection nodes = dfa.getSortedNodes();
|
||||||
|
Collection backs = dfa.getEdges(Edge.TYPE_BACK);
|
||||||
|
|
||||||
|
// handle circular constraints:
|
||||||
|
// - if deleted row A has a ciricular fk to deleted row B, then use an
|
||||||
|
// update statement to null A's fk to B
|
||||||
|
// - if inserted row A has a circular fk to updated/inserted row B,
|
||||||
|
// then null the fk in the B row object, and after flushing, use
|
||||||
|
// an update to set the fk to back to A
|
||||||
|
Collection insertUpdates = null;
|
||||||
|
Collection deleteUpdates = null;
|
||||||
|
PrimaryRow row;
|
||||||
|
RowImpl update;
|
||||||
|
Edge edge;
|
||||||
|
ForeignKey fk;
|
||||||
|
Column col;
|
||||||
|
for (Iterator itr = backs.iterator(); itr.hasNext();) {
|
||||||
|
edge = (Edge) itr.next();
|
||||||
|
if (edge.getUserObject() == null)
|
||||||
|
throw new InternalException(_loc.get("del-ins-cycle"));
|
||||||
|
|
||||||
|
// use a primary row update to prevent setting pk and fk values
|
||||||
|
// until after flush, to get latest auto-increment values
|
||||||
|
row = (PrimaryRow) edge.getTo();
|
||||||
|
if (row.getAction() == Row.ACTION_DELETE) {
|
||||||
|
// copy where conditions into new update that nulls the fk
|
||||||
|
row = (PrimaryRow) edge.getFrom();
|
||||||
|
update = new PrimaryRow(row.getTable(), Row.ACTION_UPDATE,null);
|
||||||
|
row.copyInto(update, true);
|
||||||
|
if (edge.getUserObject() instanceof ForeignKey) {
|
||||||
|
fk = (ForeignKey) edge.getUserObject();
|
||||||
|
update.setForeignKey(fk, row.getForeignKeyIO(fk), null);
|
||||||
|
} else
|
||||||
|
update.setNull((Column) edge.getUserObject());
|
||||||
|
|
||||||
|
if (deleteUpdates == null)
|
||||||
|
deleteUpdates = new LinkedList();
|
||||||
|
deleteUpdates.add(update);
|
||||||
|
} else {
|
||||||
|
// copy where conditions into new update that sets the fk
|
||||||
|
update = new PrimaryRow(row.getTable(), Row.ACTION_UPDATE,null);
|
||||||
|
if (row.getAction() == Row.ACTION_INSERT) {
|
||||||
|
if (row.getPrimaryKey() == null)
|
||||||
|
throw new InternalException(_loc.get("ref-cycle"));
|
||||||
|
update.wherePrimaryKey(row.getPrimaryKey());
|
||||||
|
} else
|
||||||
|
row.copyInto(update, true);
|
||||||
|
if (edge.getUserObject() instanceof ForeignKey) {
|
||||||
|
fk = (ForeignKey) edge.getUserObject();
|
||||||
|
update.setForeignKey(fk, row.getForeignKeyIO(fk),
|
||||||
|
row.getForeignKeySet(fk));
|
||||||
|
row.clearForeignKey(fk);
|
||||||
|
} else {
|
||||||
|
col = (Column) edge.getUserObject();
|
||||||
|
update.setRelationId(col, row.getRelationIdSet(col),
|
||||||
|
row.getRelationIdCallback(col));
|
||||||
|
row.clearRelationId(col);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (insertUpdates == null)
|
||||||
|
insertUpdates = new LinkedList();
|
||||||
|
insertUpdates.add(update);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// flush delete updates to null fks, then all rows in order, then
|
||||||
|
// the insert updates to set circular fk values
|
||||||
|
if (deleteUpdates != null)
|
||||||
|
flush(deleteUpdates, psMgr);
|
||||||
|
for (Iterator itr = nodes.iterator(); itr.hasNext();)
|
||||||
|
psMgr.flush((RowImpl) itr.next());
|
||||||
|
if (insertUpdates != null)
|
||||||
|
flush(insertUpdates, psMgr);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a new {@link DepthFirstAnalysis} suitable for the given graph
|
||||||
|
* and auto-assign settings.
|
||||||
|
*/
|
||||||
|
protected DepthFirstAnalysis newDepthFirstAnalysis(Graph graph,
|
||||||
|
boolean autoAssign) {
|
||||||
|
return new DepthFirstAnalysis(graph);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Flush the given collection of secondary rows.
|
||||||
|
*/
|
||||||
|
protected void flush(Collection rows, PreparedStatementManager psMgr) {
|
||||||
|
if (rows.size() == 0)
|
||||||
|
return;
|
||||||
|
|
||||||
|
RowImpl row;
|
||||||
|
for (Iterator itr = rows.iterator(); itr.hasNext(); ) {
|
||||||
|
row = (RowImpl) itr.next();
|
||||||
|
if (row.isValid() && !row.isDependent())
|
||||||
|
psMgr.flush(row);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,145 @@
|
||||||
|
/*
|
||||||
|
* Licensed to the Apache Software Foundation (ASF) under one
|
||||||
|
* or more contributor license agreements. See the NOTICE file
|
||||||
|
* distributed with this work for additional information
|
||||||
|
* regarding copyright ownership. The ASF licenses this file
|
||||||
|
* to you under the Apache License, Version 2.0 (the
|
||||||
|
* "License"); you may not use this file except in compliance
|
||||||
|
* with the License. You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing,
|
||||||
|
* software distributed under the License is distributed on an
|
||||||
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||||
|
* KIND, either express or implied. See the License for the
|
||||||
|
* specific language governing permissions and limitations
|
||||||
|
* under the License.
|
||||||
|
*/
|
||||||
|
package org.apache.openjpa.lib.graph;
|
||||||
|
|
||||||
|
import java.util.Collection;
|
||||||
|
import java.util.HashMap;
|
||||||
|
import java.util.HashSet;
|
||||||
|
import java.util.Iterator;
|
||||||
|
import java.util.LinkedList;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.Map;
|
||||||
|
import java.util.Set;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* <p>Performs a breadth-first walk of a given {@link Graph},
|
||||||
|
* notifying visitors as it sees each node. See the BFS algorithm
|
||||||
|
* in the book 'Introduction to Algorithms' by Cormen, Leiserson, and
|
||||||
|
* Rivest.</p>
|
||||||
|
* <p/>
|
||||||
|
* <p>Each {@link GraphVisitor} will be notified when a node
|
||||||
|
* is colored black (nodeVisited), edge seen (edgeVisited),
|
||||||
|
* and a node is seen for the first time, i.e. colored gray (nodeSeen).</p>
|
||||||
|
*
|
||||||
|
* @author Steve Kim
|
||||||
|
* @since 1.0.0
|
||||||
|
* @nojavadoc
|
||||||
|
*/
|
||||||
|
public class BreadthFirstWalk {
|
||||||
|
|
||||||
|
private final Graph _graph;
|
||||||
|
private final Set _visitors = new HashSet();
|
||||||
|
private final List _queue = new LinkedList();
|
||||||
|
private final Map _nodeInfo = new HashMap();
|
||||||
|
|
||||||
|
public BreadthFirstWalk(Graph graph) {
|
||||||
|
_graph = graph;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Begins the breadth first traversal.
|
||||||
|
*/
|
||||||
|
public void walk() {
|
||||||
|
_queue.clear();
|
||||||
|
_nodeInfo.clear();
|
||||||
|
|
||||||
|
Collection nodes = _graph.getNodes();
|
||||||
|
for (Iterator itr = nodes.iterator(); itr.hasNext();)
|
||||||
|
_nodeInfo.put(itr.next(), new NodeInfo());
|
||||||
|
|
||||||
|
Object node;
|
||||||
|
NodeInfo info;
|
||||||
|
for (Iterator itr = nodes.iterator(); itr.hasNext();) {
|
||||||
|
node = itr.next();
|
||||||
|
info = (NodeInfo) _nodeInfo.get(node);
|
||||||
|
if (info.color == NodeInfo.COLOR_WHITE)
|
||||||
|
enqueue(node, info);
|
||||||
|
processQueue();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Process the queue to see what data needs to be obtained.
|
||||||
|
*/
|
||||||
|
private void processQueue() {
|
||||||
|
Object node;
|
||||||
|
Object other;
|
||||||
|
NodeInfo info;
|
||||||
|
NodeInfo otherInfo;
|
||||||
|
Collection edges;
|
||||||
|
Edge edge;
|
||||||
|
while (_queue.size() > 0) {
|
||||||
|
node = _queue.remove(0);
|
||||||
|
info = (NodeInfo) _nodeInfo.get(node);
|
||||||
|
visit(node, info);
|
||||||
|
|
||||||
|
edges = _graph.getEdgesFrom(node);
|
||||||
|
for (Iterator itr = edges.iterator(); itr.hasNext();) {
|
||||||
|
edge = (Edge) itr.next();
|
||||||
|
edgeVisited(edge);
|
||||||
|
other = edge.getOther(node);
|
||||||
|
otherInfo = (NodeInfo) _nodeInfo.get(other);
|
||||||
|
if (otherInfo.color == NodeInfo.COLOR_WHITE)
|
||||||
|
enqueue(other, otherInfo);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Push the given node onto the queue to be processed.
|
||||||
|
* Notify visitors.
|
||||||
|
*/
|
||||||
|
protected void enqueue(Object node, NodeInfo info) {
|
||||||
|
_queue.add(node);
|
||||||
|
info.color = NodeInfo.COLOR_GRAY;
|
||||||
|
for (Iterator i = _visitors.iterator(); i.hasNext();)
|
||||||
|
((GraphVisitor) i.next()).nodeSeen(node);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Visit the node. Mark the node black and notify visitors.
|
||||||
|
*/
|
||||||
|
protected void visit(Object node, NodeInfo info) {
|
||||||
|
info.color = NodeInfo.COLOR_BLACK;
|
||||||
|
for (Iterator i = _visitors.iterator(); i.hasNext();)
|
||||||
|
((GraphVisitor) i.next()).nodeVisited(node);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* An edge is seen. Notify visitors.
|
||||||
|
*/
|
||||||
|
protected void edgeVisited(Edge edge) {
|
||||||
|
for (Iterator i = _visitors.iterator(); i.hasNext();)
|
||||||
|
((GraphVisitor) i.next()).edgeVisited(edge);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* add a {@link GraphVisitor} to be notified during breadth first search.
|
||||||
|
*/
|
||||||
|
public void addGraphVisitor(GraphVisitor visitor) {
|
||||||
|
_visitors.add(visitor);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* remove a given {@link GraphVisitor} from the listener set.
|
||||||
|
*/
|
||||||
|
public void removeGraphVisitor(GraphVisitor visitor) {
|
||||||
|
_visitors.remove(visitor);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,215 @@
|
||||||
|
/*
|
||||||
|
* Licensed to the Apache Software Foundation (ASF) under one
|
||||||
|
* or more contributor license agreements. See the NOTICE file
|
||||||
|
* distributed with this work for additional information
|
||||||
|
* regarding copyright ownership. The ASF licenses this file
|
||||||
|
* to you under the Apache License, Version 2.0 (the
|
||||||
|
* "License"); you may not use this file except in compliance
|
||||||
|
* with the License. You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing,
|
||||||
|
* software distributed under the License is distributed on an
|
||||||
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||||
|
* KIND, either express or implied. See the License for the
|
||||||
|
* specific language governing permissions and limitations
|
||||||
|
* under the License.
|
||||||
|
*/
|
||||||
|
package org.apache.openjpa.lib.graph;
|
||||||
|
|
||||||
|
import java.util.AbstractList;
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.Arrays;
|
||||||
|
import java.util.Collection;
|
||||||
|
import java.util.Collections;
|
||||||
|
import java.util.Comparator;
|
||||||
|
import java.util.HashMap;
|
||||||
|
import java.util.Iterator;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.Map;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* <p>Performs a depth-first analysis of a given {@link Graph}, caching
|
||||||
|
* information about the graph's nodes and edges. See the DFS algorithm
|
||||||
|
* in the book 'Introduction to Algorithms' by Cormen, Leiserson, and
|
||||||
|
* Rivest. The algorithm has been modified to group sibling nodes without
|
||||||
|
* connections together during the topological sort.</p>
|
||||||
|
*
|
||||||
|
* @author Abe White
|
||||||
|
* @since 1.0.0
|
||||||
|
* @nojavadoc
|
||||||
|
*/
|
||||||
|
public class DepthFirstAnalysis {
|
||||||
|
|
||||||
|
private final Graph _graph;
|
||||||
|
private final Map _nodeInfo = new HashMap();
|
||||||
|
private Comparator _comp;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Constructor. Performs the analysis on the given graph and caches
|
||||||
|
* the resulting information.
|
||||||
|
*/
|
||||||
|
public DepthFirstAnalysis(Graph graph) {
|
||||||
|
_graph = graph;
|
||||||
|
|
||||||
|
// initialize node infos
|
||||||
|
Collection nodes = graph.getNodes();
|
||||||
|
for (Iterator itr = nodes.iterator(); itr.hasNext();)
|
||||||
|
_nodeInfo.put(itr.next(), new NodeInfo());
|
||||||
|
|
||||||
|
// visit all nodes -- see intro to algo's book
|
||||||
|
NodeInfo info;
|
||||||
|
Object node;
|
||||||
|
for (Iterator itr = nodes.iterator(); itr.hasNext();) {
|
||||||
|
node = itr.next();
|
||||||
|
info = (NodeInfo) _nodeInfo.get(node);
|
||||||
|
if (info.color == NodeInfo.COLOR_WHITE)
|
||||||
|
visit(graph, node, info, 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Visit a node. See Introduction to Algorithms book for details.
|
||||||
|
*/
|
||||||
|
private int visit(Graph graph, Object node, NodeInfo info, int time) {
|
||||||
|
// discover node
|
||||||
|
info.color = NodeInfo.COLOR_GRAY;
|
||||||
|
|
||||||
|
// explore all vertices from that node depth first
|
||||||
|
Collection edges = graph.getEdgesFrom(node);
|
||||||
|
Edge edge;
|
||||||
|
Object other;
|
||||||
|
NodeInfo otherInfo;
|
||||||
|
int maxChildTime = time - 1;
|
||||||
|
int childTime;
|
||||||
|
for (Iterator itr = edges.iterator(); itr.hasNext();) {
|
||||||
|
edge = (Edge) itr.next();
|
||||||
|
other = edge.getOther(node);
|
||||||
|
otherInfo = (NodeInfo) _nodeInfo.get(other);
|
||||||
|
if (otherInfo.color == NodeInfo.COLOR_WHITE) {
|
||||||
|
// undiscovered node; recurse into it
|
||||||
|
childTime = visit(graph, other, otherInfo, time);
|
||||||
|
edge.setType(Edge.TYPE_TREE);
|
||||||
|
} else if (otherInfo.color == NodeInfo.COLOR_GRAY) {
|
||||||
|
childTime = -1;
|
||||||
|
edge.setType(Edge.TYPE_BACK);
|
||||||
|
} else {
|
||||||
|
childTime = otherInfo.finished;
|
||||||
|
edge.setType(Edge.TYPE_FORWARD);
|
||||||
|
}
|
||||||
|
maxChildTime = Math.max(maxChildTime, childTime);
|
||||||
|
}
|
||||||
|
|
||||||
|
// finished with node
|
||||||
|
info.color = NodeInfo.COLOR_BLACK;
|
||||||
|
info.finished = maxChildTime + 1;
|
||||||
|
return info.finished;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set the comparator that should be used for ordering groups of nodes
|
||||||
|
* with the same dependencies.
|
||||||
|
*/
|
||||||
|
public void setNodeComparator(Comparator comp) {
|
||||||
|
_comp = comp;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return the nodes in topologically-sorted order. This is often used
|
||||||
|
* to order dependencies. If each graph edge (u, v) represents a
|
||||||
|
* dependency of v on u, then this method will return the nodes in the
|
||||||
|
* order that they should be evaluated to satisfy all dependencies. Of
|
||||||
|
* course, if the graph is cyclic (has back edges), then no such ordering
|
||||||
|
* is possible, though this method will still return the correct order
|
||||||
|
* as if edges creating the cycles did not exist.
|
||||||
|
*/
|
||||||
|
public List getSortedNodes() {
|
||||||
|
Map.Entry[] entries = (Map.Entry[]) _nodeInfo.entrySet().
|
||||||
|
toArray(new Map.Entry[_nodeInfo.size()]);
|
||||||
|
Arrays.sort(entries, new NodeInfoComparator(_comp));
|
||||||
|
return new NodeList(entries);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return all edges of the given type. This method can be used to
|
||||||
|
* discover all edges that cause cycles in the graph by passing it
|
||||||
|
* the {@link #EDGE_BACK} edge type.
|
||||||
|
*/
|
||||||
|
public Collection getEdges(int type) {
|
||||||
|
Collection typed = null;
|
||||||
|
Edge edge;
|
||||||
|
Object node;
|
||||||
|
for (Iterator nodes = _graph.getNodes().iterator(); nodes.hasNext();) {
|
||||||
|
node = nodes.next();
|
||||||
|
for (Iterator itr = _graph.getEdgesFrom(node).iterator();
|
||||||
|
itr.hasNext();) {
|
||||||
|
edge = (Edge) itr.next();
|
||||||
|
if (edge.getType() == type) {
|
||||||
|
if (typed == null)
|
||||||
|
typed = new ArrayList();
|
||||||
|
typed.add(edge);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return (typed == null) ? Collections.EMPTY_LIST : typed;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return the logical time that the given node was finished in
|
||||||
|
* the graph walk, or -1 if the node is not part of the graph.
|
||||||
|
*/
|
||||||
|
public int getFinishedTime(Object node) {
|
||||||
|
NodeInfo info = (NodeInfo) _nodeInfo.get(node);
|
||||||
|
if (info == null)
|
||||||
|
return -1;
|
||||||
|
return info.finished;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Comparator for toplogically sorting entries in the node info map.
|
||||||
|
*/
|
||||||
|
private static class NodeInfoComparator
|
||||||
|
implements Comparator {
|
||||||
|
|
||||||
|
private final Comparator _subComp;
|
||||||
|
|
||||||
|
public NodeInfoComparator(Comparator subComp) {
|
||||||
|
_subComp = subComp;
|
||||||
|
}
|
||||||
|
|
||||||
|
public int compare(Object o1, Object o2) {
|
||||||
|
Map.Entry e1 = (Map.Entry) o1;
|
||||||
|
Map.Entry e2 = (Map.Entry) o2;
|
||||||
|
NodeInfo n1 = (NodeInfo) e1.getValue();
|
||||||
|
NodeInfo n2 = (NodeInfo) e2.getValue();
|
||||||
|
|
||||||
|
// reverse finished order
|
||||||
|
int ret = n2.finished - n1.finished;
|
||||||
|
if (ret == 0 && _subComp != null)
|
||||||
|
ret = _subComp.compare(e1.getKey(), e2.getKey());
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* List of node-to-nodeinfo entries that exposes just the nodes.
|
||||||
|
*/
|
||||||
|
private static class NodeList
|
||||||
|
extends AbstractList {
|
||||||
|
|
||||||
|
private final Map.Entry[] _entries;
|
||||||
|
|
||||||
|
public NodeList(Map.Entry[] entries) {
|
||||||
|
_entries = entries;
|
||||||
|
}
|
||||||
|
|
||||||
|
public Object get(int idx) {
|
||||||
|
return _entries[idx].getKey();
|
||||||
|
}
|
||||||
|
|
||||||
|
public int size() {
|
||||||
|
return _entries.length;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,189 @@
|
||||||
|
/*
|
||||||
|
* Licensed to the Apache Software Foundation (ASF) under one
|
||||||
|
* or more contributor license agreements. See the NOTICE file
|
||||||
|
* distributed with this work for additional information
|
||||||
|
* regarding copyright ownership. The ASF licenses this file
|
||||||
|
* to you under the Apache License, Version 2.0 (the
|
||||||
|
* "License"); you may not use this file except in compliance
|
||||||
|
* with the License. You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing,
|
||||||
|
* software distributed under the License is distributed on an
|
||||||
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||||
|
* KIND, either express or implied. See the License for the
|
||||||
|
* specific language governing permissions and limitations
|
||||||
|
* under the License.
|
||||||
|
*/
|
||||||
|
package org.apache.openjpa.lib.graph;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* <p>A graph edge. Includes the from and to nodes, an arbitrary user object,
|
||||||
|
* and a weight. Edges can be either directed or undirected.</p>
|
||||||
|
*
|
||||||
|
* @author Abe White
|
||||||
|
* @since 1.0.0
|
||||||
|
* @nojavadoc
|
||||||
|
*/
|
||||||
|
public class Edge {
|
||||||
|
|
||||||
|
/**
|
||||||
|
* An edge (u, v) is a tree edge if node v was first discovered by
|
||||||
|
* traversing the edge.
|
||||||
|
*/
|
||||||
|
public static final int TYPE_TREE = 1;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* An edge (u, v) is a back edge if it creates a cycle back to an
|
||||||
|
* ancestor in the graph.
|
||||||
|
*/
|
||||||
|
public static final int TYPE_BACK = 2;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* An edge (u, v) is a forward edge if it is not a tree or back edge.
|
||||||
|
*/
|
||||||
|
public static final int TYPE_FORWARD = 3;
|
||||||
|
|
||||||
|
private final Object _from;
|
||||||
|
private final Object _to;
|
||||||
|
private final boolean _directed;
|
||||||
|
|
||||||
|
private int _type = 0;
|
||||||
|
private double _weight = 0;
|
||||||
|
private Object _userObj = null;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Constructor.
|
||||||
|
*
|
||||||
|
* @param from the node the edge comes from
|
||||||
|
* @param to the node the edge goes to
|
||||||
|
* @param directed whether the edge is directed
|
||||||
|
*/
|
||||||
|
public Edge(Object from, Object to, boolean directed) {
|
||||||
|
if (from == null)
|
||||||
|
throw new NullPointerException("from == null");
|
||||||
|
if (to == null)
|
||||||
|
throw new NullPointerException("to == null");
|
||||||
|
_from = from;
|
||||||
|
_to = to;
|
||||||
|
_directed = directed;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Constructor.
|
||||||
|
*
|
||||||
|
* @param from the node the edge comes from
|
||||||
|
* @param to the node the edge goes to
|
||||||
|
* @param directed whether the edge is directed
|
||||||
|
* @param userObject an associated object
|
||||||
|
*/
|
||||||
|
public Edge(Object from, Object to, boolean directed, Object userObject) {
|
||||||
|
this(from, to, directed);
|
||||||
|
_userObj = userObject;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return the node the edge links from.
|
||||||
|
*/
|
||||||
|
public Object getFrom() {
|
||||||
|
return _from;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return the node the edge links to.
|
||||||
|
*/
|
||||||
|
public Object getTo() {
|
||||||
|
return _to;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return the node on the opposite end of the given one, or null if the
|
||||||
|
* given node is not part of this edge.
|
||||||
|
*/
|
||||||
|
public Object getOther(Object node) {
|
||||||
|
if (_to == node)
|
||||||
|
return _from;
|
||||||
|
if (_from == node)
|
||||||
|
return _to;
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return true if this edge links to the given node. For undirected edges,
|
||||||
|
* this method returns true if either side is equal to the given node.
|
||||||
|
*/
|
||||||
|
public boolean isTo(Object node) {
|
||||||
|
return _to == node || (!_directed && _from == node);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return true if this edge links from the given node. For undirected
|
||||||
|
* edges, this method returns true if either side is equal to the given
|
||||||
|
* node.
|
||||||
|
*/
|
||||||
|
public boolean isFrom(Object node) {
|
||||||
|
return _from == node || (!_directed && _to == node);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return whether the edge is directed.
|
||||||
|
*/
|
||||||
|
public boolean isDirected() {
|
||||||
|
return _directed;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return the weight of the edge.
|
||||||
|
*/
|
||||||
|
public double getWeight() {
|
||||||
|
return _weight;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set the weight of the edge.
|
||||||
|
*/
|
||||||
|
public void setWeight(double weight) {
|
||||||
|
_weight = weight;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Arbitrary user object associated with the edge.
|
||||||
|
*/
|
||||||
|
public Object getUserObject() {
|
||||||
|
return _userObj;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Arbitrary user object associated with the edge.
|
||||||
|
*/
|
||||||
|
public void setUserObject(Object obj) {
|
||||||
|
_userObj = obj;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Traversal bookkeeping info.
|
||||||
|
*/
|
||||||
|
public int getType() {
|
||||||
|
return _type;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Traversal bookkeeping info.
|
||||||
|
*/
|
||||||
|
public void setType(int type) {
|
||||||
|
_type = type;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Clear traversal info.
|
||||||
|
*/
|
||||||
|
public void clearTraversal() {
|
||||||
|
_type = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
public String toString() {
|
||||||
|
return super.toString() + "[from=" + getFrom() + ";to=" + getTo()
|
||||||
|
+ ";directed=" + isDirected () + ";weight=" + getWeight () + "]";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,199 @@
|
||||||
|
/*
|
||||||
|
* Licensed to the Apache Software Foundation (ASF) under one
|
||||||
|
* or more contributor license agreements. See the NOTICE file
|
||||||
|
* distributed with this work for additional information
|
||||||
|
* regarding copyright ownership. The ASF licenses this file
|
||||||
|
* to you under the Apache License, Version 2.0 (the
|
||||||
|
* "License"); you may not use this file except in compliance
|
||||||
|
* with the License. You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing,
|
||||||
|
* software distributed under the License is distributed on an
|
||||||
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||||
|
* KIND, either express or implied. See the License for the
|
||||||
|
* specific language governing permissions and limitations
|
||||||
|
* under the License.
|
||||||
|
*/
|
||||||
|
package org.apache.openjpa.lib.graph;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.Collection;
|
||||||
|
import java.util.Collections;
|
||||||
|
import java.util.HashMap;
|
||||||
|
import java.util.HashSet;
|
||||||
|
import java.util.Iterator;
|
||||||
|
import java.util.Map;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* <p>Graph representation using the adjacency list form. See the book
|
||||||
|
* 'Introduction to Algorithms' by Cormen, Leiserson, and Rivest.</p>
|
||||||
|
*
|
||||||
|
* @author Abe White
|
||||||
|
* @since 1.0.0
|
||||||
|
* @nojavadoc
|
||||||
|
*/
|
||||||
|
public class Graph {
|
||||||
|
|
||||||
|
// map each node to list of edges from that node
|
||||||
|
private final Map _nodes = new HashMap();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Clear the graph.
|
||||||
|
*/
|
||||||
|
public void clear() {
|
||||||
|
_nodes.clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return true if the graph contains the given node.
|
||||||
|
*/
|
||||||
|
public boolean containsNode(Object node) {
|
||||||
|
return _nodes.containsKey(node);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return a view of all nodes in the graph.
|
||||||
|
*/
|
||||||
|
public Collection getNodes() {
|
||||||
|
return _nodes.keySet();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Add a node to the graph. Adding a node a second time has no effect.
|
||||||
|
*/
|
||||||
|
public void addNode(Object node) {
|
||||||
|
if (node == null)
|
||||||
|
throw new NullPointerException("node = null");
|
||||||
|
if (!containsNode(node))
|
||||||
|
_nodes.put(node, null);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Remove a node from the graph. All edges to and from the node
|
||||||
|
* will be cleared.
|
||||||
|
*
|
||||||
|
* @return true if the node was removed, false otherwise
|
||||||
|
*/
|
||||||
|
public boolean removeNode(Object node) {
|
||||||
|
boolean rem = containsNode(node);
|
||||||
|
if (rem) {
|
||||||
|
Collection edges = getEdgesTo(node);
|
||||||
|
for (Iterator itr = edges.iterator(); itr.hasNext();)
|
||||||
|
removeEdge((Edge) itr.next());
|
||||||
|
_nodes.remove(node);
|
||||||
|
}
|
||||||
|
return rem;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return all edges in the graph.
|
||||||
|
*/
|
||||||
|
public Collection getEdges() {
|
||||||
|
Collection all = new HashSet();
|
||||||
|
Collection edges;
|
||||||
|
for (Iterator itr = _nodes.values().iterator(); itr.hasNext();) {
|
||||||
|
edges = (Collection) itr.next();
|
||||||
|
if (edges != null)
|
||||||
|
all.addAll(edges);
|
||||||
|
}
|
||||||
|
return all;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return all the edges from a particular node.
|
||||||
|
*/
|
||||||
|
public Collection getEdgesFrom(Object node) {
|
||||||
|
Collection edges = (Collection) _nodes.get(node);
|
||||||
|
return (edges == null) ? Collections.EMPTY_LIST : edges;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return all the edges to a particular node.
|
||||||
|
*/
|
||||||
|
public Collection getEdgesTo(Object node) {
|
||||||
|
Collection edges = getEdges();
|
||||||
|
Collection to = new ArrayList();
|
||||||
|
Edge edge;
|
||||||
|
for (Iterator itr = edges.iterator(); itr.hasNext();) {
|
||||||
|
edge = (Edge) itr.next();
|
||||||
|
if (edge.isTo(node))
|
||||||
|
to.add(edge);
|
||||||
|
}
|
||||||
|
return to;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Return all the edges from one node to another.
|
||||||
|
*/
|
||||||
|
public Collection getEdges(Object from, Object to) {
|
||||||
|
Collection edges = getEdgesFrom(from);
|
||||||
|
Collection matches = new ArrayList(edges.size());
|
||||||
|
Edge edge;
|
||||||
|
for (Iterator itr = edges.iterator(); itr.hasNext();) {
|
||||||
|
edge = (Edge) itr.next();
|
||||||
|
if (edge.isTo(to))
|
||||||
|
matches.add(edge);
|
||||||
|
}
|
||||||
|
return matches;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Add an edge to the graph.
|
||||||
|
*/
|
||||||
|
public void addEdge(Edge edge) {
|
||||||
|
if (!containsNode(edge.getTo()))
|
||||||
|
throw new IllegalArgumentException(edge.getTo().toString());
|
||||||
|
if (!containsNode(edge.getFrom()))
|
||||||
|
throw new IllegalArgumentException(edge.getFrom().toString());
|
||||||
|
|
||||||
|
Collection from = (Collection) _nodes.get(edge.getFrom());
|
||||||
|
if (from == null) {
|
||||||
|
from = new ArrayList(3);
|
||||||
|
_nodes.put(edge.getFrom(), from);
|
||||||
|
}
|
||||||
|
from.add(edge);
|
||||||
|
|
||||||
|
if (!edge.isDirected() && !edge.getFrom().equals(edge.getTo())) {
|
||||||
|
Collection to = (Collection) _nodes.get(edge.getTo());
|
||||||
|
if (to == null) {
|
||||||
|
to = new ArrayList(3);
|
||||||
|
_nodes.put(edge.getTo(), to);
|
||||||
|
}
|
||||||
|
to.add(edge);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Remove an edge from the graph.
|
||||||
|
*
|
||||||
|
* @return true if the edge was removed, false if not in the graph
|
||||||
|
*/
|
||||||
|
public boolean removeEdge(Edge edge) {
|
||||||
|
Collection edges = (Collection) _nodes.get(edge.getFrom());
|
||||||
|
if (edges == null)
|
||||||
|
return false;
|
||||||
|
boolean rem = edges.remove(edge);
|
||||||
|
if (rem && !edge.isDirected()) {
|
||||||
|
edges = (Collection) _nodes.get(edge.getTo());
|
||||||
|
if (edges != null)
|
||||||
|
edges.remove(edge);
|
||||||
|
}
|
||||||
|
return rem;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Clear all nodes and edges of the bookkeeping information from their
|
||||||
|
* last traversal.
|
||||||
|
*/
|
||||||
|
public void clearTraversal() {
|
||||||
|
Collection edges;
|
||||||
|
for (Iterator vals = _nodes.values().iterator(); vals.hasNext();) {
|
||||||
|
edges = (Collection) vals.next();
|
||||||
|
if (edges != null)
|
||||||
|
for (Iterator ed = edges.iterator(); ed.hasNext();)
|
||||||
|
((Edge) ed.next()).clearTraversal ();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,47 @@
|
||||||
|
/*
|
||||||
|
* Licensed to the Apache Software Foundation (ASF) under one
|
||||||
|
* or more contributor license agreements. See the NOTICE file
|
||||||
|
* distributed with this work for additional information
|
||||||
|
* regarding copyright ownership. The ASF licenses this file
|
||||||
|
* to you under the Apache License, Version 2.0 (the
|
||||||
|
* "License"); you may not use this file except in compliance
|
||||||
|
* with the License. You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing,
|
||||||
|
* software distributed under the License is distributed on an
|
||||||
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||||
|
* KIND, either express or implied. See the License for the
|
||||||
|
* specific language governing permissions and limitations
|
||||||
|
* under the License.
|
||||||
|
*/
|
||||||
|
package org.apache.openjpa.lib.graph;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* <p>A helper interface that allows third parties to be notified of
|
||||||
|
* graph events during graph traversals</p>
|
||||||
|
*
|
||||||
|
* @author Steve Kim
|
||||||
|
* @since 1.0.0
|
||||||
|
* @nojavadoc
|
||||||
|
*/
|
||||||
|
public interface GraphVisitor {
|
||||||
|
|
||||||
|
/**
|
||||||
|
* May not be called. The meaning of this method is dependent
|
||||||
|
* on the traversal being used. See each appropriate graph
|
||||||
|
* walker for details.
|
||||||
|
*/
|
||||||
|
public void nodeSeen(Object node);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* will only be called once per node
|
||||||
|
*/
|
||||||
|
public void nodeVisited(Object node);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* may visit the node twice (both sides)
|
||||||
|
*/
|
||||||
|
public void edgeVisited(Edge edge);
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,35 @@
|
||||||
|
/*
|
||||||
|
* Licensed to the Apache Software Foundation (ASF) under one
|
||||||
|
* or more contributor license agreements. See the NOTICE file
|
||||||
|
* distributed with this work for additional information
|
||||||
|
* regarding copyright ownership. The ASF licenses this file
|
||||||
|
* to you under the Apache License, Version 2.0 (the
|
||||||
|
* "License"); you may not use this file except in compliance
|
||||||
|
* with the License. You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing,
|
||||||
|
* software distributed under the License is distributed on an
|
||||||
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||||
|
* KIND, either express or implied. See the License for the
|
||||||
|
* specific language governing permissions and limitations
|
||||||
|
* under the License.
|
||||||
|
*/
|
||||||
|
package org.apache.openjpa.lib.graph;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* <p>Struct used to track graph node information during traversal.</p>
|
||||||
|
*
|
||||||
|
* @author Abe White
|
||||||
|
* @since 1.0.0
|
||||||
|
*/
|
||||||
|
class NodeInfo {
|
||||||
|
|
||||||
|
public static final int COLOR_WHITE = 0;
|
||||||
|
public static final int COLOR_GRAY = 1;
|
||||||
|
public static final int COLOR_BLACK = 2;
|
||||||
|
|
||||||
|
public int finished = 0;
|
||||||
|
public int color = COLOR_WHITE;
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,27 @@
|
||||||
|
<!--
|
||||||
|
Licensed to the Apache Software Foundation (ASF) under one
|
||||||
|
or more contributor license agreements. See the NOTICE file
|
||||||
|
distributed with this work for additional information
|
||||||
|
regarding copyright ownership. The ASF licenses this file
|
||||||
|
to you under the Apache License, Version 2.0 (the
|
||||||
|
"License"); you may not use this file except in compliance
|
||||||
|
with the License. You may obtain a copy of the License at
|
||||||
|
|
||||||
|
http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
|
||||||
|
Unless required by applicable law or agreed to in writing,
|
||||||
|
software distributed under the License is distributed on an
|
||||||
|
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||||
|
KIND, either express or implied. See the License for the
|
||||||
|
specific language governing permissions and limitations
|
||||||
|
under the License.
|
||||||
|
-->
|
||||||
|
<html>
|
||||||
|
<body>
|
||||||
|
<p><strong>Graph Abstraction</strong></p>
|
||||||
|
|
||||||
|
<p>
|
||||||
|
This package provides a graph abstraction and graph-related algorithms.
|
||||||
|
</p>
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
|
|
@ -0,0 +1,80 @@
|
||||||
|
/*
|
||||||
|
* Licensed to the Apache Software Foundation (ASF) under one
|
||||||
|
* or more contributor license agreements. See the NOTICE file
|
||||||
|
* distributed with this work for additional information
|
||||||
|
* regarding copyright ownership. The ASF licenses this file
|
||||||
|
* to you under the Apache License, Version 2.0 (the
|
||||||
|
* "License"); you may not use this file except in compliance
|
||||||
|
* with the License. You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing,
|
||||||
|
* software distributed under the License is distributed on an
|
||||||
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||||
|
* KIND, either express or implied. See the License for the
|
||||||
|
* specific language governing permissions and limitations
|
||||||
|
* under the License.
|
||||||
|
*/
|
||||||
|
package org.apache.openjpa.lib.graph;
|
||||||
|
|
||||||
|
import java.util.Collection;
|
||||||
|
import java.util.Iterator;
|
||||||
|
|
||||||
|
import org.apache.openjpa.lib.test.AbstractTestCase;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* <p>Tests the {@link DepthFirstAnalysis} type.</p>
|
||||||
|
*
|
||||||
|
* @author Abe White
|
||||||
|
*/
|
||||||
|
public class TestDepthFirstAnalysis
|
||||||
|
extends AbstractTestCase {
|
||||||
|
|
||||||
|
private DepthFirstAnalysis _dfa = null;
|
||||||
|
|
||||||
|
public void setUp() {
|
||||||
|
Graph graph = new Graph();
|
||||||
|
Object node1 = new Object();
|
||||||
|
Object node2 = new Object();
|
||||||
|
Object node3 = new Object();
|
||||||
|
Object node4 = new Object();
|
||||||
|
graph.addNode(node1);
|
||||||
|
graph.addNode(node2);
|
||||||
|
graph.addNode(node3);
|
||||||
|
graph.addNode(node4);
|
||||||
|
graph.addEdge(new Edge(node1, node2, true));
|
||||||
|
graph.addEdge(new Edge(node2, node3, true));
|
||||||
|
graph.addEdge(new Edge(node3, node1, true));
|
||||||
|
graph.addEdge(new Edge(node3, node4, true));
|
||||||
|
graph.addEdge(new Edge(node2, node2, true));
|
||||||
|
_dfa = new DepthFirstAnalysis(graph);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void testNodeSorting() {
|
||||||
|
Collection nodes = _dfa.getSortedNodes();
|
||||||
|
assertEquals(4, nodes.size());
|
||||||
|
|
||||||
|
int time = Integer.MAX_VALUE;
|
||||||
|
Object node;
|
||||||
|
for (Iterator itr = nodes.iterator(); itr.hasNext();) {
|
||||||
|
node = itr.next();
|
||||||
|
assertTrue(time >= _dfa.getFinishedTime(node));
|
||||||
|
time = _dfa.getFinishedTime(node);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public void testEdgeTyping() {
|
||||||
|
Collection edges = _dfa.getEdges(Edge.TYPE_BACK);
|
||||||
|
assertEquals(2, edges.size());
|
||||||
|
Iterator itr = edges.iterator();
|
||||||
|
Edge edge0 = (Edge) itr.next();
|
||||||
|
Edge edge1 = (Edge) itr.next();
|
||||||
|
assertTrue((edge0.getTo() == edge0.getFrom())
|
||||||
|
|| edge1.getTo() == edge1.getFrom());
|
||||||
|
}
|
||||||
|
|
||||||
|
public static void main(String[] args) {
|
||||||
|
main(TestDepthFirstAnalysis.class);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,148 @@
|
||||||
|
/*
|
||||||
|
* Licensed to the Apache Software Foundation (ASF) under one
|
||||||
|
* or more contributor license agreements. See the NOTICE file
|
||||||
|
* distributed with this work for additional information
|
||||||
|
* regarding copyright ownership. The ASF licenses this file
|
||||||
|
* to you under the Apache License, Version 2.0 (the
|
||||||
|
* "License"); you may not use this file except in compliance
|
||||||
|
* with the License. You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing,
|
||||||
|
* software distributed under the License is distributed on an
|
||||||
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||||
|
* KIND, either express or implied. See the License for the
|
||||||
|
* specific language governing permissions and limitations
|
||||||
|
* under the License.
|
||||||
|
*/
|
||||||
|
package org.apache.openjpa.lib.graph;
|
||||||
|
|
||||||
|
import java.util.Collection;
|
||||||
|
import java.util.Iterator;
|
||||||
|
|
||||||
|
import org.apache.openjpa.lib.test.AbstractTestCase;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* <p>Tests the {@link Graph} type, and in so doing implicitly tests the
|
||||||
|
* {@link Edge} as well.</p>
|
||||||
|
*
|
||||||
|
* @author Abe White
|
||||||
|
*/
|
||||||
|
public class TestGraph
|
||||||
|
extends AbstractTestCase {
|
||||||
|
|
||||||
|
private Graph _graph = new Graph();
|
||||||
|
private Object _node1 = new Object();
|
||||||
|
private Object _node2 = new Object();
|
||||||
|
private Object _node3 = new Object();
|
||||||
|
private Edge _edge1 = new Edge(_node1, _node2, true);
|
||||||
|
private Edge _edge2 = new Edge(_node2, _node3, true);
|
||||||
|
private Edge _edge3 = new Edge(_node1, _node3, false);
|
||||||
|
private Edge _edge4 = new Edge(_node2, _node2, false);
|
||||||
|
|
||||||
|
public void setUp() {
|
||||||
|
_graph.addNode(_node1);
|
||||||
|
_graph.addNode(_node2);
|
||||||
|
_graph.addNode(_node3);
|
||||||
|
_graph.addEdge(_edge1);
|
||||||
|
_graph.addEdge(_edge2);
|
||||||
|
_graph.addEdge(_edge3);
|
||||||
|
_graph.addEdge(_edge4);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Tests adding and retrieving nodes and edges.
|
||||||
|
*/
|
||||||
|
public void testAddRetrieve() {
|
||||||
|
assertEquals(3, _graph.getNodes().size());
|
||||||
|
assertEquals(4, _graph.getEdges().size());
|
||||||
|
|
||||||
|
Collection edges = _graph.getEdgesFrom(_node1);
|
||||||
|
assertEquals(2, edges.size());
|
||||||
|
Iterator itr = edges.iterator();
|
||||||
|
Edge edge0 = (Edge) itr.next();
|
||||||
|
Edge edge1 = (Edge) itr.next();
|
||||||
|
assertTrue((edge0 == _edge1 && edge1 == _edge3)
|
||||||
|
|| (edge0 == _edge3 && edge1 == _edge1));
|
||||||
|
|
||||||
|
edges = _graph.getEdgesTo(_node1);
|
||||||
|
assertEquals(1, edges.size());
|
||||||
|
assertEquals(_edge3, edges.iterator().next());
|
||||||
|
|
||||||
|
edges = _graph.getEdges(_node1, _node3);
|
||||||
|
assertEquals(1, edges.size());
|
||||||
|
assertEquals(_edge3, edges.iterator().next());
|
||||||
|
edges = _graph.getEdges(_node3, _node1);
|
||||||
|
assertEquals(1, edges.size());
|
||||||
|
assertEquals(_edge3, edges.iterator().next());
|
||||||
|
|
||||||
|
edges = _graph.getEdgesFrom(_node2);
|
||||||
|
assertEquals(2, edges.size());
|
||||||
|
itr = edges.iterator();
|
||||||
|
edge0 = (Edge) itr.next();
|
||||||
|
edge1 = (Edge) itr.next();
|
||||||
|
assertTrue((edge0 == _edge2 && edge1 == _edge4)
|
||||||
|
|| (edge0 == _edge4 && edge1 == _edge2));
|
||||||
|
|
||||||
|
edges = _graph.getEdgesTo(_node2);
|
||||||
|
assertEquals(2, edges.size());
|
||||||
|
itr = edges.iterator();
|
||||||
|
edge0 = (Edge) itr.next();
|
||||||
|
edge1 = (Edge) itr.next();
|
||||||
|
assertTrue((edge0 == _edge1 && edge1 == _edge4)
|
||||||
|
|| (edge0 == _edge4 && edge1 == _edge1));
|
||||||
|
|
||||||
|
edges = _graph.getEdges(_node2, _node2);
|
||||||
|
assertEquals(1, edges.size());
|
||||||
|
assertEquals(_edge4, edges.iterator().next());
|
||||||
|
|
||||||
|
edges = _graph.getEdgesFrom(_node3);
|
||||||
|
assertEquals(1, edges.size());
|
||||||
|
assertEquals(_edge3, edges.iterator().next());
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Test removing edges.
|
||||||
|
*/
|
||||||
|
public void testRemoveEdges() {
|
||||||
|
assertTrue(_graph.removeEdge(_edge2));
|
||||||
|
Collection edges = _graph.getEdgesFrom(_node2);
|
||||||
|
assertEquals(1, edges.size());
|
||||||
|
assertEquals(_edge4, edges.iterator().next());
|
||||||
|
|
||||||
|
assertTrue(_graph.removeEdge(_edge3));
|
||||||
|
edges = _graph.getEdgesFrom(_node1);
|
||||||
|
assertEquals(1, edges.size());
|
||||||
|
assertEquals(_edge1, edges.iterator().next());
|
||||||
|
edges = _graph.getEdgesTo(_node1);
|
||||||
|
assertEquals(0, edges.size());
|
||||||
|
edges = _graph.getEdgesTo(_node3);
|
||||||
|
assertEquals(0, edges.size());
|
||||||
|
edges = _graph.getEdgesFrom(_node3);
|
||||||
|
assertEquals(0, edges.size());
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Test removing nodes.
|
||||||
|
*/
|
||||||
|
public void testRemoveNodes() {
|
||||||
|
assertTrue(_graph.removeNode(_node3));
|
||||||
|
Collection edges = _graph.getEdges();
|
||||||
|
assertEquals(2, edges.size());
|
||||||
|
Iterator itr = edges.iterator();
|
||||||
|
Edge edge0 = (Edge) itr.next();
|
||||||
|
Edge edge1 = (Edge) itr.next();
|
||||||
|
assertTrue((edge0 == _edge1 && edge1 == _edge4)
|
||||||
|
|| (edge0 == _edge4 && edge1 == _edge1));
|
||||||
|
edges = _graph.getEdgesFrom(_node1);
|
||||||
|
assertEquals(1, edges.size());
|
||||||
|
assertEquals(_edge1, edges.iterator().next());
|
||||||
|
edges = _graph.getEdgesTo(_node1);
|
||||||
|
assertEquals(0, edges.size());
|
||||||
|
}
|
||||||
|
|
||||||
|
public static void main(String[] args) {
|
||||||
|
main(TestGraph.class);
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue