org.apache.tinkerpop.gremlin.structure.util.star

## Class StarGraph

- java.lang.Object
- - org.apache.tinkerpop.gremlin.structure.util.star.StarGraph

- All Implemented Interfaces:
    Serializable, AutoCloseable, Graph, Host

      public final class StarGraph
      extends Object
      implements Graph, Serializable

  A `StarGraph` is a form of `Attachable` (though the `Graph` implementation does not implement that interface itself). It is a very limited `Graph` implementation that holds a single `Vertex` and its related properties and edges (and their properties). It is designed to be an efficient memory representation of this data structure, thus making it good for network and disk-based serialization.
  Author:
    Marko A. Rodriguez (http://markorodriguez.com)
  See Also:
    Serialized Form

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `StarGraph.Builder` StarGraph builder with options to customize its internals
    `class` | `StarGraph.StarAdjacentVertex`
    `class` | `StarGraph.StarEdge`
    `class` | `StarGraph.StarElement<E extends Element>`
    `static class` | `StarGraph.StarGraphFeatures`
    `class` | `StarGraph.StarInEdge`
    `class` | `StarGraph.StarOutEdge`
    `class` | `StarGraph.StarProperty<V>`
    `class` | `StarGraph.StarVertex`
    `class` | `StarGraph.StarVertexProperty<V>`

    - ### Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.structure.Graph

      `Graph.Exceptions, Graph.Features, Graph.Hidden, Graph.OptIn, Graph.OptIns, Graph.OptOut, Graph.OptOuts, Graph.Variables`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected boolean` | `compareIdsUsingStrings`
    `protected Map<Object,Map<String,Object>>` | `edgeProperties`
    `protected boolean` | `internStrings`
    `protected Map<Object,Map<String,Object>>` | `metaProperties`
    `protected Long` | `nextId`
    `protected StarGraph.StarVertex` | `starVertex`

    - ### Fields inherited from interface org.apache.tinkerpop.gremlin.structure.Graph

      `GRAPH`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `Vertex` | `addVertex(Object... keyValues)` Add a `Vertex` to the graph given an optional series of key/value pairs.
    `Optional<StarGraph>` | `applyGraphFilter(GraphFilter graphFilter)`
    `static StarGraph.Builder` | `build()`
    `static StarGraph.Builder` | `builder()` Deprecated. As of release 3.3.5, replaced by `build()`.
    `void` | `close()` Closing a `Graph` is equivalent to "shutdown" and implies that no further operations can be executed on the instance.
    `GraphComputer` | `compute()` Generate a `GraphComputer` using the default engine of the underlying graph system.
    `<C extends GraphComputer> C` | `compute(Class<C> graphComputerClass)` Declare the `GraphComputer` to use for OLAP operations on the graph.
    `Configuration` | `configuration()` Get the `Configuration` associated with the construction of this graph.
    `Iterator<Edge>` | `edges(Object... edgeIds)` Get the `Edge` objects in this graph with the provided edge ids or `Edge` objects.
    `Graph.Features` | `features()` Gets the `Graph.Features` exposed by the underlying `Graph` implementation.
    `StarGraph.StarVertex` | `getStarVertex()` Gets the `Vertex` representative of the `StarGraph`.
    `static StarGraph` | `of(Vertex vertex)` Creates a new `StarGraph` from a `Vertex`.
    `static StarGraph` | `open()` Creates an empty `StarGraph`.
    `String` | `toString()`
    `Transaction` | `tx()` Configure and control the transactions for those graphs that support this feature.
    `Graph.Variables` | `variables()` A collection of global `Graph.Variables` associated with the graph.
    `Iterator<Vertex>` | `vertices(Object... vertexIds)` Get the `Vertex` objects in this graph with the provided vertex ids or `Vertex` objects themselves.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface org.apache.tinkerpop.gremlin.structure.Graph

      `addVertex, io, traversal, traversal`

    - ### Methods inherited from interface org.apache.tinkerpop.gremlin.structure.util.Host

      `getHostingVertex`

- - ### Field Detail

    - #### nextId

          protected Long nextId

    - #### starVertex

          protected StarGraph.StarVertex starVertex

    - #### edgeProperties

          protected Map<Object,Map<String,Object>> edgeProperties

    - #### metaProperties

          protected Map<Object,Map<String,Object>> metaProperties

    - #### internStrings

          protected final boolean internStrings

    - #### compareIdsUsingStrings

          protected final boolean compareIdsUsingStrings

  - ### Method Detail

    - #### getStarVertex

          public StarGraph.StarVertex getStarVertex()

      Gets the `Vertex` representative of the `StarGraph`.

    - #### addVertex

          public Vertex addVertex(Object... keyValues)

      Description copied from interface: `Graph`
      Add a `Vertex` to the graph given an optional series of key/value pairs. These key/values must be provided in an even number where the odd numbered arguments are `String` property keys and the even numbered arguments are the related property values.
      Specified by:
        `addVertex` in interface `Graph`
      Parameters:
        `keyValues` - The key/value pairs to turn into vertex properties
      Returns:
        The newly created vertex

    - #### compute

          public <C extends GraphComputer> C compute(Class<C> graphComputerClass)
                                              throws IllegalArgumentException

      Description copied from interface: `Graph`
      Declare the `GraphComputer` to use for OLAP operations on the graph. If the graph does not support graph computer then an `UnsupportedOperationException` is thrown.
      Specified by:
        `compute` in interface `Graph`
      Parameters:
        `graphComputerClass` - The graph computer class to use.
      Returns:
        A graph computer for processing this graph
      Throws:
        `IllegalArgumentException` - if the provided `GraphComputer` class is not supported.

    - #### compute

          public GraphComputer compute()
                                throws IllegalArgumentException

      Description copied from interface: `Graph`
      Generate a `GraphComputer` using the default engine of the underlying graph system. This is a shorthand method for the more involved method that uses `Graph.compute(Class)`.
      Specified by:
        `compute` in interface `Graph`
      Returns:
        A default graph computer
      Throws:
        `IllegalArgumentException` - if there is no default graph computer

    - #### vertices

          public Iterator<Vertex> vertices(Object... vertexIds)

      Description copied from interface: `Graph`
      Get the `Vertex` objects in this graph with the provided vertex ids or `Vertex` objects themselves. If no ids are provided, get all vertices. Note that a vertex identifier does not need to correspond to the actual id used in the graph. It needs to be a bit more flexible than that in that given the `Graph.Features` around id support, multiple arguments might be applicable here.

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsNumericIds()` then it should support filters as with:
      - g.vertices(v)
      - g.vertices(v.id())
      - g.vertices(1)
      - g.vertices(1L)
      - g.vertices(1.0d)
      - g.vertices(1.0f)
      - g.vertices("1")

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsCustomIds()` ()} then it should support filters as with:
      - g.vertices(v)
      - g.vertices(v.id())
      - g.vertices(v.id().toString())

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsAnyIds()` ()} then it should support filters as with:
      - g.vertices(v)
      - g.vertices(v.id())

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsStringIds()` ()} then it should support filters as with:
      - g.vertices(v)
      - g.vertices(v.id().toString())
      - g.vertices("id")

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsStringIds()` ()} then it should support filters as with:
      - g.vertices(v)
      - g.vertices(v.id().toString())
      - g.vertices("id")
      Specified by:
        `vertices` in interface `Graph`
      Parameters:
        `vertexIds` - the ids of the vertices to get
      Returns:
        an `Iterator` of vertices that match the provided vertex ids

    - #### edges

          public Iterator<Edge> edges(Object... edgeIds)

      Description copied from interface: `Graph`
      Get the `Edge` objects in this graph with the provided edge ids or `Edge` objects. If no ids are provided, get all edges. Note that an edge identifier does not need to correspond to the actual id used in the graph. It needs to be a bit more flexible than that in that given the `Graph.Features` around id support, multiple arguments might be applicable here.

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsNumericIds()` then it should support filters as with:
      - g.edges(e)
      - g.edges(e.id())
      - g.edges(1)
      - g.edges(1L)
      - g.edges(1.0d)
      - g.edges(1.0f)
      - g.edges("1")

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsCustomIds()` ()} then it should support filters as with:
      - g.edges(e)
      - g.edges(e.id())
      - g.edges(e.id().toString())

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsAnyIds()` ()} then it should support filters as with:
      - g.edges(e)
      - g.edges(e.id())

      If the graph return `true` for `Graph.Features.ElementFeatures.supportsStringIds()` ()} then it should support filters as with:
      - g.edges(e)
      - g.edges(e.id().toString())
      - g.edges("id")
      Specified by:
        `edges` in interface `Graph`
      Parameters:
        `edgeIds` - the ids of the edges to get
      Returns:
        an `Iterator` of edges that match the provided edge ids

    - #### tx

          public Transaction tx()

      Description copied from interface: `Graph`
      Configure and control the transactions for those graphs that support this feature. Note that this method does not indicate the creation of a "transaction" object. A `Transaction` in the TinkerPop context is a transaction "factory" or "controller" that helps manage transactions owned by the underlying graph database.
      Specified by:
        `tx` in interface `Graph`

    - #### variables

          public Graph.Variables variables()

      Description copied from interface: `Graph`
      A collection of global `Graph.Variables` associated with the graph. Variables are used for storing metadata about the graph.
      Specified by:
        `variables` in interface `Graph`
      Returns:
        The variables associated with this graph

    - #### configuration

          public Configuration configuration()

      Description copied from interface: `Graph`
      Get the `Configuration` associated with the construction of this graph. Whatever configuration was passed to `GraphFactory.open(Configuration)` is what should be returned by this method.
      Specified by:
        `configuration` in interface `Graph`
      Returns:
        the configuration used during graph construction.

    - #### features

          public Graph.Features features()

      Description copied from interface: `Graph`
      Gets the `Graph.Features` exposed by the underlying `Graph` implementation.
      Specified by:
        `features` in interface `Graph`

    - #### close

          public void close()
                     throws Exception

      Description copied from interface: `Graph`
      Closing a `Graph` is equivalent to "shutdown" and implies that no further operations can be executed on the instance. Users should consult the documentation of the underlying graph database implementation for what this "shutdown" will mean in general and, if supported, how open transactions are handled. It will typically be the end user's responsibility to synchronize the thread that calls `close()` with other threads that are accessing open transactions. In other words, be sure that all work performed on the `Graph` instance is complete prior to calling this method.

      TinkerPop does not enforce any particular semantics with respect to "shutdown". It is up to the graph provider to decide what this method will do.
      Specified by:
        `close` in interface `AutoCloseable`
      Specified by:
        `close` in interface `Graph`
      Throws:
        `Exception`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### open

          public static StarGraph open()

      Creates an empty `StarGraph`.

    - #### of

          public static StarGraph of(Vertex vertex)

      Creates a new `StarGraph` from a `Vertex`.

    - #### builder

          @Deprecated
          public static StarGraph.Builder builder()

      Deprecated. As of release 3.3.5, replaced by `build()`.

    - #### build

          public static StarGraph.Builder build()

    - #### applyGraphFilter

          public Optional<StarGraph> applyGraphFilter(GraphFilter graphFilter)

Copyright © 2013–2021 Apache Software Foundation. All rights reserved.