LuceneConfig (Alfresco 5.3.a-SNAPSHOT API)

All Known Subinterfaces:

LuceneIndexerAndSearcher

All Known Implementing Classes:

AbstractLuceneIndexerAndSearcherFactory, ADMLuceneIndexerAndSearcherFactory, ADMLuceneUnIndexedIndexAndSearcherFactory
```
public interface LuceneConfig
```

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`org.springframework.context.ConfigurableApplicationContext`	`getApplicationContext()` Gets the application context through which events can be broadcast
`NodeBulkLoader`	`getBulkLoader()` Get preloader - may be null if preloading is not supported
`long`	`getCommitLockTimeout()`
`org.alfresco.repo.search.MLAnalysisMode`	`getDefaultMLIndexAnalysisMode()` The default mode for analysing ML text during index.
`org.alfresco.repo.search.MLAnalysisMode`	`getDefaultMLSearchAnalysisMode()` The default mode for analysis of ML text during search.
`boolean`	`getFairLocking()` Should we use a 'fair' locking policy, giving queue-like access behaviour to the indexes and avoiding starvation? Default is `false` since fair locking appears to cause deadlock on old JVMs.
`int`	`getIndexerBatchSize()` The batch size in which to group flushes of the index.
`int`	`getIndexerMaxFieldLength()` Get the max field length that determine how many tokens are put into the index
`String`	`getIndexRootLocation()` The path to the index location
`int`	`getMaxDocIdCacheSize()` How many document ids to cache (-ve => unbounded)
`int`	`getMaxDocsForInMemoryIndex()` Max docs to allow for in memory indexes (does no apply to merges)
`int`	`getMaxDocsForInMemoryMerge()` Max doc number that will merged in memory (and not on disk)
`int`	`getMaxDocumentCacheSize()` How many documents to cache (-ve => unbounded)
`int`	`getMaxIsCategoryCacheSize()` How many categories to cache (-ve => unbounded)
`int`	`getMaxLinkAspectCacheSize()` How many link aspects to cache (-ve => unbounded)
`int`	`getMaxParentCacheSize()` How many parents to cache (-ve => unbounded)
`int`	`getMaxPathCacheSize()` How many paths to cache (-ve => unbounded)
`double`	`getMaxRamInMbForInMemoryIndex()` Max Ram to allow for in memory indexes (does not apply to merges)
`double`	`getMaxRamInMbForInMemoryMerge()` Ram based limit for in memory merges
`int`	`getMaxRawResultSetSizeForInMemorySort()`
`long`	`getMaxTransformationTime()`
`int`	`getMaxTypeCacheSize()` How many types to cache (-ve => unbounded)
`int`	`getMergerMaxBufferedDocs()` Lucene merger config
`int`	`getMergerMaxMergeDocs()` Lucene merger config
`int`	`getMergerMergeFactor()` Lucene merger config
`double`	`getMergerRamBufferSizeMb()` Ram based limit for in memory portion of merger index.
`int`	`getMergerTargetIndexCount()` Target index count.
`int`	`getMergerTargetOverlayCount()` Target overlays (will apply deletions and create indexes if over this limit)
`int`	`getMergerTargetOverlaysBlockingFactor()` The factor by which the target overlay count is multiplied to determine the allowable number of overlays before blocking.
`boolean`	`getPostSortDateTime()` If we are using the DateAnalyser then lucene sort is only to the date, as that is all that is in the index.
`int`	`getQueryMaxClauses()` The maximum numbr of sub-queries the can be generated out of wild card expansion etc
`int`	`getTermIndexInterval()` Lucene term index interval
`ThreadPoolExecutor`	`getThreadPoolExecutor()` Get the thread pool for index merging etc
`boolean`	`getUseInMemorySort()`
`boolean`	`getUseNioMemoryMapping()` Use the nio memory mapping (work arounf for bugs with some JVMs)
`long`	`getWriteLockTimeout()`
`int`	`getWriterMaxBufferedDocs()` Lucene writer config
`int`	`getWriterMaxMergeDocs()` Lucene writer config
`int`	`getWriterMergeFactor()` Lucene writer config
`double`	`getWriterRamBufferSizeMb()` Ram based limit for in memory portion of writer index.
`boolean`	`isCacheEnabled()` Is caching enabled for each index fragment?
`boolean`	`isContentIndexingEnabled()`
`void`	`setCacheEnabled(boolean cacheEnabled)`
`void`	`setCommitLockTimeout(long timeout)`
`void`	`setContentIndexingEnabled(boolean contentIndexingEnabled)` Enable/Disable the indexing of content Content is not indexed and FTS disabled When disabled, documents are marked as requiring FTS indexing.
`void`	`setDefaultMLIndexAnalysisMode(org.alfresco.repo.search.MLAnalysisMode mode)`
`void`	`setDefaultMLSearchAnalysisMode(org.alfresco.repo.search.MLAnalysisMode mode)`
`void`	`setFairLocking(boolean fairLocking)`
`void`	`setIndexerBatchSize(int indexerBatchSize)`
`void`	`setIndexerMaxFieldLength(int indexerMaxFieldLength)`
`void`	`setLockDirectory(String lockDirectory)` Set the lock dir - just to make sure - this should no longer be used.
`void`	`setLockPollInterval(long time)`
`void`	`setMaxAtomicTransformationTime(long maxAtomicTransformationTime)`
`void`	`setMaxDocIdCacheSize(int maxDocIdCacheSize)`
`void`	`setMaxDocsForInMemoryIndex(int maxDocsForInMemoryIndex)`
`void`	`setMaxDocsForInMemoryMerge(int maxDocsForInMemoryMerge)`
`void`	`setMaxDocumentCacheSize(int maxDocumentCacheSize)`
`void`	`setMaxIsCategoryCacheSize(int maxIsCategoryCacheSize)`
`void`	`setMaxLinkAspectCacheSize(int maxLinkAspectCacheSize)`
`void`	`setMaxParentCacheSize(int maxParentCacheSize)`
`void`	`setMaxPathCacheSize(int maxPathCacheSize)`
`void`	`setMaxRamInMbForInMemoryIndex(double maxRamInMbForInMemoryIndex)`
`void`	`setMaxRamInMbForInMemoryMerge(double maxRamInMbForInMemoryMerge)`
`void`	`setMaxTypeCacheSize(int maxTypeCacheSize)`
`void`	`setMergerMaxBufferedDocs(int mergerMaxBufferedDocs)`
`void`	`setMergerMaxMergeDocs(int mergerMaxMergeDocs)`
`void`	`setMergerMergeFactor(int mergerMergeFactor)`
`void`	`setMergerRamBufferSizeMb(double mergerRamBufferSizeMb)`
`void`	`setMergerTargetIndexCount(int mergerTargetIndexCount)`
`void`	`setMergerTargetOverlayCount(int mergerTargetOverlayCount)`
`void`	`setMergerTargetOverlaysBlockingFactor(int mergerTargetOverlaysBlockingFactor)`
`void`	`setPostSortDateTime(boolean postSortDateTime)`
`void`	`setQueryMaxClauses(int queryMaxClauses)`
`void`	`setTermIndexInterval(int termIndexInterval)`
`void`	`setUseNioMemoryMapping(boolean useNioMemoryMapping)`
`void`	`setWriteLockTimeout(long timeout)`
`void`	`setWriterMaxBufferedDocs(int writerMaxBufferedDocs)`
`void`	`setWriterMaxMergeDocs(int writerMaxMergeDocs)`
`void`	`setWriterMergeFactor(int writerMergeFactor)`
`void`	`setWriterRamBufferSizeMb(double writerRamBufferSizeMb)`

