LimitsConfig (EXALEAD CloudView Custom code SDK)

java.lang.Object
- com.exalead.search.v30.LimitsConfig

All Implemented Interfaces:

com.exalead.util.Checkable, java.io.Serializable
```
public class LimitsConfig
extends java.lang.Object
implements com.exalead.util.Checkable, java.io.Serializable
```
No documentation for this element.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`java.util.List<ContentGroupLimitsConfig>`	`contentGroupLimitsConfig`
`static int`	`DEFAULT_ENOUGH_SLICES_PERCENTAGE`
`static int`	`DEFAULT_FULL_GRACE_DELAY_M_S`
`static double`	`DEFAULT_HITS_SAMPLING`
`static int`	`DEFAULT_INTERRUPT_GRACE_DELAY_M_S`
`static long`	`DEFAULT_MAX_PATHS_TO_CONSIDER`
`static long`	`DEFAULT_NEED_SECU_BLOCK_SIZE`
`static boolean`	`DEFAULT_USES_CONSECUTIVE_QUERIES`
`int`	`enoughSlicesPercentage`
`int`	`fullGraceDelayMS`
`double`	`hitsSampling`
`int`	`interruptGraceDelayMS`
`int`	`mainHeapFlushInterval` Deprecated.
`int`	`maxFetchedHits`
`int`	`maxHitsPerSlice`
`int`	`maxKeptHits`
`long`	`maxPathsToConsider`
`int`	`maxQueryTimeMS`
`int`	`maxTotalTimeMS`
`long`	`needSecuBlockSize`
`int`	`sliceHeapFlushInterval`
`boolean`	`usesConsecutiveQueries`

Constructor Summary

Constructors
Constructor and Description

LimitsConfig()

LimitsConfig(LimitsConfig o)
Copy constructor

