bleve: github.com/blevesearch/bleve/registry Index | Files

package registry

import "github.com/blevesearch/bleve/registry"

Index

Package Files

analyzer.go cache.go char_filter.go datetime_parser.go fragment_formatter.go fragmenter.go highlighter.go index_type.go registry.go store.go token_filter.go token_maps.go tokenizer.go

Variables

var ErrAlreadyDefined = fmt.Errorf("item already defined")

func AnalyzerBuild Uses

func AnalyzerBuild(name string, config map[string]interface{}, cache *Cache) (interface{}, error)

func AnalyzerTypesAndInstances Uses

func AnalyzerTypesAndInstances() ([]string, []string)

func CharFilterBuild Uses

func CharFilterBuild(name string, config map[string]interface{}, cache *Cache) (interface{}, error)

func CharFilterTypesAndInstances Uses

func CharFilterTypesAndInstances() ([]string, []string)

func DateTimeParserBuild Uses

func DateTimeParserBuild(name string, config map[string]interface{}, cache *Cache) (interface{}, error)

func DateTimeParserTypesAndInstances Uses

func DateTimeParserTypesAndInstances() ([]string, []string)

func FragmentFormatterBuild Uses

func FragmentFormatterBuild(name string, config map[string]interface{}, cache *Cache) (interface{}, error)

func FragmentFormatterTypesAndInstances Uses

func FragmentFormatterTypesAndInstances() ([]string, []string)

func FragmenterBuild Uses

func FragmenterBuild(name string, config map[string]interface{}, cache *Cache) (interface{}, error)

func FragmenterTypesAndInstances Uses

func FragmenterTypesAndInstances() ([]string, []string)

func HighlighterBuild Uses

func HighlighterBuild(name string, config map[string]interface{}, cache *Cache) (interface{}, error)

func HighlighterTypesAndInstances Uses

func HighlighterTypesAndInstances() ([]string, []string)

func IndexTypesAndInstances Uses

func IndexTypesAndInstances() ([]string, []string)

func KVStoreTypesAndInstances Uses

func KVStoreTypesAndInstances() ([]string, []string)

func RegisterAnalyzer Uses

func RegisterAnalyzer(name string, constructor AnalyzerConstructor)

func RegisterCharFilter Uses

func RegisterCharFilter(name string, constructor CharFilterConstructor)

func RegisterDateTimeParser Uses

func RegisterDateTimeParser(name string, constructor DateTimeParserConstructor)

func RegisterFragmentFormatter Uses

func RegisterFragmentFormatter(name string, constructor FragmentFormatterConstructor)

func RegisterFragmenter Uses

func RegisterFragmenter(name string, constructor FragmenterConstructor)

func RegisterHighlighter Uses

func RegisterHighlighter(name string, constructor HighlighterConstructor)

func RegisterIndexType Uses

func RegisterIndexType(name string, constructor IndexTypeConstructor)

func RegisterKVStore Uses

func RegisterKVStore(name string, constructor KVStoreConstructor)

func RegisterTokenFilter Uses

func RegisterTokenFilter(name string, constructor TokenFilterConstructor)

func RegisterTokenMap Uses

func RegisterTokenMap(name string, constructor TokenMapConstructor)

func RegisterTokenizer Uses

func RegisterTokenizer(name string, constructor TokenizerConstructor)

func TokenFilterBuild Uses

func TokenFilterBuild(name string, config map[string]interface{}, cache *Cache) (interface{}, error)

func TokenFilterTypesAndInstances Uses

func TokenFilterTypesAndInstances() ([]string, []string)

func TokenMapBuild Uses

func TokenMapBuild(name string, config map[string]interface{}, cache *Cache) (interface{}, error)

func TokenMapTypesAndInstances Uses

func TokenMapTypesAndInstances() ([]string, []string)

func TokenizerBuild Uses

func TokenizerBuild(name string, config map[string]interface{}, cache *Cache) (interface{}, error)

func TokenizerTypesAndInstances Uses

func TokenizerTypesAndInstances() ([]string, []string)

type AnalyzerCache Uses

type AnalyzerCache struct {
    *ConcurrentCache
}

func NewAnalyzerCache Uses