- Method Detail
  - setLockDirectory
```
void setLockDirectory(String lockDirectory)
```
    Set the lock dir - just to make sure - this should no longer be used.
    
    Parameters:
    
    lockDirectory - String
  - getIndexRootLocation
```
String getIndexRootLocation()
```
    The path to the index location
    
    Returns:
    
    String
  - getIndexerBatchSize
```
int getIndexerBatchSize()
```
    The batch size in which to group flushes of the index.
    
    Returns:
    
    int
  - getQueryMaxClauses
```
int getQueryMaxClauses()
```
    The maximum numbr of sub-queries the can be generated out of wild card expansion etc
    
    Returns:
    
    int
  - getDefaultMLIndexAnalysisMode
```
org.alfresco.repo.search.MLAnalysisMode getDefaultMLIndexAnalysisMode()
```
    The default mode for analysing ML text during index.
    
    Returns:
    
    MLAnalysisMode
  - getDefaultMLSearchAnalysisMode
```
org.alfresco.repo.search.MLAnalysisMode getDefaultMLSearchAnalysisMode()
```
    The default mode for analysis of ML text during search.
    
    Returns:
    
    MLAnalysisMode
  - getIndexerMaxFieldLength
```
int getIndexerMaxFieldLength()
```
    Get the max field length that determine how many tokens are put into the index
    
    Returns:
    
    int
  - getThreadPoolExecutor
