store

type BaseDataInput struct {
	// contains filtered or unexported fields
}

type BaseDataOutput struct {
	// contains filtered or unexported fields
}

type BaseIndexInput struct {
	*BaseDataInput
	// contains filtered or unexported fields
}

type BaseIndexOutput struct {
	*BaseDataOutput
	// contains filtered or unexported fields
}

type Buffer struct {
	*bytes.Buffer
}

type BufferInput struct {
	*BaseDataInput
	// contains filtered or unexported fields
}

type BufferOutput struct {
	*BaseDataOutput
	// contains filtered or unexported fields
}

type BufferedChecksumIndexInput struct {
	*BaseIndexInput
	// contains filtered or unexported fields
}

type BytesInput struct {
	*BaseDataInput
	// contains filtered or unexported fields
}

type BytesOutput struct {
	*BaseDataOutput
	// contains filtered or unexported fields
}

type BytesRandomAccessInput struct {
	// contains filtered or unexported fields
}

type ChecksumIndexInput interface {
	IndexInput

	// GetChecksum Returns the current checksum value
	GetChecksum() uint32
}

type CloneReader interface {
	io.Reader

	Clone() CloneReader
}

type ContextType int

type DataInput interface {
	// ByteReader Reads and returns a single byte.
	// See Also: DataOutput.writeByte(byte)
	//ReadByte() (byte, error)
	io.ByteReader

	CloneReader

	// ReadUint16 Reads two bytes and returns a short.
	// See Also: DataOutput.writeByte(byte)
	ReadUint16(ctx context.Context) (uint16, error)

	// ReadUint32 Reads four bytes and returns an int.
	// See Also: DataOutput.writeInt(int)
	ReadUint32(ctx context.Context) (uint32, error)

	// ReadUvarint
	// Reads an int stored in variable-length format. Reads between one and five bytes.
	// Smaller values take fewer bytes. Negative numbers are supported, but should be avoided.
	// The format is described further in DataOutput.writeVInt(int).
	// See Also: DataOutput.writeVInt(int)
	ReadUvarint(ctx context.Context) (uint64, error)

	// ReadZInt32 Read a zig-zag-encoded variable-length integer.
	// See Also: DataOutput.writeZInt(int)
	ReadZInt32(ctx context.Context) (int64, error)

	// ReadUint64 Reads eight bytes and returns a long.
	// See Also: DataOutput.writeLong(long)
	ReadUint64(ctx context.Context) (uint64, error)

	// ReadZInt64 Read a zig-zag-encoded variable-length integer. Reads between one and ten bytes.
	// See Also: DataOutput.writeZLong(long)
	ReadZInt64(ctx context.Context) (int64, error)

	// ReadString Reads a string.
	// See Also: DataOutput.writeString(String)
	ReadString(ctx context.Context) (string, error)

	// ReadMapOfStrings Reads a Map<String,String> previously written with DataOutput.writeMapOfStrings(Map).
	// Returns: An immutable map containing the written contents.
	ReadMapOfStrings(ctx context.Context) (map[string]string, error)

	// ReadSetOfStrings Reads a Set<String> previously written with DataOutput.writeSetOfStrings(Set).
	// Returns: An immutable set containing the written contents.
	ReadSetOfStrings(ctx context.Context) (map[string]struct{}, error)

	SkipBytes(ctx context.Context, numBytes int) error
}

type DataOutput interface {
	// ByteWriter Write a single byte.
	// The most primitive data type is an eight-bit byte. Files are accessed as sequences of bytes.
	// All other data types are defined as sequences of bytes, so file formats are byte-order independent.
	// See Also: IndexInput.readByte()
	io.ByteWriter

	// Writer
	// Writes an array of bytes.
	io.Writer

	// WriteUint32 Writes an int as four bytes.
	// 32-bit unsigned integer written as four bytes, high-order bytes first.
	// See Also: DataInput.readInt()
	WriteUint32(ctx context.Context, i uint32) error

	// WriteUint16 Writes a short as two bytes.
	// See Also: DataInput.readShort()
	WriteUint16(ctx context.Context, i uint16) error

	// WriteUvarint
	// Writes an int in a variable-length format. Writes between one and five bytes. Smaller
	// values take fewer bytes. Negative numbers are supported, but should be avoided.
	// VByte is a variable-length format for positive integers is defined where the high-order bit of each
	// byte indicates whether more bytes remain to be read. The low-order seven bits are appended as
	// increasingly more significant bits in the resulting integer value. Thus values from zero to 127 may
	// be stored in a single byte, values from 128 to 16,383 may be stored in two bytes, and so on.
	WriteUvarint(ctx context.Context, i uint64) error

	// WriteZInt32 Write a zig-zag-encoded variable-length integer. This is typically useful to write small
	// signed ints and is equivalent to calling writeVInt(BitUtil.zigZagEncode(i)).
	// See Also: DataInput.readZInt()
	WriteZInt32(ctx context.Context, i int32) error

	// WriteUint64 Writes a long as eight bytes.
	// 64-bit unsigned integer written as eight bytes, high-order bytes first.
	// See Also: DataInput.readLong()
	WriteUint64(ctx context.Context, i uint64) error

	// WriteZInt64 Write a zig-zag-encoded variable-length long. Writes between one and ten bytes. This is typically
	// useful to write small signed ints.
	// See Also: DataInput.readZLong()
	WriteZInt64(ctx context.Context, i int64) error

	// WriteString Writes a string.
	// Writes strings as UTF-8 encoded bytes. First the length, in bytes, is written as a VInt, followed by the bytes.
	// See Also: DataInput.readString()
	WriteString(ctx context.Context, s string) error

	// CopyBytes Copy numBytes bytes from input to ourself.
	CopyBytes(ctx context.Context, input DataInput, numBytes int) error

	// WriteMapOfStrings Writes a String map.
	// First the size is written as an vInt, followed by each key-value pair written as two consecutive Strings.
	WriteMapOfStrings(ctx context.Context, values map[string]string) error

	// WriteSetOfStrings Writes a String set.
	//First the size is written as an vInt, followed by each value written as a String.
	WriteSetOfStrings(ctx context.Context, values map[string]struct{}) error
}