func NewAnalyzerCache() *AnalyzerCache

func (*AnalyzerCache) AnalyzerNamed Uses

func (c *AnalyzerCache) AnalyzerNamed(name string, cache *Cache) (*analysis.Analyzer, error)

func (*AnalyzerCache) DefineAnalyzer Uses

func (c *AnalyzerCache) DefineAnalyzer(name string, typ string, config map[string]interface{}, cache *Cache) (*analysis.Analyzer, error)

type AnalyzerConstructor Uses

type AnalyzerConstructor func(config map[string]interface{}, cache *Cache) (*analysis.Analyzer, error)

type AnalyzerRegistry Uses

type AnalyzerRegistry map[string]AnalyzerConstructor

type Cache Uses

type Cache struct {
    CharFilters        *CharFilterCache
    Tokenizers         *TokenizerCache
    TokenMaps          *TokenMapCache
    TokenFilters       *TokenFilterCache
    Analyzers          *AnalyzerCache
    DateTimeParsers    *DateTimeParserCache
    FragmentFormatters *FragmentFormatterCache
    Fragmenters        *FragmenterCache
    Highlighters       *HighlighterCache
}

func NewCache Uses

func NewCache() *Cache

func (*Cache) AnalyzerNamed Uses

func (c *Cache) AnalyzerNamed(name string) (*analysis.Analyzer, error)

func (*Cache) CharFilterNamed Uses

func (c *Cache) CharFilterNamed(name string) (analysis.CharFilter, error)

func (*Cache) DateTimeParserNamed Uses

func (c *Cache) DateTimeParserNamed(name string) (analysis.DateTimeParser, error)

func (*Cache) DefineAnalyzer Uses

func (c *Cache) DefineAnalyzer(name string, config map[string]interface{}) (*analysis.Analyzer, error)

func (*Cache) DefineCharFilter Uses

func (c *Cache) DefineCharFilter(name string, config map[string]interface{}) (analysis.CharFilter, error)

func (*Cache) DefineDateTimeParser Uses

func (c *Cache) DefineDateTimeParser(name string, config map[string]interface{}) (analysis.DateTimeParser, error)

func (*Cache) DefineFragmentFormatter Uses

func (c *Cache) DefineFragmentFormatter(name string, config map[string]interface{}) (highlight.FragmentFormatter, error)

func (*Cache) DefineFragmenter Uses

func (c *Cache) DefineFragmenter(name string, config map[string]interface{}) (highlight.Fragmenter, error)

func (*Cache) DefineHighlighter Uses

func (c *Cache) DefineHighlighter(name string, config map[string]interface{}) (highlight.Highlighter, error)

func (*Cache) DefineTokenFilter Uses

func (c *Cache) DefineTokenFilter(name string, config map[string]interface{}) (analysis.TokenFilter, error)

func (*Cache) DefineTokenMap Uses

func (c *Cache) DefineTokenMap(name string, config map[string]interface{}) (analysis.TokenMap, error)

func (*Cache) DefineTokenizer Uses

func (c *Cache) DefineTokenizer(name string, config map[string]interface{}) (analysis.Tokenizer, error)

func (*Cache) FragmentFormatterNamed Uses

func (c *Cache) FragmentFormatterNamed(name string) (highlight.FragmentFormatter, error)

func (*Cache) FragmenterNamed Uses

func (c *Cache) FragmenterNamed(name string) (highlight.Fragmenter, error)

func (*Cache) HighlighterNamed Uses

func (c *Cache) HighlighterNamed(name string) (highlight.Highlighter, error)

func (*Cache) TokenFilterNamed Uses

func (c *Cache) TokenFilterNamed(name string) (analysis.TokenFilter, error)

func (*Cache) TokenMapNamed Uses

func (c *Cache) TokenMapNamed(name string) (analysis.TokenMap, error)

func (*Cache) TokenizerNamed Uses

func (c *Cache) TokenizerNamed(name string) (analysis.Tokenizer, error)

type CacheBuild Uses

type CacheBuild func(name string, config map[string]interface{}, cache *Cache) (interface{}, error)

type CharFilterCache Uses

