org.eclipse.rdf4j.repository.event.base

## Class InterceptingRepositoryConnectionWrapper

- java.lang.Object
- - org.eclipse.rdf4j.repository.base.AbstractRepositoryConnection
  - - org.eclipse.rdf4j.repository.base.RepositoryConnectionWrapper
    - - org.eclipse.rdf4j.repository.event.base.InterceptingRepositoryConnectionWrapper

- All Implemented Interfaces:
    AutoCloseable, DelegatingRepositoryConnection, InterceptingRepositoryConnection, RepositoryConnection

      public class InterceptingRepositoryConnectionWrapper
      extends RepositoryConnectionWrapper
      implements InterceptingRepositoryConnection

  Wrapper that notifies interceptors of events on RepositoryConnections before they happen. Any interceptor can block the operation by returning true from the relevant notification method. To do so will also cause the notification process to stop, i.e. no other interceptors will be notified. The order in which interceptors are notified is unspecified.
  Author:
    Herko ter Horst
  See Also:
    `InterceptingRepositoryWrapper`

- - ### Field Summary

    - ### Fields inherited from class org.eclipse.rdf4j.repository.base.AbstractRepositoryConnection

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `InterceptingRepositoryConnectionWrapper(Repository repository, RepositoryConnection connection)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addRepositoryConnectionInterceptor(RepositoryConnectionInterceptor interceptor)` Registers a `RepositoryConnectionInterceptor` that will receive notifications of operations that are performed on this connection.
    `void` | `addWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)`
    `void` | `begin()` Begins a new transaction, requiring `RepositoryConnection.commit()` or `RepositoryConnection.rollback()` to be called to end the transaction.
    `void` | `clear(Resource... contexts)` Removes all statements from a specific contexts in the repository.
    `void` | `clearNamespaces()` Removes all namespace declarations from the repository.
    `void` | `close()` Closes the connection, freeing resources.
    `void` | `commit()` Commits the active transaction.
    `protected boolean` | `isDelegatingAdd()` If false then the following add methods will call `RepositoryConnectionWrapper.addWithoutCommit(Resource, IRI, Value, Resource[])`.
    `protected boolean` | `isDelegatingRemove()` If false then the following remove methods will call `RepositoryConnectionWrapper.removeWithoutCommit(Resource, IRI, Value, Resource[])`.
    `Update` | `prepareUpdate(QueryLanguage ql, String update, String baseURI)` Prepares an Update operation.
    `void` | `removeNamespace(String prefix)` Removes a namespace declaration by removing the association between a prefix and a namespace name.
    `void` | `removeRepositoryConnectionInterceptor(RepositoryConnectionInterceptor interceptor)` Removes a registered `RepositoryConnectionInterceptor` from this connection.
    `void` | `removeWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts)`
    `void` | `rollback()` Rolls back all updates in the active transaction.
    `void` | `setAutoCommit(boolean autoCommit)` Deprecated.
    `void` | `setNamespace(String prefix, String name)` Sets the prefix for a namespace.

    - ### Methods inherited from class org.eclipse.rdf4j.repository.base.RepositoryConnectionWrapper

      `add, add, add, add, add, add, add, add, begin, begin, exportStatements, exportStatements, getContextIDs, getDelegate, getIsolationLevel, getNamespace, getNamespaces, getStatements, hasStatement, hasStatement, isActive, isAutoCommit, isDelegatingRead, isEmpty, isOpen, prepareBooleanQuery, prepareGraphQuery, prepareQuery, prepareTupleQuery, remove, remove, remove, remove, setDelegate, setIsolationLevel, setParserConfig, size`

    - ### Methods inherited from class org.eclipse.rdf4j.repository.base.AbstractRepositoryConnection

      `addWithoutCommit, conditionalCommit, conditionalRollback, export, getParserConfig, getRepository, getValueFactory, prepareBooleanQuery, prepareGraphQuery, prepareQuery, prepareTupleQuery, prepareUpdate, removeWithoutCommit, startLocalTransaction`

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

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

    - ### Methods inherited from interface org.eclipse.rdf4j.repository.RepositoryConnection

      `add, add, add, add, add, add, add, add, add, add, begin, begin, export, exportStatements, getContextIDs, getIsolationLevel, getNamespace, getNamespaces, getParserConfig, getRepository, getStatements, getStatements, getStatements, getValueFactory, hasStatement, hasStatement, hasStatement, isActive, isAutoCommit, isEmpty, isOpen, prepareBooleanQuery, prepareBooleanQuery, prepareBooleanQuery, prepareGraphQuery, prepareGraphQuery, prepareGraphQuery, prepareQuery, prepareQuery, prepareQuery, prepareTupleQuery, prepareTupleQuery, prepareTupleQuery, prepareUpdate, prepareUpdate, remove, remove, remove, remove, remove, remove, setIsolationLevel, setParserConfig, size`

