Module org.jgrapht.io
Package org.jgrapht.nio.json

Class JSONImporter<V,​E>

  • Type Parameters:
    V - the vertex type
    E - the edge type
    All Implemented Interfaces:
    GraphImporter<V,​E>
    public class JSONImporter<V,​E>
extends BaseEventDrivenImporter<V,​E>
implements GraphImporter<V,​E>
    Imports a graph from a JSON file. Below is a small example of a graph in JSON format. 
     {
   "nodes": [
     { "id": "1" },
     { "id": "2", "label": "Node 2 label" },
     { "id": "3" }
   ],
   "edges": [
     { "source": "1", "target": "2", "weight": 2.0, "label": "Edge between 1 and 2" },
     { "source": "2", "target": "3", "weight": 3.0, "label": "Edge between 2 and 3" }
   ]
 }

    In case the graph is weighted then the importer also reads edge weights. Otherwise edge weights are ignored. The importer also supports reading additional string attributes such as label or custom user attributes.

    The parser completely ignores elements from the input that are not related to vertices or edges of the graph. Moreover, complicated nested structures which are inside vertices or edges are simply returned as a whole. For example, in the following graph 

     {
   "nodes": [
     { "id": "1" },
     { "id": "2" }
   ],
   "edges": [
     { "source": "1", "target": "2", "points": { "x": 1.0, "y": 2.0 } }
   ]
 }
    the points attribute of the edge is returned as a string containing {"x":1.0,"y":2.0}. The same is done for arrays or any other arbitrary nested structure.

    The graph vertices and edges are build using the corresponding graph suppliers. The id of the vertices in the original dot file are reported as a vertex attribute named "ID". Thus, in case vertices in the dot file also contain an "ID" attribute, such an attribute will be reported multiple times.

    The default behavior of the importer is to use the graph vertex supplier in order to create vertices. The user can also bypass vertex creation by providing a custom vertex factory method using setVertexFactory(Function). The factory method is responsible to create a new graph vertex given the vertex identifier read from file. Additionally this importer also supports creating vertices with setVertexWithAttributesFactory(BiFunction). This factory method is responsible for creating a new graph vertex given the vertex identifier read from file together with all available attributes of the vertex at the location of the file where the vertex is first defined.

    The default behavior of the importer is to use the graph edge supplier in order to create edges. The user can also bypass edge creation by providing a custom edge factory method using setEdgeWithAttributesFactory(Function). The factory method is responsible to create a new graph edge given all available attributes of the edge at the location of the file where the edge is first defined.

    Author:
    Dimitrios Michail

    • Field Detail

      • DEFAULT_VERTEX_ID_KEY

        public static final String DEFAULT_VERTEX_ID_KEY
        Default key used for vertex ID.
        See Also:
        Constant Field Values

      • DEFAULT_VERTICES_COLLECTION_NAME

        public static final String DEFAULT_VERTICES_COLLECTION_NAME
        Default name for the vertices collection
        See Also:
        Constant Field Values

      • DEFAULT_EDGES_COLLECTION_NAME

        public static final String DEFAULT_EDGES_COLLECTION_NAME
        Default name for the edges collection
        See Also:
        Constant Field Values

    • Constructor Detail

      • JSONImporter

        public JSONImporter()
        Construct a new importer

    • Method Detail

      • importGraph

        public void importGraph​(Graph<V,​E> graph,
                        Reader input)
        Import a graph.

        The provided graph must be able to support the features of the graph that is read. For example if the file contains self-loops then the graph provided must also support self-loops. The same for multiple edges.

        If the provided graph is a weighted graph, the importer also reads edge weights. Otherwise edge weights are ignored.

        Specified by:
        importGraph in interface GraphImporter<V,​E>
        Parameters:
        graph - the output graph
        input - the input reader
        Throws:
        ImportException - in case an error occurs, such as I/O or parse error

      • getVertexFactory

        public Function<String,​V> getVertexFactory()
        Get the user custom vertex factory. This is null by default and the graph supplier is used instead.
        Returns:
        the user custom vertex factory

      • setVertexFactory

        public void setVertexFactory​(Function<String,​V> vertexFactory)
        Set the user custom vertex factory. The default behavior is being null in which case the graph vertex supplier is used. If supplied the vertex factory is called every time a new vertex is encountered in the file. The method is called with parameter the vertex identifier from the file and should return the actual graph vertex to add to the graph.
        Parameters:
        vertexFactory - a vertex factory

      • setVertexWithAttributesFactory

        public void setVertexWithAttributesFactory​(BiFunction<String,​Map<String,​Attribute>,​V> vertexWithAttributesFactory)
        Set the user custom vertex factory with attributes. The default behavior is being null in which case the graph vertex supplier is used. If supplied the vertex factory is called every time a new vertex is encountered in the input. The method is called with parameter the vertex identifier from the input and a set of attributes and should return the actual graph vertex to add to the graph. Note that the set of attributes might not be complete, as only attributes available at the first vertex definition are collected.
        Parameters:
        vertexWithAttributesFactory - a vertex factory with attributes

      • getEdgeWithAttributesFactory

        public Function<Map<String,​Attribute>,​E> getEdgeWithAttributesFactory()
        Get the user custom edges factory with attributes. This is null by default and the graph supplier is used instead.
        Returns:
        the user custom edge factory with attributes.

      • setEdgeWithAttributesFactory

        public void setEdgeWithAttributesFactory​(Function<Map<String,​Attribute>,​E> edgeWithAttributesFactory)
        Set the user custom edge factory with attributes. The default behavior is being null in which case the graph edge supplier is used. If supplied the edge factory is called every time a new edge is encountered in the input. The method is called with parameter the set of attributes and should return the actual graph edge to add to the graph. Note that the set of attributes might not be complete, as only attributes available at the first edge definition are collected.
        Parameters:
        edgeWithAttributesFactory - an edge factory with attributes

      • getVerticesCollectionName

        public String getVerticesCollectionName()
        Get the name used for the vertices collection in the file.
        Returns:
        the name used for the vertices collection in the file.

      • setVerticesCollectionName

        public void setVerticesCollectionName​(String verticesCollectionName)
        Set the name used for the vertices collection in the file.
        Parameters:
        verticesCollectionName - the name

      • getEdgesCollectionName

        public String getEdgesCollectionName()
        Get the name used for the edges collection in the file.
        Returns:
        the name used for the edges collection in the file.

      • setEdgesCollectionName

        public void setEdgesCollectionName​(String edgesCollectionName)
        Set the name used for the edges collection in the file.
        Parameters:
        edgesCollectionName - the name