Author: mes
Date: 2011-08-30 12:59:33 -0700 (Tue, 30 Aug 2011)
New Revision: 26655
Added:
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CySubEdgeImpl.java
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CySubNodeImpl.java
Modified:
core3/impl/trunk/core-task-impl/src/main/java/org/cytoscape/task/internal/creation/AbstractNetworkFromSelectionTask.java
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/ArrayGraph.java
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/ArraySubGraph.java
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyEdgeImpl.java
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyNodeImpl.java
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyTableEntryImpl.java
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyTableImpl.java
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyTableManagerImpl.java
Log:
fixes #278 #308 SubNetworks now contains separate CyNode objects along with
their own CyTables.
Modified:
core3/impl/trunk/core-task-impl/src/main/java/org/cytoscape/task/internal/creation/AbstractNetworkFromSelectionTask.java
===================================================================
---
core3/impl/trunk/core-task-impl/src/main/java/org/cytoscape/task/internal/creation/AbstractNetworkFromSelectionTask.java
2011-08-30 19:24:24 UTC (rev 26654)
+++
core3/impl/trunk/core-task-impl/src/main/java/org/cytoscape/task/internal/creation/AbstractNetworkFromSelectionTask.java
2011-08-30 19:59:33 UTC (rev 26655)
@@ -135,7 +135,7 @@
// copy node location only.
for (View<CyNode> newNodeView : newView.getNodeViews()) {
- View<CyNode> origNodeView =
curView.getNodeView(newNodeView.getModel());
+ View<CyNode> origNodeView =
curView.getNodeView(parentNetwork.getNode(newNodeView.getModel().getIndex()));
newNodeView.setVisualProperty(MinimalVisualLexicon.NODE_X_LOCATION,
origNodeView.getVisualProperty(MinimalVisualLexicon.NODE_X_LOCATION));
newNodeView.setVisualProperty(MinimalVisualLexicon.NODE_Y_LOCATION,
Modified:
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/ArrayGraph.java
===================================================================
---
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/ArrayGraph.java
2011-08-30 19:24:24 UTC (rev 26654)
+++
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/ArrayGraph.java
2011-08-30 19:59:33 UTC (rev 26655)
@@ -81,15 +81,18 @@
private NodePointer firstNode;
private final List<NodePointer> nodePointers;
private final List<EdgePointer> edgePointers;
- private final Map<String, CyTable> netAttrMgr;
- private final Map<String, CyTable> nodeAttrMgr;
- private final Map<String, CyTable> edgeAttrMgr;
+ private final Map<String,CyTable> netTables;
+ private final Map<String,CyTable> nodeTables;
+ private final Map<String,CyTable> edgeTables;
private final CyEventHelper eventHelper;
private final List<CySubNetwork> subNetworks;
private final CySubNetwork base;
private final CyTableManagerImpl tableMgr;
+ private final CyTableFactory tableFactory;
private final CyServiceRegistrar serviceRegistrar;
+ private final boolean publicTables;
+
/**
* Creates a new ArrayGraph object.
* @param eh The CyEventHelper used for firing events.
@@ -99,6 +102,8 @@
final CyServiceRegistrar serviceRegistrar, final
boolean publicTables)
{
this.tableMgr = tableMgr;
+ this.tableFactory = tableFactory;
+ this.publicTables = publicTables;
this.serviceRegistrar = serviceRegistrar;
suid = SUIDFactory.getNextSUID();
numSubNetworks = 0;
@@ -108,67 +113,79 @@
nodePointers = new ArrayList<NodePointer>();
edgePointers = new ArrayList<EdgePointer>();
- netAttrMgr = new HashMap<String, CyTable>();
- netAttrMgr.put(CyNetwork.DEFAULT_ATTRS,
- tableFactory.createTable(suid + " network",
Identifiable.SUID, Long.class,
- publicTables, false));
- netAttrMgr.put(CyNetwork.HIDDEN_ATTRS,
- tableFactory.createTable(suid + " network",
Identifiable.SUID, Long.class, false,
- false));
-
-
netAttrMgr.get(CyNetwork.DEFAULT_ATTRS).createColumn(CyTableEntry.NAME,
String.class,
- true);
+ netTables = createNetworkTables(suid);
getCyRow().set(CyTableEntry.NAME, "");
- // potential leak since "this" isn't yet fully constructed
- nodeAttrMgr = new HashMap<String, CyTable>();
- nodeAttrMgr.put(CyNetwork.DEFAULT_ATTRS,
- tableFactory.createTable(suid + " node",
Identifiable.SUID, Long.class,
- publicTables, false));
- nodeAttrMgr.put(CyNetwork.HIDDEN_ATTRS,
- tableFactory.createTable(suid + " node",
Identifiable.SUID, Long.class,
- false, false));
+ nodeTables = createNodeTables(suid);
+ edgeTables = createEdgeTables(suid);
-
nodeAttrMgr.get(CyNetwork.DEFAULT_ATTRS).createColumn(CyTableEntry.NAME,
-
String.class, true);
-
nodeAttrMgr.get(CyNetwork.DEFAULT_ATTRS).createColumn(CyNetwork.SELECTED,
-
Boolean.class, true);
+ tableMgr.setTableMap(CyNetwork.class, this, netTables);
+ tableMgr.setTableMap(CyNode.class, this, nodeTables);
+ tableMgr.setTableMap(CyEdge.class, this, edgeTables);
- edgeAttrMgr = new HashMap<String, CyTable>();
- edgeAttrMgr.put(CyNetwork.DEFAULT_ATTRS,
- tableFactory.createTable(suid + " edge",
Identifiable.SUID, Long.class,
- publicTables, false));
- edgeAttrMgr.put(CyNetwork.HIDDEN_ATTRS,
- tableFactory.createTable(suid + " edge",
Identifiable.SUID, Long.class,
- false, false));
-
-
edgeAttrMgr.get(CyNetwork.DEFAULT_ATTRS).createColumn(CyTableEntry.NAME,
-
String.class, true);
-
edgeAttrMgr.get(CyNetwork.DEFAULT_ATTRS).createColumn(CyNetwork.SELECTED,
-
Boolean.class, true);
-
edgeAttrMgr.get(CyNetwork.DEFAULT_ATTRS).createColumn(CyEdge.INTERACTION,
-
String.class, true);
eventHelper = eh;
subNetworks = new ArrayList<CySubNetwork>();
base = addSubNetwork();
+ }
- tableMgr.setTableMap(CyNetwork.class, base, netAttrMgr);
- tableMgr.setTableMap(CyNode.class, base, nodeAttrMgr);
- tableMgr.setTableMap(CyEdge.class, base, edgeAttrMgr);
+ private void registerAllTables() {
+ for (final CyTable table : netTables.values())
+ tableMgr.addTable(table);
+ for (final CyTable table : nodeTables.values())
+ tableMgr.addTable(table);
+ for (final CyTable table : edgeTables.values())
+ tableMgr.addTable(table);
}
- /** Registers the network, node, and edge tables with the table
mananger. */
- void registerAllTables() {
- for (final CyTable table : netAttrMgr.values())
- tableMgr.addTable(table);
- for (final CyTable table : nodeAttrMgr.values())
- tableMgr.addTable(table);
- for (final CyTable table : edgeAttrMgr.values())
- tableMgr.addTable(table);
+ private Map<String,CyTable> createNetworkTables(long suidx) {
+ Map<String,CyTable> netAttrMgr = new HashMap<String, CyTable>();
+ netAttrMgr.put(CyNetwork.DEFAULT_ATTRS, tableFactory.createTable(suidx
+ " network", Identifiable.SUID, Long.class, publicTables, false));
+ netAttrMgr.put(CyNetwork.HIDDEN_ATTRS, tableFactory.createTable(suidx
+ " network", Identifiable.SUID, Long.class, false, false));
+
+
netAttrMgr.get(CyNetwork.DEFAULT_ATTRS).createColumn(CyTableEntry.NAME,
String.class, true);
+ //getCyRow().set(CyTableEntry.NAME, "");
+ return netAttrMgr;
}
+ private Map<String,CyTable> createNodeTables(long suidx) {
+ Map<String,CyTable> nodeAttrMgr = new HashMap<String, CyTable>();
+ nodeAttrMgr.put(CyNetwork.DEFAULT_ATTRS,
+ tableFactory.createTable(suidx + " node", Identifiable.SUID,
Long.class,
+ publicTables, false));
+ nodeAttrMgr.put(CyNetwork.HIDDEN_ATTRS,
+ tableFactory.createTable(suidx + " node", Identifiable.SUID,
Long.class,
+ false, false));
+
+
nodeAttrMgr.get(CyNetwork.DEFAULT_ATTRS).createColumn(CyTableEntry.NAME,
+ String.class, true);
+
nodeAttrMgr.get(CyNetwork.DEFAULT_ATTRS).createColumn(CyNetwork.SELECTED,
+ Boolean.class, true);
+
+ return nodeAttrMgr;
+
+ }
+
+ private Map<String,CyTable> createEdgeTables(long suidx) {
+ Map<String,CyTable> edgeAttrMgr = new HashMap<String, CyTable>();
+ edgeAttrMgr.put(CyNetwork.DEFAULT_ATTRS,
+ tableFactory.createTable(suidx + " edge", Identifiable.SUID,
Long.class,
+ publicTables, false));
+ edgeAttrMgr.put(CyNetwork.HIDDEN_ATTRS,
+ tableFactory.createTable(suidx + " edge", Identifiable.SUID,
Long.class,
+ false, false));
+
+
edgeAttrMgr.get(CyNetwork.DEFAULT_ATTRS).createColumn(CyTableEntry.NAME,
+ String.class, true);
+
edgeAttrMgr.get(CyNetwork.DEFAULT_ATTRS).createColumn(CyNetwork.SELECTED,
+ Boolean.class, true);
+
edgeAttrMgr.get(CyNetwork.DEFAULT_ATTRS).createColumn(CyEdge.INTERACTION,
+ String.class, true);
+
+ return edgeAttrMgr;
+ }
+
/**
* {@inheritDoc}
*/
@@ -287,6 +304,7 @@
synchronized List<CyNode> getNeighborList(final CyNode n, final
CyEdge.Type e, final int inId) {
if (!containsNode(n)) {
+ //System.out.println("network doesn't contain node, so
no neighbors: " + n);
return new ArrayList<CyNode>();
//TODO log.warning("this node is not contained in the
network");
}
@@ -312,9 +330,11 @@
synchronized List<CyEdge> getAdjacentEdgeList(final CyNode n, final
CyEdge.Type e, final int inId) {
if (!containsNode(n)) {
+ //System.out.println("doesn't contain node: " + n);
return new ArrayList<CyEdge>();
// TODO log.warning("this node is not contained in the
network");
}
+ //System.out.println("getting adjacent edge list for node: " +
n);
final NodePointer np = getNodePointer(n);
final List<CyEdge> ret = new ArrayList<CyEdge>(countEdges(np,
e, inId));
@@ -367,19 +387,21 @@
return nodeAdd();
}
- CyNode nodeAdd() {
+ CyNodeImpl nodeAdd() {
final NodePointer n;
+ final CyNodeImpl rootNode;
synchronized (this) {
final int index = nodePointers.size();
- n = new NodePointer(index, new CyNodeImpl(index,
nodeAttrMgr, eventHelper));
+ rootNode = new CyNodeImpl(index, nodeTables,
eventHelper);
+ n = new NodePointer(index, rootNode);
nodePointers.add(n);
nodeCount++;
// In ArrayGraph we only ever add the node to the root.
firstNode = n.insert(firstNode,ROOT);
}
- return n.cyNode;
+ return rootNode;
}
/**
@@ -423,23 +445,29 @@
}
// Will be called from ArraySubGraph.
- CyEdge edgeAdd(final CyNode s, final CyNode t, final boolean directed,
final CyNetwork net) {
+ CyEdgeImpl edgeAdd(final CyNode s, final CyNode t, final boolean
directed, final CyNetwork net) {
final EdgePointer e;
+ final CyEdgeImpl rootEdge;
+ final CyNode rootS = getRootNode(s);
+ final CyNode rootT = getRootNode(t);
+
synchronized (this) {
+ // here we check with possible sub node, not just root
node
if (!net.containsNode(s))
throw new IllegalArgumentException("source node
is not a member of this network");
+ // here we check with possible sub node, not just root
node
if (!net.containsNode(t))
throw new IllegalArgumentException("target node
is not a member of this network");
- final NodePointer source = getNodePointer(s);
- final NodePointer target = getNodePointer(t);
+ final NodePointer source = getNodePointer(rootS);
+ final NodePointer target = getNodePointer(rootT);
final int index = edgePointers.size();
- e = new EdgePointer(source, target, directed, index,
- new CyEdgeImpl(s, t, directed,
index, edgeAttrMgr));
+ rootEdge = new CyEdgeImpl(rootS, rootT, directed,
index, edgeTables);
+ e = new EdgePointer(source, target, directed, index,
rootEdge);
// adds to the root network, adding to the subnetwork
is handled in ArraySubGraph
e.insert(ROOT);
@@ -449,9 +477,26 @@
edgeCount++;
}
- return e.cyEdge;
+ //System.out.println("adding edge: " + rootEdge);
+
+ return rootEdge;
}
+ private CyNode getRootNode(CyNode node) {
+ if ( node instanceof CySubNodeImpl )
+ return ((CySubNodeImpl)node).getRootNode();
+ else
+ return node;
+ }
+
+ private CyEdge getRootEdge(CyEdge edge) {
+ if ( edge instanceof CySubEdgeImpl )
+ return ((CySubEdgeImpl)edge).getRootEdge();
+ else
+ return edge;
+ }
+
+
/**
* {@inheritDoc}
*/
@@ -488,13 +533,11 @@
public boolean containsNode(final CyNode node) {
if (node == null)
return false;
- //throw new NullPointerException("node is null");
final int ind = node.getIndex();
if (ind < 0)
return false;
- //throw new IllegalArgumentException("node index less
than zero");
final NodePointer thisNode;
@@ -508,7 +551,9 @@
if ( thisNode == null )
return false;
- return thisNode.cyNode.equals(node);
+ final CyNode rootNode = getRootNode(node);
+
+ return thisNode.cyNode.equals(rootNode);
}
/**
@@ -534,7 +579,9 @@
if ( thisEdge == null )
return false;
- return thisEdge.cyEdge.equals(edge);
+ final CyEdge rootEdge = getRootEdge(edge);
+
+ return thisEdge.cyEdge.equals(rootEdge);
}
/**
@@ -566,31 +613,28 @@
/**
* {@inheritDoc}
*/
- public CyRow getCyRow(final String namespace) {
- if (namespace == null)
- throw new NullPointerException("namespace is null");
+ public synchronized CyRow getCyRow() {
+ return getCyRow(CyNetwork.DEFAULT_ATTRS);
+ }
- final CyRow ret;
- final CyTable mgr;
-
- synchronized (this) {
- mgr = netAttrMgr.get(namespace);
+ public CyRow getCyRow(final String namespace) {
+ if (namespace == null)
+ throw new NullPointerException("namespace is null");
- if (mgr == null)
- throw new NullPointerException("attribute
manager is null for namespace: " + namespace);
+ final CyRow ret;
+ final CyTable mgr;
+
+ synchronized (this) {
+ mgr = netTables.get(namespace);
- ret = mgr.getRow(suid);
- }
+ if (mgr == null)
+ throw new NullPointerException("attribute manager is null for
namespace: " + namespace);
- return ret;
- }
+ ret = mgr.getRow(suid);
+ }
- /**
- * {@inheritDoc}
- */
- public CyRow getCyRow() {
- return getCyRow(CyNetwork.DEFAULT_ATTRS);
- }
+ return ret;
+ }
private Iterator<EdgePointer> edgesAdjacent(final NodePointer n, final
CyEdge.Type edgeType, final int inId) {
assert(n!=null);
@@ -866,12 +910,16 @@
*/
public synchronized CySubNetwork addSubNetwork() {
final int newId = ++numSubNetworks;
- final ArraySubGraph sub = new
ArraySubGraph(this,newId,eventHelper);
+ final long newSUID = SUIDFactory.getNextSUID();
+ final Map<String,CyTable> newNetTable =
createNetworkTables(newSUID);
+ final Map<String,CyTable> newNodeTable =
createNodeTables(newSUID);
+ final Map<String,CyTable> newEdgeTable =
createEdgeTables(newSUID);
+ final ArraySubGraph sub = new
ArraySubGraph(this,newSUID,newId,eventHelper,newNetTable,newNodeTable,newEdgeTable,tableMgr);
serviceRegistrar.registerAllServices(sub, new Properties());
subNetworks.add(sub);
- tableMgr.setTableMap(CyNetwork.class, sub, netAttrMgr);
- tableMgr.setTableMap(CyNode.class, sub, nodeAttrMgr);
- tableMgr.setTableMap(CyEdge.class, sub, edgeAttrMgr);
+ tableMgr.setTableMap(CyNetwork.class, sub, newNetTable);
+ tableMgr.setTableMap(CyNode.class, sub, newNodeTable);
+ tableMgr.setTableMap(CyEdge.class, sub, newEdgeTable);
return sub;
}
@@ -914,21 +962,21 @@
* {@inheritDoc}
*/
public CyTable getDefaultNetworkTable() {
- return netAttrMgr.get(CyNetwork.DEFAULT_ATTRS);
+ return netTables.get(CyNetwork.DEFAULT_ATTRS);
}
/**
* {@inheritDoc}
*/
public CyTable getDefaultNodeTable() {
- return nodeAttrMgr.get(CyNetwork.DEFAULT_ATTRS);
+ return nodeTables.get(CyNetwork.DEFAULT_ATTRS);
}
/**
* {@inheritDoc}
*/
public CyTable getDefaultEdgeTable() {
- return edgeAttrMgr.get(CyNetwork.DEFAULT_ATTRS);
+ return edgeTables.get(CyNetwork.DEFAULT_ATTRS);
}
/**
@@ -937,4 +985,8 @@
public synchronized boolean containsNetwork(final CyNetwork net) {
return subNetworks.contains(net);
}
+
+ public String toString() {
+ return "CyNetwork: " + suid + " name: " +
getCyRow().get("name", String.class);
+ }
}
Modified:
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/ArraySubGraph.java
===================================================================
---
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/ArraySubGraph.java
2011-08-30 19:24:24 UTC (rev 26654)
+++
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/ArraySubGraph.java
2011-08-30 19:59:33 UTC (rev 26655)
@@ -37,6 +37,7 @@
import org.cytoscape.model.CyNode;
import org.cytoscape.model.CyRow;
import org.cytoscape.model.SUIDFactory;
+import org.cytoscape.model.CyTableManager;
import org.cytoscape.model.events.AddedNodesEvent;
import org.cytoscape.model.events.AddedEdgesEvent;
import org.cytoscape.model.events.AboutToRemoveNodesEvent;
@@ -49,10 +50,10 @@
import org.cytoscape.model.subnetwork.CyRootNetwork;
import java.util.Collection;
-import java.util.HashSet;
+import java.util.HashMap;
import java.util.List;
+import java.util.ArrayList;
import java.util.Map;
-import java.util.Set;
/**
@@ -67,21 +68,30 @@
private int internalNodeCount;
private int internalEdgeCount;
private NodePointer inFirstNode;
- private Set<CyNode> nodeSet;
- private Set<CyEdge> edgeSet;
+ private Map<CyNode,CyNode> subNodeMap;
+ private Map<CyEdge,CyEdge> subEdgeMap;
private boolean fireAddedNodesAndEdgesEvents;
- ArraySubGraph(final ArrayGraph par, final int inId, final CyEventHelper
eventHelper) {
+ private final Map<String,CyTable> netTables;
+ private final Map<String,CyTable> nodeTables;
+ private final Map<String,CyTable> edgeTables;
+ private final CyTableManager tableMgr;
+
+ ArraySubGraph(final ArrayGraph par, final long inSUID, final int inId,
final CyEventHelper eventHelper, final Map<String,CyTable> netTables, final
Map<String,CyTable> nodeTables, final Map<String,CyTable> edgeTables,
CyTableManager tableMgr) {
assert(par != null);
parent = par;
internalId = inId;
this.eventHelper = DIUtil.stripProxy(eventHelper);
- internalSUID = SUIDFactory.getNextSUID();
+ internalSUID = inSUID;
+ this.netTables = netTables;
+ this.nodeTables = nodeTables;
+ this.edgeTables = edgeTables;
+ this.tableMgr = tableMgr;
+
+ subNodeMap = new HashMap<CyNode,CyNode>(20000);
+ subEdgeMap = new HashMap<CyEdge,CyEdge>(20000);
- nodeSet = new HashSet<CyNode>(20000);
- edgeSet = new HashSet<CyEdge>(20000);
-
internalNodeCount = 0;
internalEdgeCount = 0;
fireAddedNodesAndEdgesEvents = false;
@@ -127,10 +137,11 @@
public CyNode addNode() {
final CyNode ret;
synchronized (this) {
- ret = parent.nodeAdd();
- updateNode(ret);
+ CyNodeImpl rootNode = parent.nodeAdd();
+ updateNode(rootNode);
internalNodeCount++;
- nodeSet.add(ret);
+ ret = new CySubNodeImpl(rootNode,nodeTables);
+ subNodeMap.put(rootNode,ret);
}
if (fireAddedNodesAndEdgesEvents)
@@ -145,11 +156,13 @@
public CyEdge addEdge(final CyNode source, final CyNode target, final
boolean isDirected) {
// important that it's edgeAdd and not addEdge
final CyEdge ret;
+
synchronized (this) {
- ret = parent.edgeAdd(source, target, isDirected, this);
- updateEdge(ret);
+ CyEdgeImpl rootEdge = parent.edgeAdd(source, target,
isDirected, this);
+ updateEdge(rootEdge);
internalEdgeCount++;
- edgeSet.add(ret);
+ ret = new CySubEdgeImpl(rootEdge,edgeTables,subNodeMap);
+ subEdgeMap.put(rootEdge,ret);
}
if (fireAddedNodesAndEdgesEvents)
@@ -158,7 +171,39 @@
return ret;
}
+ private CyNode getRootNode(CyNode node) {
+ if ( node instanceof CySubNodeImpl )
+ return ((CySubNodeImpl)node).getRootNode();
+ else
+ return node;
+ }
+ private CyNodeImpl getRootNodeImpl(CyNode node) {
+ if ( node instanceof CySubNodeImpl )
+ return
(CyNodeImpl)(((CySubNodeImpl)node).getRootNode());
+ else if ( node instanceof CyNodeImpl )
+ return (CyNodeImpl)node;
+ else
+ throw new IllegalArgumentException("unrecognized node
type");
+ }
+
+ private CyEdge getRootEdge(CyEdge edge) {
+ if ( edge instanceof CySubEdgeImpl )
+ return ((CySubEdgeImpl)edge).getRootEdge();
+ else
+ return edge;
+ }
+
+ private CyEdgeImpl getRootEdgeImpl(CyEdge edge) {
+ if ( edge instanceof CySubEdgeImpl )
+ return
(CyEdgeImpl)(((CySubEdgeImpl)edge).getRootEdge());
+ else if ( edge instanceof CyEdgeImpl )
+ return (CyEdgeImpl)edge;
+ else
+ throw new IllegalArgumentException("unrecognized edge
type");
+ }
+
+
/**
* {@inheritDoc}
*/
@@ -177,35 +222,54 @@
* {@inheritDoc}
*/
public synchronized List<CyNode> getNodeList() {
- return parent.getNodeList(inFirstNode, internalId,
internalNodeCount);
+ return convertToSubNodes( parent.getNodeList(inFirstNode,
internalId, internalNodeCount) );
}
+ private List<CyNode> convertToSubNodes(List<CyNode> rootNodes) {
+ List<CyNode> subNodes = new ArrayList<CyNode>(rootNodes.size());
+ for ( CyNode root : rootNodes )
+ subNodes.add( subNodeMap.get(root) );
+ return subNodes;
+ }
+
+
/**
* {@inheritDoc}
*/
public synchronized List<CyEdge> getEdgeList() {
- return parent.getEdgeList(inFirstNode, internalId,
internalEdgeCount);
+ return convertToSubEdges( parent.getEdgeList(inFirstNode,
internalId, internalEdgeCount) );
}
+ private List<CyEdge> convertToSubEdges(List<CyEdge> rootEdges) {
+ List<CyEdge> subEdges = new ArrayList<CyEdge>(rootEdges.size());
+ for ( CyEdge root : rootEdges )
+ subEdges.add( subEdgeMap.get(root) );
+ return subEdges;
+ }
+
/**
* {@inheritDoc}
*/
public boolean containsNode(final CyNode node) {
- return parent.containsNode(node) && nodeSet.contains(node);
+ final CyNode rootNode = getRootNode(node);
+ return parent.containsNode(rootNode) &&
subNodeMap.containsKey(rootNode);
}
/**
* {@inheritDoc}
*/
public boolean containsEdge(final CyEdge edge) {
- return parent.containsEdge(edge) && edgeSet.contains(edge);
+ final CyEdge rootEdge = getRootEdge(edge);
+ return parent.containsEdge(rootEdge) &&
subEdgeMap.containsKey(rootEdge);
}
/**
* {@inheritDoc}
*/
public boolean containsEdge(final CyNode from, final CyNode to) {
- return containsNode(from) && containsNode(to) &&
parent.containsEdge(from, to, internalId);
+ final CyNode rootFrom = getRootNode(from);
+ final CyNode rootTo = getRootNode(to);
+ return containsNode(rootFrom) && containsNode(rootTo) &&
parent.containsEdge(rootFrom, rootTo, internalId);
}
/**
@@ -218,10 +282,7 @@
return null;
// make sure the subnetwork still contains the node
- if ( nodeSet.contains(n) )
- return n;
- else
- return null;
+ return subNodeMap.get(n);
}
/**
@@ -234,24 +295,21 @@
return null;
// make sure the subnetwork still contains the edge
- if ( edgeSet.contains(e) )
- return e;
- else
- return null;
+ return subEdgeMap.get(e);
}
/**
* {@inheritDoc}
*/
public List<CyNode> getNeighborList(final CyNode node, final
CyEdge.Type edgeType) {
- return parent.getNeighborList(node, edgeType, internalId);
+ return convertToSubNodes(
parent.getNeighborList(getRootNode(node), edgeType, internalId) );
}
/**
* {@inheritDoc}
*/
public List<CyEdge> getAdjacentEdgeList(final CyNode node, final
CyEdge.Type edgeType) {
- return parent.getAdjacentEdgeList(node, edgeType, internalId);
+ return convertToSubEdges(
parent.getAdjacentEdgeList(getRootNode(node), edgeType, internalId) );
}
/**
@@ -259,23 +317,20 @@
*/
public List<CyEdge> getConnectingEdgeList(final CyNode source, final
CyNode target,
final CyEdge.Type edgeType) {
- return parent.getConnectingEdgeList(source, target, edgeType,
internalId);
+ return convertToSubEdges(
parent.getConnectingEdgeList(getRootNode(source), getRootNode(target),
edgeType, internalId) );
}
/**
* {@inheritDoc}
*/
- public CyRow getCyRow(final String namespace) {
- return parent.getCyRow(namespace);
- }
-
- /**
- * {@inheritDoc}
- */
public CyRow getCyRow() {
- return parent.getCyRow();
+ return getCyRow(CyNetwork.DEFAULT_ATTRS);
}
+ public CyRow getCyRow(final String namespace) {
+ return netTables.get(namespace).getRow(internalSUID);
+ }
+
/**
* {@inheritDoc}
*/
@@ -283,6 +338,7 @@
if (node == null)
throw new NullPointerException("node is null");
+ final CyNode subNode;
synchronized (this) {
if (containsNode(node))
return false;
@@ -292,10 +348,13 @@
// add node
internalNodeCount++;
- nodeSet.add(node);
- updateNode(node);
+ final CyNodeImpl rootNode = getRootNodeImpl(node);
+ subNode = new CySubNodeImpl(rootNode,nodeTables);
+
+ subNodeMap.put(rootNode,subNode);
+ updateNode(rootNode);
}
- eventHelper.addEventPayload((CyNetwork)this, node,
AddedNodesEvent.class);
+ eventHelper.addEventPayload((CyNetwork)this, subNode,
AddedNodesEvent.class);
return true;
}
@@ -304,6 +363,7 @@
if (edge == null)
throw new NullPointerException("edge is null");
+ final CyEdge subEdge;
synchronized (this) {
if (containsEdge(edge))
return false;
@@ -319,11 +379,13 @@
addNode(edge.getTarget());
// add edge
+ final CyEdgeImpl rootEdge = getRootEdgeImpl(edge);
+ subEdge = new
CySubEdgeImpl(rootEdge,edgeTables,subNodeMap);
internalEdgeCount++;
- edgeSet.add(edge);
- updateEdge(edge);
+ subEdgeMap.put(rootEdge,subEdge);
+ updateEdge(rootEdge);
}
- eventHelper.addEventPayload((CyNetwork)this, edge,
AddedEdgesEvent.class);
+ eventHelper.addEventPayload((CyNetwork)this, subEdge,
AddedEdgesEvent.class);
return true;
}
@@ -342,18 +404,21 @@
synchronized (this) {
for (CyNode n : nodes) {
-
+ //System.out.println("removing node: " + n);
+
if (!containsNode(n))
return false;
// remove adjacent edges
removeEdgesInternal(getAdjacentEdgeList(n,
CyEdge.Type.ANY));
+
+ final CyNode rootNode = getRootNode(n);
- final NodePointer node =
parent.getNodePointer(n);
+ final NodePointer node =
parent.getNodePointer(rootNode);
inFirstNode =
node.remove(inFirstNode,internalId);
internalNodeCount--;
- nodeSet.remove(n);
+ subNodeMap.remove(rootNode);
}
}
@@ -386,28 +451,42 @@
// should be called from within a synchronized block
private boolean removeEdgesInternal(Collection<CyEdge> edges) {
+ //System.out.println("removeEdgesInternal edges size: " +
edges.size());
for (CyEdge edge : edges) {
- if (!containsEdge(edge))
+ if (!containsEdge(edge)) {
+ //System.out.println("doesn't contain edge: " +
edge);
return false;
+ }
- final EdgePointer e = parent.getEdgePointer(edge);
-
+ CyEdge rootEdge = getRootEdge(edge);
+ final EdgePointer e = parent.getEdgePointer(rootEdge);
+
e.remove(internalId);
internalEdgeCount--;
- edgeSet.remove(edge);
+ subEdgeMap.remove(rootEdge);
}
+ //System.out.println("theoretically removed appropriate edges");
return true;
}
@Override
public void handleEvent(final NetworkAddedEvent e) {
if (e.getNetwork() == this) {
- parent.registerAllTables();
+ registerAllTables();
fireAddedNodesAndEdgesEvents = true;
}
}
+ private void registerAllTables() {
+ for (final CyTable table : netTables.values())
+ tableMgr.addTable(table);
+ for (final CyTable table : nodeTables.values())
+ tableMgr.addTable(table);
+ for (final CyTable table : edgeTables.values())
+ tableMgr.addTable(table);
+ }
+
/**
* Tests object for equality with this object.
* @param o The object to test for equality.
@@ -433,14 +512,18 @@
}
public CyTable getDefaultNetworkTable() {
- return parent.getDefaultNetworkTable();
+ return netTables.get(CyNetwork.DEFAULT_ATTRS);
}
public CyTable getDefaultNodeTable() {
- return parent.getDefaultNodeTable();
+ return nodeTables.get(CyNetwork.DEFAULT_ATTRS);
}
public CyTable getDefaultEdgeTable() {
- return parent.getDefaultEdgeTable();
+ return edgeTables.get(CyNetwork.DEFAULT_ATTRS);
}
+
+ public String toString() {
+ return "CyNetwork: " + internalSUID + " name: " +
getCyRow().get("name", String.class);
+ }
}
Modified:
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyEdgeImpl.java
===================================================================
---
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyEdgeImpl.java
2011-08-30 19:24:24 UTC (rev 26654)
+++
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyEdgeImpl.java
2011-08-30 19:59:33 UTC (rev 26655)
@@ -49,8 +49,8 @@
final private int index;
final private boolean directed;
- CyEdgeImpl(CyNode src, CyNode tgt, boolean dir, int ind, Map<String,
CyTable> attrMgr) {
- super(attrMgr);
+ CyEdgeImpl(CyNode src, CyNode tgt, boolean dir, int ind, final
Map<String,CyTable> table) {
+ super(table);
source = src;
target = tgt;
directed = dir;
Modified:
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyNodeImpl.java
===================================================================
---
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyNodeImpl.java
2011-08-30 19:24:24 UTC (rev 26654)
+++
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyNodeImpl.java
2011-08-30 19:59:33 UTC (rev 26655)
@@ -46,8 +46,8 @@
private CyNetwork nestedNet;
final private CyEventHelper eventHelper;
- CyNodeImpl(int ind, Map<String, CyTable> attrMgr, final CyEventHelper
eventHelper) {
- super(attrMgr);
+ CyNodeImpl(int ind, final Map<String,CyTable> table, final
CyEventHelper eventHelper) {
+ super(table);
index = ind;
nestedNet = null;
this.eventHelper = eventHelper;
Added:
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CySubEdgeImpl.java
===================================================================
---
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CySubEdgeImpl.java
(rev 0)
+++
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CySubEdgeImpl.java
2011-08-30 19:59:33 UTC (rev 26655)
@@ -0,0 +1,78 @@
+/*
+ Copyright (c) 2008, 2010, The Cytoscape Consortium (www.cytoscape.org)
+
+ This library is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ any later version.
+
+ This library is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF
+ MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. The software and
+ documentation provided hereunder is on an "as is" basis, and the
+ Institute for Systems Biology and the Whitehead Institute
+ have no obligations to provide maintenance, support,
+ updates, enhancements or modifications. In no event shall the
+ Institute for Systems Biology and the Whitehead Institute
+ be liable to any party for direct, indirect, special,
+ incidental or consequential damages, including lost profits, arising
+ out of the use of this software and its documentation, even if the
+ Institute for Systems Biology and the Whitehead Institute
+ have been advised of the possibility of such damage. See
+ the GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this library; if not, write to the Free Software Foundation,
+ Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+*/
+package org.cytoscape.model.internal;
+
+
+import org.cytoscape.event.CyEventHelper;
+import org.cytoscape.model.CyEdge;
+import org.cytoscape.model.CyNetwork;
+import org.cytoscape.model.CyNode;
+import org.cytoscape.model.CyRow;
+import org.cytoscape.model.CyTable;
+import org.cytoscape.model.events.SetNestedNetworkEvent;
+import org.cytoscape.model.events.UnsetNestedNetworkEvent;
+
+import java.util.List;
+import java.util.Map;
+
+
+class CySubEdgeImpl extends CyTableEntryImpl implements CyEdge {
+
+ private final CyEdgeImpl rootEdge;
+ private final Map<CyNode,CyNode> subNodeMap;
+
+ CySubEdgeImpl(CyEdgeImpl rootEdge, Map<String,CyTable> edgeTable,
Map<CyNode,CyNode> subNodeMap) {
+ super(edgeTable, rootEdge.getSUID());
+ this.rootEdge = rootEdge;
+ this.subNodeMap = subNodeMap;
+ }
+
+ public int getIndex() {
+ return rootEdge.getIndex();
+ }
+
+ public String toString() {
+ return rootEdge.toString();
+ }
+
+ public CyNode getSource() {
+ return subNodeMap.get(rootEdge.getSource());
+ }
+
+ public CyNode getTarget() {
+ return subNodeMap.get(rootEdge.getTarget());
+ }
+
+ public boolean isDirected() {
+ return rootEdge.isDirected();
+ }
+
+ public CyEdge getRootEdge() {
+ return rootEdge;
+ }
+}
Added:
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CySubNodeImpl.java
===================================================================
---
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CySubNodeImpl.java
(rev 0)
+++
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CySubNodeImpl.java
2011-08-30 19:59:33 UTC (rev 26655)
@@ -0,0 +1,72 @@
+/*
+ Copyright (c) 2008, 2010, The Cytoscape Consortium (www.cytoscape.org)
+
+ This library is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ any later version.
+
+ This library is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF
+ MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. The software and
+ documentation provided hereunder is on an "as is" basis, and the
+ Institute for Systems Biology and the Whitehead Institute
+ have no obligations to provide maintenance, support,
+ updates, enhancements or modifications. In no event shall the
+ Institute for Systems Biology and the Whitehead Institute
+ be liable to any party for direct, indirect, special,
+ incidental or consequential damages, including lost profits, arising
+ out of the use of this software and its documentation, even if the
+ Institute for Systems Biology and the Whitehead Institute
+ have been advised of the possibility of such damage. See
+ the GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this library; if not, write to the Free Software Foundation,
+ Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+*/
+package org.cytoscape.model.internal;
+
+
+import org.cytoscape.event.CyEventHelper;
+import org.cytoscape.model.CyEdge;
+import org.cytoscape.model.CyNetwork;
+import org.cytoscape.model.CyNode;
+import org.cytoscape.model.CyRow;
+import org.cytoscape.model.CyTable;
+import org.cytoscape.model.events.SetNestedNetworkEvent;
+import org.cytoscape.model.events.UnsetNestedNetworkEvent;
+
+import java.util.List;
+import java.util.Map;
+
+
+class CySubNodeImpl extends CyTableEntryImpl implements CyNode {
+
+ private final CyNodeImpl rootNode;
+
+ CySubNodeImpl(CyNodeImpl rootNode, Map<String,CyTable> nodeTable) {
+ super(nodeTable, rootNode.getSUID());
+ this.rootNode = rootNode;
+ }
+
+ public int getIndex() {
+ return rootNode.getIndex();
+ }
+
+ public String toString() {
+ return "SUBNODE of : " + rootNode.toString();
+ }
+
+ public CyNetwork getNetwork() {
+ return rootNode.getNetwork();
+ }
+
+ public void setNetwork(final CyNetwork n) {
+ rootNode.setNetwork(n);
+ }
+
+ public CyNode getRootNode() {
+ return rootNode;
+ }
+}
Modified:
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyTableEntryImpl.java
===================================================================
---
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyTableEntryImpl.java
2011-08-30 19:24:24 UTC (rev 26654)
+++
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyTableEntryImpl.java
2011-08-30 19:59:33 UTC (rev 26655)
@@ -42,13 +42,17 @@
private final long suid;
private final Map<String, CyTable> attrMgr;
- CyTableEntryImpl(final Map<String, CyTable> attrMgr) {
- suid = SUIDFactory.getNextSUID();
+ CyTableEntryImpl(final Map<String, CyTable> attrMgr, long suid) {
+ this.suid = suid;
this.attrMgr = attrMgr;
getCyRow().set(CyTableEntry.NAME, "");
getCyRow().set(CyNetwork.SELECTED, Boolean.FALSE);
}
+ CyTableEntryImpl(final Map<String, CyTable> attrMgr) {
+ this(attrMgr,SUIDFactory.getNextSUID());
+ }
+
final public long getSUID() {
return suid;
}
Modified:
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyTableImpl.java
===================================================================
---
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyTableImpl.java
2011-08-30 19:24:24 UTC (rev 26654)
+++
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyTableImpl.java
2011-08-30 19:59:33 UTC (rev 26655)
@@ -1000,8 +1000,7 @@
@Override
public Map<String, Object> getAllValues() {
- final Map<String, Object> nameToValueMap =
- new HashMap<String, Object>(types.size());
+ final Map<String, Object> nameToValueMap = new
HashMap<String, Object>(types.size());
for (final CyColumn column : types.values()) {
final String columnName = column.getName();
final Class<?> type = column.getType();
@@ -1020,13 +1019,16 @@
return CyTableImpl.this;
}
- @Override
+// @Override
public String toString() {
+ return "Table: " + title + " SUID: " + suid + "
isImmutable: " + isImmutable + " public: " + pub;
+ /*
final StringBuilder builder = new StringBuilder();
final Map<String, Object> allVal = getAllValues();
for(String key: getAllValues().keySet())
builder.append(key + " = " + allVal.get(key) +
", ");
return builder.toString();
+ */
}
}
}
Modified:
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyTableManagerImpl.java
===================================================================
---
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyTableManagerImpl.java
2011-08-30 19:24:24 UTC (rev 26654)
+++
core3/impl/trunk/model-impl/impl/src/main/java/org/cytoscape/model/internal/CyTableManagerImpl.java
2011-08-30 19:59:33 UTC (rev 26655)
@@ -27,14 +27,8 @@
*/
package org.cytoscape.model.internal;
+import org.cytoscape.event.CyEventHelper;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import org.cytoscape.event.CyEventHelper;
import org.cytoscape.model.CyEdge;
import org.cytoscape.model.CyNetwork;
import org.cytoscape.model.CyNode;
@@ -47,21 +41,32 @@
import org.cytoscape.model.events.TableAboutToBeDeletedEvent;
import org.cytoscape.model.events.TableAddedEvent;
import org.cytoscape.model.events.TableDeletedEvent;
+
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
/**
* An interface describing a factory used for managing {@link CyTable} objects.
* This class will be provided as a service through Spring/OSGi.
*/
public class CyTableManagerImpl implements CyTableManager,
NetworkAboutToBeDestroyedListener {
private static final Logger logger =
LoggerFactory.getLogger(CyTableManagerImpl.class);
-
private final CyEventHelper eventHelper;
private final Map<Class<?>, Map<CyNetwork, Map<String, CyTable>>>
networkTableMap;
private final Map<Long, CyTable> tables;
+ /**
+ * Creates a new CyTableManagerImpl object.
+ *
+ * @param eventHelper DOCUMENT ME!
+ */
public CyTableManagerImpl(final CyEventHelper eventHelper) {
this.eventHelper = eventHelper;
@@ -73,61 +78,133 @@
tables = new HashMap<Long, CyTable>();
}
+ /**
+ * DOCUMENT ME!
+ */
@Override
- public synchronized void reset() {
- networkTableMap.clear();
- tables.clear();
- }
+ public synchronized void reset() {
+ networkTableMap.clear();
+ tables.clear();
+ }
+ /**
+ * DOCUMENT ME!
+ *
+ * @param graphObjectType DOCUMENT ME!
+ * @param network DOCUMENT ME!
+ *
+ * @return DOCUMENT ME!
+ */
@Override
- public synchronized Map<String, CyTable> getTableMap(final
Class<?> graphObjectType, final CyNetwork network) {
- if (network == null || graphObjectType == null)
- return null;
+ public synchronized Map<String, CyTable> getTableMap(final Class<?>
graphObjectType,
+ final CyNetwork
network) {
+ if ((network == null) || (graphObjectType == null)) {
+ return null;
+ }
- Map<CyNetwork, Map<String, CyTable>> tmap =
networkTableMap.get(graphObjectType);
+ Map<CyNetwork, Map<String, CyTable>> tmap =
networkTableMap.get(graphObjectType);
- if (tmap == null)
- throw new IllegalArgumentException("no data
tables of type: " + graphObjectType + " exist");
+ if (tmap == null) {
+ throw new IllegalArgumentException("no data tables of
type: " + graphObjectType
+ + " exist");
+ }
- return
networkTableMap.get(graphObjectType).get(network);
+ return tmap.get(network);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param graphObjectType DOCUMENT ME!
+ * @param network DOCUMENT ME!
+ * @param table DOCUMENT ME!
+ */
+ public void addNetworkTable(Class<?> graphObjectType, final CyNetwork
network,
+ final CyTable table) {
+ if (network == null) {
+ throw new NullPointerException("CyNetwork is null");
}
+ if (graphObjectType == null) {
+ throw new NullPointerException("Type is null");
+ }
+
+ if (table == null) {
+ throw new NullPointerException("Table is null");
+ }
+
+ if (!networkTableMap.containsKey(graphObjectType)) {
+ networkTableMap.put(graphObjectType, new
HashMap<CyNetwork, Map<String, CyTable>>());
+ }
+
+ Map<CyNetwork, Map<String, CyTable>> tmap =
networkTableMap.get(graphObjectType);
+ Map<String, CyTable> tm = new HashMap<String, CyTable>();
+ tm.put(CyNetwork.DEFAULT_ATTRS, table);
+
+ tmap.put(network, tm);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param graphObjectType DOCUMENT ME!
+ * @param network DOCUMENT ME!
+ * @param tm DOCUMENT ME!
+ */
public synchronized void setTableMap(final Class<?> graphObjectType,
final CyNetwork network,
- final Map<String, CyTable> tm) {
- if (network == null)
+ final Map<String, CyTable> tm) {
+ if (network == null) {
throw new NullPointerException("CyNetwork is null");
- if (graphObjectType == null)
+ }
+
+ if (graphObjectType == null) {
throw new NullPointerException("Type is null");
+ }
- if (!networkTableMap.containsKey(graphObjectType))
+ if (!networkTableMap.containsKey(graphObjectType)) {
networkTableMap.put(graphObjectType, new
HashMap<CyNetwork, Map<String, CyTable>>());
+ }
Map<CyNetwork, Map<String, CyTable>> tmap =
networkTableMap.get(graphObjectType);
- if (tm == null)
+ if (tm == null) {
tmap.remove(network);
- else
+ } else {
tmap.put(network, tm);
+ }
}
- @Override
+ /**
+ * DOCUMENT ME!
+ *
+ * @param t DOCUMENT ME!
+ */
public synchronized void addTable(final CyTable t) {
- if (t == null)
+ if (t == null) {
throw new NullPointerException("added table is null");
+ }
tables.put(t.getSUID(), t);
eventHelper.fireEvent(new TableAddedEvent(this, t));
}
-
+ /**
+ * DOCUMENT ME!
+ *
+ * @param includePrivate DOCUMENT ME!
+ *
+ * @return DOCUMENT ME!
+ */
@Override
public synchronized Set<CyTableMetadata> getAllTables(final boolean
includePrivate) {
Set<CyTableMetadata> res = new HashSet<CyTableMetadata>();
for (Long key : tables.keySet()) {
- if (includePrivate || tables.get(key).isPublic())
+ if (includePrivate || tables.get(key).isPublic()) {
res.add(createMetadata(tables.get(key)));
+ }
}
+
return res;
}
@@ -135,14 +212,19 @@
Class<?> entryType = null;
String entryNamespace = null;
Set<CyNetwork> networks = new HashSet<CyNetwork>();
- for (Entry<Class<?>, Map<CyNetwork, Map<String, CyTable>>>
mapEntry : networkTableMap.entrySet()) {
+
+ for (Entry<Class<?>, Map<CyNetwork, Map<String, CyTable>>>
mapEntry : networkTableMap
+
.entrySet()) {
Class<?> type = mapEntry.getKey();
Map<CyNetwork, Map<String, CyTable>> networkMap =
mapEntry.getValue();
+
for (Entry<CyNetwork, Map<String, CyTable>> entry :
networkMap.entrySet()) {
CyNetwork network = entry.getKey();
+
for (Entry<String, CyTable> tableEntry :
entry.getValue().entrySet()) {
String namespace = tableEntry.getKey();
CyTable table = tableEntry.getValue();
+
if (table.getSUID() ==
cyTable.getSUID()) {
entryType = type;
entryNamespace = namespace;
@@ -151,12 +233,21 @@
}
}
}
- if (networks.size() > 0)
+
+ if (networks.size() > 0) {
return new CyTableMetadataImpl(entryType, cyTable,
networks, entryNamespace);
+ }
return new CyTableMetadataImpl(null, cyTable, networks, null);
}
+ /**
+ * DOCUMENT ME!
+ *
+ * @param suid DOCUMENT ME!
+ *
+ * @return DOCUMENT ME!
+ */
@Override
public synchronized CyTable getTable(final long suid) {
return tables.get(suid);
@@ -164,41 +255,63 @@
void deleteTableInternal(final long suid, boolean force) {
CyTableImpl table;
+
synchronized (this) {
table = (CyTableImpl) tables.get(suid);
- if (table == null)
+
+ if (table == null) {
return;
+ }
}
eventHelper.fireEvent(new TableAboutToBeDeletedEvent(this,
table));
synchronized (this) {
table = (CyTableImpl) tables.get(suid);
- if (table == null)
+
+ if (table == null) {
return;
+ }
- if (!force && table.getMutability() !=
Mutability.MUTABLE)
+ if (!force && (table.getMutability() !=
Mutability.MUTABLE)) {
throw new IllegalArgumentException("can't
delete an immutable table!");
+ }
table.removeAllVirtColumns();
tables.remove(suid);
}
+
eventHelper.fireEvent(new TableDeletedEvent(this));
logger.debug("CyTable removed: table ID = " + table.getSUID());
table = null;
}
+ private static final Class[] tableTypes = new Class[] {
+ CyNetwork.class,
CyNode.class, CyEdge.class
+ };
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e DOCUMENT ME!
+ */
@Override
public void handleEvent(NetworkAboutToBeDestroyedEvent e) {
CyNetwork network = e.getNetwork();
- for (Class<?> type : new Class[] { CyNetwork.class,
CyNode.class, CyEdge.class }) {
+
+ for (Class<?> type : tableTypes) {
for (CyTable table : getTableMap(type,
network).values()) {
deleteTableInternal(table.getSUID(), true);
}
}
}
+ /**
+ * DOCUMENT ME!
+ *
+ * @param suid DOCUMENT ME!
+ */
@Override
public void deleteTable(long suid) {
deleteTableInternal(suid, false);
--
You received this message because you are subscribed to the Google Groups
"cytoscape-cvs" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/cytoscape-cvs?hl=en.
