1//  Copyright (c) 2014 Couchbase, Inc.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// 		http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package registry
16
17import (
18	"fmt"
19
20	"github.com/blevesearch/bleve/v2/analysis"
21	"github.com/blevesearch/bleve/v2/search/highlight"
22)
23
24var stores = make(KVStoreRegistry, 0)
25var indexTypes = make(IndexTypeRegistry, 0)
26
27// highlight
28var fragmentFormatters = make(FragmentFormatterRegistry, 0)
29var fragmenters = make(FragmenterRegistry, 0)
30var highlighters = make(HighlighterRegistry, 0)
31
32// analysis
33var charFilters = make(CharFilterRegistry, 0)
34var tokenizers = make(TokenizerRegistry, 0)
35var tokenMaps = make(TokenMapRegistry, 0)
36var tokenFilters = make(TokenFilterRegistry, 0)
37var analyzers = make(AnalyzerRegistry, 0)
38var dateTimeParsers = make(DateTimeParserRegistry, 0)
39
40type Cache struct {
41	CharFilters        *CharFilterCache
42	Tokenizers         *TokenizerCache
43	TokenMaps          *TokenMapCache
44	TokenFilters       *TokenFilterCache
45	Analyzers          *AnalyzerCache
46	DateTimeParsers    *DateTimeParserCache
47	FragmentFormatters *FragmentFormatterCache
48	Fragmenters        *FragmenterCache
49	Highlighters       *HighlighterCache
50}
51
52func NewCache() *Cache {
53	return &Cache{
54		CharFilters:        NewCharFilterCache(),
55		Tokenizers:         NewTokenizerCache(),
56		TokenMaps:          NewTokenMapCache(),
57		TokenFilters:       NewTokenFilterCache(),
58		Analyzers:          NewAnalyzerCache(),
59		DateTimeParsers:    NewDateTimeParserCache(),
60		FragmentFormatters: NewFragmentFormatterCache(),
61		Fragmenters:        NewFragmenterCache(),
62		Highlighters:       NewHighlighterCache(),
63	}
64}
65
66func typeFromConfig(config map[string]interface{}) (string, error) {
67	prop, ok := config["type"]
68	if !ok {
69		return "", fmt.Errorf("'type' property is not defined")
70	}
71	typ, ok := prop.(string)
72	if !ok {
73		return "", fmt.Errorf("'type' property must be a string, not %T", prop)
74	}
75	return typ, nil
76}
77
78func (c *Cache) CharFilterNamed(name string) (analysis.CharFilter, error) {
79	return c.CharFilters.CharFilterNamed(name, c)
80}
81
82func (c *Cache) DefineCharFilter(name string, config map[string]interface{}) (analysis.CharFilter, error) {
83	typ, err := typeFromConfig(config)
84	if err != nil {
85		return nil, err
86	}
87	return c.CharFilters.DefineCharFilter(name, typ, config, c)
88}
89
90func (c *Cache) TokenizerNamed(name string) (analysis.Tokenizer, error) {
91	return c.Tokenizers.TokenizerNamed(name, c)
92}
93
94func (c *Cache) DefineTokenizer(name string, config map[string]interface{}) (analysis.Tokenizer, error) {
95	typ, err := typeFromConfig(config)
96	if err != nil {
97		return nil, fmt.Errorf("cannot resolve '%s' tokenizer type: %s", name, err)
98	}
99	return c.Tokenizers.DefineTokenizer(name, typ, config, c)
100}
101
102func (c *Cache) TokenMapNamed(name string) (analysis.TokenMap, error) {
103	return c.TokenMaps.TokenMapNamed(name, c)
104}
105
106func (c *Cache) DefineTokenMap(name string, config map[string]interface{}) (analysis.TokenMap, error) {
107	typ, err := typeFromConfig(config)
108	if err != nil {
109		return nil, err
110	}
111	return c.TokenMaps.DefineTokenMap(name, typ, config, c)
112}
113
114func (c *Cache) TokenFilterNamed(name string) (analysis.TokenFilter, error) {
115	return c.TokenFilters.TokenFilterNamed(name, c)
116}
117
118func (c *Cache) DefineTokenFilter(name string, config map[string]interface{}) (analysis.TokenFilter, error) {
119	typ, err := typeFromConfig(config)
120	if err != nil {
121		return nil, err
122	}
123	return c.TokenFilters.DefineTokenFilter(name, typ, config, c)
124}
125
126func (c *Cache) AnalyzerNamed(name string) (*analysis.Analyzer, error) {
127	return c.Analyzers.AnalyzerNamed(name, c)
128}
129
130func (c *Cache) DefineAnalyzer(name string, config map[string]interface{}) (*analysis.Analyzer, error) {
131	typ, err := typeFromConfig(config)
132	if err != nil {
133		return nil, err
134	}
135	return c.Analyzers.DefineAnalyzer(name, typ, config, c)
136}
137
138func (c *Cache) DateTimeParserNamed(name string) (analysis.DateTimeParser, error) {
139	return c.DateTimeParsers.DateTimeParserNamed(name, c)
140}
141
142func (c *Cache) DefineDateTimeParser(name string, config map[string]interface{}) (analysis.DateTimeParser, error) {
143	typ, err := typeFromConfig(config)
144	if err != nil {
145		return nil, err
146	}
147	return c.DateTimeParsers.DefineDateTimeParser(name, typ, config, c)
148}
149
150func (c *Cache) FragmentFormatterNamed(name string) (highlight.FragmentFormatter, error) {
151	return c.FragmentFormatters.FragmentFormatterNamed(name, c)
152}
153
154func (c *Cache) DefineFragmentFormatter(name string, config map[string]interface{}) (highlight.FragmentFormatter, error) {
155	typ, err := typeFromConfig(config)
156	if err != nil {
157		return nil, err
158	}
159	return c.FragmentFormatters.DefineFragmentFormatter(name, typ, config, c)
160}
161
162func (c *Cache) FragmenterNamed(name string) (highlight.Fragmenter, error) {
163	return c.Fragmenters.FragmenterNamed(name, c)
164}
165
166func (c *Cache) DefineFragmenter(name string, config map[string]interface{}) (highlight.Fragmenter, error) {
167	typ, err := typeFromConfig(config)
168	if err != nil {
169		return nil, err
170	}
171	return c.Fragmenters.DefineFragmenter(name, typ, config, c)
172}
173
174func (c *Cache) HighlighterNamed(name string) (highlight.Highlighter, error) {
175	return c.Highlighters.HighlighterNamed(name, c)
176}
177
178func (c *Cache) DefineHighlighter(name string, config map[string]interface{}) (highlight.Highlighter, error) {
179	typ, err := typeFromConfig(config)
180	if err != nil {
181		return nil, err
182	}
183	return c.Highlighters.DefineHighlighter(name, typ, config, c)
184}
185