obvious.data.Node java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Gson g =new Gson()
GsonBuilder gsonBuilder;gsonBuilder.create()
new GsonBuilder().create()
Smart code suggestions by Codota
}

/**
 * Adds a given node to the current graph.
 * @param node node to add to the graph
 * @return true if the node is added
 */
public boolean addNode(Node node) {
 try {
  int rowId = graph.addVertex();
  for (int i = 0; i < node.getSchema().getColumnCount(); i++) {
   if (nodeSchema.hasColumn(node.getSchema().getColumnName(i))) {
    TypedFormat format = formatFactory.getFormat(
      node.getSchema().getColumnType(i).getSimpleName());
     StringBuffer v = format.format(node.get(i),
       new StringBuffer(), new FieldPosition(0));
    graph.getVertexTable().setValueAt(v.toString(), rowId,
      graph.getVertexTable().indexOf(
        node.getSchema().getColumnName(i)));
   }
  }
  nodeToId.put(node, rowId);
  fireNetworkEvent(node.getRow(), node.getRow(), 0,
    NetworkListener.INSERT_NODE);
  return true;
 } catch (Exception e) {
  throw new ObviousRuntimeException(e);
 }
}

/**
 * Removes a node.
 * @param node node to remove
 * @return true if removed
 */
public boolean removeNode(Node node) {
 try {
  if (!nodeToId.containsValue(node.getRow())) {
   return false;
  }
  graph.removeVertex(node.getRow());
  nodeToId.remove(node);
  fireNetworkEvent(node.getRow(), node.getRow(), 0,
    NetworkListener.DELETE_NODE);
  return true;
 } catch (Exception e) {
  e.printStackTrace();
  throw new ObviousRuntimeException(e);
 }
}

  prefEdge = graph.addEdge(graph.getNode(source.getRow()),
  graph.getNode(target.getRow()));
} else {
 prefEdge = graph.addEdge(graph.getNodeFromKey(source.getInt(nodeKey)),
   graph.getNodeFromKey(target.getInt(nodeKey)));
  prefEdge.set(colName, source.get(nodeKey));
 } else if (graphCol && edge.get(colName).equals(targetKey)
   && nodeKey != null) {
  prefEdge.set(colName, target.get(nodeKey));
 } else if (graphCol && edge.get(colName).equals(sourceKey)
   && nodeKey == null) {
  prefEdge.set(colName, source.getRow());
 } else if (graphCol && edge.get(colName).equals(targetKey)
   && nodeKey == null) {
  prefEdge.set(colName, target.getRow());
 } else {
  prefEdge.set(colName, edge.get(colName));

/**
 * Adds a given node to the current graph.
 * @param node node to add to the graph
 * @return true if the node is added
 */
public boolean addNode(Node node) {
 try {
  // if prefNode (prefuse) tuple and node (obvious) tuple are compatible
  // i.e their schema are compatible.
  prefuse.data.Node prefNode = this.graph.addNode();
  for (int i = 0; i < node.getTable().getSchema().getColumnCount(); i++) {
   prefNode.set(node.getSchema().getColumnName(i), node.get(i));
  }
  int nodeId = prefNode.getRow();
  fireNetworkEvent(nodeId, nodeId, 0,
    NetworkListener.INSERT_NODE);
  return true;
 } catch (Exception e) {
  throw new ObviousRuntimeException(e);
 }
}

/**
 * Loads the table with the data of external CSV files.
 * @return an obvious network
 * @throws ObviousxException when exception occurs
 */
public Network loadGraph() throws ObviousxException {
 CSVTableImport nodeImport = new CSVTableImport(nodeFile, new TableImpl(nodeSchema),
   separator);
 CSVTableImport edgeImport = new CSVTableImport(edgeFile, new TableImpl(edgeSchema),
   separator);
 Table nodeTable = nodeImport.loadTable();
 Table edgeTable = edgeImport.loadTable();
 for (int i = 0; i < nodeTable.getRowCount(); i++) {
  Node node = new NodeImpl(nodeTable, i);
  network.addNode(node);
  if (nodeId == null) {
   idToNode.put(node.getRow(), node);
  } else {
   idToNode.put(node.get(nodeId), node);
  }
 }
 for (int i = 0; i < edgeTable.getRowCount(); i++) {
  Edge edge = new EdgeImpl(edgeTable, i);
  network.addEdge(edge, idToNode.get(edge.get(sourceCol)),
    idToNode.get(edge.get(targetCol)),
    network.getEdgeType(edge));
 }
 return this.network;
}

/**
 * Gets the id of an input node.
 * @param node a node of the graph
 * @return id of the node
 */
private Integer getNodeId(Node node) {
 Integer id = null;
 for (Map.Entry<Node, Integer> e : nodeToId.entrySet()) {
  boolean nodeEquals = true;
  for (int i = 0; i < nodeSchema.getColumnCount(); i++) {
   String colName = nodeSchema.getColumnName(i);
   if (!node.get(colName).equals(e.getKey().get(colName))) {
    nodeEquals = false;
    break;
   }
  }
  if (nodeEquals) {
   id = e.getValue();
   break;
  }
 }
 return id;
}

/**
 * Converts an Obvious tree to an infovis tree.
 * @param tree tree to convert
 * @return the converted infovis tree
 */
private infovis.Tree convertToIvtkTree(Tree<Node, Edge> tree) {
 if (tree.getEdges().size() != 0 && tree.getNodes().size() != 0) {
  Schema nodeSchema = tree.getNodes().iterator().next().getSchema()
   .getDataSchema();
  Schema edgeSchema = tree.getEdges().iterator().next().getSchema()
   .getDataSchema();
  Tree<Node, Edge> ivtkTree = new IvtkObviousTree(nodeSchema, edgeSchema);
  ObviousLib.fillTree(tree, ivtkTree);
  return (infovis.Tree)
   ivtkTree.getUnderlyingImpl(infovis.Tree.class);
 } else {
  throw new ObviousRuntimeException("Empty tree!");
 }
}

@SuppressWarnings("unchecked")
@Override
public Iterator nodes() {
 Collection<obvious.data.Node> obvNodes = network.getNodes();
 ArrayList<Node> prefNodes = new ArrayList<Node>();
 for (obvious.data.Node node : obvNodes) {
  prefNodes.add(new WrapToPrefNode(network, (TupleImpl) node,
    node.getRow()));
 }
 return prefNodes.iterator();
}

/**
 * Gets the id of an input node.
 * @param node a node of the graph
 * @return id of the node
 */
private Integer getNodeId(Node node) {
 Integer id = null;
 for (Map.Entry<Node, Integer> e : nodeToId.entrySet()) {
  boolean nodeEquals = true;
  for (int i = 0; i < nodeSchema.getColumnCount(); i++) {
   String colName = nodeSchema.getColumnName(i);
   if (!node.get(colName).equals(e.getKey().get(colName))) {
    nodeEquals = false;
    break;
   }
  }
  if (nodeEquals) {
   id = e.getValue();
   break;
  }
 }
 return id;
}

/**
 * Constructor.
 * @param inNetwork obvious network to wrap
 */
public WrapToPrefGraph(Network inNetwork) {
 super(new WrapToPrefTable(inNetwork.getNodeTable()),
   new WrapToPrefTable(inNetwork.getEdgeTable()), true);
 this.network = inNetwork;
 if (network.getNodes().size() != 0) {
  this.nodeSchema = network.getNodes().iterator().next().getSchema();
 }
 if (network.getEdges().size() != 0) {
  this.edgeSchema = network.getEdges().iterator().next().getSchema();
 }
 m_nodeTuples = new TupleManager(getNodeTable(), this, Table.class);
 m_edgeTuples = new TupleManager(getEdgeTable(), this, Table.class);
}

@SuppressWarnings("unchecked")
@Override
public Iterator neighbors(Node n) {
 Collection<obvious.data.Node> obvNodes = network.getNeighbors(
   getObviousNode(n));
 ArrayList<Node> prefNodes = new ArrayList<Node>();
 for (obvious.data.Node node : obvNodes) {
  prefNodes.add(new WrapToPrefNode(network, (TupleImpl) node,
    node.getRow()));
 }
 return prefNodes.iterator();
}

TypedFormat format = formatFactory.getFormat(
  nodeSchema.getColumnType(i).getSimpleName());
StringBuffer value = format.format(node.get(i),
  new StringBuffer(), new FieldPosition(0));
serializer.writeCharacters(value.toString());

@SuppressWarnings("unchecked")
@Override
public Iterator inNeighbors(Node n) {
 Collection<obvious.data.Node> obvNodes = network.getPredecessors(
   getObviousNode(n));
 ArrayList<Node> prefNodes = new ArrayList<Node>();
 for (obvious.data.Node node : obvNodes) {
  prefNodes.add(new WrapToPrefNode(network, (TupleImpl) node,
    node.getRow()));
 }
 return prefNodes.iterator();
}

network.addNode(node);
for (Node n : network.getNodes()) {
 if (n.get(nodeId).equals(id)) {
  node = n;
  break;

@SuppressWarnings("unchecked")
@Override
public Iterator outNeighbors(Node n) {
 Collection<obvious.data.Node> obvNodes = network.getSuccessors(
   getObviousNode(n));
 ArrayList<Node> prefNodes = new ArrayList<Node>();
 for (obvious.data.Node node : obvNodes) {
  prefNodes.add(new WrapToPrefNode(network, (TupleImpl) node,
    node.getRow()));
 }
 return prefNodes.iterator();
}

@Override
public int getTargetNode(int edge) {
 return network.getTarget(getObviousEdge(edge)).getRow();
}

@Override
public int getSourceNode(int edge) {
 return network.getSource(getObviousEdge(edge)).getRow();
}

/**
 * Get out-linking edges for a specific node.
 * @param node spotted node
 * @return collection of out-linking edges
 */
@SuppressWarnings("unchecked")
public Collection<Edge> getOutEdges(Node node) {
 Collection<Edge> outEdge = new ArrayList<Edge>();
 prefuse.data.Node prefNode = this.graph.getNodeFromKey(
   this.graph.getKey(node.getRow()));
 Iterator<Edge> i = this.graph.outEdges(prefNode);
 while (i.hasNext()) {
  outEdge.add(new PrefuseObviousEdge((prefuse.data.Edge) i.next()));
 }
 return outEdge;
}

/**
 * Gets incident edges for a spotted node.
 * @param node spotted
 * @return collection of incident edges
 */
@SuppressWarnings("unchecked")
public Collection<Edge> getIncidentEdges(Node node) {
 Collection<Edge> edge = new ArrayList<Edge>();
 prefuse.data.Node prefNode = this.graph.getNodeFromKey(
   this.graph.getKey(node.getRow()));
 Iterator<Edge> i = this.graph.edges(prefNode);
 while (i.hasNext()) {
  edge.add(new PrefuseObviousEdge((prefuse.data.Edge) i.next()));
 }
 return edge;
}

/**
 * Gets the neighbors node.
 * @param node central node to determine the neighborhood
 * @return collection of nodes that are neighbors
 */
@SuppressWarnings("unchecked")
public Collection<Node> getNeighbors(Node node) {
 Collection<Node> neighbor = new ArrayList<Node>();
 prefuse.data.Node prefNode = this.graph.getNodeFromKey(
   this.graph.getKey(node.getRow()));
 Iterator<prefuse.data.Node> i = this.graph.neighbors(prefNode);
 while (i.hasNext()) {
  neighbor.add(new PrefuseObviousNode((prefuse.data.Node) i.next()));
 }
 return neighbor;
}

Most used methods

Popular in Java

Start an intent from android
getContentResolver (Context)
runOnUiThread (Activity)
scheduleAtFixedRate (Timer)
Schedules the specified task for repeated fixed-rate execution, beginning after the specified delay.
InputStream (java.io)
A readable source of bytes.Most clients will use input streams that read data from the file system (
RandomAccessFile (java.io)
Allows reading from and writing to a file in a random-access manner. This is different from the uni-
Dictionary (java.util)
The Dictionary class is the abstract parent of any class, such as Hashtable, which maps keys to valu
Filter (javax.servlet)
A filter is an object that performs filtering tasks on either the request to a resource (a servlet o
JList (javax.swing)
Location (org.springframework.beans.factory.parsing)
Class that models an arbitrary location in a Resource.Typically used to track the location of proble

How to useNode in obvious.data

Best Java code snippets using obvious.data.Node (Showing top 20 results out of 315)

How to use
Node
in
obvious.data