```
ThreadPoolExecutor getThreadPoolExecutor()
```
    Get the thread pool for index merging etc
    
    Returns:
    
    ThreadPoolExecutor
  - getBulkLoader
```
NodeBulkLoader getBulkLoader()
```
    Get preloader - may be null if preloading is not supported
  - getUseNioMemoryMapping
```
boolean getUseNioMemoryMapping()
```
    Use the nio memory mapping (work arounf for bugs with some JVMs)
    
    Returns:
    
    boolean
  - getMaxDocsForInMemoryMerge
```
int getMaxDocsForInMemoryMerge()
```
    Max doc number that will merged in memory (and not on disk)
    
    Returns:
    
    int
  - getWriterMaxBufferedDocs
```
int getWriterMaxBufferedDocs()
```
    Lucene writer config
    
    Returns:
    
    int
  - getWriterMergeFactor
```
int getWriterMergeFactor()
```
    Lucene writer config
    
    Returns:
    
    int
  - getWriterMaxMergeDocs
```
int getWriterMaxMergeDocs()
```
    Lucene writer config
    
    Returns:
    
    int
  - getMergerMaxBufferedDocs
```
int getMergerMaxBufferedDocs()
```
    Lucene merger config
    
    Returns:
    
    int
  - getMergerMergeFactor
```
int getMergerMergeFactor()
```
    Lucene merger config
    
    Returns:
    
    int
  - getMergerMaxMergeDocs
```
int getMergerMaxMergeDocs()
```
    Lucene merger config
    
    Returns:
    
    int
  - getMergerTargetOverlayCount
```
int getMergerTargetOverlayCount()
```
    Target overlays (will apply deletions and create indexes if over this limit)
    
    Returns:
    
    int
  - getMergerTargetOverlaysBlockingFactor
```
int getMergerTargetOverlaysBlockingFactor()
```
    The factor by which the target overlay count is multiplied to determine the allowable number of overlays before blocking.
    
    Returns:
    
    the factor by which the target overlay count is multiplied to determine the allowable number of overlays before blocking
  - getMergerTargetIndexCount
```
int getMergerTargetIndexCount()
```
    Target index count. Over this indexes will be merged together.
    
    Returns:
    
    int
  - getTermIndexInterval
```
int getTermIndexInterval()
```
    Lucene term index interval
    
    Returns:
    
    int
  - isCacheEnabled
```
boolean isCacheEnabled()
```
    Is caching enabled for each index fragment?
    
    Returns:
    
    boolean
  - getMaxIsCategoryCacheSize
```
int getMaxIsCategoryCacheSize()
```
    How many categories to cache (-ve => unbounded)
    
    Returns:
    
    int
  - getMaxDocumentCacheSize
```
int getMaxDocumentCacheSize()
```
    How many documents to cache (-ve => unbounded)
    
    Returns:
    
    int
  - getMaxDocIdCacheSize
```
int getMaxDocIdCacheSize()
```
    How many document ids to cache (-ve => unbounded)
    
    Returns:
    
    int
  - getMaxPathCacheSize
```
int getMaxPathCacheSize()
```
    How many paths to cache (-ve => unbounded)
    
    Returns:
    
    int
  - getMaxTypeCacheSize
```
int getMaxTypeCacheSize()
```
    How many types to cache (-ve => unbounded)
    
    Returns:
    
    int
  - getMaxParentCacheSize