type CharFilterCache struct {
    *ConcurrentCache
}

func NewCharFilterCache Uses

func NewCharFilterCache() *CharFilterCache

func (*CharFilterCache) CharFilterNamed Uses

func (c *CharFilterCache) CharFilterNamed(name string, cache *Cache) (analysis.CharFilter, error)

func (*CharFilterCache) DefineCharFilter Uses

func (c *CharFilterCache) DefineCharFilter(name string, typ string, config map[string]interface{}, cache *Cache) (analysis.CharFilter, error)

type CharFilterConstructor Uses

type CharFilterConstructor func(config map[string]interface{}, cache *Cache) (analysis.CharFilter, error)

type CharFilterRegistry Uses

type CharFilterRegistry map[string]CharFilterConstructor

type ConcurrentCache Uses

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

func NewConcurrentCache Uses

func NewConcurrentCache() *ConcurrentCache

func (*ConcurrentCache) DefineItem Uses

func (c *ConcurrentCache) DefineItem(name string, typ string, config map[string]interface{}, cache *Cache, build CacheBuild) (interface{}, error)

func (*ConcurrentCache) ItemNamed Uses

func (c *ConcurrentCache) ItemNamed(name string, cache *Cache, build CacheBuild) (interface{}, error)

type DateTimeParserCache Uses

type DateTimeParserCache struct {
    *ConcurrentCache
}

func NewDateTimeParserCache Uses

func NewDateTimeParserCache() *DateTimeParserCache

func (*DateTimeParserCache) DateTimeParserNamed Uses

func (c *DateTimeParserCache) DateTimeParserNamed(name string, cache *Cache) (analysis.DateTimeParser, error)

func (*DateTimeParserCache) DefineDateTimeParser Uses

func (c *DateTimeParserCache) DefineDateTimeParser(name string, typ string, config map[string]interface{}, cache *Cache) (analysis.DateTimeParser, error)

type DateTimeParserConstructor Uses

type DateTimeParserConstructor func(config map[string]interface{}, cache *Cache) (analysis.DateTimeParser, error)

type DateTimeParserRegistry Uses

type DateTimeParserRegistry map[string]DateTimeParserConstructor

type FragmentFormatterCache Uses

type FragmentFormatterCache struct {
    *ConcurrentCache
}

func NewFragmentFormatterCache Uses

func NewFragmentFormatterCache() *FragmentFormatterCache

func (*FragmentFormatterCache) DefineFragmentFormatter Uses

func (c *FragmentFormatterCache) DefineFragmentFormatter(name string, typ string, config map[string]interface{}, cache *Cache) (highlight.FragmentFormatter, error)

func (*FragmentFormatterCache) FragmentFormatterNamed Uses

func (c *FragmentFormatterCache) FragmentFormatterNamed(name string, cache *Cache) (highlight.FragmentFormatter, error)

type FragmentFormatterConstructor Uses

type FragmentFormatterConstructor func(config map[string]interface{}, cache *Cache) (highlight.FragmentFormatter, error)

type FragmentFormatterRegistry Uses

type FragmentFormatterRegistry map[string]FragmentFormatterConstructor

type FragmenterCache Uses

type FragmenterCache struct {
    *ConcurrentCache
}

func NewFragmenterCache Uses

func NewFragmenterCache() *FragmenterCache

func (*FragmenterCache) DefineFragmenter Uses

func (c *FragmenterCache) DefineFragmenter(name string, typ string, config map[string]interface{}, cache *Cache) (highlight.Fragmenter, error)

func (*FragmenterCache) FragmenterNamed Uses

func (c *FragmenterCache) FragmenterNamed(name string, cache *Cache) (highlight.Fragmenter, error)

type FragmenterConstructor Uses

type FragmenterConstructor func(config map[string]interface{}, cache *Cache) (highlight.Fragmenter, error)

type FragmenterRegistry Uses

type FragmenterRegistry map[string]FragmenterConstructor

type HighlighterCache Uses

type HighlighterCache struct {
    *ConcurrentCache
}

func NewHighlighterCache Uses

func NewHighlighterCache() *HighlighterCache

func (*HighlighterCache) DefineHighlighter Uses

