Interface Graph

All Known Subinterfaces:
BackwardRuleInfGraphI, ForwardRuleInfGraphI, GraphWithPerform, InfGraph
All Known Implementing Classes:
BaseInfGraph, BasicForwardRuleInfGraph, CollectionGraph, CompositionBase, Delta, Difference, DisjointUnion, Dyadic, FBRuleInfGraph, GraphBase, GraphMem, GraphMem2, GraphMem2Fast, GraphMem2Legacy, GraphMem2Roaring, GraphMemBase, GraphPlain, Intersection, LPBackwardRuleInfGraph, MonitorGraph, MultiUnion, Polyadic, RandomOrderGraph, RDFSRuleInfGraph, RETERuleInfGraph, SafeGraph, TransitiveInfGraph, Union, WrappedGraph

public interface Graph
The interface to be satisfied by implementations maintaining collections of RDF triples. The core interface is small (add, delete, find, contains) and is augmented by additional classes to handle more complicated matters such as event management. The good practice is to explicitly close every ExtendedIterator and Stream produced by the Graph right after query operation. Depending on the implementation, the iterator and stream may throw a ConcurrentModificationException if continued with it after modification operation. This may happen even if the queried data does not relate directly to the modified data (i.e. when triple search pattern does not match added or deleted triple). A ExtendedIterator and Stream should be operated on (invoking materializing ExtendedIterator or terminal Stream operation) only once; in general reusable are not allowed and may lead to an exception.
See Also:
  • Field Details

    • emptyGraph

      static final Graph emptyGraph
      An immutable empty graph.
  • Method Details

    • dependsOn

      boolean dependsOn(Graph other)
      true if this graph's content depends on the other graph. May be pessimistic (ie return true if it's not sure). Typically true when a graph is a composition of other graphs, eg union.
      Parameters:
      other - the graph this graph may depend on
      Returns:
      false if this does not depend on other
    • getTransactionHandler

      TransactionHandler getTransactionHandler()
      returns this Graph's transaction handler
    • getCapabilities

      Capabilities getCapabilities()
      returns this Graph's capabilities
    • getEventManager

      GraphEventManager getEventManager()
      Answer this Graph's event manager.
    • getPrefixMapping

      PrefixMapping getPrefixMapping()
      returns this Graph's prefix mapping. Each call on a given Graph gets the same PrefixMapping object, which is the one used by the Graph.
    • add

      void add(Triple t) throws AddDeniedException
      Add the triple t (if possible) to the set belonging to this graph
      Parameters:
      t - the triple to add to the graph
      Throws:
      AddDeniedException - if the triple cannot be added
    • add

      default void add(Node s, Node p, Node o) throws AddDeniedException
      Add the triple comprised of s,p,o to the set belonging to this graph
      Throws:
      AddDeniedException - if the triple cannot be added
    • delete

      void delete(Triple t) throws DeleteDeniedException
      Delete the triple t (if possible) from the set belonging to this graph
      Parameters:
      t - the triple to delete to the graph
      Throws:
      DeleteDeniedException - if the triple cannot be removed
    • delete

      default void delete(Node s, Node p, Node o) throws DeleteDeniedException
      Delete the triple comprised of s,p,o from the set belonging to this graph
      Throws:
      AddDeniedException - if the triple cannot be added
      DeleteDeniedException
    • find

      Returns an iterator over all the Triples that match the triple pattern.
      Parameters:
      m - a Triple encoding the pattern to look for
      Returns:
      an iterator of all triples in this graph that match m
    • find

      ExtendedIterator<Triple> find(Node s, Node p, Node o)
      Returns an iterator over Triples matching a pattern.
      Returns:
      an iterator of triples in this graph matching the pattern.
    • stream

      default Stream<Triple> stream(Node s, Node p, Node o)
      Returns a Stream of Triples matching a pattern.
      Returns:
      a stream of triples in this graph matching the pattern.
    • stream

      default Stream<Triple> stream()
      Returns a Stream of all triples in the graph.
      Returns:
      a stream of triples in this graph.
    • find

      default ExtendedIterator<Triple> find()
      Returns an iterator over all Triples in the graph. Equivalent to find(Node.ANY, Node.ANY, Node.ANY)
      Returns:
      an iterator of all triples in this graph
    • isIsomorphicWith

      boolean isIsomorphicWith(Graph g)
      Compare this graph with another using the method described in http://www.w3.org/TR/rdf-concepts#section-Graph-syntax Note: this implementation does not handle correctly blank nodes in quoted triples (RDF-star). If you need to work with RDF-star, use the slower implementation in org.apache.jena.sparql.util.IsoMatcher.
      Parameters:
      g - Compare against this.
      Returns:
      boolean True if the two graphs are isomorphic.
    • contains

      boolean contains(Node s, Node p, Node o)
      Answer true iff the graph contains a triple matching (s, p, o). s/p/o may be concrete or fluid. Equivalent to find(s,p,o).hasNext, but an implementation is expected to optimise this in easy cases.
    • contains

      boolean contains(Triple t)
      Answer true iff the graph contains a triple that t matches; t may be fluid.
    • clear

      void clear()
      Remove all the statements from this graph.
    • remove

      void remove(Node s, Node p, Node o)
      Remove all triples that match by find(s, p, o)
    • close

      void close()
      Free all resources, any further use of this Graph is an error.
    • isEmpty

      boolean isEmpty()
      Answer true iff this graph is empty. "Empty" means "has as few triples as it can manage", because an inference graph may have irremovable axioms and their consequences.
    • size

      int size()
      For a concrete graph this returns the number of triples in the graph. For graphs which might infer additional triples it results an estimated lower bound of the number of triples. For example, an inference graph might return the number of triples in the raw data graph.
    • isClosed

      boolean isClosed()
      Answer true iff .close() has been called on this Graph.