All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary Annotation Types Summary
| Class |
Description |
| AbstractPostingOutputStream |
Abstract class that is extended by other posting output stream implementations
|
| AbstractQuerying |
|
| AbstractQuerying.AbstractQueryingCommand |
|
| AbstractScoringMatching |
|
| AccumulatorResultSet |
A result set instance that uses maps internally until initialise() is called
|
| AdhocEvaluation |
Performs the evaluation for TREC's tasks, except the named page task.
|
| AdhocFullQueryEvaluation |
Performs a query by query evaluation of a results file.
|
| AfterEffect |
This class provides a contract for implementing the first normalisation by
after effect models for the DFR framework.
|
| ANDIterablePosting |
An instance of IterablePostings that works with passed arrays of ids and frequencies.
|
| ANDQueryOp |
This combines multiple operators into a single op, where must all occur
in a document.
|
| AnyclassLauncher |
|
| ApplicationSetup |
This class retrieves and provides access
to all the constants and parameters for
the system.
|
| ApplicationSetup.TerrierApplicationPlugin |
Interface for plugins.
|
| ApplicationSetupBasedTest |
Base class for a test that requires ApplicationSetup to be correctly initialised.
|
| ApplyTermPipeline |
|
| ArrayOfBasicIterablePosting |
An instance of IterablePostings that works with passed arrays of ids and frequencies
|
| ArrayOfBlockFieldIterablePosting |
An array structure that golds BlockFieldIterablePostings
|
| ArrayOfBlockIterablePosting |
An array structure that golds BlockIterablePostings
|
| ArrayOfFieldIterablePosting |
An instance of IterablePostings that works with passed arrays of ids and frequencies
for each field.
|
| ArrayOfIdsIterablePosting |
An instance of IterablePostings that works with a passed array of ids
|
| ArrayUtils |
Handy methods for resizing arrays, and other handy array methods
This is a fresh implementation of the capacity methods, without the
use of any prelicensed code.
|
| B |
This class implements the B model for the first normalisation by
after effect.
|
| B |
This class implements the B basic model for randomness.
|
| BA |
This class implements an approximation of the binomial distribution through
the Kullback-Leibler divergence to weight query terms for query expansion.
|
| BaseCompressingMetaIndex |
A MetaIndex implementation that compresses contents. |
| BaseCompressingMetaIndex.InputStream |
An iterator for reading a MetaIndex as a stream
|
| BaseMatching |
Performs the matching of documents with a query, by first assigning scores to
documents for each query term and modifying these scores with the appropriate modifiers.
|
| BaseMatching.MatchingState |
|
| BaseMetaIndexBuilder |
Abstract base class for compressed and uncompressed metaindex building
Properties:
metaindex.compressed.max.data.in-mem.mb - maximum size that a meta index .zdata file will be kept in memory.
|
| BaseTermPipelineAccessor |
A base implementation for TermPipelineAccessor
|
| BasicDocumentIndexEntry |
A basic document index entry.
|
| BasicDocumentIndexEntry.Factory |
Returna a factory for creating document index entries
|
| BasicIndexer |
BasicIndexer is the default indexer for Terrier.
|
| BasicIterablePosting |
|
| BasicIterablePostingDocidOnly |
Posting iterator class that only returns identifiers, not frequencies.
|
| BasicLexiconEntry |
Contains all the information about one entry in the Lexicon.
|
| BasicLexiconEntry.Factory |
Factory for creating LexiconEntry objects
|
| BasicModel |
This class provides a contract for implementing the basic models for randomness in the DFR framework,
for use with the DFRWeightingModel class.
|
| BasicPostingImpl |
Implementation of a Posting that is non-iterable.
|
| BasicSinglePassIndexer |
This class indexes a document collection (skipping the direct file construction).
|
| BasicTermStatsLexiconEntry |
A LexiconEntry which only contains EntryStatistics
|
| BatchEndToEndTest |
|
| BatchEndToEndTest.BatchEndToEndTestEventHooks |
|
| BatchEvaluationCommand |
|
| BatchIndexing |
Abstract class for all code that set up the batch indexers
|
| BatchIndexing.Command |
|
| BB2 |
This class implements the BB2 weighting model.
|
| BitByteOutputStream |
An implementation of BitOutputStream that does no buffering.
|
| BitFileBuffered |
Implementation of BitInSeekable/BitIn interfaces similar to BitFile.
|
| BitFileBuffered.BitInBuffered |
Implements a BitIn around a RandomDataInput
|
| BitFileChannel |
|
| BitFileChannel.FileChannelBitInBuffered |
|
| BitFileInMemory |
Class which enables a bit compressed file to be read wholly into memory
and accessed from there with lot latency.
|
| BitFileInMemoryLarge |
Allows access to bit compressed files that are loaded entirely into memory.
|
| BitFilePosition |
A (number of bytes, number of bits) position in a bit file.
|
| BitIn |
Interface describing the read compression methods supported
by the BitFileBuffered and BitInputStream classes.
|
| BitInBase |
Base class for various BitIn implementations
|
| BitIndexPointer |
|
| BitInputStream |
This class reads from a file or an InputStream integers that can be coded with different encoding algorithms.
|
| BitInSeekable |
Interface for reading a bit compressed file in a random access manner.
|
| BitOut |
Interface describing the writing compression methods supported
by the BitOutputStream classes.
|
| BitOutputStream |
This class provides methods to write compressed integers to an outputstream.
The numbers are written into a byte starting from the most significant bit (i.e, left to right).
|
| BitPostingIndex |
Class for various bit compressed index implementations, including parents to current DirectIndex and InvertedIndex implementations.
|
| BitPostingIndexInputStream |
Input stream for a bit posting index.
|
| BitUtilities |
Utility methods for use in the BitFile classes.
|
| BitWritable |
Like o.a.h.io.Writable, but for using BitIn and BitOut
|
| BlockDirectInvertedOutputStream |
Writes a block direct or block inverted index, when passed appropriate posting lists.
|
| BlockDocumentPostingList |
Represents the postings of one document, and saves block (term position) information.
|
| BlockEntryStatistics |
Deprecated. |
| BlockFieldDirectInvertedOutputStream |
Writes out a blocks and fields direct index to an output stream
|
| BlockFieldDocumentPostingList |
BlockFieldDocumentPostingList class
|
| BlockFieldIterablePosting |
class BlockFieldIterablePosting
|
| BlockFieldORIterablePosting |
ORIterablePosting implementation that implements FieldPosting and BlockPosting
|
| BlockFieldPostingImpl |
A writable block field posting list
|
| BlockIndexer |
An indexer that saves block information for the indexed terms.
|
| BlockInverted2DirectIndexBuilder |
Create a block direct index from a BlockInvertedIndex.
|
| BlockInvertedIndexBuilder |
Builds an inverted index saving term-block information.
|
| BlockIterablePosting |
A writable block iterable posting list
|
| BlockMultiDirectIterablePosting |
|
| BlockMultiIterablePosting |
|
| BlockORIterablePosting |
ORIterablePosting implementation that implements BlockPosting
|
| BlockPosting |
Interface implemented by posting objects that have position information
recorded.
|
| BlockPostingImpl |
BlockPostingImpl class
|
| BlockSinglePassIndexer |
Indexes a document collection saving block information for the indexed terms.
|
| BlockStructureMerger |
This class merges two sets of data structures (ie direct index,
inverted index, document index, lexicon and statistics), created by
Terrier with position information (blocks) and possibly field
information, into one set of data structures.
|
| BM |
This class implements the BM weighting model, which generates the original
weight given by the BM25 formula, without frequency normalisation and query
term weighting.
|
| BM25 |
This class implements the Okapi BM25 weighting model.
|
| BM25F |
A convenience subclass of PerFieldNormWeightingModel setup to
do specifically BM25F, as described by [Zaragoza TREC-2004].
|
| Bo1 |
This class implements the Bo1 model for query expansion.
|
| Bo2 |
This class implements the Bo2 model for query expansion.
|
| BooleanFallback |
This class provides a boolean fallback document score modifier for
matching.
|
| BooleanScoreModifier |
If not all the query terms appear in a document, then this
modifier zeros the document's score.
|
| Br |
This class implements the Bernoulli model of randomness
|
| CandidateResult |
A class used to when maintaining a top-k candidate documents ResultSet.
|
| CandidateResultSet |
ResultSet which is created from a set of CandidateResults.
|
| CheckClosedStreams |
Utility class during testing to ensure that all files are closed
|
| CheckClosedStreams.CloseCheckFilterInputStream |
|
| CheckClosedStreams.CloseCheckFilterOutputStream |
|
| ClassNameParser<K> |
|
| ClassNameParserConstants |
Token literal values and constants.
|
| ClassNameParserTokenManager |
Token Manager.
|
| CLITool |
CLITool is an abstract class for all classes that are Terrier commands.
|
| CLITool.CLIParsedCLITool |
|
| CLITool.HelpAliasCLITool |
|
| CLITool.HelpCLITool |
|
| Collection |
This interface encapsulates the most fundamental concept to
indexing with Terrier - a Collection.
|
| CollectionDocumentList |
|
| CollectionFactory |
Implements a factory for Collection objects.
|
| CollectionResultSet |
This class implements the interface ResultSet and
models the set of all documents in the
collection.
|
| CollectionStatistics |
This class provides basic statistics for the indexed
collection of documents, such as the average length of documents,
or the total number of documents in the collection.
|
| CompressingMetaIndex |
Implementation of BaseCompressingMetaIndex that uses Zlib deflate algorithm to compress entries
|
| CompressingMetaIndex.InputStream |
|
| CompressingMetaIndexBuilder |
Creates a metaindex structure that compresses all values using Deflate.
|
| CompressionFactory |
Configures the compression to be used when creating an IndexOnDisk.
|
| CompressionFactory.BitCompressionConfiguration |
|
| CompressionFactory.BitIdOnlyCompressionConfiguration |
|
| CompressionFactory.CompressionConfiguration |
A configuration object used by the disk indexers for configuring the compression for direct and inverted files.
|
| ConcurrentBitFileBuffered |
|
| ConcurrentBitFileBuffered.ConcurrentBitInBuffered |
|
| ConcurrentBitPostingIndexUtilities |
|
| ConcurrentDecodingMetaIndex |
|
| ConcurrentIndexLoader |
An index loader for index references for indices that we wish to be thread safe
|
| ConcurrentIndexUtils |
|
| ConcurrentReadable |
This annotation makes that an index data
structure can be read by more than one thread concurrently.
|
| CoordinateMatch |
A weighting model that returns 1 for each match.
|
| CountingInputStream |
Sub-Class of Filter Input Stream with the extra method
getPos which returns the position in the Stream
|
| CreateSingleLexicon |
Facilitates the generation of a single lexicon structure on disk from a multi-index
|
| CropTerm |
Reduces the size of terms passing through the term pipeline to the maximum allowed
size for this indexing run.
|
| DanishSnowballStemmer |
Danish stemmer implmented by Snowball.
|
| DateRangeOp |
|
| DebuggingBitIn |
This class provides debugging at the bit stream level.
|
| DebuggingDataInput |
Debugging code to test classes that implement DataInput
|
| DebuggingDataOutput |
Debugging code to test classes that implement DataOutput
|
| Decorate |
This class decorates a result set with metadata.
|
| DefaultSummariser |
Summariser that was originally in the Decorate class, and formed
the Terrier release from 3.0
|
| DependenceModelPreProcess |
|
| DependenceScoreModifier |
Base class for Dependence models.
|
| DFIC |
Divergence From Independence model based on Chi-square statistics
(i.e., standardized Chi-squared distance from independence in term frequency tf).
|
| DFIZ |
Divergence From Independence model based on Standardization
(i.e., standardized distance from independence in term frequency tf).
|
| DFR_BM |
This class implements the DFR BM weighting model, which is an approximation of
BM25 in the DFR framework.
|
| DFR_BM25 |
This class implements the DFR_BM25 weighting model.
|
| DFRBagExpansionTerms |
This class implements a data structure of terms in the top-retrieved documents.
|
| DFRDependenceScoreModifier |
Implements the pBiL and pBil2 DFR-based dependence models.
|
| DFRee |
This class implements the DFRee weighting model.
|
| DFReeKLIM |
This class implements the DFReeKLIM weighting model.
|
| DFRWeightingModel |
This class implements a modular Divergence from Randomness weighting model.
|
| DirectInvertedDocidOnlyOuptutStream |
A BitPosting writing class that doesn't write any frequency information
|
| DirectInvertedOutputStream |
Writes a block direct or block inverted index, when passed appropriate posting lists.
|
| DirichletLM |
Bayesian smoothing with Dirichlet Prior.
|
| DisjunctiveQuery |
Models a disjunctive choice in single term queries in a query.
|
| DiskIndexWriter |
Utility class for writing an existing index to disk
|
| Distance |
Class containing useful utility methods for counting the number of occurrences
of two terms within windows, etc.
|
| Dl |
This class implements a simple document length weighting model.
|
| DLH |
This class implements the DLH weighting model.
|
| DLH13 |
This class implements the DLH13 weighting model.
|
| Document |
This interface encapsulates the concept of a document during indexing.
|
| DocumentExtractor |
Deprecated. |
| DocumentIndex |
Interface for a document index.
|
| DocumentIndexBuilder |
A builder for the document index.
|
| DocumentIndexEntry |
A document index entry.
|
| DocumentPostingList |
Represents the postings of one document.
|
| DocumentScoreModifier |
The interface that should be implemented by each class that assigns
or modifies a score of a document.
|
| DPH |
This class implements the DPH hypergeometric weighting model.
|
| DumpTerm |
Useful development phase TermPipeline object that allows
prints every term that passes through it to System.err
|
| DutchSnowballStemmer |
Dutch stemmer implmented by Snowball.
|
| EnglishSnowballStemmer |
English stemmer implmented by Snowball.
|
| EnglishTokeniser |
Tokenises text obtained from a text stream assuming English language.
|
| EntryStatistics |
An interface for basic statistics about a lexicon entry.
|
| Evaluation |
|
| ExpansionTerms |
Base class for weighting term occurrences in feedback documents.
|
| ExpansionTerms.ExpansionTerm |
This class implements a data structure
for a term in the top-retrieved documents.
|
| ExplicitMultiTermQuery |
MultiTermQuery where it is denoted by ( ) notation
|
| ExtensibleSinglePassIndexer |
Directly based on BasicSinglePassIndexer, with just a few modifications
to enable some extra hooks.
|
| FatCandidateResult |
|
| FatCandidateResultSet |
|
| FatFeaturedScoringMatching |
|
| FatFull |
|
| FatQueryResultSet |
|
| FatResultSet |
A result set that encapsulates the postings for terms within the query
|
| FatResultsMatching |
|
| FatScoringMatching |
Scores a FatResultSet into a normal ResultSet for a given weighting model
|
| FatUtils |
|
| FeaturedQueryResultSet |
A result set implementation that accommodates multiple query feature scores,
besides the original relevance scores.
|
| FeaturedResultSet |
A result set to accommodate multiple feature scores.
|
| FeaturedScoringMatching |
|
| FeedbackDocument |
Class representing feedback documents, pseudo- or otherwise.
|
| FeedbackSelector |
Implements of this class can be used to select feedback documents.
|
| FieldDirectInvertedOutputStream |
Bit out class for writing a posting list with fields
|
| FieldDocumentIndex |
Interface for a fields document index
|
| FieldDocumentIndexEntry |
A document index entry for use with fields
|
| FieldDocumentIndexEntry.Factory |
Factory for creating a field document index entry
|
| FieldDocumentPostingList |
FieldDocumentPostingList class
|
| FieldEntryStatistics |
The statistics for a field entry.
|
| FieldIterablePosting |
A posting iterator for field postings.
|
| FieldLexiconEntry |
A LexiconEntry with field support
|
| FieldLexiconEntry.Factory |
Factory for a LexiconEntry
|
| FieldLexiconMap |
class FieldLexicanMap
|
| FieldOnlyIterablePosting |
This class takes an IterablePosting list that has fields,
and makes it appear as a single basic posting list.
|
| FieldORIterablePosting |
ORIterablePosting implementation that implements FieldPosting
|
| FieldPosting |
Interface implemented by posting objects that have field information
recorded.
|
| FieldPostingImpl |
Implementation of a posting containing fields
|
| FieldQuery |
Models a query qualified with a field.
|
| FieldScore |
A class for modifying the retrieval scores of documents,
according to whether the query terms appear to any of the
fields, or tags specified by the property
FieldTags.process.
|
| FileDocument |
Models a document which corresponds to one file.
|
| FileFind |
Takes a list of paths and filenames on the
command line, and finds all the files in
those directories, displaying only absolute
filenames on Standard Output.
|
| FilePosition |
Models a position within a file as the offset in bytes
and the offset in bits in that byte.
|
| Files |
Utililty class for opening readers/writers and input/output streams to files.
|
| Files.FSCapability |
constants declaring which capabilities a file system has
|
| Files.PathTransformation |
a search regex and a replacement for path transformations
|
| FileSystem |
This is the Terrier File Abstraction Layer interface depicting the operations available for a file system.
|
| FilterMatching |
|
| FinnishSnowballStemmer |
Finnish stemmer implmented by Snowball.
|
| FixedSizeInputStream |
An inputstream which only reads a fixed length of a parent input stream.
|
| FixedSizeIntWritableFactory |
Makes an IntWritable, which has a fixed Writable size of 4 bytes.
|
| FixedSizeTextFactory |
Makes a Text object that has a fixed size when written using Writable methods.
|
| FixedSizeWriteableFactory<T extends org.apache.hadoop.io.Writable> |
Sub-interface for WritableFactory, where the Writable objects have a fixed size on
disk.
|
| FlatJSONDocument |
This is a Terrier Document implementation of a document stored in JSON format.
|
| FrenchSnowballStemmer |
French stemmer implmented by Snowball.
|
| FSADocumentIndex |
Document Index saved as a fixed size array
|
| FSADocumentIndex.FSADocumentIndexIterator |
Gets an iterator over the documents in this index
|
| FSADocumentIndexInMem |
A DocumentIndex implementation that loads everything in memory.
|
| FSADocumentIndexInMemFields |
A version of FSADocumentIndexInMem for indices with fields.
|
| FSAFieldDocumentIndex |
Fields document index stored as a fixed size array
|
| FSArrayFile<V extends org.apache.hadoop.io.Writable> |
A file for accessing Writable classes written on disk.
|
| FSArrayFile.ArrayFileIterator<V extends org.apache.hadoop.io.Writable> |
ArrayFileIterator class
|
| FSArrayFile.ArrayFileWriter |
interface ArrayFileWriter
|
| FSArrayFileInMem<V extends org.apache.hadoop.io.Writable> |
Version of FSArrayFile that keeps the file contents in memory, and decodes the bytes
into object as required.
|
| FSOMapFileLexicon |
Instance of a Lexicon<String> where a FSOrderedMapFile is always used as a backing store.
|
| FSOMapFileLexicon.MapFileLexiconEntryIterator |
|
| FSOMapFileLexicon.MapFileLexiconIterator |
|
| FSOMapFileLexiconGeneric<K1,K2 extends org.apache.hadoop.io.WritableComparable> |
|
| FSOMapFileLexiconGeneric.MapFileLexiconEntryIterator<T extends org.apache.hadoop.io.WritableComparable<?>> |
Iterate through the values in order
|
| FSOMapFileLexiconGeneric.MapFileLexiconIterator<T1,T2 extends org.apache.hadoop.io.WritableComparable<?>> |
An iterator over the lexicon
|
| FSOMapFileLexiconOutputStream |
A LexiconOutputStream for FSOMapFileLexicon.
|
| FSOMapFileLexiconOutputStreamGeneric<T1,T2 extends org.apache.hadoop.io.WritableComparable<?>> |
|
| FSOMapFileLexiconUtilities |
|
| FSOrderedMapFile<K extends org.apache.hadoop.io.WritableComparable,V extends org.apache.hadoop.io.Writable> |
An implementation of java.util.Map that can be accessed from disk.
|
| FSOrderedMapFile.EntryIterator<IK extends org.apache.hadoop.io.Writable,IV extends org.apache.hadoop.io.Writable> |
an iterator for entries.
|
| FSOrderedMapFile.FSOMapFileBSearchShortcut<KEY> |
interface FSOMapFileBSearchShortcut
|
| FSOrderedMapFile.MapFileInMemory<IK extends org.apache.hadoop.io.Writable,IV extends org.apache.hadoop.io.Writable> |
MapFileInMemory class
|
| FSOrderedMapFile.MapFileWriter |
Interface for writing a FSOMapFile
|
| FSOrderedMapFile.MultiFSOMapWriter |
Writes out a FSOMapFile, but assumes that input data need not be sorted by key.
|
| Full |
Performs the matching of documents with a query, by first assigning scores to documents for each query term
and modifying these scores with the appropriate modifiers.
|
| Full |
An exhaustive TAAT approach for matching documents to a query.
|
| FuzzyTermOp |
A synonym class that uses leveinsten distance to match terms.
|
| GammaFunction |
Base class for implementations of the Gamma function.
|
| GermanSnowballStemmer |
German stemmer implmented by Snowball.
|
| GrowingMapQueryResultCache<K> |
an abstract results cache that puts stuff into an ever-growing Map
|
| GrowingMapQueryStringResultCache |
|
| HadoopPlugin |
This class provides the main glue between Terrier and Hadoop.
|
| HeapSort |
An implementation of the heap sort algorithm as described in Cormen et al.
|
| HeapSort |
An implementation of the heap sort algorithm as described in Cormen et al.
|
| HeapSortInt |
An implementation of the heap sort algorithm as described in Cormen et al.
|
| Hiemstra_LM |
This class implements the Hiemstra LM weighting model.
|
| HTTPFileSystem |
Implements a read-only HTTP file system for Terrier.
|
| HungarianSnowballStemmer |
Hungerian stemmer implmented by Snowball.
|
| IdentityTokeniser |
A Tokeniser implementation that returns the input as is.
|
| Idf |
This class computes the idf values for specific terms in the collection.
|
| IF |
This class implements the IF basic model for randomness.
|
| IFB2 |
This class implements the IFB2 weighting model.
|
| In |
This class implements the In basic model for randomness.
|
| In_exp |
This class implements the In_exp basic model for randomness.
|
| In_expB2 |
This class implements the In_expB2 weighting model, namely Inverse Expected Document Frequency model with
Bernoulli after-effect and normalisation 2.
|
| In_expC2 |
This class implements the In_expC2 weighting model.
|
| InB2 |
This class implements the InB2 weighting model, namely
Inverse Document Frequency model with Bernoulli after-effect and normalisation 2.
|
| IncrementalDeleteFixedNumber |
Within an incremental index, this is a possible policy for deleting old index shards.
|
| IncrementalDeletePolicy |
This class represents a policy for deleting index shards during a flush.
|
| IncrementalFlushDocs |
An IncrementalFlushPolicy that will flush an index to disk after
a fixed number of documents have been emitted.
|
| IncrementalFlushMemory |
An IncrementalFlushPolicy that will flush an index to disk after
a memory-used threshold has been reached.
|
| IncrementalFlushPolicy |
Policy for flushing out documents in an index to disks
|
| IncrementalFlushTime |
An IncrementalFlushPolicy that will flush an index to disk after
after a fixed period of time.
|
| IncrementalIndex |
This is the main Index class for an incremental index.
|
| IncrementalIndex.Loader |
|
| IncrementalMergeGeometric |
Geometric merge implementation.
|
| IncrementalMergePolicy |
A policy for merging different indices together on disk
|
| IncrementalMergeSingle |
Merge flushed index partitions into a single partition.
|
| IncrementalSelectiveMatching |
This class is used by the incremental indexer to do selective matching on a
MultiIndex structure.
|
| IncrementalSelectiveMostRecent |
This class enables search over a subset of the shards in an incremental index.
|
| Index |
Base class for all Index implementations
|
| Index.DirectIndexRef |
|
| IndexConfigurable |
Interface defining that an index structure wants access to the
Index object it is associated with.
|
| Indexer |
Properties:
termpipelines - the sequence of TermPipeline stages (e.g.
|
| IndexFactory |
This is the main developer API for loading an index.
|
| IndexFactory.DirectIndexLoader |
|
| IndexFactory.IndexLoader |
|
| IndexOnDisk |
The replacement for what was Index in earlier Terrier versions.
|
| IndexOnDisk.DiskIndexLoader |
|
| IndexRef |
|
| IndexStatsCommand |
|
| IndexTestUtils |
|
| IndexUtil |
Class with handy utilities for use on an Index.
|
| IndexUtil.Command |
|
| Information |
This class implements the Kullback-Leibler divergence for
query expansion.
|
| InL2 |
This class implements the InL2 weighting model.
|
| InteractiveQuerying |
This class performs interactive querying at the command line.
|
| InteractiveQuerying.Command |
|
| Inverted2DirectCommand |
|
| Inverted2DirectIndexBuilder |
Create a direct index from an InvertedIndex.
|
| InvertedIndexBuilder |
Builds an inverted index.
|
| ItalianSnowballStemmer |
Italian stemmer implmented by Snowball.
|
| IterablePosting |
An interface that allows a list of postings to be iterated over.
|
| IterablePostingImpl |
A base implementation of an IterablePosting, that provides
a base implementation of next(int) method.
|
| JForestsCommand |
|
| JforestsModelMatching |
|
| Js_KLs |
This class implements the Js_KLs weighting model, which is the product
of two measures: the Jefrreys' divergence with the Kullback Leibler's divergence.
|
| JSONOutputFormat |
|
| KillHandler |
Utility class for when releasing resources when the runtime system is shutting down.
|
| KillHandler.Killable |
Interface denoting an object which can be killed by the KillHandler
|
| KL |
This class implements the Kullback-Leibler divergence for
query expansion.
|
| KLComplete |
This class implements the complete Kullback-Leibler divergence for
query expansion.
|
| KLCorrect |
This class implements the correct Kullback-Leibler divergence for
query expansion, which takes the contribution into consideration.
|
| L |
This class implements the L model for the first normalisation by
after effect.
|
| L5 |
This class implements the L5 model for the first normalisation by
after effect.
|
| LabelDecorator |
A post-process to expand an existing result set to a FeaturedResultSet and add labels
|
| LearnedModelMatching |
|
| LemurTF_IDF |
This class implements the TF_IDF weighting model as it is implemented in Lemur. |
| LETOROutputFormat |
Outputs a featured result set in the LETOR format.
|
| Lexicon<KEY> |
A lexicon (a.k.a.
|
| Lexicon.LexiconFileEntry<KEY2> |
|
| LexiconBuilder |
Builds temporary lexicons during indexing a collection and
merges them when the indexing of a collection has finished.
|
| LexiconBuilder.BasicLexiconCollectionStaticticsCounter |
counts global statistics in the non-fields case
|
| LexiconBuilder.CollectionStatisticsCounter |
Counter of LexiconEntries
|
| LexiconBuilder.FieldLexiconCollectionStaticticsCounter |
counts global statistics in the fields case
|
| LexiconBuilder.NullCollectionStatisticsCounter |
|
| LexiconEntry |
Base class for all LexiconEntry implementations.
|
| LexiconMap |
This class keeps track of the total counts of terms within a bundle of documents being indexed.
|
| LexiconMerger |
Merges many lexicons, termids and offsets are not kept.
|
| LexiconOutputStream<KEY> |
This class implements an output stream for the lexicon structure.
|
| LexiconUtil |
Lexicon utilities class.
|
| LGD |
This class implements the LGD weighting model.
|
| LinearModelMatching |
|
| LinkedBuffer |
Implements an element of a linked list that contains a byte array
|
| LL |
This class implements the LL model for the first normalisation by
after effect.
|
| LocalFileSystem |
This is a Terrier File Abstraction Layer implementation of the local file system.
|
| LocalFileSystem.LocalRandomAccessFile |
A file that supports random access
|
| LocalManager |
This class is responsible for handling/co-ordinating the main high-level
operations of a query.
|
| LocalManager.Builder |
|
| LookAheadReader |
Implements a Reader, that encapsulates another stream, but only upto the
point that a pre-defined end marker in the stream is identified.
|
| LookAheadStream |
Implements an InputStream, that encapsulates another stream, but only upto the
point that a pre-defined end marker in the stream is identified.
|
| LookAheadStreamCaseInsensitive |
Version of LookAheadStream that is case-insensitive.
|
| LRUMap<K,V> |
A map with a fixed maximum size.
|
| LZ4CompressedMetaIndex |
MetaIndex implementation for when records are compressed using LZ4
|
| LZ4CompressedMetaIndex.InputStream |
|
| LZ4MetaIndexBuilder |
Writes all metadata using Zstandard compression.
|
| Manager |
|
| ManagerFactory |
|
| ManagerFactory.Builder |
interface for Builders of Managers
|
| ManagerRequisite |
|
| MapEntry<K,V> |
Implementation of java.util.Map.Entry.
|
| MapLexicon<K1,K2 extends org.apache.hadoop.io.WritableComparable> |
Implementation of a lexicon.
|
| MapLexicon.Id2EntryIndexLookup |
Interface for getting the lexicon term index for a given term id
|
| MapLexicon.IdIsIndex |
Lexicon map where the termid is the term index
|
| Matching |
Interface for all Matching implementations.
|
| MatchingEntry |
A MatchingEntry is the application of a matching Operator to the index at hand,
i.e.
|
| MatchingOpQLParser |
|
| MatchingQueryTerms |
Models a query used for matching documents.
|
| MatchingQueryTerms.MatchingTerm |
|
| MatchingQueryTerms.QueryTermProperties |
The weight and the modifiers associated with a query term.
|
| MatchOpQLParser |
|
| MatchOpQLParserConstants |
Token literal values and constants.
|
| MatchOpQLParserTokenManager |
Token Manager.
|
| MavenResolver |
Resolves Maven dependencies specified in terrier.mvn.coords and adds
to classpath.
|
| MavenResolver.MutableURLClassLoader |
|
| MDL2 |
This class implements the MDL2 field-based weighting model.
|
| MemoryChecker |
Interface for various implementation which are used to determine
if memory has been exhausted.
|
| MemoryCollectionStatistics |
This class provides basic statistics in memory for a collection of documents,
such as the average length of documents, or the total number of documents in
the collection.
|
| MemoryCompressedMetaIndex |
An in-memory version of a Meta-data index.
|
| MemoryDirectIndex |
This is a DirectIndex structure that is held fully in memory, it
is based upon the MemoryInverted class.
|
| MemoryDirectIterablePosting |
Provides iteration capabilities over a Memory Direct Posting
|
| MemoryDocumentIndex |
An in-memory version of the Document index.
|
| MemoryDocumentIndexFields |
Document index (fields).
|
| MemoryDocumentIndexFieldsMap |
A memory document index structure that supports fields and fast lookups via
a map structure.
|
| MemoryDocumentIndexMap |
This class is a special variant of the Memory index class where the
Document index is backed by a fast mapping structure in memory.
|
| MemoryFields |
Super-type of fields index implementations.
|
| MemoryFieldsDirectIndex |
|
| MemoryFieldsDirectIterablePosting |
|
| MemoryFieldsIndex |
An in-memory incremental fields index (non-compressed).
|
| MemoryFieldsIndex.Loader |
|
| MemoryFieldsInvertedIndex |
Postings list (non-compressed) (fields).
|
| MemoryFieldsIterablePosting |
Iterable posting (fields).
|
| MemoryFieldsLexiconEntry |
Lexicon entry (fields).
|
| MemoryIndex |
An index held in fully memory.
|
| MemoryIndex.Loader |
|
| MemoryInvertedIndex |
A basic inverted file implementation for use with MemoryIndex structures.
|
| MemoryIterablePosting |
A postings list implementation held fully in memory.
|
| MemoryLexicon |
The lexicon structure for a MemoryIndex.
|
| MemoryLexiconEntry |
A lexicon entry stored in a MemoryLexicon.
|
| MemoryLinkedOutputStream |
This class implements an OutputStream that writes everything in memory, and never flushes the data to disk.
|
| MemoryMetaIndex |
An in-memory version of a Meta-data index.
|
| MemoryMetaIndexMap |
A memory meta index structure that supports fast look-ups via a map.
|
| MemoryOutputStream |
This class extends an ordinary OutputStream to handle transparently writes in memory.
|
| MemoryPointer |
Pointer type for use with MemoryIndex.
|
| MemoryPostingList |
A memory posting list interface
|
| MemorySBOS |
This class extends the BitByteOutputStream, so it provides the compression writing functions, but
uses a MemoryOutputStream as an underlying OutputStream, so it is needed to be flushed to disk separately.
|
| MetaIndex |
Interface for document metadata.
|
| MetaIndexBuilder |
Abstract class for writing document metadata to a disk index.
|
| MetaIndexMap |
An interface defining a meta index structure
|
| ML2 |
This class implements the ML2 field-based weighting model.
|
| Model |
This interface encapsulates all the common functionality between
standard IR models (including DFR models, TF/IDF, BM25 etc), and
Language Modelling models (Terrier includes PonteCroft Language
Modelling model).
|
| MQTRewritingProcess |
|
| MRF |
|
| MRFDependenceScoreModifier |
Implements Markov Random Fields.
|
| MSExcelDocument |
Deprecated. |
| MSPowerPointDocument |
Deprecated. |
| MSWordDocument |
Deprecated. |
| MultiDirect |
Multi Direct Index structure.
|
| MultiDirectIterablePosting |
This acts as a wrapper class that surrounds an IterablePosting object.
|
| MultiDoc |
A Document index class that represents multiple document indices from
different shards.
|
| MultiDocumentEntry |
A document index entry that represents a document within a multi-index
It stores information about the shard that the document comes from.
|
| MultiDocumentFileCollection |
|
| MultiIndex |
The central MultiIndex structure.
|
| MultiInverted |
An inverted file implementation for a MultIndex.
|
| MultiIterablePosting |
A posting list implementation used within a MultiIndex.
|
| MultiLexicon |
A Lexicon index structure for use with a MultiIndex.
|
| MultiLexiconEntry |
A Lexicon entry that spans multiple index shards.
|
| MultiMeta |
A MetaIndex for use with a MultiIndex.
|
| MultiSort |
The current implementation is a simple extension of the existing HeapSort to
allow an int array to be used as the key array while sorting.
|
| MultiStats |
A collection statistics class for use with a MultiIndex.
|
| MultiTermOp |
this is an abstract operator, which implements common
functionalities for operators that consist of multiple terms.
|
| MultiTermQuery |
Represents a query consisting of more than one terms or
other sub-queries, qualified with field, requirement or
phrase operators.
|
| NamedPageEvaluation |
Performs the evaluation for TREC's named/home page finding task.
|
| NgramEntryStatistics |
Represent statistics of n-grams, such as those used in
sequence dependence models.
|
| NoDuplicatesSinglePassIndexing |
Single pass indexer that performs document deduplication based upon the
the docno.
|
| NoNegativeReq |
|
| NonIncrementalDocumentIndexEntry |
This class is created to represent a DocumentIndexEntry that
do not assume an incremental docids, but instead maintains the docid.
|
| NonIncrementalDocumentIndexEntry.Factory |
Returna a factory for creating document index entries
|
| NoOp |
A do-nothing term pipeline object.
|
| Normalisation |
This class provides a contract for implementing frequency normalisation methods.
|
| Normalisation0 |
This class implements an empty normalisation.
|
| Normalisation1 |
This class implements the DFR normalisation 1, which is identical to DFR
normalisation 2 with c=1.0
|
| Normalisation2 |
This class implements the DFR normalisation 2.
|
| Normalisation2exp |
This class implements the DFR normalisation 2 with natural logorithm.
|
| Normalisation3 |
This class implements the Dirichlet Priors normalisation.
|
| NormalisationB |
This class implements BM25's normalisation method.
|
| NormalisationF |
This class implements an increasing density function for the frequency normalisation.
|
| NormalisationJ |
This class implements the tf normalisation based on Jelinek-Mercer smoothing for language modelling.
|
| NormalisationJN |
This class implements the tf normalisation based on Jelinek-Mercer smoothing
for language modelling where collection model is given by document frequency
instead of term frequency.
|
| NormalisationP |
This class implements Term Frequency Normalisation via
Pareto Distributions
|
| NormalisationStatic |
This class implements a Normalisation method that forces all
term frequencies to the value of the parameter.
|
| Normalised2LETOROutputFormat |
As LETOROutputFormat, but uses normalisation 2 to normalise all scores in [0,1] for each query
|
| NormalisedLETOROutputFormat |
As LETOROutputFormat, but normalises all scores in [0,1] for each query
|
| NorwegianSnowballStemmer |
Norwegian stemmer implmented by Snowball.
|
| Null |
A weighting model that returns 0 for each match.
|
| NullOutputFormat |
An OutputFormat instance which does nothing.
|
| NullQueryResultCache |
Do nothing QueryResultCache
|
| Operator |
A match op is a possible query "term" in the query
|
| OrderedMap<K,V> |
Specified a map interface where keys are ordered, and can be retrieved
using an integer index.
|
| ORIterablePosting |
An IterablePosting that combines more than one IterablePosting into a single IterablePosting.
|
| OutputFormat |
interface for adjusting the output of TRECQuerying
|
| P |
This class implements the P basic model for randomness.
|
| ParallelTRECQuerying |
An instance of TRECQuerying that will invoke multiple threads concurrently
|
| ParallelTRECQuerying.Command |
|
| 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.
|
| pBiL |
|
| pBiL2 |
|
| PDFDocument |
Implements a Document object for reading PDF documents, using Apache PDFBox. |
| PerFieldNormWeightingModel |
A class for generating arbitrary per-field normalisation models.
|
| PhraseIterablePosting |
Implementation of an IterablePosting for block indices that returns
only documents that match a multi-term phase.
|
| PhraseOp |
This combines multiple operators into a single op, where they occur adjacently.
|
| PhraseQuery |
Models a phrase query, which can have a proximity requirement.
|
| PhraseScoreModifier |
This is the class performs the re-scoring for a phrase queries.
|
| PL |
This class implements the PL weighting model.
|
| PL2 |
This class implements the PL2 weighting model.
|
| PL2F |
A convenience subclass of PerFieldNormWeightingModel setup to
do specifically PL2F.
|
| POIDocument |
Represents Microsoft Office documents, which are parsed by the Apache POI library
|
| Pointer |
A base interface for all pointers.
|
| PorterStemmer |
Stemmer, implementing the Porter Stemming Algorithm.
|
| PortugueseSnowballStemmer |
Portuguese stemmer implmented by Snowball.
|
| PostFilter |
PostFilters are designed to complement PostProcesses.
|
| Posting |
This interface represents one posting in a posting list.
|
| PostingIdComparator |
A comparator object for Posting objects, where they are sorted by id.
|
| PostingIndex<POINTERTYPE extends Pointer> |
An interface for accessing a posting list.
|
| PostingIndexInputStream |
Interface for reading postings from an input stream
|
| PostingListManager |
The PostingListManager is responsible for opening the appropriate posting lists IterablePosting given
the MatchingQueryTerms object. |
| PostingListManager.PostingListManagerPlugin |
Interface for plugins to further alter the posting lists managed by the PostingListManager
|
| PostingTestUtils |
|
| PostingUtil |
Handy methods for Posting classes, such as obtaining all ids in a
posting list, or selecting the minimum id in an array of posting lists.
|
| PostingUtil.DocidSpecificDocumentIndex |
|
| PostProcess |
Deprecated. |
| PrefixTermOp |
A synonym class that matches terms with a common prefix in the lexicon.
|
| Process |
Process Interface.
|
| ProcessInputStream |
Reads a stream from a process
|
| ProcessPhaseRequisites |
|
| PropertiesIndex |
This class encapsulates all the Indexes at retrieval time.
|
| ProximityIterablePosting |
Implementation of an IterablePosting for block indices that returns
only documents that match phases within a fixed window size.
|
| PseudoRelevanceFeedbackSelector |
A feedback selector for pseudo-relevance feedback.
|
| Query |
An abstract class that models a query, that consists of
subqueries and query terms.
|
| Query.ForEachQueryNode |
ForEachQueryNode interface
|
| Query.QTPBuilder |
|
| Query.QueryTermsParameter |
|
| QueryExpansion |
Implements automatic query expansion as PostProcess that is applied to the result set
after 1st-time matching.
|
| QueryExpansion.QueryExpansionConfig |
|
| QueryExpansionModel |
This class should be extended by the classes used
for weighting terms and documents.
|
| QueryExpansionModelFactory |
A factory method for handling the initialisation of expansion models.
|
| QueryParser |
Useful class to parse the query.
|
| QueryParserException |
Thrown by the Manager when it cannot parse the query
|
| QueryResultCache |
Interface for introducing caching strategies into TRECQuerying
|
| QueryResultSet |
A result set for a given query.
|
| QuerySource |
This interface denotes a source of queries for batch evaluation
|
| QuerySourceUtils |
|
| RandomDataInput |
This interface represents an interface on a RandomAccessFile.
|
| RandomDataInputMemory |
Implements a RandomDataInput backed by a byte[] rather than a file.
|
| RandomDataInputMemory.SeeakableByteArrayInputStream |
class which allows seeking over a ByteArrayInputStream
|
| RandomDataOutput |
This interface represents an interface on the writing behaviour of a RandomAccessFile.
|
| RawOutputFormat |
interface for writing the output of TRECQuerying to a stream
|
| ReadOnlyMap<K,V> |
A null implementation of java.util.Map that does nothing.
|
| RelevanceFeedbackSelector |
Selects feedback documents from a qrels file, using the query id.
|
| RelevanceFeedbackSelectorDocids |
A feedback document selector that operates as RelevanceFeedbackSelector, except
that this should be used when docids are specified in the qrels file, not docnos.
|
| RelevantOnlyFeedbackDocuments |
Select only feedback documents which have relevance > 0
|
| RemoveDiacritics |
Removes diacritics in letters.
|
| Request |
Request contains the details of the search engine for one query, including the query itself,
the resultset, the controls and the context objects.
|
| RequiredTermModifier |
Resets the scores of documents according to whether a term is required
or not, and whether it appears in the retrieved documents.
|
| RequirementQuery |
Models a query where the query terms have been qualified
with a requirement operator, either plus, or minus.
|
| ResetScores |
Resets the scores in the resultset to 0.00001d
|
| ResourceFileSystem |
Implements a read-only file system based on Java resources.
|
| RestClientManagerBuilder |
This class facilitates a Manager to be obtained for a remote HTTP REST index
reference.
|
| ResultSet |
The interface that defines the functionalities of a
result set.
|
| RomanianSnowballStemmer |
Romanian stemmer implmented by Snowball.
|
| Rounding |
A class for performing the rounding of a number
in various ways for various applications.
|
| RuntimeMemoryChecker |
A memory checker that uses the Java Runtime instance to check the amount of available memory.
|
| RussianSnowballStemmer |
Russian stemmer implmented by Snowball.
|
| Scope |
Checks that the prefix of the document number (upto the first "-") is included in
this list of scopes as given by the scope control.
|
| ScoredDoc |
|
| ScoredDocList |
|
| ScoringMatching |
Matching implementation that uses a parent Matching instance to get the docids to work with.
|
| ScoringMatchingWithFat |
|
| SearchRequest |
SearchRequest is the one of two main classes of which are made available to client code by
the Terrier framework at retrieval time.
|
| SearchResource |
|
| SegmentQuery |
Used to represent a particular segement of the query terms
|
| ShowDocumentCommand |
Utility command to display the contents of a document to stdout,
as obtained from the direct index.
|
| SimpleBitIndexPointer |
An implementation of a BitIndexPointer.
|
| SimpleBitIndexPointer.Factory |
|
| SimpleCharStream |
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
|
| SimpleCharStream |
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
|
| SimpleCharStream |
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
|
| SimpleDecorate |
A simple decorator, which applies all metadata in the MetaIndex to each retrieved, displayed document.
|
| SimpleDecorateProcess |
A simple decorator, which applies all metadata in the MetaIndex to each retrieved, displayed document.
|
| SimpleDocumentIndexEntry |
A document index entry that doesn't write out direct index offset.
|
| SimpleDocumentIndexEntry.Factory |
Factory for the creation of DocumentIndexEntry objects
|
| SimpleFileCollection |
Implements a collection that can read arbitrary files on disk.
|
| SimpleJettyHTTPServer |
Class to make a simple Jetty servlet.
|
| SimpleJettyHTTPServer.Command |
|
| SimpleMedlineXMLCollection |
Initial implementation of a class that generates a Collection with Documents from a
series of XML files in the Medline format.
|
| SimpleNgramEntryStatistics |
|
| SimpleStaticScoreModifier |
Provides a way to integrate a static (query independent) document (prior) feature
into the document scores.
|
| SimpleXMLCollection |
Initial implementation of a class that generates a Collection with Documents from a
series of XML files.
|
| SingleFieldModel |
Use a normal weighting model on a pre-determine subset of the field.
|
| SingleIndexRestServer |
Loads the default index and exports via a REST service at http://localhost:8080/
|
| SingleLineTRECQuery |
This class can be used to extract batch queries from a simpler format than the regular SGML TREC format.
|
| SinglePassIndexerFlushDelegate |
|
| SingleTermOp |
This class implements a single indexing token as a matching op.
|
| SingleTermQuery |
Models a query of a single term.
|
| SiteFilter |
Filter that removes hosts which dont match an appropriate site: constraint, as specified in a control.
|
| Skipable |
Deprecated. |
| SkipTermPipeline |
Class that identified tokens which should not be passed down the entire term pipeline, and instead
passed onto a specified stage instead.
|
| SnowballStemmer |
Classic Snowball stemmer implmented by Snowball.
|
| SortAscendingPairedVectors |
This class sorts a pair of arrays, where the corresponding entries
are related.
|
| SortAscendingQuadrupleVectors |
This class sorts four arrays, where the corresponding entries
are related.
|
| SortAscendingQuintupleVectors |
This class sorts five arrays, where the corresponding entries
are related.
|
| SortAscendingTripleVectors |
This class sorts five arrays, where the corresponding entries
are related.
|
| SortAscendingVectors |
This class sorts one or more arrays, based on sorting a key array, ie where
the corresponding entries are related.
|
| SortDescendingPairedVectors |
This class sorts a pair of arrays, where the corresponding entries
are related.
|
| SpanishSnowballStemmer |
Spanish stemmer implmented by Snowball.
|
| StaticFeature |
Class for query independent features loaded from file.
|
| StaticScoreModifierWeightingModel |
Base abstract class for query independent features loaded from file.
|
| StaTools |
This class implements a series of basic statistical functions.
|
| StdInOutFileSystem |
|
| Stemmer |
Interface for all stemmers.
|
| StemmerTermPipeline |
Abstract base class for Stemmers that are also TermPipeline instances
|
| Stopwords |
Implements stopword removal, as a TermPipeline object.
|
| StringComparator |
Compares two strings which may have fixed length fields separated
with a non word character (eg a dash), and a last field which corresponds
to an integer.
|
| StringTools |
This class implements useful string functions
|
| StringTools.ESCAPE |
Defines escape encodings that are supported.
|
| StructureMerger |
This class merges the structures created by Terrier, so that
we use fewer and larger inverted and direct files.
|
| StructureMerger.Command |
|
| StructureMerger.NullDocumentIndex |
|
| Summariser |
Base class for query biased summarisers.
|
| SwedishSnowballStemmer |
Swedish stemmer implmented by Snowball.
|
| SynonymOp |
This combines multiple operators into a single op.
|
| TaggedDocument |
Models a tagged document (e.g., an HTML or TREC document).
|
| TagSet |
A class that models a set of tags to process (white list),
a set of tags to skip (black list), a tag that is used as a
document delimiter, and a tag the contents of which are
used as a unique identifier.
|
| TagSet.TagSetFactory |
|
| TermCodes |
This class is used for assigning codes to terms as we
index a document collection.
|
| TermInFieldModifier |
Resets the scores of documents according to whether a term appears in
a given set of fields.
|
| TermPipeline |
Models the concept of a component in a pipeline of term processors.
|
| TermPipelineAccessor |
This interface allows code to access the TermPipeline without implementing
the end of the term pipeline.
|
| TermScoreModifier |
Deprecated.
|
| Terrier4 |
This Class allows the updating of a Terrier 3.x index to the specification of
Terrier 4.x index.
|
| Terrier5 |
This Class allows the updating of a Terrier 4.x index to the specification of
Terrier 5.x index.
|
| TerrierEvaluation |
An abstract class for evaluating the retrieval results.
|
| TerrierEvaluation.Record |
A structure of a record of retrieved document.
|
| TerrierQLParser |
|
| TerrierQLParser |
|
| TerrierQLParserConstants |
Token literal values and constants.
|
| TerrierQLParserTokenManager |
Token Manager.
|
| TerrierQLToControls |
|
| TerrierQLToMatchingQueryTerms |
|
| TerrierTimer |
This class implements a timer.
|
| Tf |
This class implements a simple Tf weighting model.
|
| TF_IDF |
This class implements the TF_IDF weighting model.
|
| ThreadedBatchIndexing |
An implementation of BatchIndexing that uses Java 8 parallel streams to
increase indexing speed on multi-core machines.
|
| ThreadSafeManager |
|
| ThreadSafeManager.Builder |
|
| Token |
Describes the input token stream.
|
| Token |
Describes the input token stream.
|
| Token |
Describes the input token stream.
|
| Tokeniser |
A tokeniser class is responsible for tokenising a block of text.
|
| Tokenizer |
The specification of the interface implemented
by tokeniser classes.
|
| TokenMgrError |
Token Manager Error.
|
| TokenMgrError |
Token Manager Error.
|
| TokenMgrError |
Token Manager Error.
|
| TokenStream |
Represents a stream of tokens found by a tokeniser.
|
| Tr3BlockFieldLexiconEntry |
Deprecated. |
| Tr3BlockFieldLexiconEntry.Factory |
Factory for creating LexiconEntries
|
| Tr3BlockLexiconEntry |
Deprecated. |
| Tr3BlockLexiconEntry.Factory |
Factory for creating block lexicon entries
|
| Tr4BasicLexiconEntry |
Contains all the information about one entry in the Lexicon.
|
| Tr4BasicLexiconEntry.Factory |
Factory for creating LexiconEntry objects
|
| Tr4BasicTermStatsLexiconEntry |
A LexiconEntry which only contains EntryStatistics
|
| Tr4FieldLexiconEntry |
A LexiconEntry with field support
|
| Tr4FieldLexiconEntry.Factory |
Factory for a LexiconEntry
|
| TRECCollection |
Models a TREC test collection by implementing the interfaces
Collection and DocumentExtractor.
|
| TRECDocidOutputFormat |
OutputFormat for writing TREC runs where the docnos are NOT looked up,
but instead the (integer, internal) docids are recorded in the .res file.
|
| TRECDocnoOutputFormat |
Standard OutputFormat for writing TREC runs
|
| TrecEvalEvaluation |
|
| TrecEvalEvaluation.Command |
|
| TRECFullTokenizer |
This class is the tokenizer used for indexing TREC topic files.
|
| TRECIndexing |
This class creates the indices for a test collection.
|
| TRECIndexingSinglePass |
|
| TRECQrelsInMemory |
Loads the relevance assessments in memory, for performing
evaluation of runs.
|
| TRECQrelsInMemory.QrelsHashSet |
Models the set of relevant documents for one query.
|
| TRECQuery |
This class is used for reading the queries
from TREC topic files.
|
| TRECQuerying |
This class performs a batch mode retrieval from a set of TREC queries.
|
| TRECQuerying.Command |
|
| TRECResultsMatching |
A matching implementation that retrieves results from a TREC result file
rather than the current index.
|
| TRECResultsMatching.InputFormat |
The result set input format.
|
| TRECSetup |
This method is for setting the correct file and directory names
in the files etc/collection.spec, etc/terrier.properties, etc.
|
| TRECUTFCollection |
Deprecated. |
| TRECWebCollection |
Version of TRECCollection which can parse
standard form DOCHDR tags in TREC Web corpoa.
|
| TRv2PorterStemmer |
This is the Porter stemming algorithm, coded up in JAVA by Gianni Amati.
|
| TRv2WeakPorterStemmer |
An implementation of the Porter stemming algorithm that uses only the first
step of the algorithm.
|
| TurkishSnowballStemmer |
Turkish stemmer implmented by Snowball.
|
| TwitterJSONCollection |
This class represents a collection of tweets stored in JSON
format.
|
| TwitterJSONDocument |
This is a Terrier Document implementation of a Tweet stored in JSON format.
|
| UncompressedMetaIndex |
|
| UncompressedMetaIndex.InputStream |
|
| UncompressedMetaIndexBuilder |
Writes all metadata as uncompressed
|
| UnitUtils |
|
| UnorderedWindowOp |
This combines multiple operators into a single op, where they occur within a specified
window of tokens.
|
| UpdatableIndex |
Interface describing an index that can be updated
|
| UTFTokeniser |
Tokenises text obtained from a text stream.
|
| UTFTwitterTokeniser |
A tokeniser designed for use on tweets.
|
| Version |
Maven automatically populates this with the version number, etc.
|
| WARC018Collection |
This object is used to parse WARC format web crawls, 0.18.
|
| WARC09Collection |
This object is used to parse WARC format web crawls, version 0.9.
|
| WARC10Collection |
This object is used to parse WARC format web crawls, version 0.10.
|
| WeakPorterStemmer |
Weak Porter Stemmer, using Porter's Java implementation as the base.
|
| WeightingModel |
This class should be extended by the classes used
for weighting terms and documents.
|
| WeightingModelFactory |
A factory method for handling the initialisation of weighting models.
|
| WeightingModelLibrary |
A library of tf normalizations for weighting models such as the pivoted length normalization
described in Singhal et al., 1996.
|
| WrappedIOException |
A class for IOException.
|
| Wrapper<T> |
Generic mutatble Wrapper class - allows non-mutatable class
to be wrapped in mutatable classes, and re-accessed later.
|
| Wrapper.IntObjectWrapper<K> |
IntObjectWrapper class
|
| WritableIndex |
Interface that defines the methods that an index should have if it has the ability
to write itself to disk once it has been loaded/altered.
|
| WritableOutputFormat |
|
| WritablePosting |
Allow a Posting to be serialized to a DataOut. |
| WriteableFactory<T> |
General interface for factories of Writable objects.
|
| WTreeMap<K,V> |
Wrapper around TreeMap implementing OrderedMap.
|
| XSqrA_M |
This class implements the XSqrA_M weighting model, which computed the
inner product of Pearson's X^2 with the information growth computed
with the multinomial M.
|
| ZstdCompressedMetaIndex |
MetaIndex implementation for when records are compressed using Zstandard
|
| ZstdCompressedMetaIndex.InputStream |
|
| ZstdMetaIndexBuilder |
Writes all metadata using Zstandard compression.
|