model

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

type DocValuesType int

type DocsAndPositionsEnum struct {
}

type DocsEnum interface {
	DocIdSetIterator
	/**
	 * Returns term frequency in the current document, or 1 if the field was
	 * indexed with {@link IndexOptions#DOCS_ONLY}. Do not call this before
	 * {@link #nextDoc} is first called, nor after {@link #nextDoc} returns
	 * {@link DocIdSetIterator#NO_MORE_DOCS}.
	 *
	 * <p>
	 * <b>NOTE:</b> if the {@link DocsEnum} was obtain with {@link #FLAG_NONE},
	 * the result of this method is undefined.
	 */
	Freq() (n int, err error)
}

type EmptyTermState struct{}

type EmptyTermsEnum struct {
	*TermsEnumImpl
}

type FieldInfo struct {
	// Field's name
	Name string
	// Internal field number
	Number int32

	*AttributesMixin
	// contains filtered or unexported fields
}

type FieldInfos struct {
	HasFreq      bool
	HasProx      bool
	HasPayloads  bool
	HasOffsets   bool
	HasVectors   bool
	HasNorms     bool
	HasDocValues bool

	Values []*FieldInfo // sorted by ID
	// contains filtered or unexported fields
}

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

type FieldNumbers struct {
	sync.Locker
	// contains filtered or unexported fields
}

type Fields interface {
	// Iterator of string
	Terms(field string) Terms
}

type IndexOptions int

type IndexableField interface {
	/** Field name */
	Name() string
	/** {@linkmodel.IndexableFieldType} describing the properties
	 * of this field. */
	FieldType() IndexableFieldType
	/**
	 * Returns the field's index-time boost.
	 * <p>
	 * Only fields can have an index-time boost, if you want to simulate
	 * a "document boost", then you must pre-multiply it across all the
	 * relevant fields yourself.
	 * <p>The boost is used to compute the norm factor for the field.  By
	 * default, in the {@link Similarity#computeNorm(FieldInvertState)} method,
	 * the boost value is multiplied by the length normalization factor and then
	 * rounded by {@link DefaultSimilarity#encodeNormValue(float)} before it is stored in the
	 * index.  One should attempt to ensure that this product does not overflow
	 * the range of that encoding.
	 * <p>
	 * It is illegal to return a boost other than 1.0f for a field that is not
	 * indexed ({@linkmodel.IndexableFieldType#indexed()} is false) or omits normalization values
	 * ({@linkmodel.IndexableFieldType#omitNorms()} returns true).
	 *
	 * @see Similarity#computeNorm(FieldInvertState)
	 * @see DefaultSimilarity#encodeNormValue(float)
	 */
	Boost() float32
	/** Non-null if this field has a binary value */
	BinaryValue() []byte

	/** Non-null if this field has a string value */
	StringValue() string

	/** Non-null if this field has a Reader value */
	ReaderValue() io.RuneReader

	/** Non-null if this field has a numeric value */
	NumericValue() interface{}

	// Creates the TokenStream used for indexing this field.  If appropriate,
	// implementations should use the given Analyzer to create the TokenStreams.
	TokenStream(analysis.Analyzer, analysis.TokenStream) (analysis.TokenStream, error)
}

type IndexableFieldType interface {
	/** True if this field should be indexed (inverted) */
	Indexed() bool
	/** True if the field's value should be stored */
	Stored() bool
	/**
	 * True if this field's value should be analyzed by the
	 * {@link Analyzer}.
	 * <p>
	 * This has no effect if {@link #indexed()} returns false.
	 */
	Tokenized() bool
	/**
	 * True if this field's indexed form should be also stored
	 * into term vectors.
	 * <p>
	 * This builds a miniature inverted-index for this field which
	 * can be accessed in a document-oriented way from
	 * {@link IndexReader#getTermVector(int,String)}.
	 * <p>
	 * This option is illegal if {@link #indexed()} returns false.
	 */
	StoreTermVectors() bool
	/**
	 * True if this field's token character offsets should also
	 * be stored into term vectors.
	 * <p>
	 * This option is illegal if term vectors are not enabled for the field
	 * ({@link #storeTermVectors()} is false)
	 */
	StoreTermVectorOffsets() bool

	/**
	 * True if this field's token positions should also be stored
	 * into the term vectors.
	 * <p>
	 * This option is illegal if term vectors are not enabled for the field
	 * ({@link #storeTermVectors()} is false).
	 */
	StoreTermVectorPositions() bool

	/**
	 * True if this field's token payloads should also be stored
	 * into the term vectors.
	 * <p>
	 * This option is illegal if term vector positions are not enabled
	 * for the field ({@link #storeTermVectors()} is false).
	 */
	StoreTermVectorPayloads() bool

	/**
	 * True if normalization values should be omitted for the field.
	 * <p>
	 * This saves memory, but at the expense of scoring quality (length normalization
	 * will be disabled), and if you omit norms, you cannot use index-time boosts.
	 */
	OmitNorms() bool

	/** {@link IndexOptions}, describing what should be
	 * recorded into the inverted index */
	IndexOptions() IndexOptions

	/**
	 * DocValues {@link DocValuesType}: if non-null then the field's value
	 * will be indexed into docValues.
	 */
	DocValueType() DocValuesType
}