```
int getMaxParentCacheSize()
```
    How many parents to cache (-ve => unbounded)
    
    Returns:
    
    int
  - getMaxLinkAspectCacheSize
```
int getMaxLinkAspectCacheSize()
```
    How many link aspects to cache (-ve => unbounded)
    
    Returns:
    
    int
  - getPostSortDateTime
```
boolean getPostSortDateTime()
```
    If we are using the DateAnalyser then lucene sort is only to the date, as that is all that is in the index. If this is true, a query that defines a sort on a datetime field will do a post sort in Java. For the DateTimeAnalyser no post sort is done. (The default config does do a post sort) In the future, this behaviour may also be set per query on the SearchParameters object.
    
    Returns:
    
    boolean
  - getApplicationContext
```
org.springframework.context.ConfigurableApplicationContext getApplicationContext()
```
    Gets the application context through which events can be broadcast
    
    Returns:
    
    ConfigurableApplicationContext
  - getMaxRamInMbForInMemoryMerge
```
double getMaxRamInMbForInMemoryMerge()
```
    Ram based limit for in memory merges
    
    Returns:
    
    double
  - getWriterRamBufferSizeMb
```
double getWriterRamBufferSizeMb()
```
    Ram based limit for in memory portion of writer index.
    
    Returns:
    
    double
  - getMergerRamBufferSizeMb
```
double getMergerRamBufferSizeMb()
```
    Ram based limit for in memory portion of merger index.
    
    Returns:
    
    double
  - getMaxDocsForInMemoryIndex
```
int getMaxDocsForInMemoryIndex()
```
    Max docs to allow for in memory indexes (does no apply to merges)
    
    Returns:
    
    int
  - getMaxRamInMbForInMemoryIndex
```
double getMaxRamInMbForInMemoryIndex()
```
    Max Ram to allow for in memory indexes (does not apply to merges)
    
    Returns:
    
    double
  - getFairLocking
```
boolean getFairLocking()
```
    Should we use a 'fair' locking policy, giving queue-like access behaviour to the indexes and avoiding starvation? Default is false since fair locking appears to cause deadlock on old JVMs.
    
    Returns:
    
    true if a fair locking policy should be used
  - setMaxAtomicTransformationTime
```
void setMaxAtomicTransformationTime(long maxAtomicTransformationTime)
```
    Parameters:
    
    maxAtomicTransformationTime - long
  - getMaxTransformationTime
```
long getMaxTransformationTime()
```
    Returns:
    
    long
  - getUseInMemorySort
```
boolean getUseInMemorySort()
```
    Returns:
    
    boolean
  - setIndexerBatchSize
```
void setIndexerBatchSize(int indexerBatchSize)
```
    Parameters:
    
    indexerBatchSize - int
  - setQueryMaxClauses
```
void setQueryMaxClauses(int queryMaxClauses)
```
    Parameters:
    
    queryMaxClauses - int
  - setWriteLockTimeout
```
void setWriteLockTimeout(long timeout)
```
    Parameters:
    
    timeout - long
  - setCommitLockTimeout
```
void setCommitLockTimeout(long timeout)
```
    Parameters:
    
    timeout - long
  - getCommitLockTimeout
```
long getCommitLockTimeout()
```
    Returns:
    
    long
  - getWriteLockTimeout
```
long getWriteLockTimeout()
```
    Returns:
    
    long
  - setLockPollInterval
```
void setLockPollInterval(long time)
```
    Parameters:
    
    time - long
  - setIndexerMaxFieldLength
```
void setIndexerMaxFieldLength(int indexerMaxFieldLength)
```
    Parameters:
    
    indexerMaxFieldLength - int
  - setDefaultMLIndexAnalysisMode
```
void setDefaultMLIndexAnalysisMode(org.alfresco.repo.search.MLAnalysisMode mode)
```
    Parameters:
    
    mode - MLAnalysisMode
  - setDefaultMLSearchAnalysisMode
```
void setDefaultMLSearchAnalysisMode(org.alfresco.repo.search.MLAnalysisMode mode)
```
    Parameters:
    
    mode - MLAnalysisMode
  - setMaxDocIdCacheSize
