org.apache.lucene.monitor

## Class Monitor

- java.lang.Object
- - org.apache.lucene.monitor.Monitor

All Implemented Interfaces:
  Closeable, AutoCloseable

    public class Monitor
    extends Object
    implements Closeable

A Monitor contains a set of `Query` objects with associated IDs, and efficiently matches them against sets of `Document` objects.

### Nested Class Summary

Nested Classes
`static class` `Monitor.QueryCacheStats` Statistics for the query cache and query index

### Field Summary

Fields
`protected Presearcher` `presearcher`

### Constructor Summary

Constructors
Constructor and Description
`Monitor(Analyzer analyzer)` Create a non-persistent Monitor instance with the default term-filtering Presearcher
`Monitor(Analyzer analyzer, MonitorConfiguration config)` Create a new Monitor instance with a specific configuration
`Monitor(Analyzer analyzer, Presearcher presearcher)` Create a new non-persistent Monitor instance
`Monitor(Analyzer analyzer, Presearcher presearcher, MonitorConfiguration configuration)` Create a new Monitor instance

### Method Summary

All Methods Instance Methods Concrete Methods
`void` `addQueryIndexUpdateListener(MonitorUpdateListener listener)` Register a `MonitorUpdateListener` that will be notified whenever changes are made to the Monitor's queryindex
`void` `clear()` Delete all queries from the monitor
`void` `close()`
`<T extends QueryMatch> PresearcherMatches<T>` `debug(Document[] docs, MatcherFactory<T> factory)` Match a DocumentBatch against the queries stored in the Monitor, also returning information about which queries were selected by the presearcher, and why.
`<T extends QueryMatch> PresearcherMatches<T>` `debug(Document doc, MatcherFactory<T> factory)` Match a single `Document` against the queries stored in the Monitor, also returning information about which queries were selected by the presearcher, and why.
`void` `deleteById(List<String> queryIds)` Delete queries from the monitor by ID
`void` `deleteById(String... queryIds)` Delete queries from the monitor by ID
`int` `getDisjunctCount()`
`MonitorQuery` `getQuery(String queryId)` Get the MonitorQuery for a given query id
`Monitor.QueryCacheStats` `getQueryCacheStats()`
`int` `getQueryCount()`
`Set<String>` `getQueryIds()`
`<T extends QueryMatch> MultiMatchingQueries<T>` `match(Document[] docs, MatcherFactory<T> factory)` Match an array of `Document`s against the queryindex, calling a `CandidateMatcher` produced by the supplied `MatcherFactory` for each possible matching query.
`<T extends QueryMatch> MatchingQueries<T>` `match(Document doc, MatcherFactory<T> factory)` Match a single `Document` against the queryindex, calling a `CandidateMatcher` produced by the supplied `MatcherFactory` for each possible matching query.
`void` `purgeCache()` Remove unused queries from the query cache.
`void` `register(Iterable<MonitorQuery> queries)` Add new queries to the monitor
`void` `register(MonitorQuery... queries)` Add new queries to the monitor

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

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

### Field Detail

#### presearcher

    protected final Presearcher presearcher

### Constructor Detail

#### Monitor

    public Monitor(Analyzer analyzer)
            throws IOException

Create a non-persistent Monitor instance with the default term-filtering Presearcher

Parameters:
  `analyzer` - to analyze `Document`s at match time
Throws:
  `IOException`

#### Monitor

    public Monitor(Analyzer analyzer,
                   Presearcher presearcher)
            throws IOException

Create a new non-persistent Monitor instance

Parameters:
  `analyzer` - to analyze `Document`s at match time
  `presearcher` - the presearcher to use
Throws:
  `IOException`

#### Monitor

    public Monitor(Analyzer analyzer,
                   MonitorConfiguration config)
            throws IOException

Create a new Monitor instance with a specific configuration

Parameters:
  `analyzer` - to analyze `Document`s at match time
  `config` - the configuration
Throws:
  `IOException`

#### Monitor

    public Monitor(Analyzer analyzer,
                   Presearcher presearcher,
                   MonitorConfiguration configuration)
            throws IOException

Create a new Monitor instance

Parameters:
  `analyzer` - to analyze `Document`s at match time
  `presearcher` - the presearcher to use
  `configuration` - the configuration
Throws:
  `IOException`

### Method Detail

#### addQueryIndexUpdateListener

    public void addQueryIndexUpdateListener(MonitorUpdateListener listener)

Register a `MonitorUpdateListener` that will be notified whenever changes are made to the Monitor's queryindex

Parameters:
  `listener` - listener to register

#### getQueryCacheStats

    public Monitor.QueryCacheStats getQueryCacheStats()

Returns:
  Statistics for the internal query index and cache

