public void process() {
// Workspace
ProjectController pc = Lookup.getDefault().lookup(ProjectController.class);
if (workspace == null) {
workspace = pc.newWorkspace(pc.getCurrentProject());
pc.openWorkspace(workspace);
}
if (container.getSource() != null) {
pc.setSource(workspace, container.getSource());
}
// Architecture
GraphModel graphModel = Lookup.getDefault().lookup(GraphController.class).getModel(workspace);
HierarchicalGraph graph = null;
switch (container.getEdgeDefault()) {
case DIRECTED:
graph = graphModel.getHierarchicalDirectedGraph();
break;
case UNDIRECTED:
graph = graphModel.getHierarchicalUndirectedGraph();
break;
case MIXED:
graph = graphModel.getHierarchicalMixedGraph();
break;
default:
graph = graphModel.getHierarchicalMixedGraph();
break;
}
GraphFactory factory = graphModel.factory();
// Attributes - Creates columns for properties
attributeModel = Lookup.getDefault().lookup(AttributeController.class).getModel(workspace);
attributeModel.mergeModel(container.getAttributeModel());
// Dynamic
if (container.getTimeFormat() != null) {
DynamicController dynamicController = Lookup.getDefault().lookup(DynamicController.class);
if (dynamicController != null) {
dynamicController.setTimeFormat(container.getTimeFormat());
}
}
int nodeCount = 0;
// Create all nodes
for (NodeDraftGetter draftNode : container.getNodes()) {
Node n = factory.newNode(draftNode.isAutoId() ? null : draftNode.getId());
flushToNode(draftNode, n);
draftNode.setNode(n);
nodeCount++;
}
// Push nodes in data structure
for (NodeDraftGetter draftNode : container.getNodes()) {
Node n = draftNode.getNode();
NodeDraftGetter[] parents = draftNode.getParents();
if (parents != null) {
for (int i = 0; i < parents.length; i++) {
Node parent = parents[i].getNode();
graph.addNode(n, parent);
}
} else {
graph.addNode(n);
}
}
// Create all edges and push to data structure
int edgeCount = 0;
for (EdgeDraftGetter edge : container.getEdges()) {
Node source = edge.getSource().getNode();
Node target = edge.getTarget().getNode();
Edge e = null;
switch (container.getEdgeDefault()) {
case DIRECTED:
e =
factory.newEdge(
edge.isAutoId() ? null : edge.getId(), source, target, edge.getWeight(), true);
break;
case UNDIRECTED:
e =
factory.newEdge(
edge.isAutoId() ? null : edge.getId(), source, target, edge.getWeight(), false);
break;
case MIXED:
e =
factory.newEdge(
edge.isAutoId() ? null : edge.getId(),
source,
target,
edge.getWeight(),
edge.getType().equals(EdgeType.UNDIRECTED) ? false : true);
break;
}
flushToEdge(edge, e);
edgeCount++;
graph.addEdge(e);
}
workspace = null;
}
protected void process(ContainerUnloader container, Workspace workspace) {
// Architecture
GraphController graphController = Lookup.getDefault().lookup(GraphController.class);
graphModel = graphController.getGraphModel(workspace);
// Get graph
Graph graph = graphModel.getGraph();
GraphFactory factory = graphModel.factory();
// Time Format & Time zone
graphModel.setTimeFormat(container.getTimeFormat());
graphModel.setTimeZone(container.getTimeZone());
// Progress
Progress.start(progressTicket, container.getNodeCount() + container.getEdgeCount());
// Attributes - Creates columns for properties
flushColumns(container);
// Counters
int addedNodes = 0, addedEdges = 0;
// Create all nodes
ElementIdType elementIdType = container.getElementIdType();
for (NodeDraft draftNode : container.getNodes()) {
String idString = draftNode.getId();
Object id = toElementId(elementIdType, idString);
Node node = graph.getNode(id);
if (node == null) {
node = factory.newNode(id);
addedNodes++;
}
flushToNode(draftNode, node);
graph.addNode(node);
Progress.progress(progressTicket);
}
// Create all edges and push to data structure
for (EdgeDraft draftEdge : container.getEdges()) {
String idString = draftEdge.getId();
Object id = toElementId(elementIdType, idString);
String sourceId = draftEdge.getSource().getId();
String targetId = draftEdge.getTarget().getId();
Node source = graph.getNode(toElementId(elementIdType, sourceId));
Node target = graph.getNode(toElementId(elementIdType, targetId));
Object type = draftEdge.getType();
int edgeType = graphModel.addEdgeType(type);
Edge edge = graph.getEdge(source, target, edgeType);
if (edge == null) {
switch (container.getEdgeDefault()) {
case DIRECTED:
edge = factory.newEdge(id, source, target, edgeType, draftEdge.getWeight(), true);
break;
case UNDIRECTED:
edge = factory.newEdge(id, source, target, edgeType, draftEdge.getWeight(), false);
break;
case MIXED:
boolean directed =
draftEdge.getDirection() == null
|| !draftEdge.getDirection().equals(EdgeDirection.UNDIRECTED);
edge = factory.newEdge(id, source, target, edgeType, draftEdge.getWeight(), directed);
break;
}
addedEdges++;
}
flushToEdge(draftEdge, edge);
graph.addEdge(edge);
Progress.progress(progressTicket);
}
// Report
int touchedNodes = container.getNodeCount();
int touchedEdges = container.getEdgeCount();
if (touchedNodes != addedNodes || touchedEdges != addedEdges) {
Logger.getLogger(getClass().getSimpleName())
.log(
Level.INFO,
"# Nodes loaded: {0} ({1} added)",
new Object[] {touchedNodes, addedNodes});
Logger.getLogger(getClass().getSimpleName())
.log(
Level.INFO,
"# Edges loaded: {0} ({1} added)",
new Object[] {touchedEdges, addedEdges});
} else {
Logger.getLogger(getClass().getSimpleName())
.log(Level.INFO, "# Nodes loaded: {0}", new Object[] {touchedNodes});
Logger.getLogger(getClass().getSimpleName())
.log(Level.INFO, "# Edges loaded: {0}", new Object[] {touchedEdges});
}
Progress.finish(progressTicket);
}
