org.hibernate.search.indexes.spi

## Class DirectoryBasedIndexManager

- java.lang.Object
- - org.hibernate.search.indexes.spi.DirectoryBasedIndexManager

- All Implemented Interfaces:
    IndexManager
  Direct Known Subclasses:
    NRTIndexManager

      public class DirectoryBasedIndexManager
      extends Object
      implements IndexManager

  This implementation of `IndexManager` is coupled to a `DirectoryProvider` and a `DirectoryBasedReaderProvider`.

  This is the base class for all embedded-Lucene index managers.

  Author:
    Sanne Grinovero (C) 2011 Red Hat Inc.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `DirectoryBasedIndexManager()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addContainedEntity(IndexedTypeIdentifier entity)`
    `void` | `awaitAsyncProcessingCompletion()` Blocks until all the previously submitted work via `IndexManager.performStreamOperation(LuceneWork, IndexingMonitor, boolean)` are applied to the index.
    `protected DirectoryProvider<?>` | `createDirectoryProvider(String indexName, Properties cfg, WorkerBuildContext buildContext)`
    `protected DirectoryBasedReaderProvider` | `createIndexReader(String indexName, Properties cfg, WorkerBuildContext buildContext)`
    `protected WorkspaceHolder` | `createWorkspaceHolder(String indexName, Properties cfg, WorkerBuildContext buildContext)`
    `void` | `destroy()` Called when a `SearchFactory` is stopped.
    `void` | `flushAndReleaseResources()` Flushes any pending write operations and closes underlying resources, for example release the index locks if this implementation uses a Lucene IndexWriter.
    `Analyzer` | `getAnalyzer(String name)`
    `IndexedTypeSet` | `getContainedTypes()`
    `Lock` | `getDirectoryModificationLock()`
    `DirectoryProvider<?>` | `getDirectoryProvider()`
    `EntityIndexBinding` | `getIndexBinding(IndexedTypeIdentifier type)`
    `LuceneIndexingParameters` | `getIndexingParameters()`
    `IndexManagerType` | `getIndexManagerType()`
    `String` | `getIndexName()` Useful for labeling and logging resources from this instance.
    `OptimizerStrategy` | `getOptimizerStrategy()`
    `ReaderProvider` | `getReaderProvider()` Provide access to `IndexReader`s.
    `LuceneWorkSerializer` | `getSerializer()`
    `Similarity` | `getSimilarity()`
    `WorkspaceHolder` | `getWorkspaceHolder()`
    `void` | `initialize(String indexName, Properties properties, Similarity similarity, WorkerBuildContext buildContext)` Initialize this `IndexManager` before its use.
    `void` | `optimize()` To optimize the underlying index.
    `void` | `performOperations(List<LuceneWork> workList, IndexingMonitor monitor)` Used to apply update operations to the index.
    `void` | `performStreamOperation(LuceneWork singleOperation, IndexingMonitor monitor, boolean forceAsync)` Perform a single non-transactional operation, best to stream large amounts of operations.
    `void` | `setSearchFactory(ExtendedSearchIntegrator boundSearchIntegrator)` Connects this `IndexManager` to a new `ExtendedSearchIntegrator`.
    `String` | `toString()`

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

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