```
void setMaxDocIdCacheSize(int maxDocIdCacheSize)
```
    Parameters:
    
    maxDocIdCacheSize - int
  - setMaxDocsForInMemoryMerge
```
void setMaxDocsForInMemoryMerge(int maxDocsForInMemoryMerge)
```
    Parameters:
    
    maxDocsForInMemoryMerge - int
  - setMaxDocumentCacheSize
```
void setMaxDocumentCacheSize(int maxDocumentCacheSize)
```
    Parameters:
    
    maxDocumentCacheSize - int
  - setMaxIsCategoryCacheSize
```
void setMaxIsCategoryCacheSize(int maxIsCategoryCacheSize)
```
    Parameters:
    
    maxIsCategoryCacheSize - int
  - setMaxLinkAspectCacheSize
```
void setMaxLinkAspectCacheSize(int maxLinkAspectCacheSize)
```
    Parameters:
    
    maxLinkAspectCacheSize - int
  - setMaxParentCacheSize
```
void setMaxParentCacheSize(int maxParentCacheSize)
```
    Parameters:
    
    maxParentCacheSize - int
  - setMaxPathCacheSize
```
void setMaxPathCacheSize(int maxPathCacheSize)
```
    Parameters:
    
    maxPathCacheSize - int
  - setMaxTypeCacheSize
```
void setMaxTypeCacheSize(int maxTypeCacheSize)
```
    Parameters:
    
    maxTypeCacheSize - int
  - setMergerMaxMergeDocs
```
void setMergerMaxMergeDocs(int mergerMaxMergeDocs)
```
    Parameters:
    
    mergerMaxMergeDocs - int
  - setMergerMergeFactor
```
void setMergerMergeFactor(int mergerMergeFactor)
```
    Parameters:
    
    mergerMergeFactor - int
  - setMergerMaxBufferedDocs
```
void setMergerMaxBufferedDocs(int mergerMaxBufferedDocs)
```
    Parameters:
    
    mergerMaxBufferedDocs - int
  - setMergerTargetIndexCount
```
void setMergerTargetIndexCount(int mergerTargetIndexCount)
```
    Parameters:
    
    mergerTargetIndexCount - int
  - setMergerTargetOverlayCount
```
void setMergerTargetOverlayCount(int mergerTargetOverlayCount)
```
    Parameters:
    
    mergerTargetOverlayCount - int
  - setMergerTargetOverlaysBlockingFactor
```
void setMergerTargetOverlaysBlockingFactor(int mergerTargetOverlaysBlockingFactor)
```
    Parameters:
    
    mergerTargetOverlaysBlockingFactor - int
  - setFairLocking
```
void setFairLocking(boolean fairLocking)
```
    Parameters:
    
    fairLocking - boolean
  - setTermIndexInterval
```
void setTermIndexInterval(int termIndexInterval)
```
    Parameters:
    
    termIndexInterval - int
  - setUseNioMemoryMapping
```
void setUseNioMemoryMapping(boolean useNioMemoryMapping)
```
    Parameters:
    
    useNioMemoryMapping - boolean
  - setWriterMaxMergeDocs
```
void setWriterMaxMergeDocs(int writerMaxMergeDocs)
```
    Parameters:
    
    writerMaxMergeDocs - int
  - setWriterMergeFactor
```
void setWriterMergeFactor(int writerMergeFactor)
```
    Parameters:
    
    writerMergeFactor - int
  - getMaxRawResultSetSizeForInMemorySort
```
int getMaxRawResultSetSizeForInMemorySort()
```
    Returns:
    
    int
  - setWriterMaxBufferedDocs
```
void setWriterMaxBufferedDocs(int writerMaxBufferedDocs)
```
    Parameters:
    
    writerMaxBufferedDocs - int
  - setCacheEnabled
```
void setCacheEnabled(boolean cacheEnabled)
```
    Parameters:
    
    cacheEnabled - boolean
  - setPostSortDateTime
```
void setPostSortDateTime(boolean postSortDateTime)
```
    Parameters:
    
    postSortDateTime - boolean
  - setMaxDocsForInMemoryIndex