func (c *HighlighterCache) DefineHighlighter(name string, typ string, config map[string]interface{}, cache *Cache) (highlight.Highlighter, error)

func (*HighlighterCache) HighlighterNamed Uses

func (c *HighlighterCache) HighlighterNamed(name string, cache *Cache) (highlight.Highlighter, error)

type HighlighterConstructor Uses

type HighlighterConstructor func(config map[string]interface{}, cache *Cache) (highlight.Highlighter, error)

type HighlighterRegistry Uses

type HighlighterRegistry map[string]HighlighterConstructor

type IndexTypeConstructor Uses

type IndexTypeConstructor func(storeName string, storeConfig map[string]interface{}, analysisQueue *index.AnalysisQueue) (index.Index, error)

func IndexTypeConstructorByName Uses

func IndexTypeConstructorByName(name string) IndexTypeConstructor

type IndexTypeRegistry Uses

type IndexTypeRegistry map[string]IndexTypeConstructor

type KVStoreConstructor Uses

type KVStoreConstructor func(mo store.MergeOperator, config map[string]interface{}) (store.KVStore, error)

KVStoreConstructor is used to build a KVStore of a specific type when specificied by the index configuration. In addition to meeting the store.KVStore interface, KVStores must also support this constructor. Note that currently the values of config must be able to be marshaled and unmarshaled using the encoding/json library (used when reading/writing the index metadata file).

func KVStoreConstructorByName Uses

func KVStoreConstructorByName(name string) KVStoreConstructor

type KVStoreRegistry Uses

type KVStoreRegistry map[string]KVStoreConstructor

type TokenFilterCache Uses

type TokenFilterCache struct {
    *ConcurrentCache
}

func NewTokenFilterCache Uses

func NewTokenFilterCache() *TokenFilterCache

func (*TokenFilterCache) DefineTokenFilter Uses

func (c *TokenFilterCache) DefineTokenFilter(name string, typ string, config map[string]interface{}, cache *Cache) (analysis.TokenFilter, error)

func (*TokenFilterCache) TokenFilterNamed Uses

func (c *TokenFilterCache) TokenFilterNamed(name string, cache *Cache) (analysis.TokenFilter, error)

type TokenFilterConstructor Uses

type TokenFilterConstructor func(config map[string]interface{}, cache *Cache) (analysis.TokenFilter, error)

type TokenFilterRegistry Uses

type TokenFilterRegistry map[string]TokenFilterConstructor

type TokenMapCache Uses

type TokenMapCache struct {
    *ConcurrentCache
}

func NewTokenMapCache Uses

func NewTokenMapCache() *TokenMapCache

func (*TokenMapCache) DefineTokenMap Uses

func (c *TokenMapCache) DefineTokenMap(name string, typ string, config map[string]interface{}, cache *Cache) (analysis.TokenMap, error)

func (*TokenMapCache) TokenMapNamed Uses

func (c *TokenMapCache) TokenMapNamed(name string, cache *Cache) (analysis.TokenMap, error)

type TokenMapConstructor Uses

type TokenMapConstructor func(config map[string]interface{}, cache *Cache) (analysis.TokenMap, error)

type TokenMapRegistry Uses

type TokenMapRegistry map[string]TokenMapConstructor

type TokenizerCache Uses

type TokenizerCache struct {
    *ConcurrentCache
}

func NewTokenizerCache Uses

func NewTokenizerCache() *TokenizerCache

func (*TokenizerCache) DefineTokenizer Uses

func (c *TokenizerCache) DefineTokenizer(name string, typ string, config map[string]interface{}, cache *Cache) (analysis.Tokenizer, error)

func (*TokenizerCache) TokenizerNamed Uses

func (c *TokenizerCache) TokenizerNamed(name string, cache *Cache) (analysis.Tokenizer, error)

type TokenizerConstructor Uses

type TokenizerConstructor func(config map[string]interface{}, cache *Cache) (analysis.Tokenizer, error)

type TokenizerRegistry Uses

type TokenizerRegistry map[string]TokenizerConstructor

Package registry imports 6 packages (graph) and is imported by 1348 packages. Updated 2016-10-27. Refresh now. Tools for package owners.