Package com.jgalgo.gen

Class EmptyGraphGenerator<V,E>

java.lang.Object
com.jgalgo.gen.EmptyGraphGenerator<V,E>
Type Parameters:
V - the vertices type
E - the edges type
All Implemented Interfaces:
GraphGenerator<V,E>
public class EmptyGraphGenerator<V,E> extends Object implements GraphGenerator<V,E>
Generate a graph with no edges.

An empty graph is a graph with no edges, and it may contains some vertices.

Author:
Barak Ugav

  • Constructor Details

    • EmptyGraphGenerator

      public EmptyGraphGenerator()
      Create a new empty generator that will use the default graph factory.

      The default graph factory does not have a default vertex builder, so if only the number of vertices is set using vertices(int), the vertex builder must be set explicitly using graphFactory().setVertexBuilder(...). Alternatively, the methods vertices(int, IdBuilder) can be used to set the number of vertices and provide a vertex/edge builder that will override the (maybe non existing) vertex builder of the graph factory. The vertex set can also be set explicitly using vertices(Collection).

    • EmptyGraphGenerator

      public EmptyGraphGenerator(GraphFactory<V,E> factory)
      Create a new empty generator that will use the given graph factory.

      If the factory has a vertex builder, it will be used to generate the vertices of the generated graph(s) if only the number of vertices is set using vertices(int). Set

      During the graph(s) generation, the method GraphFactory.setDirected(boolean) of the given factory will be called to align the created graph with the generator configuration.

      To generate int graphs, pass an instance of IntGraphFactory to this constructor.

      Parameters:
      factory - the graph factory that will be used to create the generated graph(s)

  • Method Details

    • graphFactory

      public GraphFactory<V,E> graphFactory()
      Get the graph factory that will be used to create the generated graph(s).

      It's possible to customize the factory before generating the graph(s), for example by using GraphFactory.addHint(GraphFactory.Hint) to optimize the generated graph(s) for a specific algorithm. The vertex builder will be used to generate the vertices of the generated graph(s) if only the number of vertices is set using vertices(int). Set the vertex builder of the factory to use these functions.

      During the graph(s) generation, the method GraphFactory.setDirected(boolean) of the given factory will be called to align the created graph with the generator configuration.

      Returns:
      the graph factory that will be used to create the generated graph(s)

    • emptyGraph

      public static <V, E> Graph<V,E> emptyGraph(Collection<? extends V> vertices)
      Generate a new empty undirected graph.
      Type Parameters:
      V - the vertices type
      E - the edges type
      Parameters:
      vertices - the vertices of the generated graph
      Returns:
      a new empty undirected graph

    • vertices

      public EmptyGraphGenerator<V,E> vertices(Collection<? extends V> vertices)
      Set the vertices set of the generated graph(s).

      If the generator is used to generate multiple graphs, the same vertex set will be used for all of them. This method override all previous calls to any of vertices(Collection), vertices(int) or vertices(int, IdBuilder).

      Parameters:
      vertices - the vertices set
      Returns:
      this generator

    • vertices

      public EmptyGraphGenerator<V,E> vertices(int verticesNum)
      Set the number of vertices that will be generated for each graph.

      The vertices will be generated using the vertex builder of the graph factory, see GraphFactory.setVertexBuilder(IdBuilder). The default graph factory does not have a vertex builder, so it must be set explicitly, or IntGraphFactory, which does have such builder, should be passed in the constructor. Another alternative is to use vertices(int, IdBuilder) which set the number of vertices and provide a vertex builder that will override the (maybe non existing) vertex builder of the graph factory. The generation will happen independently for each graph generated. If there is no vertex builder, an exception will be thrown during generation. This method override all previous calls to any of vertices(Collection), vertices(int) or vertices(int, IdBuilder).

      Parameters:
      verticesNum - the number of vertices that will be generated for each graph
      Returns:
      this generator
      Throws:
      IllegalArgumentException - if verticesNum is negative

    • vertices

      public EmptyGraphGenerator<V,E> vertices(int verticesNum, IdBuilder<V> vertexBuilder)
      Set the number of vertices that will be generated for each graph, and the vertex builder that will be used to generate them.

      The vertices will be generated using the provided vertex builder, and the vertex generator provided by the graph factory (if exists) will be ignored. The generation will happen independently for each graph generated. This method override all previous calls to any of vertices(Collection), vertices(int) or vertices(int, IdBuilder).

      Parameters:
      verticesNum - the number of vertices that will be generated for each graph
      vertexBuilder - the vertex builder, or null to use the vertex builder of the graph factory
      Returns:
      this generator
      Throws:
      IllegalArgumentException - if verticesNum is negative

    • directed

      public EmptyGraphGenerator<V,E> directed(boolean directed)
      Determine if the generated graph(s) is directed or undirected.

      By default, the generated graph(s) is undirected.

      Parameters:
      directed - true if the generated graph(s) will be directed, false if undirected
      Returns:
      this generator

    • generateIntoBuilder

      public GraphBuilder<V,E> generateIntoBuilder()
      Description copied from interface: GraphGenerator
      Generates a graph into a builder.

      This is the a more flexible way to generate a graph. The builder can be used to generate a mutable or immutable graph, or to add additional vertices or edges on top of the generated ones.

      Specified by:
      generateIntoBuilder in interface GraphGenerator<V,E>
      Returns:
      a new graph builder populated by the generator with the generator parameters