/*
Copyright 2008-2010 Gephi
Authors : Mathieu Bastian <mathieu.bastian@gephi.org>
Website : http://www.gephi.org
This file is part of Gephi.
Gephi is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
Gephi 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. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with Gephi. If not, see <http://www.gnu.org/licenses/>.
*/
package org.gephi.io.importer.plugin.file;
import java.awt.Color;
import java.io.Reader;
import javax.xml.stream.Location;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLReporter;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.events.XMLEvent;
import org.gephi.data.attributes.api.AttributeColumn;
import org.gephi.data.attributes.api.AttributeOrigin;
import org.gephi.data.attributes.api.AttributeType;
import org.gephi.data.properties.PropertiesColumn;
import org.gephi.dynamic.api.DynamicModel.TimeFormat;
import org.gephi.io.importer.api.ContainerLoader;
import org.gephi.io.importer.api.EdgeDefault;
import org.gephi.io.importer.api.EdgeDraft;
import org.gephi.io.importer.api.Issue;
import org.gephi.io.importer.api.NodeDraft;
import org.gephi.io.importer.api.Report;
import org.gephi.io.importer.spi.FileImporter;
import org.gephi.utils.longtask.spi.LongTask;
import org.gephi.utils.progress.Progress;
import org.gephi.utils.progress.ProgressTicket;
import org.openide.util.NbBundle;
/**
*
* @author Mathieu Bastian
*/
public class ImporterGEXF implements FileImporter, LongTask {
//GEXF
private static final String GEXF = "gexf";
private static final String GEXF_VERSION = "version";
private static final String GRAPH = "graph";
private static final String GRAPH_DEFAULT_EDGETYPE = "defaultedgetype";
private static final String GRAPH_TIMEFORMAT = "timeformat";
private static final String GRAPH_TIMEFORMAT2 = "timetype"; // GEXF 1.1
private static final String START = "start";
private static final String END = "end";
private static final String START_OPEN = "startopen";
private static final String END_OPEN = "endopen";
private static final String NODE = "node";
private static final String NODE_ID = "id";
private static final String NODE_LABEL = "label";
private static final String NODE_PID = "pid";
private static final String NODE_POSITION = "position";
private static final String NODE_COLOR = "color";
private static final String NODE_SIZE = "size";
private static final String NODE_SPELL = "slice"; // GEXF 1.1
private static final String NODE_SPELL2 = "spell";
private static final String EDGE = "edge";
private static final String EDGE_ID = "id";
private static final String EDGE_SOURCE = "source";
private static final String EDGE_TARGET = "target";
private static final String EDGE_LABEL = "label";
private static final String EDGE_TYPE = "type";
private static final String EDGE_WEIGHT = "weight";
private static final String EDGE_COLOR = "color";
private static final String EDGE_SPELL = "slice"; // GEXF 1.1
private static final String EDGE_SPELL2 = "spell";
private static final String ATTRIBUTE = "attribute";
private static final String ATTRIBUTE_ID = "id";
private static final String ATTRIBUTE_TITLE = "title";
private static final String ATTRIBUTE_TYPE = "type";
private static final String ATTRIBUTE_DEFAULT = "default";
private static final String ATTRIBUTES = "attributes";
private static final String ATTRIBUTES_CLASS = "class"; // GEXF 1.0
private static final String ATTRIBUTES_TYPE = "type";
private static final String ATTRIBUTES_TYPE2 = "mode";
private static final String ATTVALUE = "attvalue";
private static final String ATTVALUE_FOR = "for";
private static final String ATTVALUE_FOR2 = "id"; // GEXF 1.0
private static final String ATTVALUE_VALUE = "value";
private static final String ATTVALUE_START = "start";
private static final String ATTVALUE_END = "end";
//Architecture
private Reader reader;
private ContainerLoader container;
private boolean cancel;
private Report report;
private ProgressTicket progress;
private XMLStreamReader xmlReader;
public boolean execute(ContainerLoader container) {
this.container = container;
this.report = new Report();
Progress.start(progress);
try {
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
if (inputFactory.isPropertySupported("javax.xml.stream.isValidating")) {
inputFactory.setProperty("javax.xml.stream.isValidating", Boolean.FALSE);
}
inputFactory.setXMLReporter(new XMLReporter() {
@Override
public void report(String message, String errorType, Object relatedInformation, Location location) throws XMLStreamException {
System.out.println("Error:" + errorType + ", message : " + message);
}
});
xmlReader = inputFactory.createXMLStreamReader(reader);
while (xmlReader.hasNext()) {
Integer eventType = xmlReader.next();
if (eventType.equals(XMLEvent.START_ELEMENT)) {
String name = xmlReader.getLocalName();
if (GEXF.equalsIgnoreCase(name)) {
readGexf(xmlReader);
} else if (GRAPH.equalsIgnoreCase(name)) {
readGraph(xmlReader);
} else if (NODE.equalsIgnoreCase(name)) {
readNode(xmlReader, null);
} else if (EDGE.equalsIgnoreCase(name)) {
readEdge(xmlReader);
} else if (ATTRIBUTES.equalsIgnoreCase(name)) {
readAttributes(xmlReader);
}
} else if (eventType.equals(XMLStreamReader.END_ELEMENT)) {
String name = xmlReader.getLocalName();
if (NODE.equalsIgnoreCase(name)) {
}
}
}
xmlReader.close();
} catch (Exception e) {
if (e instanceof RuntimeException) {
throw (RuntimeException) e;
}
throw new RuntimeException(e);
}
Progress.finish(progress);
return !cancel;
}
private void readGexf(XMLStreamReader reader) throws Exception {
String version = "";
//Attributes
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attName = reader.getAttributeName(i).getLocalPart();
if (GEXF_VERSION.equalsIgnoreCase(attName)) {
version = reader.getAttributeValue(i);
}
}
if (!version.isEmpty() && version.equals("1.0")) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_log_version10"), Issue.Level.INFO));
} else {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_log_version11"), Issue.Level.INFO));
}
}
private void readGraph(XMLStreamReader reader) throws Exception {
String mode = "";
String defaultEdgeType = "";
String start = "";
String end = "";
String timeFormat = "";
//Attributes
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attName = reader.getAttributeName(i).getLocalPart();
if (GRAPH_DEFAULT_EDGETYPE.equalsIgnoreCase(attName)) {
defaultEdgeType = reader.getAttributeValue(i);
} else if (ATTRIBUTES_TYPE2.equalsIgnoreCase(attName)) {
mode = reader.getAttributeValue(i);
} else if (START.equalsIgnoreCase(attName)) {
start = reader.getAttributeValue(i);
} else if (END.equalsIgnoreCase(attName)) {
end = reader.getAttributeValue(i);
} else if (GRAPH_TIMEFORMAT.equalsIgnoreCase(attName) || GRAPH_TIMEFORMAT2.equalsIgnoreCase(attName)) {
timeFormat = reader.getAttributeValue(i);
}
}
//Edge Type
if (!defaultEdgeType.isEmpty()) {
if (defaultEdgeType.equalsIgnoreCase("undirected")) {
container.setEdgeDefault(EdgeDefault.UNDIRECTED);
} else if (defaultEdgeType.equalsIgnoreCase("directed")) {
container.setEdgeDefault(EdgeDefault.DIRECTED);
} else if (defaultEdgeType.equalsIgnoreCase("mutual")) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_edgedouble"), Issue.Level.WARNING));
} else {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_defaultedgetype", defaultEdgeType), Issue.Level.SEVERE));
}
}
//TimeFormat
if (!timeFormat.isEmpty()) {
if ("double".equalsIgnoreCase(timeFormat) || "float".equalsIgnoreCase(timeFormat)) {
container.setTimeFormat(TimeFormat.DOUBLE);
} else if ("date".equalsIgnoreCase(timeFormat)) {
container.setTimeFormat(TimeFormat.DATE);
} else if ("datetime".equalsIgnoreCase(timeFormat)) {
container.setTimeFormat(TimeFormat.DATETIME);
}
} else if (mode.equalsIgnoreCase("dynamic")) {
container.setTimeFormat(TimeFormat.DOUBLE);
}
//Start & End
if (!start.isEmpty()) {
container.setTimeIntervalMin(start);
}
if (!end.isEmpty()) {
container.setTimeIntervalMax(end);
}
}
private void readNode(XMLStreamReader reader, NodeDraft parent) throws Exception {
String id = "";
String label = "";
String startDate = "";
String endDate = "";
String pid = "";
boolean startOpen = false;
boolean endOpen = false;
//Attributes
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attName = reader.getAttributeName(i).getLocalPart();
if (NODE_ID.equalsIgnoreCase(attName)) {
id = reader.getAttributeValue(i);
} else if (NODE_LABEL.equalsIgnoreCase(attName)) {
label = reader.getAttributeValue(i);
} else if (START.equalsIgnoreCase(attName)) {
startDate = reader.getAttributeValue(i);
} else if (START_OPEN.equalsIgnoreCase(attName)) {
startDate = reader.getAttributeValue(i);
startOpen = true;
} else if (END.equalsIgnoreCase(attName)) {
endDate = reader.getAttributeValue(i);
} else if (END_OPEN.equalsIgnoreCase(attName)) {
endDate = reader.getAttributeValue(i);
endOpen = true;
} else if (NODE_PID.equalsIgnoreCase(attName)) {
pid = reader.getAttributeValue(i);
}
}
if (id.isEmpty()) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_nodeid"), Issue.Level.SEVERE));
return;
}
NodeDraft node = null;
if (container.nodeExists(id)) {
node = container.getNode(id);
} else {
node = container.factory().newNodeDraft();
}
node.setId(id);
node.setLabel(label);
//Parent
if (parent != null) {
node.setParent(parent);
} else if (!pid.isEmpty()) {
NodeDraft parentNode = container.getNode(pid);
if (parentNode == null) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_pid_notfound", pid, id), Issue.Level.SEVERE));
} else {
node.setParent(parentNode);
}
}
if (!container.nodeExists(id)) {
container.addNode(node);
}
boolean end = false;
boolean slices = false;
while (reader.hasNext() && !end) {
int type = reader.next();
switch (type) {
case XMLStreamReader.START_ELEMENT:
String name = xmlReader.getLocalName();
if (ATTVALUE.equalsIgnoreCase(xmlReader.getLocalName())) {
readNodeAttValue(reader, node);
} else if (NODE_POSITION.equalsIgnoreCase(name)) {
readNodePosition(reader, node);
} else if (NODE_COLOR.equalsIgnoreCase(name)) {
readNodeColor(reader, node);
} else if (NODE_SIZE.equalsIgnoreCase(name)) {
readNodeSize(reader, node);
} else if (NODE_SPELL.equalsIgnoreCase(name) || NODE_SPELL2.equalsIgnoreCase(name)) {
readNodeSpell(reader, node);
slices = true;
} else if (NODE.equalsIgnoreCase(name)) {
readNode(reader, node);
}
break;
case XMLStreamReader.END_ELEMENT:
if (NODE.equalsIgnoreCase(xmlReader.getLocalName())) {
end = true;
}
break;
}
}
//Dynamic
if (!slices && (!startDate.isEmpty() || !endDate.isEmpty())) {
try {
node.addTimeInterval(startDate, endDate, startOpen, endOpen);
} catch (IllegalArgumentException e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_node_timeinterval_parseerror", id), Issue.Level.SEVERE));
}
}
}
private void readNodeAttValue(XMLStreamReader reader, NodeDraft node) {
String fore = "";
String value = "";
String startDate = "";
String endDate = "";
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attName = reader.getAttributeName(i).getLocalPart();
if (ATTVALUE_FOR.equalsIgnoreCase(attName) || ATTVALUE_FOR2.equalsIgnoreCase(attName)) {
fore = reader.getAttributeValue(i);
} else if (ATTVALUE_VALUE.equalsIgnoreCase(attName)) {
value = reader.getAttributeValue(i);
} else if (ATTVALUE_START.equalsIgnoreCase(attName)) {
startDate = reader.getAttributeValue(i);
} else if (ATTVALUE_END.equalsIgnoreCase(attName)) {
endDate = reader.getAttributeValue(i);
}
}
if (fore.isEmpty()) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_datakey", node), Issue.Level.SEVERE));
return;
}
if (!value.isEmpty()) {
//Data attribute value
AttributeColumn column = container.getAttributeModel().getNodeTable().getColumn(fore);
if (column != null) {
if (!startDate.isEmpty() || !endDate.isEmpty()) {
//Dynamic
try {
node.addAttributeValue(column, value, startDate, endDate);
} catch (IllegalArgumentException e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_nodeattribute_timeinterval_parseerror", node), Issue.Level.SEVERE));
} catch (Exception e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_datavalue", fore, node, column.getTitle()), Issue.Level.SEVERE));
}
} else {
if (column.getType().isDynamicType()) {
node.addAttributeValue(column, value);
} else {
try {
Object val = column.getType().parse(value);
node.addAttributeValue(column, val);
} catch (Exception e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_datavalue", fore, node, column.getTitle()), Issue.Level.SEVERE));
}
}
}
}
}
}
private void readNodeColor(XMLStreamReader reader, NodeDraft node) throws Exception {
String rStr = "";
String gStr = "";
String bStr = "";
String aStr = "";
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attName = reader.getAttributeName(i).getLocalPart();
if ("r".equalsIgnoreCase(attName)) {
rStr = reader.getAttributeValue(i);
} else if ("g".equalsIgnoreCase(attName)) {
gStr = reader.getAttributeValue(i);
} else if ("b".equalsIgnoreCase(attName)) {
bStr = reader.getAttributeValue(i);
} else if ("a".equalsIgnoreCase(attName)) {
aStr = reader.getAttributeValue(i);
}
}
int r = (rStr.isEmpty()) ? 0 : Integer.parseInt(rStr);
int g = (gStr.isEmpty()) ? 0 : Integer.parseInt(gStr);
int b = (bStr.isEmpty()) ? 0 : Integer.parseInt(bStr);
float a = (aStr.isEmpty()) ? 0 : Float.parseFloat(aStr); //not used
if(r < 0 || r > 255) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_nodecolorvalue", rStr, node, "r"), Issue.Level.WARNING));
}
if(g < 0 || g > 255) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_nodecolorvalue", gStr, node, "g"), Issue.Level.WARNING));
}
if(b < 0 || b > 255) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_nodecolorvalue", bStr, node, "b"), Issue.Level.WARNING));
}
if(a < 0f || a > 1f) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_nodeopacityvalue", aStr, node), Issue.Level.WARNING));
}
node.setColor(new Color(r, g, b));
}
private void readNodePosition(XMLStreamReader reader, NodeDraft node) throws Exception {
String xStr = "";
String yStr = "";
String zStr = "";
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attName = reader.getAttributeName(i).getLocalPart();
if ("x".equalsIgnoreCase(attName)) {
xStr = reader.getAttributeValue(i);
} else if ("y".equalsIgnoreCase(attName)) {
yStr = reader.getAttributeValue(i);
} else if ("z".equalsIgnoreCase(attName)) {
zStr = reader.getAttributeValue(i);
}
}
if (!xStr.isEmpty()) {
try {
float x = Float.parseFloat(xStr);
node.setX(x);
} catch (NumberFormatException e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_nodeposition", node, "X"), Issue.Level.WARNING));
}
}
if (!yStr.isEmpty()) {
try {
float y = Float.parseFloat(yStr);
node.setY(y);
} catch (NumberFormatException e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_nodeposition", node, "Y"), Issue.Level.WARNING));
}
}
if (!zStr.isEmpty()) {
try {
float z = Float.parseFloat(zStr);
node.setZ(z);
} catch (NumberFormatException e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_nodeposition", node, "Z"), Issue.Level.WARNING));
}
}
}
private void readNodeSize(XMLStreamReader reader, NodeDraft node) throws Exception {
String attName = reader.getAttributeName(0).getLocalPart();
if ("value".equalsIgnoreCase(attName)) {
String sizeStr = reader.getAttributeValue(0);
if (!sizeStr.isEmpty()) {
try {
float size = Float.parseFloat(sizeStr);
node.setSize(size);
} catch (NumberFormatException e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_nodesize", node), Issue.Level.WARNING));
}
}
}
}
private void readNodeSpell(XMLStreamReader reader, NodeDraft node) throws Exception {
String start = "";
String end = "";
boolean startOpen = false;
boolean endOpen = false;
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attName = reader.getAttributeName(i).getLocalPart();
if (START.equalsIgnoreCase(attName)) {
start = reader.getAttributeValue(i);
} else if (END.equalsIgnoreCase(attName)) {
end = reader.getAttributeValue(i);
} else if (START_OPEN.equalsIgnoreCase(attName)) {
start = reader.getAttributeValue(i);
startOpen = true;
} else if (END_OPEN.equalsIgnoreCase(attName)) {
end = reader.getAttributeValue(i);
endOpen = true;
}
}
if (!start.isEmpty() || !end.isEmpty()) {
try {
node.addTimeInterval(start, end, startOpen, endOpen);
} catch (IllegalArgumentException e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_node_timeinterval_parseerror", node), Issue.Level.SEVERE));
}
}
}
private void readEdge(XMLStreamReader reader) throws Exception {
String id = "";
String label = "";
String source = "";
String target = "";
String weight = "";
String edgeType = "";
String startDate = "";
String endDate = "";
boolean startOpen = false;
boolean endOpen = false;
//Attributes
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attName = reader.getAttributeName(i).getLocalPart();
if (EDGE_SOURCE.equalsIgnoreCase(attName)) {
source = reader.getAttributeValue(i);
} else if (EDGE_TARGET.equalsIgnoreCase(attName)) {
target = reader.getAttributeValue(i);
} else if (EDGE_WEIGHT.equalsIgnoreCase(attName)) {
weight = reader.getAttributeValue(i);
} else if (EDGE_ID.equalsIgnoreCase(attName)) {
id = reader.getAttributeValue(i);
} else if (EDGE_TYPE.equalsIgnoreCase(attName)) {
edgeType = reader.getAttributeValue(i);
} else if (EDGE_LABEL.equalsIgnoreCase(attName)) {
label = reader.getAttributeValue(i);
} else if (START.equalsIgnoreCase(attName)) {
startDate = reader.getAttributeValue(i);
} else if (END.equalsIgnoreCase(attName)) {
endDate = reader.getAttributeValue(i);
} else if (START_OPEN.equalsIgnoreCase(attName)) {
startDate = reader.getAttributeValue(i);
startOpen = true;
} else if (END_OPEN.equalsIgnoreCase(attName)) {
endDate = reader.getAttributeValue(i);
endOpen = true;
}
}
EdgeDraft edge = container.factory().newEdgeDraft();
NodeDraft nodeSource = container.getNode(source);
NodeDraft nodeTarget = container.getNode(target);
edge.setSource(nodeSource);
edge.setTarget(nodeTarget);
//Type
if (!edgeType.isEmpty()) {
if (edgeType.equalsIgnoreCase("undirected")) {
edge.setType(EdgeDraft.EdgeType.UNDIRECTED);
} else if (edgeType.equalsIgnoreCase("directed")) {
edge.setType(EdgeDraft.EdgeType.DIRECTED);
} else if (edgeType.equalsIgnoreCase("mutual")) {
edge.setType(EdgeDraft.EdgeType.MUTUAL);
} else {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_edgetype", edgeType, edge), Issue.Level.SEVERE));
}
}
//Id
if (!id.isEmpty()) {
edge.setId(id);
}
//Weight
if (!weight.isEmpty()) {
try {
float weightNumber = Float.parseFloat(weight);
edge.setWeight(weightNumber);
} catch (NumberFormatException e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_edgeweight", edge), Issue.Level.WARNING));
}
}
//Label
if (!label.isEmpty()) {
edge.setLabel(label);
}
container.addEdge(edge);
boolean end = false;
boolean spells = false;
while (reader.hasNext() && !end) {
int type = reader.next();
switch (type) {
case XMLStreamReader.START_ELEMENT:
if (ATTVALUE.equalsIgnoreCase(xmlReader.getLocalName())) {
readEdgeAttValue(reader, edge);
} else if (EDGE_COLOR.equalsIgnoreCase(xmlReader.getLocalName())) {
readEdgeColor(reader, edge);
} else if (EDGE_SPELL.equalsIgnoreCase(xmlReader.getLocalName()) ||
EDGE_SPELL2.equalsIgnoreCase(xmlReader.getLocalName())) {
readEdgeSpell(reader, edge);
spells = true;
}
break;
case XMLStreamReader.END_ELEMENT:
if (EDGE.equalsIgnoreCase(xmlReader.getLocalName())) {
end = true;
}
break;
}
}
//Dynamic
if (!spells && (!startDate.isEmpty() || !endDate.isEmpty())) {
try {
edge.addTimeInterval(startDate, endDate, startOpen, endOpen);
} catch (IllegalArgumentException e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_edge_timeinterval_parseerror", edge), Issue.Level.SEVERE));
}
}
}
private void readEdgeAttValue(XMLStreamReader reader, EdgeDraft edge) {
String fore = "";
String value = "";
String startDate = "";
String endDate = "";
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attName = reader.getAttributeName(i).getLocalPart();
if (ATTVALUE_FOR.equalsIgnoreCase(attName) || ATTVALUE_FOR2.equalsIgnoreCase(attName)) {
fore = reader.getAttributeValue(i);
} else if (ATTVALUE_VALUE.equalsIgnoreCase(attName)) {
value = reader.getAttributeValue(i);
} else if (ATTVALUE_START.equalsIgnoreCase(attName)) {
startDate = reader.getAttributeValue(i);
} else if (ATTVALUE_END.equalsIgnoreCase(attName)) {
endDate = reader.getAttributeValue(i);
}
}
if (fore.isEmpty()) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_datakey", edge), Issue.Level.SEVERE));
return;
}
if (!value.isEmpty()) {
//Data attribute value
AttributeColumn column = container.getAttributeModel().getEdgeTable().getColumn(fore);
if (column != null) {
if (!startDate.isEmpty() || !endDate.isEmpty()) {
//Dynamic
try {
edge.addAttributeValue(column, value, startDate, endDate);
} catch (IllegalArgumentException e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_edgeattribute_timeinterval_parseerror", edge), Issue.Level.SEVERE));
} catch (Exception e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_datavalue", fore, edge, column.getTitle()), Issue.Level.SEVERE));
}
} else {
if (column.getType().isDynamicType()) {
edge.addAttributeValue(column, value);
} else {
try {
Object val = column.getType().parse(value);
edge.addAttributeValue(column, val);
} catch (Exception e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_datavalue", fore, edge, column.getTitle()), Issue.Level.SEVERE));
}
}
}
}
}
}
private void readEdgeColor(XMLStreamReader reader, EdgeDraft edge) throws Exception {
String rStr = "";
String gStr = "";
String bStr = "";
String aStr = "";
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attName = reader.getAttributeName(i).getLocalPart();
if ("r".equalsIgnoreCase(attName)) {
rStr = reader.getAttributeValue(i);
} else if ("g".equalsIgnoreCase(attName)) {
gStr = reader.getAttributeValue(i);
} else if ("b".equalsIgnoreCase(attName)) {
bStr = reader.getAttributeValue(i);
} else if ("a".equalsIgnoreCase(attName)) {
aStr = reader.getAttributeValue(i);
}
}
int r = (rStr.isEmpty()) ? 0 : Integer.parseInt(rStr);
int g = (gStr.isEmpty()) ? 0 : Integer.parseInt(gStr);
int b = (bStr.isEmpty()) ? 0 : Integer.parseInt(bStr);
float a = (aStr.isEmpty()) ? 0 : Float.parseFloat(aStr); //not used
if(r < 0 || r > 255) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_edgecolorvalue", rStr, edge, "r"), Issue.Level.WARNING));
}
if(g < 0 || g > 255) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_edgecolorvalue", gStr, edge, "g"), Issue.Level.WARNING));
}
if(b < 0 || b > 255) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_edgecolorvalue", bStr, edge, "b"), Issue.Level.WARNING));
}
if(a < 0f || a > 1f) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_edgeopacityvalue", aStr, edge), Issue.Level.WARNING));
}
edge.setColor(new Color(r, g, b));
}
private void readEdgeSpell(XMLStreamReader reader, EdgeDraft edge) throws Exception {
String start = "";
String end = "";
boolean startOpen = false;
boolean endOpen = false;
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attName = reader.getAttributeName(i).getLocalPart();
if (START.equalsIgnoreCase(attName)) {
start = reader.getAttributeValue(i);
} else if (END.equalsIgnoreCase(attName)) {
end = reader.getAttributeValue(i);
} else if (START_OPEN.equalsIgnoreCase(attName)) {
start = reader.getAttributeValue(i);
startOpen = true;
} else if (END_OPEN.equalsIgnoreCase(attName)) {
end = reader.getAttributeValue(i);
endOpen = true;
}
}
if (!start.isEmpty() || !end.isEmpty()) {
try {
edge.addTimeInterval(start, end, startOpen, endOpen);
} catch (IllegalArgumentException e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_edge_timeinterval_parseerror", edge), Issue.Level.SEVERE));
}
}
}
private void readAttributes(XMLStreamReader reader) throws Exception {
String classAtt = "";
String typeAtt = "";
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attName = reader.getAttributeName(i).getLocalPart();
if (ATTRIBUTES_CLASS.equalsIgnoreCase(attName)) {
classAtt = reader.getAttributeValue(i);
} else if (ATTRIBUTES_TYPE.equalsIgnoreCase(attName) || ATTRIBUTES_TYPE2.equalsIgnoreCase(attName)) {
typeAtt = reader.getAttributeValue(i);
}
}
boolean end = false;
while (reader.hasNext() && !end) {
int type = reader.next();
switch (type) {
case XMLStreamReader.START_ELEMENT:
if (ATTRIBUTE.equalsIgnoreCase(xmlReader.getLocalName())) {
readAttribute(reader, classAtt, typeAtt);
}
break;
case XMLStreamReader.END_ELEMENT:
if (ATTRIBUTES.equalsIgnoreCase(xmlReader.getLocalName())) {
end = true;
}
break;
}
}
}
private void readAttribute(XMLStreamReader reader, String classAtt, String typeAtt) throws Exception {
String id = "";
String type = "";
String title = "";
String defaultStr = "";
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attName = reader.getAttributeName(i).getLocalPart();
if (ATTRIBUTE_ID.equalsIgnoreCase(attName)) {
id = reader.getAttributeValue(i);
} else if (ATTRIBUTE_TYPE.equalsIgnoreCase(attName)) {
type = reader.getAttributeValue(i);
} else if (ATTRIBUTE_TITLE.equalsIgnoreCase(attName)) {
title = reader.getAttributeValue(i);
}
}
if (title.isEmpty()) {
title = id;
}
if (!id.isEmpty() && !type.isEmpty()) {
//Class type
if (classAtt.isEmpty() || !(classAtt.equalsIgnoreCase("node") || classAtt.equalsIgnoreCase("edge"))) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_attributeclass", title), Issue.Level.SEVERE));
}
//Default?
boolean end = false;
boolean defaultFlag = false;
while (reader.hasNext() && !end) {
int xmltype = reader.next();
switch (xmltype) {
case XMLStreamReader.START_ELEMENT:
if (ATTRIBUTE_DEFAULT.equalsIgnoreCase(xmlReader.getLocalName())) {
defaultFlag = true;
}
break;
case XMLStreamReader.CHARACTERS:
if (defaultFlag && !xmlReader.isWhiteSpace()) {
defaultStr = xmlReader.getText();
}
break;
case XMLStreamReader.END_ELEMENT:
if (ATTRIBUTE.equalsIgnoreCase(xmlReader.getLocalName())) {
end = true;
}
break;
}
}
//Dynamic?
boolean dynamic = typeAtt.equalsIgnoreCase("dynamic");
//Type
AttributeType attributeType = AttributeType.STRING;
if (type.equalsIgnoreCase("boolean") || type.equalsIgnoreCase("bool")) {
attributeType = dynamic ? AttributeType.DYNAMIC_BOOLEAN : AttributeType.BOOLEAN;
} else if (type.equalsIgnoreCase("integer") || type.equalsIgnoreCase("int")) {
attributeType = dynamic ? AttributeType.DYNAMIC_INT : AttributeType.INT;
} else if (type.equalsIgnoreCase("long")) {
attributeType = dynamic ? AttributeType.DYNAMIC_LONG : AttributeType.LONG;
} else if (type.equalsIgnoreCase("float")) {
attributeType = dynamic ? AttributeType.DYNAMIC_FLOAT : AttributeType.FLOAT;
} else if (type.equalsIgnoreCase("double")) {
attributeType = dynamic ? AttributeType.DYNAMIC_DOUBLE : AttributeType.DOUBLE;
} else if (type.equalsIgnoreCase("string")) {
attributeType = dynamic ? AttributeType.DYNAMIC_STRING : AttributeType.STRING;
} else if (type.equalsIgnoreCase("bigdecimal")) {
attributeType = dynamic ? AttributeType.DYNAMIC_BIGDECIMAL : AttributeType.BIGDECIMAL;
} else if (type.equalsIgnoreCase("biginteger")) {
attributeType = dynamic ? AttributeType.DYNAMIC_BIGINTEGER : AttributeType.BIGINTEGER;
} else if (type.equalsIgnoreCase("byte")) {
attributeType = dynamic ? AttributeType.DYNAMIC_BYTE : AttributeType.BYTE;
} else if (type.equalsIgnoreCase("char")) {
attributeType = dynamic ? AttributeType.DYNAMIC_CHAR : AttributeType.CHAR;
} else if (type.equalsIgnoreCase("short")) {
attributeType = dynamic ? AttributeType.DYNAMIC_SHORT : AttributeType.SHORT;
} else if (type.equalsIgnoreCase("listboolean")) {
attributeType = AttributeType.LIST_BOOLEAN;
} else if (type.equalsIgnoreCase("listint")) {
attributeType = AttributeType.LIST_INTEGER;
} else if (type.equalsIgnoreCase("listlong")) {
attributeType = AttributeType.LIST_LONG;
} else if (type.equalsIgnoreCase("listfloat")) {
attributeType = AttributeType.LIST_FLOAT;
} else if (type.equalsIgnoreCase("listdouble")) {
attributeType = AttributeType.LIST_DOUBLE;
} else if (type.equalsIgnoreCase("liststring")) {
attributeType = AttributeType.LIST_STRING;
} else if (type.equalsIgnoreCase("listbigdecimal")) {
attributeType = AttributeType.LIST_BIGDECIMAL;
} else if (type.equalsIgnoreCase("listbiginteger")) {
attributeType = AttributeType.LIST_BIGINTEGER;
} else if (type.equalsIgnoreCase("listbyte")) {
attributeType = AttributeType.LIST_BYTE;
} else if (type.equalsIgnoreCase("listchar")) {
attributeType = AttributeType.LIST_CHARACTER;
} else if (type.equalsIgnoreCase("listshort")) {
attributeType = AttributeType.LIST_SHORT;
} else {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_attributetype2", type), Issue.Level.SEVERE));
return;
}
//Default Object
Object defaultValue = null;
if (!defaultStr.isEmpty()) {
try {
defaultValue = attributeType.parse(defaultStr);
report.log(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_log_default", defaultStr, title));
} catch (Exception e) {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_attributedefault", title, attributeType.getTypeString()), Issue.Level.SEVERE));
}
}
//Add to model
if ("node".equalsIgnoreCase(classAtt) || classAtt.isEmpty()) {
if (container.getAttributeModel().getNodeTable().hasColumn(id) || container.getAttributeModel().getNodeTable().hasColumn(title)) {
report.log(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_attributecolumn_exist", id));
return;
}
container.getAttributeModel().getNodeTable().addColumn(id, title, attributeType, AttributeOrigin.DATA, defaultValue);
report.log(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_log_nodeattribute", title, attributeType.getTypeString()));
} else if ("edge".equalsIgnoreCase(classAtt) || classAtt.isEmpty()) {
if ((id.equalsIgnoreCase("weight") || title.equalsIgnoreCase("weight")) && dynamic && attributeType.equals(AttributeType.DYNAMIC_FLOAT)) {
//Dynamic weight
report.log(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_log_dynamic_weight", id));
container.getAttributeModel().getEdgeTable().removeColumn(container.getAttributeModel().getEdgeTable().getColumn(PropertiesColumn.EDGE_WEIGHT.getIndex()));
container.getAttributeModel().getEdgeTable().addColumn(id, PropertiesColumn.EDGE_WEIGHT.getTitle(), attributeType, AttributeOrigin.PROPERTY, defaultValue);
return;
} else if (container.getAttributeModel().getEdgeTable().hasColumn(id) || container.getAttributeModel().getEdgeTable().hasColumn(title)) {
report.log(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_attributecolumn_exist", id));
return;
}
container.getAttributeModel().getEdgeTable().addColumn(id, title, attributeType, AttributeOrigin.DATA, defaultValue);
report.log(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_log_edgeattribute", title, attributeType.getTypeString()));
}
} else {
report.logIssue(new Issue(NbBundle.getMessage(ImporterGEXF.class, "importerGEXF_error_attributeempty", title), Issue.Level.SEVERE));
}
}
public void setReader(Reader reader) {
this.reader = reader;
}
public ContainerLoader getContainer() {
return container;
}
public Report getReport() {
return report;
}
public boolean cancel() {
cancel = true;
return true;
}
public void setProgressTicket(ProgressTicket progressTicket) {
this.progress = progressTicket;
}
}