Package-level declarations
Types
This exception is thrown when there is an attempt to access something that has already been closed.
Base implementation for a concrete Directory that uses a LockFactory for locking.
Wraps another Checksum with an internal buffer to speed up checksum calculations.
Simple implementation of ChecksumIndexInput that wraps another input and delegates calls.
Base implementation class for buffered IndexInput.
DataInput backed by a byte array. WARNING: This class omits all low-level checks.
DataOutput backed by a byte array. WARNING: This class omits most low-level checks, so be sure to test heavily with assertions enabled.
A DataInput implementing RandomAccessInput and reading data from a list of [ ]s.
A DataOutput storing data in a list of ByteBuffers.
A Directory storing files as lists of ByteBuffers in memory.
An IndexInput backed by a ByteBuffersDataInput.
An IndexOutput writing to a ByteBuffersDataOutput.
Extension of IndexInput, computing checksum as it goes. Callers can retrieve the checksum via .getChecksum.
Abstract base class for performing write operations of Lucene's low-level data types.
A Directory provides an abstraction layer for storing a list of files. A directory contains only files (no sub-folder hierarchy).
Probe interface for tests that need to identify precise directory failure paths without relying on stack-trace inspection, which is very expensive on Kotlin/Native.
Directory implementation that delegates calls to another directory. This class can be used to add limitations on top of an existing Directory implementation such as [ ] or to add additional sanity checks for tests. However, if you plan to write your own Directory implementation, you should consider extending directly [ ] or BaseDirectory rather than try to reuse functionality of existing [ ]s by extending this class.
IndexInput implementation that delegates calls to another IndexInput. This class can be used to add limitations on top of an existing IndexInput implementation or to add additional sanity checks for tests. However, if you plan to write your own IndexInput implementation, you should consider extending directly IndexInput or DataInput rather than try to reuse functionality of existing IndexInputs by extending this class.
IndexOutput implementation that delegates calls to another directory. This class can be used to add limitations on top of an existing IndexOutput implementation such as [ ] or to add additional sanity checks for tests. However, if you plan to write your own IndexOutput implementation, you should consider extending directly [ ] or DataOutput rather than try to reuse functionality of existing [ ]s by extending this class.
Base class for file system based locking implementation. This class is explicitly checking that the passed Directory is an FSDirectory.
Abstract base class for input from a file in a Directory. A random-access input stream. Used for all Lucene index input operations.
A DataOutput for appending data to a file in a Directory.
A DataInput wrapping a plain InputStream.
An interprocess mutex lock.
Base class for Locking implementation. Directory uses instances of this class to implement locking.
This exception is thrown when the write.lock could not be acquired. This happens when a writer tries to open an index that another writer already has open.
This exception is thrown when the write.lock could not be released.
This class makes a best-effort check that a provided Lock is valid before any destructive filesystem operation.
Simple standalone server that must be running when you use VerifyingLockFactory. This server simply verifies at most one process holds the lock at a time. Run without any args to see usage.
File-based Directory implementation that uses mmap for reading, and [ ] for writing.
Implements LockFactory using native OS file locks. Note that because this LockFactory relies on java.nio.* APIs for locking, any problems with those APIs will cause locking to fail. Specifically, on certain NFS environments the java.nio.* locks will fail (the lock can incorrectly be double acquired) whereas SimpleFSLockFactory worked perfectly in those same environments. For NFS based access to an index, it's recommended that you try [ ] first and work around the one limitation that a lock file could be left when the JVM exits abnormally.
An FSDirectory implementation that uses java.nio's FileChannel's positional read, which allows multiple threads to read from the same file without synchronizing.
Use this LockFactory to disable locking entirely. This is a singleton, you have to use INSTANCE.
Wraps a RAM-resident directory around any provided delegate directory, to be used during NRT search.
A DataOutput wrapping a plain OutputStream.
Implementation class for buffered IndexOutput that writes to an OutputStream.
Random Access Index API. Unlike IndexInput, this has no concept of file position, all reads are absolute. However, like IndexInput, it is only intended for use by a single thread.
Abstract base class to rate limit IO. Typically implementations are shared across multiple IndexInputs or IndexOutputs (for example those involved all merging). Those IndexInputs and IndexOutputs would call .pause whenever the have read or written more than .getMinPauseCheckBytes bytes.
Advice regarding the read access pattern.
Implements LockFactory using Files.createFile.
Implements a LockFactory that provides locks scoped to a single JVM.
Directory that wraps another, and that sleeps and retries if obtaining the lock fails.
A delegating Directory that records which files were written to and deleted.