search

type Aggregation interface {
	Fields() []string
	Calculator() Calculator
}

type Aggregations map[string]Aggregation

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

type BucketCalculator interface {
	Calculator
	Buckets() []*Bucket
}

type Calculator interface {
	Consume(*DocumentMatch)
	Finish()
	Merge(Calculator)
}

type Collectible interface {
	Next(ctx *Context) (*DocumentMatch, error)
	DocumentMatchPoolSize() int
	Close() error
}

type Collector interface {
	Collect(context.Context, Aggregations, Collectible) (DocumentMatchIterator, error)

	Size() int
	BackingSize() int
}

type CompositeScorer interface {
	ScoreComposite(constituents []*DocumentMatch) float64
	ExplainComposite(constituents []*DocumentMatch) *Explanation
}

type ConstantGeoPointSource geo.Point

type ConstantTextValueSource []byte

type Context struct {
	DocumentMatchPool *DocumentMatchPool
	// contains filtered or unexported fields
}

type DateValueSource interface {
	Fields() []string
	Date(match *DocumentMatch) time.Time
}

type DateValuesSource interface {
	Fields() []string
	Dates(match *DocumentMatch) []time.Time
}

type DocumentMatch struct {
	Number      uint64
	Score       float64
	Explanation *Explanation
	Locations   FieldTermLocationMap
	SortValue   [][]byte

	// used to maintain natural index order
	HitNumber int

	// used to temporarily hold field term location information during
	// search processing in an efficient, recycle-friendly manner, to
	// be later incorporated into the Locations map when search
	// results are completed
	FieldTermLocations []FieldTermLocation
	// contains filtered or unexported fields
}

type DocumentMatchCollection []*DocumentMatch

type DocumentMatchIterator interface {
	Next() (*DocumentMatch, error)
	Aggregations() *Bucket
}

type DocumentMatchPool struct {
	TooSmall DocumentMatchPoolTooSmall
	// contains filtered or unexported fields
}

type DocumentMatchPoolTooSmall func(p *DocumentMatchPool) *DocumentMatch

type DocumentValueReadable interface {
	// DocumentValueReader provides a way to find all of the document
	// values stored in the specified fields.  The returned
	// DocumentValueReader provides a means to visit specific document
	// numbers.
	DocumentValueReader(fields []string) (segment.DocumentValueReader, error)
}

type DurationCalculator interface {
	Calculator
	Duration() time.Duration
}

type Explanation struct {
	Value    float64        `json:"value"`
	Message  string         `json:"message"`
	Children []*Explanation `json:"children,omitempty"`
}

type FieldFragmentMap map[string][]string

type FieldSource string

type FieldTermLocation struct {
	Field    string
	Term     string
	Location Location
}

type FieldTermLocationMap map[string]TermLocationMap

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

type GeoPointValueSource interface {
	Fields() []string
	GeoPoint(match *DocumentMatch) *geo.Point
}

type GeoPointValuesSource interface {
	Fields() []string
	GeoPoints(match *DocumentMatch) []*geo.Point
}

type Location struct {
	Pos   int
	Start int
	End   int
}

type Locations []*Location

type MatchReader interface {
	DocumentValueReadable
	StoredFieldVisitable
}

type MetricCalculator interface {
	Calculator
	Value() float64
}

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

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

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

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

type NumericValueSource interface {
	Fields() []string
	Number(match *DocumentMatch) float64
}

type NumericValuesSource interface {
	Fields() []string
	Numbers(match *DocumentMatch) []float64
}

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

type Reader interface {
	DocumentValueReadable

	StoredFieldVisitable

	CollectionStats(field string) (segment.CollectionStats, error)

	// DictionaryLookup provides a way to quickly determine if a term is
	// in the dictionary for the specified field.
	DictionaryLookup(field string) (segment.DictionaryLookup, error)

	// DictionaryIterator provides a way to explore the terms used in the
	// specified field.  You can optionally filter these terms
	// by the provided Automaton, or start/end terms.
	DictionaryIterator(field string, automaton segment.Automaton, start,
		end []byte) (segment.DictionaryIterator, error)

	// PostingsIterator provides a way to find information about all documents
	// that use the specified term in the specified field.
	PostingsIterator(term []byte, field string, includeFreq, includeNorm,
		includeTermVectors bool) (segment.PostingsIterator, error)

	// Close releases all resources associated with this Reader
	Close() error
}

type ScoreSource struct{}

type Scorer interface {
	Score(freq int, norm float64) float64
	Explain(freq int, norm float64) *Explanation
}

type Searcher interface {
	Next(ctx *Context) (*DocumentMatch, error)
	Advance(ctx *Context, number uint64) (*DocumentMatch, error)
	Close() error
	Count() uint64
	Min() int
	Size() int

	DocumentMatchPoolSize() int
}

type SearcherOptions struct {
	SimilarityForField func(field string) Similarity
	DefaultSearchField string
	DefaultAnalyzer    *analysis.Analyzer
	Explain            bool
	IncludeTermVectors bool
	Score              string
}

type Similarity interface {
	ComputeNorm(numTerms int) float32
	Scorer(boost float64, collectionStats segment.CollectionStats, termStats segment.TermStats) Scorer
}

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

type SortOrder []*Sort

type SortValue [][]byte

type StoredFieldVisitable interface {
	// VisitStoredFields will call the visitor for each stored field
	// of the specified document number.
	VisitStoredFields(number uint64, visitor segment.StoredFieldVisitor) error
}

type TermLocationMap map[string]Locations

type TextValueSource interface {
	Fields() []string
	Value(match *DocumentMatch) []byte
}

type TextValuesSource interface {
	Fields() []string
	Values(match *DocumentMatch) [][]byte
}