# All Classes

- All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary
  Class | Description
  --- | ---
  AbstractQueryConfig | This class is the base of `QueryConfigHandler` and `FieldConfig`.
  AbstractRangeQueryNode<T extends FieldValuePairQueryNode<?>> | This class should be extended by nodes intending to represent range queries.
  After | Node that represents `Intervals.after(IntervalsSource, IntervalsSource)`.
  AllowLeadingWildcardProcessor | This processor verifies if `StandardQueryConfigHandler.ConfigurationKeys.ALLOW_LEADING_WILDCARD` is defined in the `QueryConfigHandler`.
  AnalyzedText | Node that represents `Intervals.analyzedText(String, Analyzer, String, int, boolean)`.
  AnalyzerQueryNodeProcessor | This processor verifies if `StandardQueryConfigHandler.ConfigurationKeys.ANALYZER` is defined in the `QueryConfigHandler`.
  AndQuery | Factory for conjunctions
  AndQueryNode | A `AndQueryNode` represents an AND boolean operation performed on a list of nodes.
  AnyQueryNode | A `AnyQueryNode` represents an ANY operator performed on a list of nodes.
  AnyQueryNodeBuilder | Builds a BooleanQuery of SHOULD clauses, possibly with some minimum number to match.
  AtLeast | Node that represents `Intervals.atLeast(int, IntervalsSource...)`.
  BasicQueryFactory | Factory for creating basic term queries
  Before | Node that represents `Intervals.before(IntervalsSource, IntervalsSource)`.
  BooleanModifierNode | A `BooleanModifierNode` has the same behaviour as `ModifierQueryNode`, it only indicates that this modifier was added by `BooleanQuery2ModifierNodeProcessor` and not by the user.
  BooleanModifiersQueryNodeProcessor | This processor is used to apply the correct `ModifierQueryNode` to `BooleanQueryNode`s children.
  BooleanQuery2ModifierNodeProcessor | This processor is used to apply the correct `ModifierQueryNode` to `BooleanQueryNode`s children.
  BooleanQueryBuilder | Builder for `BooleanQuery`
  BooleanQueryNode | A `BooleanQueryNode` represents a list of elements which do not have an explicit boolean operator defined between them.
  BooleanQueryNodeBuilder | Builds a `BooleanQuery` object from a `BooleanQueryNode` object.
  BooleanSingleChildOptimizationQueryNodeProcessor | This processor removes every `BooleanQueryNode` that contains only one child and returns this child.
  BoostingTermBuilder | Builder for `PayloadScoreQuery`
  BoostQueryNode | A `BoostQueryNode` boosts the QueryNode tree which is under this node.
  BoostQueryNodeBuilder | This builder basically reads the `Query` object set on the `BoostQueryNode` child using `QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID` and applies the boost value defined in the `BoostQueryNode`.
  BoostQueryNodeProcessor | This processor iterates the query node tree looking for every `FieldableNode` that has `StandardQueryConfigHandler.ConfigurationKeys.BOOST` in its config.
  CharStream | This interface describes a character stream that maintains line and column number positions of the characters.
  CommonQueryParserConfiguration | Configuration options common across queryparser implementations.
  ComplexPhraseQueryParser | QueryParser which permits complex phrase query syntax eg "(john jon jonathan~) peters*".
  ComposedQuery | Base class for composite queries (such as AND/OR/NOT)
  ConfigurationKey<T> | An instance of this class represents a key that is used to retrieve a value from `AbstractQueryConfig`.
  ConstantScoreQueryBuilder | Builder for `ConstantScoreQuery`
  ContainedBy | Node that represents `Intervals.containedBy(IntervalsSource, IntervalsSource)`.
  Containing | Node that represents `Intervals.containing(IntervalsSource, IntervalsSource)`.
  CoreParser | Assembles a QueryBuilder which uses only core Lucene Query objects
  CorePlusExtensionsParser | Assembles a QueryBuilder which uses Query objects from Lucene's `sandbox` and `queries` modules in addition to core queries.
  CorePlusQueriesParser | Assembles a QueryBuilder which uses Query objects from Lucene's `queries` module in addition to core queries.
  DefaultPhraseSlopQueryNodeProcessor | This processor verifies if `StandardQueryConfigHandler.ConfigurationKeys.PHRASE_SLOP` is defined in the `QueryConfigHandler`.
  DeletedQueryNode | A `DeletedQueryNode` represents a node that was deleted from the query node tree.
  DisjunctionMaxQueryBuilder | Builder for `DisjunctionMaxQuery`
  DistanceQuery | Factory for NEAR queries
  DistanceSubQuery | Interface for queries that can be nested as subqueries into a span near.
  DOMUtils | Helper methods for parsing XML
  DummyQueryNodeBuilder | This builder does nothing.
  EscapeQuerySyntax | A parser needs to implement `EscapeQuerySyntax` to allow the QueryNode to escape the queries, when the toQueryString method is called.
  EscapeQuerySyntax.Type | Type of escaping: String for escaping syntax, NORMAL for escaping reserved words (like AND) in terms
  EscapeQuerySyntaxImpl | Implementation of `EscapeQuerySyntax` for the standard lucene syntax.
  Extend | Node that represents `Intervals.extend(IntervalsSource, int, int)`.
  ExtendableQueryParser | The `ExtendableQueryParser` enables arbitrary query parser extension based on a customizable field naming scheme.
  ExtensionQuery | `ExtensionQuery` holds all query components extracted from the original query string like the query field and the extension query string.
  Extensions | The `Extensions` class represents an extension mapping to associate `ParserExtension` instances with extension keys.
  Extensions.Pair<Cur,​Cud> | This class represents a generic pair.
  FastCharStream | An efficient implementation of JavaCC's CharStream interface.
  FieldableNode | A query node implements `FieldableNode` interface to indicate that its children and itself are associated to a specific field.
  FieldBoostMapFCListener | This listener listens for every field configuration request and assign a `StandardQueryConfigHandler.ConfigurationKeys.BOOST` to the equivalent `FieldConfig` based on a defined map: fieldName -> boostValue stored in `StandardQueryConfigHandler.ConfigurationKeys.FIELD_BOOST_MAP`.
  FieldConfig | This class represents a field configuration.
  FieldConfigListener | This interface should be implemented by classes that wants to listen for field configuration requests.
  FieldDateResolutionFCListener | This listener listens for every field configuration request and assign a `StandardQueryConfigHandler.ConfigurationKeys.DATE_RESOLUTION` to the equivalent `FieldConfig` based on a defined map: fieldName -> `DateTools.Resolution` stored in `StandardQueryConfigHandler.ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP`.
  FieldQueryNode | A `FieldQueryNode` represents a element that contains field/text tuple
  FieldQueryNodeBuilder | Builds a `TermQuery` object from a `FieldQueryNode` object.
  FieldsQuery | Forms an OR query of the provided query across multiple fields.
  FieldValuePairQueryNode<T> | This interface should be implemented by `QueryNode` that holds a field and an arbitrary value.
  FuzzyConfig | Configuration parameters for `FuzzyQuery`s
  FuzzyLikeThisQueryBuilder | Builder for `FuzzyLikeThisQuery`
  FuzzyQueryNode | A `FuzzyQueryNode` represents a element that contains field/text/similarity tuple
  FuzzyQueryNodeBuilder | Builds a `FuzzyQuery` object from a `FuzzyQueryNode` object.
  FuzzyQueryNodeProcessor | This processor iterates the query node tree looking for every `FuzzyQueryNode`, when this kind of node is found, it checks on the query configuration for `StandardQueryConfigHandler.ConfigurationKeys.FUZZY_CONFIG`, gets the fuzzy prefix length and default similarity from it and set to the fuzzy node.
  FuzzyTerm | An interval function equivalent to `FuzzyQuery`.
  GroupQueryNode | A `GroupQueryNode` represents a location where the original user typed real parenthesis on the query string.
  GroupQueryNodeBuilder | Builds no object, it only returns the `Query` object set on the `GroupQueryNode` object using a `QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID` tag.
  IntervalFunction | Representation of an interval function that can be converted to `IntervalsSource`.
  IntervalQueryNode | Node that represents an interval function.
  IntervalQueryNodeBuilder | Builds a `Query` from an `IntervalQueryNode`.
  IntervalQueryNodeProcessor | This processor makes sure that `StandardQueryConfigHandler.ConfigurationKeys.ANALYZER` is defined in the `QueryConfigHandler` and injects this analyzer into `IntervalQueryNode`s.
  LikeThisQueryBuilder | Builder for `MoreLikeThisQuery`
  MatchAllDocsQueryBuilder | Builder for `MatchAllDocsQuery`
  MatchAllDocsQueryNode | A `MatchAllDocsQueryNode` indicates that a query node tree or subtree will match all documents if executed in the index.
  MatchAllDocsQueryNodeBuilder | Builds a `MatchAllDocsQuery` object from a `MatchAllDocsQueryNode` object.
  MatchAllDocsQueryNodeProcessor | This processor converts every `WildcardQueryNode` that is "*:*" to `MatchAllDocsQueryNode`.
  MatchNoDocsQueryNode | A `MatchNoDocsQueryNode` indicates that a query node tree or subtree will not match any documents if executed in the index.
  MatchNoDocsQueryNodeBuilder | Builds a `MatchNoDocsQuery` object from a `MatchNoDocsQueryNode` object.
  MaxGaps | Node that represents `Intervals.maxgaps(int, IntervalsSource)`.
  MaxWidth | Node that represents `Intervals.maxwidth(int, IntervalsSource)`.
  Message | Message Interface for a lazy loading.
  MessageImpl | Default implementation of Message interface.
  MinShouldMatchNode | Node that represents a minimum-should-match restriction on a `GroupQueryNode`.
  MinShouldMatchNodeBuilder | Builds a `BooleanQuery` from a `MinShouldMatchNode`.
  ModifierQueryNode | A `ModifierQueryNode` indicates the modifier value (+,-,?,NONE) for each term on the query string.
  ModifierQueryNode.Modifier | Modifier type: such as required (REQ), prohibited (NOT)
  ModifierQueryNodeBuilder | Builds no object, it only returns the `Query` object set on the `ModifierQueryNode` object using a `QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID` tag.
  MultiFieldQueryNodeProcessor | This processor is used to expand terms so the query looks for the same term in different fields.
  MultiFieldQueryParser | A QueryParser which constructs queries to search multiple fields.
  MultiPhraseQueryNode | A `MultiPhraseQueryNode` indicates that its children should be used to build a `MultiPhraseQuery` instead of `PhraseQuery`.
  MultiPhraseQueryNodeBuilder | Builds a `MultiPhraseQuery` object from a `MultiPhraseQueryNode` object.
  MultiTermRewriteMethodProcessor | This processor instates the default `MultiTermQuery.RewriteMethod`, `MultiTermQuery.CONSTANT_SCORE_BLENDED_REWRITE`, for multi-term query nodes.
  NLS | MessageBundles classes extend this class, to implement a bundle.
  NLSException | Interface that exceptions should implement to support lazy loading of messages.
  NoChildOptimizationQueryNodeProcessor | A `NoChildOptimizationQueryNodeProcessor` removes every BooleanQueryNode, BoostQueryNode, TokenizedPhraseQueryNode or ModifierQueryNode that do not have a valid children.
  NonOverlapping | Node that represents `Intervals.nonOverlapping(IntervalsSource, IntervalsSource)` .
  NotContainedBy | Node that represents `Intervals.notContainedBy(IntervalsSource, IntervalsSource)`.
  NotContaining | Node that represents `Intervals.notContaining(IntervalsSource, IntervalsSource)`.
  NoTokenFoundQueryNode | A `NoTokenFoundQueryNode` is used if a term is convert into no tokens by the tokenizer/lemmatizer/analyzer (null).
  NotQuery | Factory for prohibited clauses
  NotWithin | Node that represents `Intervals.notWithin(IntervalsSource, int, IntervalsSource)`.
  NumberDateFormat | This `Format` parses `Long` into date strings and vice-versa.
  OpaqueQueryNode | A `OpaqueQueryNode` is used for specify values that are not supposed to be parsed by the parser.
  OpenRangeQueryNodeProcessor | Processes `TermRangeQuery`s with open ranges.
  Or | Node that represents `Intervals.or(IntervalsSource...)`.
  Ordered | Node that represents `Intervals.ordered(IntervalsSource...)`.
  OrQuery | Factory for disjunctions
  OrQueryNode | A `OrQueryNode` represents an OR boolean operation performed on a list of nodes.
  Overlapping | Node that represents `Intervals.overlapping(IntervalsSource, IntervalsSource)`.
  ParseException | This exception is thrown when parse errors are encountered.
  ParseException | This exception is thrown when parse errors are encountered.
  ParseException | This exception is thrown when parse errors are encountered.
  ParserException | Thrown when the xml queryparser encounters invalid syntax/configuration.
  ParserExtension | This class represents an extension base class to the Lucene standard `QueryParser`.
  PathQueryNode | A `PathQueryNode` is used to store queries like /company/USA/California /product/shoes/brown.
  PathQueryNode.QueryText | Term text with a beginning and end position
  Phrase | Node that represents `Intervals.phrase(String...)`.
  PhraseQueryNodeBuilder | Builds a `PhraseQuery` object from a `TokenizedPhraseQueryNode` object.
  PhraseSlopQueryNode | Query node for `PhraseQuery`'s slop factor.
  PhraseSlopQueryNodeProcessor | This processor removes invalid `SlopQueryNode` objects in the query node tree.
  PointQueryNode | This query node represents a field query that holds a point value.
  PointQueryNodeProcessor | This processor is used to convert `FieldQueryNode`s to `PointRangeQueryNode`s.
  PointRangeQueryBuilder | Creates a range query across 1D `PointValues`.
  PointRangeQueryNode | This query node represents a range query composed by `PointQueryNode` bounds, which means the bound values are `Number`s.
  PointRangeQueryNodeBuilder | Builds `PointValues` range queries out of `PointRangeQueryNode`s.
  PointRangeQueryNodeProcessor | This processor is used to convert `TermRangeQueryNode`s to `PointRangeQueryNode`s.
  PointsConfig | This class holds the configuration used to parse numeric queries and create `PointValues` queries.
  PointsConfigListener | This listener is used to listen to `FieldConfig` requests in `QueryConfigHandler` and add `StandardQueryConfigHandler.ConfigurationKeys.POINTS_CONFIG` based on the `StandardQueryConfigHandler.ConfigurationKeys.POINTS_CONFIG_MAP` set in the `QueryConfigHandler`.
  PrecedenceQueryNodeProcessorPipeline | This processor pipeline extends `StandardQueryNodeProcessorPipeline` and enables boolean precedence on it.
  PrecedenceQueryParser | This query parser works exactly as the standard query parser ( `StandardQueryParser` ), except that it respect the boolean precedence, so <a AND b OR c AND d> is parsed to <(+a +b) (+c +d)> instead of <+a +b +c +d>.
  PrefixWildcardQueryNode | A `PrefixWildcardQueryNode` represents wildcardquery that matches abc* or *.
  PrefixWildcardQueryNodeBuilder | Builds a `PrefixQuery` object from a `PrefixWildcardQueryNode` object.
  ProximityQueryNode | A `ProximityQueryNode` represents a query where the terms should meet specific distance conditions.
  ProximityQueryNode.ProximityType | utility class containing the distance condition and number
  ProximityQueryNode.Type | Distance condition: PARAGRAPH, SENTENCE, or NUMBER
  QueryBuilder | This interface is used by implementors classes that builds some kind of object from a query tree.
  QueryBuilder | Implemented by objects that produce Lucene Query objects from XML streams.
  QueryBuilderFactory | Factory for `QueryBuilder`
  QueryConfigHandler | This class can be used to hold any query configuration and no field configuration.
  QueryNode | A `QueryNode` is a interface implemented by all nodes on a QueryNode tree.
  QueryNodeError | Error class with NLS support
  QueryNodeException | This exception should be thrown if something wrong happens when dealing with `QueryNode`s.
  QueryNodeImpl | A `QueryNodeImpl` is the default implementation of the interface `QueryNode`
  QueryNodeOperation | Allow joining 2 QueryNode Trees, into one.
  QueryNodeParseException | This should be thrown when an exception happens during the query parsing from string to the query node tree.
  QueryNodeProcessor | A `QueryNodeProcessor` is an interface for classes that process a `QueryNode` tree.
  QueryNodeProcessorImpl | This is a default implementation for the `QueryNodeProcessor` interface, it's an abstract class, so it should be extended by classes that want to process a `QueryNode` tree.
  QueryNodeProcessorPipeline | A `QueryNodeProcessorPipeline` class should be used to build a query node processor pipeline.
  QueryParser | This class is generated by JavaCC.
  QueryParser | This class is generated by JavaCC.
  QueryParser.Operator | The default operator for parsing queries.
  QueryParserBase | This class is overridden by QueryParser in QueryParser.jj and acts to separate the majority of the Java code from the .jj grammar file.
  QueryParserConstants | Token literal values and constants.
  QueryParserConstants | Token literal values and constants.
  QueryParserHelper | This class is a helper for the query parser framework, it does all the three query parser phrases at once: text parsing, query processing and query building.
  QueryParserMessages | Flexible Query Parser message bundle class
  QueryParserTokenManager | Token Manager.
  QueryParserTokenManager | Token Manager.
  QueryParserUtil | This class defines utility methods to (help) parse query strings into `Query` objects.
  QueryTreeBuilder | This class should be used when there is a builder for each type of node.
  QuotedFieldQueryNode | A `QuotedFieldQueryNode` represents phrase query.
  RangeQueryBuilder | Builder for `TermRangeQuery`
  RangeQueryNode<T extends FieldValuePairQueryNode<?>> | This interface should be implemented by a `QueryNode` that represents some kind of range query.
  RegexpQueryNode | A `RegexpQueryNode` represents `RegexpQuery` query Examples: /[a-z]|[0-9]/
  RegexpQueryNodeBuilder | Builds a `RegexpQuery` object from a `RegexpQueryNode` object.
  RegexpQueryNodeProcessor | Processor for Regexp queries.
  RemoveDeletedQueryNodesProcessor | A `QueryNodeProcessorPipeline` class removes every instance of `DeletedQueryNode` from a query node tree.
  RemoveEmptyNonLeafQueryNodeProcessor | This processor removes every `QueryNode` that is not a leaf and has not children.
  SimpleQueryParser | SimpleQueryParser is used to parse human readable query syntax.
  SimpleTerm | Base class for queries that expand to sets of simple terms.
  SimpleTerm.MatchingTermVisitor | Callback to visit each matching term during "rewrite" in `SimpleTerm.MatchingTermVisitor.visitMatchingTerm(Term)`
  SlopQueryNode | A `SlopQueryNode` represents phrase query with a slop.
  SlopQueryNodeBuilder | This builder basically reads the `Query` object set on the `SlopQueryNode` child using `QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID` and applies the slop value defined in the `SlopQueryNode`.
  SpanBuilderBase | Base class for building `SpanQuery`s
  SpanFirstBuilder | Builder for `SpanFirstQuery`
  SpanNearBuilder | Builder for `SpanNearQuery`
  SpanNearClauseFactory | Factory for `SpanOrQuery`
  SpanNotBuilder | Builder for `SpanNotQuery`
  SpanOrBuilder | Builder for `SpanOrQuery`
  SpanOrTermsBuilder | Builder that analyzes the text into a `SpanOrQuery`
  SpanPositionRangeBuilder | Builder for `SpanPositionRangeQuery`
  SpanQueryBuilder | Interface for retrieving a `SpanQuery`.
  SpanQueryBuilderFactory | Factory for `SpanQueryBuilder`s
  SpanTermBuilder | Builder for `SpanTermQuery`
  SrndPrefixQuery | Query that matches String prefixes
  SrndQuery | Lowest level base class for surround queries
  SrndTermQuery | Simple single-term clause
  SrndTruncQuery | Query that matches wildcards
  StandardQueryBuilder | This interface should be implemented by every class that wants to build `Query` objects from `QueryNode` objects.
  StandardQueryConfigHandler | This query configuration handler is used for almost every processor defined in the `StandardQueryNodeProcessorPipeline` processor pipeline.
  StandardQueryConfigHandler.ConfigurationKeys | Class holding keys for StandardQueryNodeProcessorPipeline options.
  StandardQueryConfigHandler.Operator | Boolean Operator: AND or OR
  StandardQueryNodeProcessorPipeline | This pipeline has all the processors needed to process a query node tree, generated by `StandardSyntaxParser`, already assembled.
  StandardQueryParser | The `StandardQueryParser` is a pre-assembled query parser that supports most features of the classic Lucene query parser, allows dynamic configuration of some of its features (like multi-field expansion or wildcard query restrictions) and adds support for new query types and expressions.
  StandardQueryTreeBuilder | This query tree builder only defines the necessary map to build a `Query` tree object.
  StandardSyntaxParser | Parser for the standard Lucene syntax
  StandardSyntaxParserConstants | Token literal values and constants.
  StandardSyntaxParserTokenManager | Token Manager.
  StringUtils | String manipulation routines
  SynonymQueryNode | `QueryNode` for clauses that are synonym of each other.
  SynonymQueryNodeBuilder | Builder for `SynonymQueryNode`.
  SyntaxParser | A parser needs to implement `SyntaxParser` interface
  TermQueryBuilder | Builder for `TermQuery`
  TermRangeQueryNode | This query node represents a range query composed by `FieldQueryNode` bounds, which means the bound values are strings.
  TermRangeQueryNodeBuilder | Builds a `TermRangeQuery` object from a `TermRangeQueryNode` object.
  TermRangeQueryNodeProcessor | This processors process `TermRangeQueryNode`s.
  TermsQueryBuilder | Builds a BooleanQuery from all of the terms found in the XML element using the choice of analyzer
  TextableQueryNode | Interface for a node that has text as a `CharSequence`
  Token | Describes the input token stream.
  Token | Describes the input token stream.
  Token | Describes the input token stream.
  TokenizedPhraseQueryNode | A `TokenizedPhraseQueryNode` represents a node created by a code that tokenizes/lemmatizes/analyzes.
  TokenMgrError | Token Manager Error.
  TokenMgrError | Token Manager Error.
  TokenMgrError | Token Manager Error.
  TooManyBasicQueries | Exception thrown when `BasicQueryFactory` would exceed the limit of query clauses.
  UnescapedCharSequence | CharsSequence with escaped chars information.
  Unordered | Node that represents `Intervals.unordered(IntervalsSource...)`.
  UnorderedNoOverlaps | Node that represents `Intervals.unorderedNoOverlaps(IntervalsSource, IntervalsSource)`.
  UserInputQueryBuilder | UserInputQueryBuilder uses 1 of 2 strategies for thread-safe parsing: 1) Synchronizing access to "parse" calls on a previously supplied QueryParser or..
  ValueQueryNode<T> | This interface should be implemented by `QueryNode` that holds an arbitrary value.
  Wildcard | Node that represents `Intervals.wildcard(BytesRef)`.
  WildcardQueryNode | A `WildcardQueryNode` represents wildcard query This does not apply to phrases.
  WildcardQueryNodeBuilder | Builds a `WildcardQuery` object from a `WildcardQueryNode` object.
  WildcardQueryNodeProcessor | The `StandardSyntaxParser` creates `PrefixWildcardQueryNode` nodes which have values containing the prefixed wildcard.
  Within | Node that represents `Intervals.within(IntervalsSource, int, IntervalsSource)`.