Constructors
Constructor and Description
`LimitsConfig()`
`LimitsConfig(LimitsConfig o)` Copy constructor

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`check(boolean deep, java.lang.String errorContext)` Checks this LimitsConfig.
`static LimitsConfig`	`fromString(java.lang.String s)` String representation of this LimitsConfig.
`java.util.List<ContentGroupLimitsConfig>`	`getContentGroupLimitsConfig()` Optional specific per content group limits.
`int`	`getEnoughSlicesPercentage()` The query is interrupted if at least this percentage of active slices finished fetching hits.
`int`	`getFullGraceDelayMS()` Additional time after maxTotalTime before forcing the full hits processor to stop. Note that this elapsed time is only checked between two full hits.
`double`	`getHitsSampling()` Only fetch a sample of the matches.
`int`	`getInterruptGraceDelayMS()` After the query is interrupted, the slices have a small time period to flush their heaps. Hits that arrive to the main heap after this time period are dropped.
`int`	`getMainHeapFlushInterval()` Deprecated.
`int`	`getMaxFetchedHits()` When this total number of hits matching the query have been found (on any slice), the query is interrupted. These hits are ranked and the "best" ones are selected for navigation and full hits.
`int`	`getMaxHitsPerSlice()` Maximum number of hits that a single index slice can fetch.
`int`	`getMaxKeptHits()` Number of "best" hits that will be kept for navigation and full hits. It limits the number of hits that can be used for navigation and full hits fetch.
`long`	`getMaxPathsToConsider()` If this value is not zero, when doing expand queries without using the "expand=true" mode, the slices will only consider the first maxExploredPaths paths they find for deciding which DIDs are contained in the graph.
`int`	`getMaxQueryTimeMS()` Maximum time spent in the "hits matching" part of the search internal "query" part of the search. After this delay, hits matching is interrupted, partial results will be returned. 0 means no limit.
`int`	`getMaxTotalTimeMS()` Maximum time for the entire search (hits matching, navigation and hits computation). After this delay, the search query is aborted. 0 means no limit.
`long`	`getNeedSecuBlockSize()` If this value is not zero, when doing attrgraph queries, each document that need to be postfiltered will have its Fullhit rewritten once said number of documents to postfilter has been reached.
`int`	`getSliceHeapFlushInterval()` Each time the slice heap receives this number of hits, it will be flushed to the main heap. This parameter only impacts performance. If value is 0, the system will pick up an appropriate value. Note: Only used in unranked and heapsort.
`boolean`	`isUsesConsecutiveQueries()` Set this optio to True when you plan to use consecutive queries, then the dedup will occur.
`LimitsConfig`	`makeCopy()` Creates and returns a deep copy of this LimitsConfig.
`static LimitsConfig`	`readFrom(java.io.InputStream is)` Read this LimitsConfig from an XML fragment.
`void`	`setEnoughSlicesPercentage(int enoughSlicesPercentage)` The query is interrupted if at least this percentage of active slices finished fetching hits.
`void`	`setFullGraceDelayMS(int fullGraceDelayMS)` Additional time after maxTotalTime before forcing the full hits processor to stop. Note that this elapsed time is only checked between two full hits.
`void`	`setHitsSampling(double hitsSampling)` Only fetch a sample of the matches.
`void`	`setInterruptGraceDelayMS(int interruptGraceDelayMS)` After the query is interrupted, the slices have a small time period to flush their heaps. Hits that arrive to the main heap after this time period are dropped.
`void`	`setMainHeapFlushInterval(int mainHeapFlushInterval)` Deprecated.
`void`	`setMaxFetchedHits(int maxFetchedHits)` When this total number of hits matching the query have been found (on any slice), the query is interrupted. These hits are ranked and the "best" ones are selected for navigation and full hits.
`void`	`setMaxHitsPerSlice(int maxHitsPerSlice)` Maximum number of hits that a single index slice can fetch.
`void`	`setMaxKeptHits(int maxKeptHits)` Number of "best" hits that will be kept for navigation and full hits. It limits the number of hits that can be used for navigation and full hits fetch.
`void`	`setMaxPathsToConsider(long maxPathsToConsider)` If this value is not zero, when doing expand queries without using the "expand=true" mode, the slices will only consider the first maxExploredPaths paths they find for deciding which DIDs are contained in the graph.
`void`	`setMaxQueryTimeMS(int maxQueryTimeMS)` Maximum time spent in the "hits matching" part of the search internal "query" part of the search. After this delay, hits matching is interrupted, partial results will be returned. 0 means no limit.
`void`	`setMaxTotalTimeMS(int maxTotalTimeMS)` Maximum time for the entire search (hits matching, navigation and hits computation). After this delay, the search query is aborted. 0 means no limit.
`void`	`setNeedSecuBlockSize(long needSecuBlockSize)` If this value is not zero, when doing attrgraph queries, each document that need to be postfiltered will have its Fullhit rewritten once said number of documents to postfilter has been reached.
`void`	`setSliceHeapFlushInterval(int sliceHeapFlushInterval)` Each time the slice heap receives this number of hits, it will be flushed to the main heap. This parameter only impacts performance. If value is 0, the system will pick up an appropriate value. Note: Only used in unranked and heapsort.
`void`	`setUsesConsecutiveQueries(boolean usesConsecutiveQueries)` Set this optio to True when you plan to use consecutive queries, then the dedup will occur.
`java.lang.String`	`toString()` String representation of this LimitsConfig.
`LimitsConfig`	`withContentGroupLimitsConfig(java.util.Collection<ContentGroupLimitsConfig> __values)`
`LimitsConfig`	`withContentGroupLimitsConfig(ContentGroupLimitsConfig... __values)` Optional specific per content group limits.
`LimitsConfig`	`withEnoughSlicesPercentage(int enoughSlicesPercentage)`
`LimitsConfig`	`withEnoughSlicesPercentage(java.lang.Integer enoughSlicesPercentage)`
`LimitsConfig`	`withFullGraceDelayMS(int fullGraceDelayMS)`
`LimitsConfig`	`withFullGraceDelayMS(java.lang.Integer fullGraceDelayMS)`
`LimitsConfig`	`withHitsSampling(double hitsSampling)`
`LimitsConfig`	`withInterruptGraceDelayMS(int interruptGraceDelayMS)`
`LimitsConfig`	`withInterruptGraceDelayMS(java.lang.Integer interruptGraceDelayMS)`
`LimitsConfig`	`withMainHeapFlushInterval(int mainHeapFlushInterval)` Deprecated.
`LimitsConfig`	`withMainHeapFlushInterval(java.lang.Integer mainHeapFlushInterval)` Deprecated.
`LimitsConfig`	`withMaxFetchedHits(int maxFetchedHits)`
`LimitsConfig`	`withMaxFetchedHits(java.lang.Integer maxFetchedHits)`
`LimitsConfig`	`withMaxHitsPerSlice(int maxHitsPerSlice)`
`LimitsConfig`	`withMaxHitsPerSlice(java.lang.Integer maxHitsPerSlice)`
`LimitsConfig`	`withMaxKeptHits(int maxKeptHits)`
`LimitsConfig`	`withMaxKeptHits(java.lang.Integer maxKeptHits)`
`LimitsConfig`	`withMaxPathsToConsider(long maxPathsToConsider)`
`LimitsConfig`	`withMaxPathsToConsider(java.lang.Long maxPathsToConsider)`
`LimitsConfig`	`withMaxQueryTimeMS(int maxQueryTimeMS)`
`LimitsConfig`	`withMaxQueryTimeMS(java.lang.Integer maxQueryTimeMS)`
`LimitsConfig`	`withMaxTotalTimeMS(int maxTotalTimeMS)`
`LimitsConfig`	`withMaxTotalTimeMS(java.lang.Integer maxTotalTimeMS)`
`LimitsConfig`	`withNeedSecuBlockSize(long needSecuBlockSize)`
`LimitsConfig`	`withNeedSecuBlockSize(java.lang.Long needSecuBlockSize)`
`LimitsConfig`	`withSliceHeapFlushInterval(int sliceHeapFlushInterval)`
`LimitsConfig`	`withSliceHeapFlushInterval(java.lang.Integer sliceHeapFlushInterval)`
`LimitsConfig`	`withUsesConsecutiveQueries(boolean usesConsecutiveQueries)`
`LimitsConfig`	`withUsesConsecutiveQueries(java.lang.Boolean usesConsecutiveQueries)`
`void`	`writeTo(java.io.OutputStream os)` Write this LimitsConfig as an XML fragment

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - contentGroupLimitsConfig
```
public java.util.List<ContentGroupLimitsConfig> contentGroupLimitsConfig
```
  - maxKeptHits