#### purgeCache

    public void purgeCache()
                    throws IOException

Remove unused queries from the query cache.

This is normally called from a background thread at a rate set by configurePurgeFrequency().

Throws:
  `IOException` - on IO errors

#### close

    public void close()
               throws IOException

Specified by:
  `close` in interface `Closeable`
Specified by:
  `close` in interface `AutoCloseable`
Throws:
  `IOException`

#### register

    public void register(Iterable<MonitorQuery> queries)
                  throws IOException

Add new queries to the monitor

Parameters:
  `queries` - the MonitorQueries to add
Throws:
  `IOException`

#### register

    public void register(MonitorQuery... queries)
                  throws IOException

Add new queries to the monitor

Parameters:
  `queries` - the MonitorQueries to add
Throws:
  `IOException` - on IO errors

#### deleteById

    public void deleteById(List<String> queryIds)
                    throws IOException

Delete queries from the monitor by ID

Parameters:
  `queryIds` - the IDs to delete
Throws:
  `IOException` - on IO errors

#### deleteById

    public void deleteById(String... queryIds)
                    throws IOException

Delete queries from the monitor by ID

Parameters:
  `queryIds` - the IDs to delete
Throws:
  `IOException` - on IO errors

#### clear

    public void clear()
               throws IOException

Delete all queries from the monitor

Throws:
  `IOException` - on IO errors

#### match

    public <T extends QueryMatch> MultiMatchingQueries<T> match(Document[] docs,
                                                                MatcherFactory<T> factory)
                                                         throws IOException

Match an array of `Document`s against the queryindex, calling a `CandidateMatcher` produced by the supplied `MatcherFactory` for each possible matching query.

Type Parameters:
  `T` - the type of `QueryMatch` to return
Parameters:
  `docs` - the DocumentBatch to match
  `factory` - a `MatcherFactory` to use to create a `CandidateMatcher` for the match run
Returns:
  a `MatchingQueries` object summarizing the match run.
Throws:
  `IOException` - on IO errors

#### match

    public <T extends QueryMatch> MatchingQueries<T> match(Document doc,
                                                           MatcherFactory<T> factory)
                                                    throws IOException

Match a single `Document` against the queryindex, calling a `CandidateMatcher` produced by the supplied `MatcherFactory` for each possible matching query.

Type Parameters:
  `T` - the type of `QueryMatch` to return
Parameters:
  `doc` - the InputDocument to match
  `factory` - a `MatcherFactory` to use to create a `CandidateMatcher` for the match run
Returns:
  a `MatchingQueries` object summarizing the match run.
Throws:
  `IOException` - on IO errors

#### getQuery

    public MonitorQuery getQuery(String queryId)
                          throws IOException

Get the MonitorQuery for a given query id

Parameters:
  `queryId` - the id of the query to get
Returns:
  the MonitorQuery stored for this id, or null if not found
Throws:
  `IOException` - on IO errors
  `IllegalStateException` - if queries are not stored in the queryindex

#### getDisjunctCount

    public int getDisjunctCount()

Returns:
  the number of queries (after decomposition) stored in this Monitor

#### getQueryCount

    public int getQueryCount()
                      throws IOException

Returns:
  the number of queries stored in this Monitor
Throws:
  `IOException` - on IO errors

#### getQueryIds

    public Set<String> getQueryIds()
                            throws IOException

Returns:
  the set of query ids of the queries stored in this Monitor
Throws:
  `IOException` - on IO errors

#### debug

    public <T extends QueryMatch> PresearcherMatches<T> debug(Document[] docs,
                                                              MatcherFactory<T> factory)
                                                       throws IOException

Match a DocumentBatch against the queries stored in the Monitor, also returning information about which queries were selected by the presearcher, and why.

Type Parameters:
  `T` - the type of QueryMatch produced by the CandidateMatcher
Parameters:
  `docs` - a DocumentBatch to match against the index
  `factory` - a `MatcherFactory` to use to create a `CandidateMatcher` for the match run
Returns:
  a `PresearcherMatches` object containing debug information
Throws:
  `IOException` - on IO errors

#### debug

    public <T extends QueryMatch> PresearcherMatches<T> debug(Document doc,
                                                              MatcherFactory<T> factory)
                                                       throws IOException

Match a single `Document` against the queries stored in the Monitor, also returning information about which queries were selected by the presearcher, and why.

Type Parameters:
  `T` - the type of QueryMatch produced by the CandidateMatcher
Parameters:
  `doc` - an InputDocument to match against the index
  `factory` - a `MatcherFactory` to use to create a `CandidateMatcher` for the match run
Returns:
  a `PresearcherMatches` object containing debug information
Throws:
  `IOException` - on IO errors