- - ### Constructor Detail

    - #### InterceptingRepositoryConnectionWrapper

          public InterceptingRepositoryConnectionWrapper(Repository repository,
                                                         RepositoryConnection connection)

  - ### Method Detail

    - #### addRepositoryConnectionInterceptor

          public void addRepositoryConnectionInterceptor(RepositoryConnectionInterceptor interceptor)

      Registers a `RepositoryConnectionInterceptor` that will receive notifications of operations that are performed on this connection.
      Specified by:
        `addRepositoryConnectionInterceptor` in interface `InterceptingRepositoryConnection`

    - #### removeRepositoryConnectionInterceptor

          public void removeRepositoryConnectionInterceptor(RepositoryConnectionInterceptor interceptor)

      Removes a registered `RepositoryConnectionInterceptor` from this connection.
      Specified by:
        `removeRepositoryConnectionInterceptor` in interface `InterceptingRepositoryConnection`

    - #### isDelegatingAdd

          protected boolean isDelegatingAdd()

      Description copied from class: `RepositoryConnectionWrapper`
      If false then the following add methods will call `RepositoryConnectionWrapper.addWithoutCommit(Resource, IRI, Value, Resource[])`.
      Overrides:
        `isDelegatingAdd` in class `RepositoryConnectionWrapper`
      Returns:
        `true` to delegate add methods, `false` to call `RepositoryConnectionWrapper.addWithoutCommit(Resource, IRI, Value, Resource[])`
      See Also:
        `RepositoryConnectionWrapper.add(Iterable, Resource...)`, `RepositoryConnectionWrapper.add(Iteration, Resource...)`, `RepositoryConnectionWrapper.add(Statement, Resource...)`, `RepositoryConnectionWrapper.add(File, String, RDFFormat, Resource...)`, `RepositoryConnectionWrapper.add(InputStream, String, RDFFormat, Resource...)`, `RepositoryConnectionWrapper.add(Reader, String, RDFFormat, Resource...)`, `RepositoryConnectionWrapper.add(Resource, IRI, Value, Resource...)`, `RepositoryConnectionWrapper.add(URL, String, RDFFormat, Resource...)`

    - #### isDelegatingRemove

          protected boolean isDelegatingRemove()

      Description copied from class: `RepositoryConnectionWrapper`
      If false then the following remove methods will call `RepositoryConnectionWrapper.removeWithoutCommit(Resource, IRI, Value, Resource[])`.
      Overrides:
        `isDelegatingRemove` in class `RepositoryConnectionWrapper`
      Returns:
        `true` to delegate remove methods, `false` to call `RepositoryConnectionWrapper.removeWithoutCommit(Resource, IRI, Value, Resource...)`
      See Also:
        `RepositoryConnectionWrapper.clear(Resource...)`, `RepositoryConnectionWrapper.remove(Iterable, Resource...)`, `RepositoryConnectionWrapper.remove(Iteration, Resource...)`, `RepositoryConnectionWrapper.remove(Statement, Resource...)`, `RepositoryConnectionWrapper.remove(Resource, IRI, Value, Resource...)`

    - #### addWithoutCommit

          public void addWithoutCommit(Resource subject,
                                       IRI predicate,
                                       Value object,
                                       Resource... contexts)
                                throws RepositoryException

      Overrides:
        `addWithoutCommit` in class `RepositoryConnectionWrapper`
      Throws:
        `RepositoryException`

    - #### clear

          public void clear(Resource... contexts)
                     throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Removes all statements from a specific contexts in the repository.
      Specified by:
        `clear` in interface `RepositoryConnection`
      Overrides:
        `clear` in class `RepositoryConnectionWrapper`
      Parameters:
        `contexts` - The context(s) to remove the data from. Note that this parameter is a vararg and as such is optional. If no contexts are supplied the method operates on the entire repository.
      Throws:
        `RepositoryException` - If the statements could not be removed from the repository, for example because the repository is not writable.

    - #### begin

          public void begin()
                     throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Begins a new transaction, requiring `RepositoryConnection.commit()` or `RepositoryConnection.rollback()` to be called to end the transaction. The transaction will use the currently set `isolation level` for this connection.
      Specified by:
        `begin` in interface `RepositoryConnection`
      Overrides:
        `begin` in class `RepositoryConnectionWrapper`
      Throws:
        `RepositoryException` - If the connection could not start the transaction. One possible reason this may happen is if a transaction is already `active` on the current connection.
      See Also:
        `RepositoryConnection.begin(IsolationLevel)`, `RepositoryConnection.isActive()`, `RepositoryConnection.commit()`, `RepositoryConnection.rollback()`, `RepositoryConnection.setIsolationLevel(IsolationLevel)`

    - #### close

          public void close()
                     throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Closes the connection, freeing resources. If a `transaction` is `active` on the connection, all non-committed operations will be lost by actively calling `RepositoryConnection.rollback()` on any active transactions.

      Implementation note: All implementations must override this method if they have any resources that they need to free.

      Specified by:
        `close` in interface `AutoCloseable`
      Specified by:
        `close` in interface `RepositoryConnection`
      Overrides:
        `close` in class `RepositoryConnectionWrapper`
      Throws:
        `RepositoryException` - If the connection could not be closed.

    - #### commit

          public void commit()
                      throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Commits the active transaction. This operation ends the active transaction.
      Specified by:
        `commit` in interface `RepositoryConnection`
      Overrides:
        `commit` in class `RepositoryConnectionWrapper`
      Throws:
        `UnknownTransactionStateException` - if the transaction state can not be determined. This can happen for instance when communication with a repository fails or times out.
        `RepositoryException` - If the connection could not be committed, or if the connection does not have an active transaction.
      See Also:
        `RepositoryConnection.isActive()`, `RepositoryConnection.begin()`, `RepositoryConnection.rollback()`

    - #### removeWithoutCommit

          public void removeWithoutCommit(Resource subject,
                                          IRI predicate,
                                          Value object,
                                          Resource... contexts)
                                   throws RepositoryException

      Overrides:
        `removeWithoutCommit` in class `RepositoryConnectionWrapper`
      Throws:
        `RepositoryException`

    - #### removeNamespace

          public void removeNamespace(String prefix)
                               throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Removes a namespace declaration by removing the association between a prefix and a namespace name.
      Specified by:
        `removeNamespace` in interface `RepositoryConnection`
      Overrides:
        `removeNamespace` in class `RepositoryConnectionWrapper`
      Parameters:
        `prefix` - The namespace prefix, or an empty string in case of the default namespace.
      Throws:
        `RepositoryException` - If the namespace prefix could not be removed.

    - #### clearNamespaces

          public void clearNamespaces()
                               throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Removes all namespace declarations from the repository.
      Specified by:
        `clearNamespaces` in interface `RepositoryConnection`
      Overrides:
        `clearNamespaces` in class `RepositoryConnectionWrapper`
      Throws:
        `RepositoryException` - If the namespace declarations could not be removed.

    - #### rollback

          public void rollback()
                        throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Rolls back all updates in the active transaction. This operation ends the active transaction.
      Specified by:
        `rollback` in interface `RepositoryConnection`
      Overrides:
        `rollback` in class `RepositoryConnectionWrapper`
      Throws:
        `UnknownTransactionStateException` - if the transaction state can not be determined. This can happen for instance when communication with a repository fails or times out.
        `RepositoryException` - If the transaction could not be rolled back, or if the connection does not have an active transaction.
      See Also:
        `RepositoryConnection.isActive()`, `RepositoryConnection.begin()`, `RepositoryConnection.commit()`

    - #### setAutoCommit

          @Deprecated
          public void setAutoCommit(boolean autoCommit)
                                         throws RepositoryException

      Deprecated.
      Description copied from interface: `RepositoryConnection`
      Enables or disables auto-commit mode for the connection. If a connection is in auto-commit mode, then all updates will be executed and committed as individual transactions. Otherwise, the updates are grouped into transactions that are terminated by a call to either `RepositoryConnection.commit()` or `RepositoryConnection.rollback()`. By default, new connections are in auto-commit mode.

      NOTE: If this connection is switched to auto-commit mode during a transaction, the transaction is committed.

      Specified by:
        `setAutoCommit` in interface `RepositoryConnection`
      Overrides:
        `setAutoCommit` in class `RepositoryConnectionWrapper`
      Throws:
        `RepositoryException` - In case the mode switch failed, for example because a currently active transaction failed to commit.
      See Also:
        `RepositoryConnection.commit()`

    - #### setNamespace

          public void setNamespace(String prefix,
                                   String name)
                            throws RepositoryException

      Description copied from interface: `RepositoryConnection`
      Sets the prefix for a namespace.
      Specified by:
        `setNamespace` in interface `RepositoryConnection`
      Overrides:
        `setNamespace` in class `RepositoryConnectionWrapper`
      Parameters:
        `prefix` - The new prefix, or an empty string in case of the default namespace.
        `name` - The namespace name that the prefix maps to.
      Throws:
        `RepositoryException` - If the namespace could not be set in the repository, for example because the repository is not writable.

    - #### prepareUpdate

          public Update prepareUpdate(QueryLanguage ql,
                                      String update,
                                      String baseURI)
                               throws MalformedQueryException,
                                      RepositoryException

      Description copied from interface: `RepositoryConnection`
      Prepares an Update operation.
      Specified by:
        `prepareUpdate` in interface `RepositoryConnection`
      Overrides:
        `prepareUpdate` in class `RepositoryConnectionWrapper`
      Parameters:
        `ql` - The `query language` in which the update operation is formulated.
        `update` - The update operation string.
        `baseURI` - The base URI to resolve any relative URIs that are in the update against, can be `null` if the update does not contain any relative URIs.
      Returns:
        a `Update` ready to be executed on this `RepositoryConnection`.
      Throws:
        `MalformedQueryException` - If the supplied update operation string is malformed.
        `RepositoryException`

Copyright © 2015-2020 Eclipse Foundation. All Rights Reserved.