```
public int maxKeptHits
```
  - maxHitsPerSlice
```
public int maxHitsPerSlice
```
  - mainHeapFlushInterval
```
@Deprecated
public int mainHeapFlushInterval
```
    Deprecated.
  - sliceHeapFlushInterval
```
public int sliceHeapFlushInterval
```
  - maxQueryTimeMS
```
public int maxQueryTimeMS
```
  - maxFetchedHits
```
public int maxFetchedHits
```
  - enoughSlicesPercentage
```
public int enoughSlicesPercentage
```
  - DEFAULT_ENOUGH_SLICES_PERCENTAGE
```
public static final int DEFAULT_ENOUGH_SLICES_PERCENTAGE
```
    See Also:
    
    Constant Field Values
  - interruptGraceDelayMS
```
public int interruptGraceDelayMS
```
  - DEFAULT_INTERRUPT_GRACE_DELAY_M_S
```
public static final int DEFAULT_INTERRUPT_GRACE_DELAY_M_S
```
    See Also:
    
    Constant Field Values
  - maxTotalTimeMS
```
public int maxTotalTimeMS
```
  - fullGraceDelayMS
```
public int fullGraceDelayMS
```
  - DEFAULT_FULL_GRACE_DELAY_M_S
```
public static final int DEFAULT_FULL_GRACE_DELAY_M_S
```
    See Also:
    
    Constant Field Values
  - hitsSampling
```
public double hitsSampling
```
  - DEFAULT_HITS_SAMPLING
```
public static final double DEFAULT_HITS_SAMPLING
```
    See Also:
    
    Constant Field Values
  - usesConsecutiveQueries
```
public boolean usesConsecutiveQueries
```
  - DEFAULT_USES_CONSECUTIVE_QUERIES
