Package com.jgalgo.graph

Interface IntGraphFactory

  • All Superinterfaces:
    GraphFactory<Integer,​Integer>
    All Known Subinterfaces:
    IndexGraphFactory
    public interface IntGraphFactory
extends GraphFactory<Integer,​Integer>
    A factory for IntGraph objects.

    The factory can be used to create new empty graphs, with different options and capabilities. Few methods are available to optimize the graph implementation choice. The factory can also be used to create a copy of an existing graphs, with the same vertices and edges, with/without copying the vertices/edges weights.

    Both the graph factory and IntGraphBuilder are used to create new graphs. The difference is that vertices and edges can be added to the builder, which is then used to construct non empty graphs, while the factory is only used to choose a graph implementation and create an empty graph.

    This interface is a specific version of GraphFactory for IntGraph.

    Author:
    Barak Ugav
    See Also:
    newDirected(), newUndirected(), IntGraph, IntGraphBuilder

    • Method Detail

      • newCopyOf

        default IntGraph newCopyOf​(Graph<Integer,​Integer> g)
        Description copied from interface: GraphFactory
        Create a copy of a given graph, with the same vertices and edges, without copying weights.

        An identical copy of the given graph will be created, with the same vertices and edges, without copying the vertices/edges weights. The returned Graph will always be modifiable, with no side affects on the original graph.

        Differing from Graph.copy(), the capabilities of the new graph are determined by the factory configuration, rather than copied from the given graph. Note for example that if the factory chooses to use an implementation that does not (have to) support self edges (if GraphFactory.allowSelfEdges(boolean) was not called with true), attempting to create a copy of a graph that does contains self edges will result in an exception.

        Specified by:
        newCopyOf in interface GraphFactory<Integer,​Integer>
        Parameters:
        g - the original graph to copy
        Returns:
        an identical copy of the given graph, with the same vertices and edges, without the original graph weights

      • newCopyOf

        IntGraph newCopyOf​(Graph<Integer,​Integer> g,
                   boolean copyWeights)
        Description copied from interface: GraphFactory
        Create a copy of a given graph, with the same vertices and edges, with/without copying weights.

        An identical copy of the given graph will be created, with the same vertices and edges, with/without copying the vertices/edges weights. The returned Graph will always be modifiable, with no side affects on the original graph.

        Differing from Graph.copy(boolean), the capabilities of the new graph are determined by the factory configuration, rather than copied from the given graph. Note for example that if the factory chooses to use an implementation that does not (have to) support self edges (if GraphFactory.allowSelfEdges(boolean) was not called with true), attempting to create a copy of a graph that does contains self edges will result in an exception.

        Specified by:
        newCopyOf in interface GraphFactory<Integer,​Integer>
        Parameters:
        g - the original graph to copy
        copyWeights - if true, the weights of the vertices and edges will be copied to the new graph
        Returns:
        an identical copy of the given graph, with the same vertices and edges, with/without the original graph weights

      • newBuilder

        IntGraphBuilder newBuilder()
        Description copied from interface: GraphFactory
        Create a new graph builder with the factory parameters.

        The created builder can be used to add vertices and edges, and then build a (mutable or immutable) non empty graph, differing from the factory which only builds empty graphs. The capabilities such as un/directed, support of self edges, support of parallel edges, and hints such as expected number of vertices and edges, other hints, etc. are copied from the factory to the builder.

        Specified by:
        newBuilder in interface GraphFactory<Integer,​Integer>
        Returns:
        a new graph builder with the factory parameters

      • setDirected

        IntGraphFactory setDirected​(boolean directed)
        Description copied from interface: GraphFactory
        Determine if graphs built by this factory should be directed or not.
        Specified by:
        setDirected in interface GraphFactory<Integer,​Integer>
        Parameters:
        directed - if true, graphs built by this factory will be directed
        Returns:
        this factory

      • allowSelfEdges

        IntGraphFactory allowSelfEdges​(boolean selfEdges)
        Description copied from interface: GraphFactory
        Determine if graphs built by this factory should be support self edges.
        Specified by:
        allowSelfEdges in interface GraphFactory<Integer,​Integer>
        Parameters:
        selfEdges - if true, graphs built by this factory will support self edges
        Returns:
        this factory

      • allowParallelEdges

        IntGraphFactory allowParallelEdges​(boolean parallelEdges)
        Description copied from interface: GraphFactory
        Determine if graphs built by this factory should be support parallel edges.
        Specified by:
        allowParallelEdges in interface GraphFactory<Integer,​Integer>
        Parameters:
        parallelEdges - if true, graphs built by this factory will support parallel edges
        Returns:
        this factory

      • expectedVerticesNum

        IntGraphFactory expectedVerticesNum​(int expectedVerticesNum)
        Description copied from interface: GraphFactory
        Set the expected number of vertices that will exist in the graph.
        Specified by:
        expectedVerticesNum in interface GraphFactory<Integer,​Integer>
        Parameters:
        expectedVerticesNum - the expected number of vertices in the graph
        Returns:
        this factory

      • expectedEdgesNum

        IntGraphFactory expectedEdgesNum​(int expectedEdgesNum)
        Description copied from interface: GraphFactory
        Set the expected number of edges that will exist in the graph.
        Specified by:
        expectedEdgesNum in interface GraphFactory<Integer,​Integer>
        Parameters:
        expectedEdgesNum - the expected number of edges in the graph
        Returns:
        this factory

      • newUndirected

        static IntGraphFactory newUndirected()
        Create an undirected int graph factory.
        Returns:
        a new factory that can build undirected int graphs

      • newDirected

        static IntGraphFactory newDirected()
        Create a directed int graph factory.
        Returns:
        a new factory that can build directed int graphs

      • newFrom

        static IntGraphFactory newFrom​(IntGraph g)
        Create a new graph factory based on a given implementation.

        The new factory will build graphs with the same capabilities (inclusive) as the given graph, possibly choosing to use a similar implementation. The factory will NOT copy the graph itself (the vertices, edges and weights), for such use case see IntGraph.copy() or newCopyOf(Graph).

        Parameters:
        g - a graph from which the factory should copy its capabilities (inclusive)
        Returns:
        a new graph factory that will create graphs with the same capabilities (inclusive) of the given graph

      • setOption

        default IntGraphFactory setOption​(String key,
                                  Object value)
        Description copied from interface: GraphFactory
        [TL;DR Don't call me!] Set an option.

        The builder might support different options to customize its implementation. These options never change the behavior of the algorithm, only its internal implementation. The possible options are not exposed as 'public' because they are not part of the API and may change in the future.

        These options are mainly for debug and benchmark purposes.

        Specified by:
        setOption in interface GraphFactory<Integer,​Integer>
        Parameters:
        key - the option key
        value - the option value
        Returns:
        this builder