```
void setMaxDocsForInMemoryIndex(int maxDocsForInMemoryIndex)
```
    Parameters:
    
    maxDocsForInMemoryIndex - int
  - setMaxRamInMbForInMemoryMerge
```
void setMaxRamInMbForInMemoryMerge(double maxRamInMbForInMemoryMerge)
```
    Parameters:
    
    maxRamInMbForInMemoryMerge - double
  - setMaxRamInMbForInMemoryIndex
```
void setMaxRamInMbForInMemoryIndex(double maxRamInMbForInMemoryIndex)
```
    Parameters:
    
    maxRamInMbForInMemoryIndex - double
  - setMergerRamBufferSizeMb
```
void setMergerRamBufferSizeMb(double mergerRamBufferSizeMb)
```
    Parameters:
    
    mergerRamBufferSizeMb - double
  - setWriterRamBufferSizeMb
```
void setWriterRamBufferSizeMb(double writerRamBufferSizeMb)
```
    Parameters:
    
    writerRamBufferSizeMb - double
  - isContentIndexingEnabled
```
boolean isContentIndexingEnabled()
```
    Returns:
    
    if content indexing is enable.
  - setContentIndexingEnabled
```
void setContentIndexingEnabled(boolean contentIndexingEnabled)
```
    Enable/Disable the indexing of content Content is not indexed and FTS disabled When disabled, documents are marked as requiring FTS indexing. When enabled the normal FTS process will catch up with content that was not indexed.
    
    Parameters:
    
    contentIndexingEnabled - boolean

Interface LuceneConfig

Method Summary

Method Detail

setLockDirectory

getIndexRootLocation

getIndexerBatchSize

getQueryMaxClauses

getDefaultMLIndexAnalysisMode

getDefaultMLSearchAnalysisMode

getIndexerMaxFieldLength

getThreadPoolExecutor

getBulkLoader

getUseNioMemoryMapping

getMaxDocsForInMemoryMerge

getWriterMaxBufferedDocs

getWriterMergeFactor

getWriterMaxMergeDocs

getMergerMaxBufferedDocs

getMergerMergeFactor

getMergerMaxMergeDocs

getMergerTargetOverlayCount

getMergerTargetOverlaysBlockingFactor

getMergerTargetIndexCount

getTermIndexInterval

isCacheEnabled

getMaxIsCategoryCacheSize

getMaxDocumentCacheSize

getMaxDocIdCacheSize

getMaxPathCacheSize

getMaxTypeCacheSize

getMaxParentCacheSize

getMaxLinkAspectCacheSize

getPostSortDateTime

getApplicationContext

getMaxRamInMbForInMemoryMerge

getWriterRamBufferSizeMb

getMergerRamBufferSizeMb

getMaxDocsForInMemoryIndex

getMaxRamInMbForInMemoryIndex

getFairLocking

setMaxAtomicTransformationTime

getMaxTransformationTime

getUseInMemorySort

setIndexerBatchSize

setQueryMaxClauses

setWriteLockTimeout

setCommitLockTimeout

getCommitLockTimeout

getWriteLockTimeout

setLockPollInterval

setIndexerMaxFieldLength

setDefaultMLIndexAnalysisMode

setDefaultMLSearchAnalysisMode

setMaxDocIdCacheSize

setMaxDocsForInMemoryMerge

setMaxDocumentCacheSize

setMaxIsCategoryCacheSize

setMaxLinkAspectCacheSize

setMaxParentCacheSize

setMaxPathCacheSize

setMaxTypeCacheSize

setMergerMaxMergeDocs

setMergerMergeFactor

setMergerMaxBufferedDocs

setMergerTargetIndexCount

setMergerTargetOverlayCount

setMergerTargetOverlaysBlockingFactor

setFairLocking

setTermIndexInterval

setUseNioMemoryMapping

setWriterMaxMergeDocs

setWriterMergeFactor

getMaxRawResultSetSizeForInMemorySort

setWriterMaxBufferedDocs

setCacheEnabled

setPostSortDateTime

setMaxDocsForInMemoryIndex

setMaxRamInMbForInMemoryMerge

setMaxRamInMbForInMemoryIndex

setMergerRamBufferSizeMb