```
public static final boolean DEFAULT_USES_CONSECUTIVE_QUERIES
```
    See Also:
    
    Constant Field Values
  - maxPathsToConsider
```
public long maxPathsToConsider
```
  - DEFAULT_MAX_PATHS_TO_CONSIDER
```
public static final long DEFAULT_MAX_PATHS_TO_CONSIDER
```
    See Also:
    
    Constant Field Values
  - needSecuBlockSize
```
public long needSecuBlockSize
```
  - DEFAULT_NEED_SECU_BLOCK_SIZE
```
public static final long DEFAULT_NEED_SECU_BLOCK_SIZE
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - LimitsConfig
```
public LimitsConfig()
```
  - LimitsConfig
```
public LimitsConfig(LimitsConfig o)
```
    Copy constructor
- Method Detail
  - getContentGroupLimitsConfig
```
public java.util.List<ContentGroupLimitsConfig> getContentGroupLimitsConfig()
```
    Optional specific per content group limits.
  - withContentGroupLimitsConfig
```
public LimitsConfig withContentGroupLimitsConfig(ContentGroupLimitsConfig... __values)
```
    Optional specific per content group limits.
  - withContentGroupLimitsConfig
```
public LimitsConfig withContentGroupLimitsConfig(java.util.Collection<ContentGroupLimitsConfig> __values)
```
  - setMaxKeptHits
```
public void setMaxKeptHits(int maxKeptHits)
```
    Number of "best" hits that will be kept for navigation and full hits.
    
    It limits the number of hits that can be used for navigation and full hits fetch. Reducing this parameter can slightly increase performance in some situations (many slices, IO-bound). The "nhits" value in answer is at most equal to this limit.
    
    0 means no limit.
    
    Note: Heapsort executor is used if this setting is defined in ranked mode. If not in ranked mode, this setting is ignored.
  - getMaxKeptHits
```
public int getMaxKeptHits()
```
    Number of "best" hits that will be kept for navigation and full hits.
    
    It limits the number of hits that can be used for navigation and full hits fetch. Reducing this parameter can slightly increase performance in some situations (many slices, IO-bound). The "nhits" value in answer is at most equal to this limit.
    
    0 means no limit.
    
    Note: Heapsort executor is used if this setting is defined in ranked mode. If not in ranked mode, this setting is ignored.
  - withMaxKeptHits
```
public LimitsConfig withMaxKeptHits(int maxKeptHits)
```
  - withMaxKeptHits
```
public LimitsConfig withMaxKeptHits(java.lang.Integer maxKeptHits)
```
  - setMaxHitsPerSlice
```
public void setMaxHitsPerSlice(int maxHitsPerSlice)
```
    Maximum number of hits that a single index slice can fetch.
  - getMaxHitsPerSlice
```
public int getMaxHitsPerSlice()
```
    Maximum number of hits that a single index slice can fetch.
  - withMaxHitsPerSlice
```
public LimitsConfig withMaxHitsPerSlice(int maxHitsPerSlice)
```
  - withMaxHitsPerSlice
```
public LimitsConfig withMaxHitsPerSlice(java.lang.Integer maxHitsPerSlice)
```
  - setMainHeapFlushInterval
```
@Deprecated
public void setMainHeapFlushInterval(int mainHeapFlushInterval)
```
    Deprecated.
    
    Unused setting
  - getMainHeapFlushInterval
```
@Deprecated
public int getMainHeapFlushInterval()
```
    Deprecated.
    
    Unused setting
  - withMainHeapFlushInterval
```
@Deprecated
public LimitsConfig withMainHeapFlushInterval(int mainHeapFlushInterval)
```
    Deprecated.
  - withMainHeapFlushInterval
```
@Deprecated
public LimitsConfig withMainHeapFlushInterval(java.lang.Integer mainHeapFlushInterval)
```
    Deprecated.
  - setSliceHeapFlushInterval
```
public void setSliceHeapFlushInterval(int sliceHeapFlushInterval)
```
    Each time the slice heap receives this number of hits, it will be flushed to the main heap.
    This parameter only impacts performance.
    If value is 0, the system will pick up an appropriate value.
    
    Note: Only used in unranked and heapsort. Not used in localsort.
  - getSliceHeapFlushInterval
```
public int getSliceHeapFlushInterval()
```
    Each time the slice heap receives this number of hits, it will be flushed to the main heap.
    This parameter only impacts performance.
    If value is 0, the system will pick up an appropriate value.
    
    Note: Only used in unranked and heapsort. Not used in localsort.
  - withSliceHeapFlushInterval
```
public LimitsConfig withSliceHeapFlushInterval(int sliceHeapFlushInterval)
```
  - withSliceHeapFlushInterval
```
public LimitsConfig withSliceHeapFlushInterval(java.lang.Integer sliceHeapFlushInterval)
```
  - setMaxQueryTimeMS
```
public void setMaxQueryTimeMS(int maxQueryTimeMS)
```
    Maximum time spent in the "hits matching" part of the search internal "query" part of the search.
    
    After this delay, hits matching is interrupted, partial results will be returned.
    
    0 means no limit.
  - getMaxQueryTimeMS
```
public int getMaxQueryTimeMS()
```
    Maximum time spent in the "hits matching" part of the search internal "query" part of the search.
    
    After this delay, hits matching is interrupted, partial results will be returned.
    
    0 means no limit.
  - withMaxQueryTimeMS
```
public LimitsConfig withMaxQueryTimeMS(int maxQueryTimeMS)
```
  - withMaxQueryTimeMS
```
public LimitsConfig withMaxQueryTimeMS(java.lang.Integer maxQueryTimeMS)
```
  - setMaxFetchedHits
```
public void setMaxFetchedHits(int maxFetchedHits)
```
    When this total number of hits matching the query have been found (on any slice), the query is interrupted.
    
    These hits are ranked and the "best" ones are selected for navigation and full hits. Reducing this parameter improves performance but it means that a potentially "better" hit located further in the index will not be found. Above this limit, the "nmatches" value in answer will be estimated.
    
    0 means no limit.
  - getMaxFetchedHits
```
public int getMaxFetchedHits()
```
    When this total number of hits matching the query have been found (on any slice), the query is interrupted.
    
    These hits are ranked and the "best" ones are selected for navigation and full hits. Reducing this parameter improves performance but it means that a potentially "better" hit located further in the index will not be found. Above this limit, the "nmatches" value in answer will be estimated.
    
    0 means no limit.
  - withMaxFetchedHits
```
public LimitsConfig withMaxFetchedHits(int maxFetchedHits)
```
  - withMaxFetchedHits
```
public LimitsConfig withMaxFetchedHits(java.lang.Integer maxFetchedHits)
```
  - setEnoughSlicesPercentage
```
public void setEnoughSlicesPercentage(int enoughSlicesPercentage)
```
    The query is interrupted if at least this percentage of active slices
    finished fetching hits.
  - getEnoughSlicesPercentage
```
public int getEnoughSlicesPercentage()
```
    The query is interrupted if at least this percentage of active slices
    finished fetching hits.
  - withEnoughSlicesPercentage
```
public LimitsConfig withEnoughSlicesPercentage(int enoughSlicesPercentage)
```
  - withEnoughSlicesPercentage
```
public LimitsConfig withEnoughSlicesPercentage(java.lang.Integer enoughSlicesPercentage)
```
  - setInterruptGraceDelayMS
```
public void setInterruptGraceDelayMS(int interruptGraceDelayMS)
```
    After the query is interrupted, the slices have a small time period to flush their heaps.
    Hits that arrive to the main heap after this time period are dropped.
  - getInterruptGraceDelayMS
```
public int getInterruptGraceDelayMS()
```
    After the query is interrupted, the slices have a small time period to flush their heaps.
    Hits that arrive to the main heap after this time period are dropped.
  - withInterruptGraceDelayMS
```
public LimitsConfig withInterruptGraceDelayMS(int interruptGraceDelayMS)
```
  - withInterruptGraceDelayMS
```
public LimitsConfig withInterruptGraceDelayMS(java.lang.Integer interruptGraceDelayMS)
```
  - setMaxTotalTimeMS
```
public void setMaxTotalTimeMS(int maxTotalTimeMS)
```
    Maximum time for the entire search (hits matching, navigation and hits computation).
    
    After this delay, the search query is aborted.
    
    0 means no limit.
  - getMaxTotalTimeMS
```
public int getMaxTotalTimeMS()
```
    Maximum time for the entire search (hits matching, navigation and hits computation).
    
    After this delay, the search query is aborted.
    
    0 means no limit.
  - withMaxTotalTimeMS
```
public LimitsConfig withMaxTotalTimeMS(int maxTotalTimeMS)
```
  - withMaxTotalTimeMS
```
public LimitsConfig withMaxTotalTimeMS(java.lang.Integer maxTotalTimeMS)
```
  - setFullGraceDelayMS
```
public void setFullGraceDelayMS(int fullGraceDelayMS)
```
    Additional time after maxTotalTime before forcing the full hits processor to stop.
    Note that this elapsed time is only checked between two full hits.
  - getFullGraceDelayMS
```
public int getFullGraceDelayMS()
```
    Additional time after maxTotalTime before forcing the full hits processor to stop.
    Note that this elapsed time is only checked between two full hits.
  - withFullGraceDelayMS
```
public LimitsConfig withFullGraceDelayMS(int fullGraceDelayMS)
```
  - withFullGraceDelayMS
```
public LimitsConfig withFullGraceDelayMS(java.lang.Integer fullGraceDelayMS)
```
  - setHitsSampling
```
public void setHitsSampling(double hitsSampling)
```
    Only fetch a sample of the matches. This is useful to improve search performance while still getting a good hits distribution.
  - getHitsSampling
```
public double getHitsSampling()
```
    Only fetch a sample of the matches. This is useful to improve search performance while still getting a good hits distribution.
  - withHitsSampling
```
public LimitsConfig withHitsSampling(double hitsSampling)
```
  - setUsesConsecutiveQueries
```
public void setUsesConsecutiveQueries(boolean usesConsecutiveQueries)
```
    Set this optio to True when you plan to use consecutive queries, then the dedup will occur.
  - isUsesConsecutiveQueries
```
public boolean isUsesConsecutiveQueries()
```
    Set this optio to True when you plan to use consecutive queries, then the dedup will occur.
  - withUsesConsecutiveQueries
```
public LimitsConfig withUsesConsecutiveQueries(boolean usesConsecutiveQueries)
```
  - withUsesConsecutiveQueries
```
public LimitsConfig withUsesConsecutiveQueries(java.lang.Boolean usesConsecutiveQueries)
```
  - setMaxPathsToConsider
```
public void setMaxPathsToConsider(long maxPathsToConsider)
```
    If this value is not zero, when doing expand queries without using the "expand=true" mode, the
    slices will only consider the first maxExploredPaths paths they find for deciding which
    DIDs are contained in the graph.
  - getMaxPathsToConsider
```
public long getMaxPathsToConsider()
```
    If this value is not zero, when doing expand queries without using the "expand=true" mode, the
    slices will only consider the first maxExploredPaths paths they find for deciding which
    DIDs are contained in the graph.
  - withMaxPathsToConsider
```
public LimitsConfig withMaxPathsToConsider(long maxPathsToConsider)
```
  - withMaxPathsToConsider
```
public LimitsConfig withMaxPathsToConsider(java.lang.Long maxPathsToConsider)
```
  - setNeedSecuBlockSize
```
public void setNeedSecuBlockSize(long needSecuBlockSize)
```
    If this value is not zero, when doing attrgraph queries, each document that need to be postfiltered
    will have its Fullhit rewritten once said number of documents to postfilter has been reached.
  - getNeedSecuBlockSize
```
public long getNeedSecuBlockSize()
```
    If this value is not zero, when doing attrgraph queries, each document that need to be postfiltered
    will have its Fullhit rewritten once said number of documents to postfilter has been reached.
  - withNeedSecuBlockSize
```
public LimitsConfig withNeedSecuBlockSize(long needSecuBlockSize)
```
  - withNeedSecuBlockSize
```
public LimitsConfig withNeedSecuBlockSize(java.lang.Long needSecuBlockSize)
```
  - makeCopy
```
public LimitsConfig makeCopy()
```
    Creates and returns a deep copy of this LimitsConfig.
  - readFrom
```
public static LimitsConfig readFrom(java.io.InputStream is)
                             throws javax.xml.bind.JAXBException