type Int32Slice []int32

type SeekStatus int

type SegmentInfo struct {
	Dir store.Directory

	Name string

	*AttributesMixin
	// contains filtered or unexported fields
}

type SegmentReadState struct {
	Dir               store.Directory
	SegmentInfo       *SegmentInfo
	FieldInfos        FieldInfos
	Context           store.IOContext
	TermsIndexDivisor int
	SegmentSuffix     string
}

type SegmentWriteState struct {
	Directory       store.Directory
	SegmentInfo     *SegmentInfo
	FieldInfos      FieldInfos
	DelCountOnFlush int
	SegUpdates      interface{} // BufferedUpdates
	LiveDocs        util.MutableBits
	SegmentSuffix   string

	Context store.IOContext
	// contains filtered or unexported fields
}

type TermState interface {
	CopyFrom(other TermState)
	Clone() TermState
}

type Terms interface {
	Iterator(reuse TermsEnum) TermsEnum
	DocCount() int
	SumTotalTermFreq() int64
	SumDocFreq() int64
}

type TermsEnum interface {
	util.BytesRefIterator

	Attributes() *util.AttributeSource
	/* Attempts to seek to the exact term, returning
	true if the term is found. If this returns false, the
	enum is unpositioned. For some codecs, seekExact may
	be substantially faster than seekCeil. */
	SeekExact(text []byte) (ok bool, err error)
	/* Seeks to the specified term, if it exists, or to the
	next (ceiling) term. Returns SeekStatus to
	indicate whether exact term was found, a different
	term was found, or EOF was hit. The target term may
	be before or after the current term. If this returns
	SeekStatus.END, then enum is unpositioned. */
	SeekCeil(text []byte) SeekStatus
	/* Seeks to the specified term by ordinal (position) as
	previously returned by ord. The target ord
	may be before or after the current ord, and must be
	within bounds. */
	SeekExactByPosition(ord int64) error
	/* Expert: Seeks a specific position by TermState previously obtained
	from termState(). Callers shoudl maintain the TermState to
	use this method. Low-level implementations may position the TermsEnum
	without re-seeking the term dictionary.

	Seeking by TermState should only be used iff the state was obtained
	from the same instance.

	NOTE: Using this method with an incompatible TermState might leave
	this TermsEnum in undefiend state. On a segment level
	TermState instances are compatible only iff the source and the
	target TermsEnum operate on the same field. If operating on segment
	level, TermState instances must not be used across segments.

	NOTE: A seek by TermState might not restore the
	AttributeSource's state. AttributeSource state must be
	maintained separately if the method is used. */
	SeekExactFromLast(text []byte, state TermState) error
	/* Returns current term. Do not call this when enum
	is unpositioned. */
	Term() []byte
	/* Returns ordinal position for current term. This is an
	optional method (the codec may panic). Do not call this
	when the enum is unpositioned. */
	Ord() int64
	/* Returns the number of documentsw containing the current
	term. Do not call this when enum is unpositioned. */
	DocFreq() (df int, err error)
	/* Returns the total numnber of occurrences of this term
	across all documents (the sum of the freq() for each
	doc that has this term). This will be -1 if the
	codec doesn't support this measure. Note that, like
	other term measures, this measure does not take
	deleted documents into account. */
	TotalTermFreq() (tf int64, err error)
	/* Get DocsEnum for the current term. Do not
	call this when the enum is unpositioned. This method
	will not return nil. */
	Docs(liveDocs util.Bits, reuse DocsEnum) (de DocsEnum, err error)
	/* Get DocsEnum for the current term, with
	control over whether freqs are required. Do not
	call this when the enum is unpositioned. This method
	will not return nil. */
	DocsByFlags(liveDocs util.Bits, reuse DocsEnum, flags int) (de DocsEnum, err error)
	/* Get DocsAndPositionEnum for the current term.
	Do not call this when the enum is unpositioned. This
	method will return nil if positions were not
	indexed. */
	DocsAndPositions(liveDocs util.Bits, reuse DocsAndPositionsEnum) DocsAndPositionsEnum
	/* Get DocsAndPositionEnum for the current term,
	with control over whether offsets and payloads are
	required. Some codecs may be able to optimize their
	implementation when offsets and/or payloads are not required.
	Do not call this when the enum is unpositioned. This
	will return nil if positions were not indexed. */
	DocsAndPositionsByFlags(liveDocs util.Bits, reuse DocsAndPositionsEnum, flags int) DocsAndPositionsEnum
	/* Expert: Returns the TermsEnum internal state to position the TermsEnum
	without re-seeking the term dictionary.

	NOTE: A sek by TermState might not capture the
	AttributeSource's state. Callers must maintain the
	AttributeSource states separately. */
	TermState() (ts TermState, err error)
}

type TermsEnumImpl struct {
	TermsEnum
	// contains filtered or unexported fields
}