- - ### Constructor Detail

    - #### DirectoryBasedIndexManager

          public DirectoryBasedIndexManager()

  - ### Method Detail

    - #### getIndexName

          public String getIndexName()

      Description copied from interface: `IndexManager`
      Useful for labeling and logging resources from this instance.
      Specified by:
        `getIndexName` in interface `IndexManager`
      Returns:
        the name of the index maintained by this manager.

    - #### getReaderProvider

          public ReaderProvider getReaderProvider()

      Description copied from interface: `IndexManager`
      Provide access to `IndexReader`s.
      Specified by:
        `getReaderProvider` in interface `IndexManager`
      Returns:
        a `ReaderProvider` instance for the index managed by this instance

    - #### destroy

          public void destroy()

      Description copied from interface: `IndexManager`
      Called when a `SearchFactory` is stopped. This method typically releases resources.
      Specified by:
        `destroy` in interface `IndexManager`

    - #### initialize

          public void initialize(String indexName,
                                 Properties properties,
                                 Similarity similarity,
                                 WorkerBuildContext buildContext)

      Description copied from interface: `IndexManager`
      Initialize this `IndexManager` before its use.
      Specified by:
        `initialize` in interface `IndexManager`
      Parameters:
        `indexName` - the unique name of the index (manager). Can be used to retrieve a `IndexManager` instance via the search factory and `IndexManagerHolder`.
        `properties` - the configuration properties
        `similarity` - defines the component of Lucene scoring
        `buildContext` - context information needed to initialize this index manager

    - #### getContainedTypes

          public IndexedTypeSet getContainedTypes()

      Specified by:
        `getContainedTypes` in interface `IndexManager`
      Returns:
        the set of classes being indexed in this manager

    - #### getSimilarity

          public Similarity getSimilarity()

      Specified by:
        `getSimilarity` in interface `IndexManager`
      Returns:
        the `Similarity` applied to this index. Note, only a single `Similarity` can be applied to a given index.

    - #### performStreamOperation

          public void performStreamOperation(LuceneWork singleOperation,
                                             IndexingMonitor monitor,
                                             boolean forceAsync)

      Description copied from interface: `IndexManager`
      Perform a single non-transactional operation, best to stream large amounts of operations. Operations might be applied out-of-order! To mark two series of operations which need to be applied in order, use a transactional operation between them: a transactional operation will always flush all streaming operations first, and be applied before subsequent streaming operations.
      Specified by:
        `performStreamOperation` in interface `IndexManager`
      Parameters:
        `singleOperation` - the operation to perform
        `monitor` - no be notified of indexing events
        `forceAsync` - if true, the invocation will not block to wait for it being applied. When false this will depend on the backend configuration.

    - #### awaitAsyncProcessingCompletion

          public void awaitAsyncProcessingCompletion()

      Description copied from interface: `IndexManager`
      Blocks until all the previously submitted work via `IndexManager.performStreamOperation(LuceneWork, IndexingMonitor, boolean)` are applied to the index.
      Specified by:
        `awaitAsyncProcessingCompletion` in interface `IndexManager`

    - #### performOperations

          public void performOperations(List<LuceneWork> workList,
                                        IndexingMonitor monitor)

      Description copied from interface: `IndexManager`
      Used to apply update operations to the index. Operations can be applied in sync or async, depending on the IndexManager implementation and configuration.
      Specified by:
        `performOperations` in interface `IndexManager`
      Parameters:
        `workList` - the list of write operations to apply.
        `monitor` - no be notified of indexing events

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### getAnalyzer

          public Analyzer getAnalyzer(String name)

      Specified by:
        `getAnalyzer` in interface `IndexManager`
      Parameters:
        `name` - the name of the analyzer to retrieve.
      Returns:
        Returns the `Analyzer` with the given name (see also `AnalyzerDef`)

    - #### setSearchFactory

          public void setSearchFactory(ExtendedSearchIntegrator boundSearchIntegrator)

      Description copied from interface: `IndexManager`
      Connects this `IndexManager` to a new `ExtendedSearchIntegrator`.
      Specified by:
        `setSearchFactory` in interface `IndexManager`
      Parameters:
        `boundSearchIntegrator` - the existing search factory to which to associate this index manager with

    - #### addContainedEntity

          public void addContainedEntity(IndexedTypeIdentifier entity)

      Specified by:
        `addContainedEntity` in interface `IndexManager`
      Parameters:
        `entity` - Adds the specified entity type to this index manager, making it responsible for manging this type.

    - #### optimize

          public void optimize()

      Description copied from interface: `IndexManager`
      To optimize the underlying index. Some implementations might ignore the request, if it doesn't apply to them.
      Specified by:
        `optimize` in interface `IndexManager`

    - #### getSerializer

          public LuceneWorkSerializer getSerializer()

      Specified by:
        `getSerializer` in interface `IndexManager`

    - #### flushAndReleaseResources

          public void flushAndReleaseResources()

      Description copied from interface: `IndexManager`
      Flushes any pending write operations and closes underlying resources, for example release the index locks if this implementation uses a Lucene IndexWriter.
      Specified by:
        `flushAndReleaseResources` in interface `IndexManager`

    - #### getWorkspaceHolder

          public WorkspaceHolder getWorkspaceHolder()

    - #### getIndexBinding

          public EntityIndexBinding getIndexBinding(IndexedTypeIdentifier type)

    - #### getDirectoryModificationLock

          public Lock getDirectoryModificationLock()

    - #### getDirectoryProvider

          public DirectoryProvider<?> getDirectoryProvider()

    - #### getOptimizerStrategy

          public OptimizerStrategy getOptimizerStrategy()

    - #### getIndexingParameters

          public LuceneIndexingParameters getIndexingParameters()

    - #### createWorkspaceHolder

          protected WorkspaceHolder createWorkspaceHolder(String indexName,
                                                          Properties cfg,
                                                          WorkerBuildContext buildContext)

    - #### createIndexReader

          protected DirectoryBasedReaderProvider createIndexReader(String indexName,
                                                                   Properties cfg,
                                                                   WorkerBuildContext buildContext)

    - #### createDirectoryProvider

          protected DirectoryProvider<?> createDirectoryProvider(String indexName,
                                                                 Properties cfg,
                                                                 WorkerBuildContext buildContext)

    - #### getIndexManagerType

          public IndexManagerType getIndexManagerType()

      Specified by:
        `getIndexManagerType` in interface `IndexManager`
      Returns:
        the `IndexManagerType` of this implementation.

Copyright © 2006-2017 Red Hat, Inc. All Rights Reserved