type Directory interface {

	// ListAll Returns names of all files stored in this directory. The output must be in sorted
	// (UTF-16, java's String.compareTo) order.
	// Throws: IOException – in case of I/O error
	ListAll(ctx context.Context) ([]string, error)

	// DeleteFile Removes an existing file in the directory. This method must throw either
	// NoSuchFileException or FileNotFoundException if name points to a non-existing file.
	// Params: name – the name of an existing file.
	// Throws: IOException – in case of I/O error
	DeleteFile(ctx context.Context, name string) error

	// FileLength Returns the byte length of a file in the directory. This method must throw either
	// NoSuchFileException or FileNotFoundException if name points to a non-existing file.
	// Params: name – the name of an existing file.
	// Throws: IOException – in case of I/O error
	FileLength(ctx context.Context, name string) (int64, error)

	// CreateOutput Creates a new, empty file in the directory and returns an IndexOutput instance for
	// appending data to this file. This method must throw java.nio.file.FileAlreadyExistsException if
	// the file already exists.
	// Params: name – the name of the file to create.
	// Throws: IOException – in case of I/O error
	CreateOutput(ctx context.Context, name string) (IndexOutput, error)

	// CreateTempOutput Creates a new, empty, temporary file in the directory and returns an IndexOutput
	// instance for appending data to this file. The temporary file name
	// (accessible via IndexOutput.getName()) will start with prefix, end with suffix and have a reserved
	// file extension .tmp.
	CreateTempOutput(ctx context.Context, prefix, suffix string) (IndexOutput, error)

	// Rename Renames source file to dest file where dest must not already exist in the directory.
	// It is permitted for this operation to not be truly atomic, for example both source and dest can
	// be visible temporarily in listAll(). However, the implementation of this method must ensure the
	// content of dest appears as the entire source atomically. So once dest is visible for readers,
	// the entire content of previous source is visible. This method is used by IndexWriter to publish commits.
	Rename(ctx context.Context, source, dest string) error

	// OpenInput Opens a stream for reading an existing file. This method must throw either
	// NoSuchFileException or FileNotFoundException if name points to a non-existing file.
	// Params: name – the name of an existing file.
	// Throws: IOException – in case of I/O error
	OpenInput(ctx context.Context, name string) (IndexInput, error)

	// ObtainLock Acquires and returns a Lock for a file with the given name.
	// Params: name – the name of the lock file
	// Throws:  LockObtainFailedException – (optional specific exception) if the lock could not be obtained
	//			because it is currently held elsewhere.
	// IOException – if any i/o error occurs attempting to gain the lock
	ObtainLock(name string) (Lock, error)

	// Closer Closes the directory.
	io.Closer

	// EnsureOpen Ensures this directory is still open.
	// Throws: AlreadyClosedException – if this directory is closed.
	EnsureOpen() error
}

type DirectoryDefault struct {
	DeleteFile func(ctx context.Context, name string) error
}

type DirectorySPI interface {
	DeleteFile(ctx context.Context, name string) error
}

type FSDirectory interface {
	Directory

	// GetDirectory Returns: the underlying filesystem directory
	GetDirectory() (string, error)
}

type FSIndexOutput struct {
	*OutputStream
}

type FSLockFactory interface {
	LockFactory

	// FSLockFactoryInner Implement this method to obtain a lock for a FSDirectory instance.
	// Throws: IOException – if the lock could not be obtained.
	FSLockFactoryInner
}