```
    Read this LimitsConfig from an XML fragment.
    
    Throws:
    
    javax.xml.bind.JAXBException
  - writeTo
```
public void writeTo(java.io.OutputStream os)
             throws javax.xml.bind.JAXBException,
                    java.io.IOException
```
    Write this LimitsConfig as an XML fragment
    
    Throws:
    
    javax.xml.bind.JAXBException
    
    java.io.IOException
  - fromString
```
public static LimitsConfig fromString(java.lang.String s)
                               throws javax.xml.bind.JAXBException,
                                      java.io.UnsupportedEncodingException
```
    String representation of this LimitsConfig.
    
    Throws:
    
    javax.xml.bind.JAXBException
    
    java.io.UnsupportedEncodingException
  - toString
```
public java.lang.String toString()
```
    String representation of this LimitsConfig.
    
    Overrides:
    
    toString in class java.lang.Object
  - check
```
public void check(boolean deep,
                  java.lang.String errorContext)
           throws com.exalead.util.TypedException
```
    Checks this LimitsConfig.
    
    Specified by:
    
    check in interface com.exalead.util.Checkable
    
    Throws:
    
    com.exalead.util.TypedException

Class LimitsConfig

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

contentGroupLimitsConfig

maxKeptHits

maxHitsPerSlice

mainHeapFlushInterval

sliceHeapFlushInterval

maxQueryTimeMS

maxFetchedHits

enoughSlicesPercentage

DEFAULT_ENOUGH_SLICES_PERCENTAGE

interruptGraceDelayMS

DEFAULT_INTERRUPT_GRACE_DELAY_M_S

maxTotalTimeMS

fullGraceDelayMS

DEFAULT_FULL_GRACE_DELAY_M_S

hitsSampling

DEFAULT_HITS_SAMPLING

usesConsecutiveQueries

DEFAULT_USES_CONSECUTIVE_QUERIES

maxPathsToConsider

DEFAULT_MAX_PATHS_TO_CONSIDER

needSecuBlockSize

DEFAULT_NEED_SECU_BLOCK_SIZE

Constructor Detail

LimitsConfig

LimitsConfig

Method Detail

getContentGroupLimitsConfig

withContentGroupLimitsConfig

withContentGroupLimitsConfig

setMaxKeptHits

getMaxKeptHits

withMaxKeptHits

withMaxKeptHits

setMaxHitsPerSlice

getMaxHitsPerSlice

withMaxHitsPerSlice

withMaxHitsPerSlice

setMainHeapFlushInterval

getMainHeapFlushInterval

withMainHeapFlushInterval

withMainHeapFlushInterval

setSliceHeapFlushInterval

getSliceHeapFlushInterval

withSliceHeapFlushInterval

withSliceHeapFlushInterval

setMaxQueryTimeMS

getMaxQueryTimeMS

withMaxQueryTimeMS

withMaxQueryTimeMS

setMaxFetchedHits

getMaxFetchedHits

withMaxFetchedHits

withMaxFetchedHits

setEnoughSlicesPercentage

getEnoughSlicesPercentage

withEnoughSlicesPercentage

withEnoughSlicesPercentage

setInterruptGraceDelayMS

getInterruptGraceDelayMS

withInterruptGraceDelayMS

withInterruptGraceDelayMS

setMaxTotalTimeMS

getMaxTotalTimeMS

withMaxTotalTimeMS

withMaxTotalTimeMS

setFullGraceDelayMS

getFullGraceDelayMS

withFullGraceDelayMS

withFullGraceDelayMS

setHitsSampling

getHitsSampling

withHitsSampling

setUsesConsecutiveQueries

isUsesConsecutiveQueries