type FSLockFactoryBase struct {
	// contains filtered or unexported fields
}

type FSLockFactoryInner interface {
	ObtainFSLock(dir FSDirectory, lockName string) (Lock, error)
}

type FlushInfo struct {
	NumDocs              int
	EstimatedSegmentSize int64
}

type Hash interface {
	Write(p []byte)
	Sum() uint32
	Clone() Hash
}

type IOContext struct {
	Type      ContextType
	MergeInfo *MergeInfo
	FlushInfo *FlushInfo
	ReadOnce  bool
}

type IOContextOption func(ctx *IOContext)

type IndexInput interface {
	DataInput

	io.Closer

	// Seeker Sets current pos in this file, where the next read will occur. If this is beyond the end
	// of the file then this will throw EOFException and then the stream is in an undetermined state.
	// See Also: getFilePointer()
	//Seek(pos int64, whence int) (int64, error)
	io.Seeker

	IndexInputSPI
}

type IndexInputSPI interface {
	// GetFilePointer Returns the current pos in this file, where the next read will occur.
	// See Also: seek(long)
	GetFilePointer() int64

	// Slice Creates a slice of this index input, with the given description, offset, and length.
	// The slice is sought to the beginning.
	Slice(sliceDescription string, offset, length int64) (IndexInput, error)

	// Length The number of bytes in the file.
	Length() int64

	// RandomAccessSlice Creates a random-access slice of this index input, with the given offset and length.
	// The default implementation calls slice, and it doesn't support random access, it implements absolute
	// reads as seek+read.
	RandomAccessSlice(offset int64, length int64) (RandomAccessInput, error)
}

type IndexOutput interface {
	io.Closer

	DataOutput

	GetName() string

	// GetFilePointer Returns the current pos in this file,
	// where the next write will occur.
	GetFilePointer() int64

	GetChecksum() (uint32, error)
}

type InputStream struct {
	*BaseDataInput
	// contains filtered or unexported fields
}

type Lock interface {
	// Closer Releases exclusive access.
	// Note that exceptions thrown from close may require human intervention, as it may mean the lock was no longer valid, or that fs permissions prevent removal of the lock file, or other reasons.
	// Closes this stream and releases any system resources associated with it. If the stream is already closed then invoking this method has no effect.
	// As noted in AutoCloseable.close(), cases where the close may fail require careful attention. It is strongly advised to relinquish the underlying resources and to internally mark the Closeable as closed, prior to throwing the IOException.
	// Throws: LockReleaseFailedException – optional specific exception) if the lock could not be properly released.
	io.Closer

	// EnsureValid Best effort check that this lock is still valid. Locks could become invalidated externally for a number of reasons, for example if a user deletes the lock file manually or when a network filesystem is in use.
	// Throws: IOException – if the lock is no longer valid.
	EnsureValid() error
}

type LockFactory interface {

	// ObtainLock Return a new obtained Lock instance identified by lockName.
	// Params: lockName – name of the lock to be created.
	// Throws: 	LockObtainFailedException – (optional specific exception) if the lock could not be obtained
	//			because it is currently held elsewhere.
	//			IOException – if any i/o error occurs attempting to gain the lock
	ObtainLock(dir Directory, lockName string) (Lock, error)
}

type MergeInfo struct {
	TotalMaxDoc         int
	EstimatedMergeBytes int
	IsExternal          bool
	MergeMaxNumSegments int
}

type MmapDataInput struct {
	*BaseDataInput
	// contains filtered or unexported fields
}

type NIOFSDirectory struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type NIOFSIndexInput struct {
	*BaseIndexInput
	// contains filtered or unexported fields
}

type NoLock struct {
}

type NoLockFactory struct {
	// contains filtered or unexported fields
}

type OutputStream struct {
	*BaseIndexOutput
	// contains filtered or unexported fields
}

type RandomAccessInput interface {
	io.ReaderAt

	// ReadU8
	// Reads a byte at the given pos in the file
	// See Also: DataInput.readByte
	ReadU8(pos int64) (byte, error)

	// ReadU16
	// Reads a short at the given pos in the file
	// See Also: DataInput.readShort
	ReadU16(pos int64) (uint16, error)

	// ReadU32
	// Reads an integer at the given pos in the file
	// See Also: DataInput.readInt
	ReadU32(pos int64) (uint32, error)

	// ReadU64
	// Reads a long at the given pos in the file
	// See Also: DataInput.readLong
	ReadU64(pos int64) (uint64, error)
}

type SimpleFSLock struct {
	// contains filtered or unexported fields
}

type SimpleFSLockFactory struct {
	*FSLockFactoryBase
}

type SingleInstanceLock struct {
	*SingleInstanceLockFactory
	// contains filtered or unexported fields
}

type SingleInstanceLockFactory struct {
	sync.RWMutex
	// contains filtered or unexported fields
}