From 9fefb18528b849b097816af8cd67c79f6f6f68db Mon Sep 17 00:00:00 2001 From: CascadingRadium Date: Tue, 25 Feb 2025 14:30:11 +0530 Subject: [PATCH] Refactor registry components to return an error instead of panicking on duplicate analysis component registration --- analysis/analyzer/custom/custom.go | 5 ++++- analysis/analyzer/keyword/keyword.go | 5 ++++- analysis/analyzer/simple/simple.go | 5 ++++- analysis/analyzer/standard/standard.go | 5 ++++- analysis/analyzer/web/web.go | 5 ++++- analysis/char/asciifolding/asciifolding.go | 5 ++++- analysis/char/html/html.go | 5 ++++- analysis/char/regexp/regexp.go | 5 ++++- analysis/char/zerowidthnonjoiner/zerowidthnonjoiner.go | 5 ++++- analysis/datetime/flexible/flexible.go | 5 ++++- analysis/datetime/iso/iso.go | 5 ++++- analysis/datetime/optional/optional.go | 5 ++++- analysis/datetime/percent/percent.go | 5 ++++- analysis/datetime/sanitized/sanitized.go | 5 ++++- analysis/datetime/timestamp/microseconds/microseconds.go | 5 ++++- analysis/datetime/timestamp/milliseconds/milliseconds.go | 5 ++++- analysis/datetime/timestamp/nanoseconds/nanoseconds.go | 5 ++++- analysis/datetime/timestamp/seconds/seconds.go | 5 ++++- analysis/lang/ar/analyzer_ar.go | 5 ++++- analysis/lang/ar/arabic_normalize.go | 5 ++++- analysis/lang/ar/stemmer_ar.go | 5 ++++- analysis/lang/ar/stop_filter_ar.go | 5 ++++- analysis/lang/ar/stop_words_ar.go | 5 ++++- analysis/lang/bg/stop_filter_bg.go | 5 ++++- analysis/lang/bg/stop_words_bg.go | 5 ++++- analysis/lang/ca/articles_ca.go | 5 ++++- analysis/lang/ca/elision_ca.go | 5 ++++- analysis/lang/ca/stop_filter_ca.go | 5 ++++- analysis/lang/ca/stop_words_ca.go | 5 ++++- analysis/lang/cjk/analyzer_cjk.go | 5 ++++- analysis/lang/cjk/cjk_bigram.go | 5 ++++- analysis/lang/cjk/cjk_width.go | 5 ++++- analysis/lang/ckb/analyzer_ckb.go | 5 ++++- analysis/lang/ckb/sorani_normalize.go | 5 ++++- analysis/lang/ckb/sorani_stemmer_filter.go | 5 ++++- analysis/lang/ckb/stop_filter_ckb.go | 5 ++++- analysis/lang/ckb/stop_words_ckb.go | 5 ++++- analysis/lang/cs/stop_filter_cs.go | 5 ++++- analysis/lang/cs/stop_words_cs.go | 5 ++++- analysis/lang/da/analyzer_da.go | 5 ++++- analysis/lang/da/stemmer_da.go | 5 ++++- analysis/lang/da/stop_filter_da.go | 5 ++++- analysis/lang/da/stop_words_da.go | 5 ++++- analysis/lang/de/analyzer_de.go | 5 ++++- analysis/lang/de/german_normalize.go | 5 ++++- analysis/lang/de/light_stemmer_de.go | 5 ++++- analysis/lang/de/stemmer_de_snowball.go | 5 ++++- analysis/lang/de/stop_filter_de.go | 5 ++++- analysis/lang/de/stop_words_de.go | 5 ++++- analysis/lang/el/stop_filter_el.go | 5 ++++- analysis/lang/el/stop_words_el.go | 5 ++++- analysis/lang/en/analyzer_en.go | 5 ++++- analysis/lang/en/plural_stemmer.go | 5 ++++- analysis/lang/en/possessive_filter_en.go | 5 ++++- analysis/lang/en/stemmer_en_snowball.go | 5 ++++- analysis/lang/en/stop_filter_en.go | 5 ++++- analysis/lang/en/stop_words_en.go | 5 ++++- analysis/lang/es/analyzer_es.go | 5 ++++- analysis/lang/es/light_stemmer_es.go | 6 ++++-- analysis/lang/es/spanish_normalize.go | 5 ++++- analysis/lang/es/stemmer_es_snowball.go | 5 ++++- analysis/lang/es/stop_filter_es.go | 5 ++++- analysis/lang/es/stop_words_es.go | 5 ++++- analysis/lang/eu/stop_filter_eu.go | 5 ++++- analysis/lang/eu/stop_words_eu.go | 5 ++++- analysis/lang/fa/analyzer_fa.go | 5 ++++- analysis/lang/fa/persian_normalize.go | 5 ++++- analysis/lang/fa/stop_filter_fa.go | 5 ++++- analysis/lang/fa/stop_words_fa.go | 5 ++++- analysis/lang/fi/analyzer_fi.go | 5 ++++- analysis/lang/fi/stemmer_fi.go | 5 ++++- analysis/lang/fi/stop_filter_fi.go | 5 ++++- analysis/lang/fi/stop_words_fi.go | 5 ++++- analysis/lang/fr/analyzer_fr.go | 5 ++++- analysis/lang/fr/articles_fr.go | 5 ++++- analysis/lang/fr/elision_fr.go | 5 ++++- analysis/lang/fr/light_stemmer_fr.go | 5 ++++- analysis/lang/fr/minimal_stemmer_fr.go | 5 ++++- analysis/lang/fr/stemmer_fr_snowball.go | 5 ++++- analysis/lang/fr/stop_filter_fr.go | 5 ++++- analysis/lang/fr/stop_words_fr.go | 5 ++++- analysis/lang/ga/articles_ga.go | 5 ++++- analysis/lang/ga/elision_ga.go | 5 ++++- analysis/lang/ga/stop_filter_ga.go | 5 ++++- analysis/lang/ga/stop_words_ga.go | 5 ++++- analysis/lang/gl/stop_filter_gl.go | 5 ++++- analysis/lang/gl/stop_words_gl.go | 5 ++++- analysis/lang/hi/analyzer_hi.go | 5 ++++- analysis/lang/hi/hindi_normalize.go | 5 ++++- analysis/lang/hi/hindi_stemmer_filter.go | 5 ++++- analysis/lang/hi/stop_filter_hi.go | 5 ++++- analysis/lang/hi/stop_words_hi.go | 5 ++++- analysis/lang/hr/analyzer_hr.go | 5 ++++- analysis/lang/hr/stemmer_hr.go | 5 ++++- analysis/lang/hr/stop_filter_hr.go | 5 ++++- analysis/lang/hr/stop_words_hr.go | 5 ++++- analysis/lang/hr/suffix_transformation_hr.go | 5 ++++- analysis/lang/hu/analyzer_hu.go | 5 ++++- analysis/lang/hu/stemmer_hu.go | 5 ++++- analysis/lang/hu/stop_filter_hu.go | 5 ++++- analysis/lang/hu/stop_words_hu.go | 5 ++++- analysis/lang/hy/stop_filter_hy.go | 5 ++++- analysis/lang/hy/stop_words_hy.go | 5 ++++- analysis/lang/id/stop_filter_id.go | 5 ++++- analysis/lang/id/stop_words_id.go | 5 ++++- analysis/lang/in/indic_normalize.go | 5 ++++- analysis/lang/it/analyzer_it.go | 5 ++++- analysis/lang/it/articles_it.go | 5 ++++- analysis/lang/it/elision_it.go | 5 ++++- analysis/lang/it/light_stemmer_it.go | 5 ++++- analysis/lang/it/stemmer_it_snowball.go | 5 ++++- analysis/lang/it/stop_filter_it.go | 5 ++++- analysis/lang/it/stop_words_it.go | 5 ++++- analysis/lang/nl/analyzer_nl.go | 5 ++++- analysis/lang/nl/stemmer_nl.go | 5 ++++- analysis/lang/nl/stop_filter_nl.go | 5 ++++- analysis/lang/nl/stop_words_nl.go | 5 ++++- analysis/lang/no/analyzer_no.go | 5 ++++- analysis/lang/no/stemmer_no.go | 5 ++++- analysis/lang/no/stop_filter_no.go | 5 ++++- analysis/lang/no/stop_words_no.go | 5 ++++- analysis/lang/pl/analyzer_pl.go | 5 ++++- analysis/lang/pl/stemmer_pl.go | 5 ++++- analysis/lang/pl/stop_filter_pl.go | 5 ++++- analysis/lang/pl/stop_words_pl.go | 5 ++++- analysis/lang/pt/analyzer_pt.go | 5 ++++- analysis/lang/pt/light_stemmer_pt.go | 5 ++++- analysis/lang/pt/stop_filter_pt.go | 5 ++++- analysis/lang/pt/stop_words_pt.go | 5 ++++- analysis/lang/ro/analyzer_ro.go | 5 ++++- analysis/lang/ro/stemmer_ro.go | 5 ++++- analysis/lang/ro/stop_filter_ro.go | 5 ++++- analysis/lang/ro/stop_words_ro.go | 5 ++++- analysis/lang/ru/analyzer_ru.go | 5 ++++- analysis/lang/ru/stemmer_ru.go | 5 ++++- analysis/lang/ru/stop_filter_ru.go | 5 ++++- analysis/lang/ru/stop_words_ru.go | 5 ++++- analysis/lang/sv/analyzer_sv.go | 5 ++++- analysis/lang/sv/stemmer_sv.go | 5 ++++- analysis/lang/sv/stop_filter_sv.go | 5 ++++- analysis/lang/sv/stop_words_sv.go | 5 ++++- analysis/lang/tr/analyzer_tr.go | 5 ++++- analysis/lang/tr/stemmer_tr.go | 5 ++++- analysis/lang/tr/stop_filter_tr.go | 5 ++++- analysis/lang/tr/stop_words_tr.go | 5 ++++- analysis/token/apostrophe/apostrophe.go | 5 ++++- analysis/token/camelcase/camelcase.go | 5 ++++- analysis/token/compound/dict.go | 5 ++++- analysis/token/edgengram/edgengram.go | 5 ++++- analysis/token/elision/elision.go | 5 ++++- analysis/token/hierarchy/hierarchy.go | 5 ++++- analysis/token/keyword/keyword.go | 5 ++++- analysis/token/length/length.go | 5 ++++- analysis/token/lowercase/lowercase.go | 5 ++++- analysis/token/ngram/ngram.go | 5 ++++- analysis/token/porter/porter.go | 5 ++++- analysis/token/reverse/reverse.go | 5 ++++- analysis/token/shingle/shingle.go | 5 ++++- analysis/token/snowball/snowball.go | 5 ++++- analysis/token/stop/stop.go | 5 ++++- analysis/token/truncate/truncate.go | 5 ++++- analysis/token/unicodenorm/unicodenorm.go | 5 ++++- analysis/token/unique/unique.go | 5 ++++- analysis/tokenizer/exception/exception.go | 5 ++++- analysis/tokenizer/letter/letter.go | 5 ++++- analysis/tokenizer/regexp/regexp.go | 5 ++++- analysis/tokenizer/single/single.go | 5 ++++- analysis/tokenizer/unicode/unicode.go | 5 ++++- analysis/tokenizer/web/web.go | 5 ++++- analysis/tokenizer/whitespace/whitespace.go | 5 ++++- analysis/tokenmap/custom.go | 5 ++++- index/scorch/scorch.go | 5 ++++- index/upsidedown/store/boltdb/store.go | 5 ++++- index/upsidedown/store/goleveldb/store.go | 5 ++++- index/upsidedown/store/gtreap/store.go | 7 +++++-- index/upsidedown/store/metrics/store.go | 5 ++++- index/upsidedown/store/moss/store.go | 5 ++++- index/upsidedown/store/null/null.go | 5 ++++- index/upsidedown/upsidedown.go | 5 ++++- mapping/synonym.go | 5 ++++- registry/analyzer.go | 5 +++-- registry/char_filter.go | 5 +++-- registry/datetime_parser.go | 5 +++-- registry/fragment_formatter.go | 5 +++-- registry/fragmenter.go | 5 +++-- registry/highlighter.go | 5 +++-- registry/index_type.go | 7 ++++--- registry/store.go | 7 ++++--- registry/synonym_source.go | 5 +++-- registry/token_filter.go | 5 +++-- registry/token_maps.go | 5 +++-- registry/tokenizer.go | 5 +++-- search/highlight/format/ansi/ansi.go | 5 ++++- search/highlight/format/html/html.go | 5 ++++- search/highlight/format/plain/plain.go | 5 ++++- search/highlight/fragmenter/simple/simple.go | 5 ++++- search/highlight/highlighter/ansi/ansi.go | 5 ++++- search/highlight/highlighter/html/html.go | 5 ++++- search/highlight/highlighter/simple/highlighter_simple.go | 6 +++++- 199 files changed, 788 insertions(+), 215 deletions(-) diff --git a/analysis/analyzer/custom/custom.go b/analysis/analyzer/custom/custom.go index 5e28c95a5..5df940e5e 100644 --- a/analysis/analyzer/custom/custom.go +++ b/analysis/analyzer/custom/custom.go @@ -101,7 +101,10 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(Name, AnalyzerConstructor) + err := registry.RegisterAnalyzer(Name, AnalyzerConstructor) + if err != nil { + panic(err) + } } func getCharFilters(charFilterNames []string, cache *registry.Cache) ([]analysis.CharFilter, error) { diff --git a/analysis/analyzer/keyword/keyword.go b/analysis/analyzer/keyword/keyword.go index 6bb56d6f7..6eb052eb8 100644 --- a/analysis/analyzer/keyword/keyword.go +++ b/analysis/analyzer/keyword/keyword.go @@ -34,5 +34,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(Name, AnalyzerConstructor) + err := registry.RegisterAnalyzer(Name, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/analyzer/simple/simple.go b/analysis/analyzer/simple/simple.go index 6954e5d53..2a9834bad 100644 --- a/analysis/analyzer/simple/simple.go +++ b/analysis/analyzer/simple/simple.go @@ -42,5 +42,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(Name, AnalyzerConstructor) + err := registry.RegisterAnalyzer(Name, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/analyzer/standard/standard.go b/analysis/analyzer/standard/standard.go index 96387bd79..fa752be57 100644 --- a/analysis/analyzer/standard/standard.go +++ b/analysis/analyzer/standard/standard.go @@ -48,5 +48,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(Name, AnalyzerConstructor) + err := registry.RegisterAnalyzer(Name, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/analyzer/web/web.go b/analysis/analyzer/web/web.go index 1dea34051..778586e26 100644 --- a/analysis/analyzer/web/web.go +++ b/analysis/analyzer/web/web.go @@ -48,5 +48,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(Name, AnalyzerConstructor) + err := registry.RegisterAnalyzer(Name, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/char/asciifolding/asciifolding.go b/analysis/char/asciifolding/asciifolding.go index 4b422aed8..eaf31a13a 100644 --- a/analysis/char/asciifolding/asciifolding.go +++ b/analysis/char/asciifolding/asciifolding.go @@ -50,7 +50,10 @@ func AsciiFoldingFilterConstructor(config map[string]interface{}, cache *registr } func init() { - registry.RegisterCharFilter(Name, AsciiFoldingFilterConstructor) + err := registry.RegisterCharFilter(Name, AsciiFoldingFilterConstructor) + if err != nil { + panic(err) + } } // Converts characters above ASCII to their ASCII equivalents. diff --git a/analysis/char/html/html.go b/analysis/char/html/html.go index 4cf2c630a..d939fdb07 100644 --- a/analysis/char/html/html.go +++ b/analysis/char/html/html.go @@ -50,5 +50,8 @@ func CharFilterConstructor(config map[string]interface{}, cache *registry.Cache) } func init() { - registry.RegisterCharFilter(Name, CharFilterConstructor) + err := registry.RegisterCharFilter(Name, CharFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/char/regexp/regexp.go b/analysis/char/regexp/regexp.go index b645322d5..a94236af9 100644 --- a/analysis/char/regexp/regexp.go +++ b/analysis/char/regexp/regexp.go @@ -58,5 +58,8 @@ func CharFilterConstructor(config map[string]interface{}, cache *registry.Cache) } func init() { - registry.RegisterCharFilter(Name, CharFilterConstructor) + err := registry.RegisterCharFilter(Name, CharFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/char/zerowidthnonjoiner/zerowidthnonjoiner.go b/analysis/char/zerowidthnonjoiner/zerowidthnonjoiner.go index 991f90918..0a39fa6b5 100644 --- a/analysis/char/zerowidthnonjoiner/zerowidthnonjoiner.go +++ b/analysis/char/zerowidthnonjoiner/zerowidthnonjoiner.go @@ -32,5 +32,8 @@ func CharFilterConstructor(config map[string]interface{}, cache *registry.Cache) } func init() { - registry.RegisterCharFilter(Name, CharFilterConstructor) + err := registry.RegisterCharFilter(Name, CharFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/datetime/flexible/flexible.go b/analysis/datetime/flexible/flexible.go index cb5f234d5..36cc9e809 100644 --- a/analysis/datetime/flexible/flexible.go +++ b/analysis/datetime/flexible/flexible.go @@ -60,5 +60,8 @@ func DateTimeParserConstructor(config map[string]interface{}, cache *registry.Ca } func init() { - registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + err := registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/datetime/iso/iso.go b/analysis/datetime/iso/iso.go index cd75b1036..721829c4e 100644 --- a/analysis/datetime/iso/iso.go +++ b/analysis/datetime/iso/iso.go @@ -239,5 +239,8 @@ func DateTimeParserConstructor(config map[string]interface{}, cache *registry.Ca } func init() { - registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + err := registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/datetime/optional/optional.go b/analysis/datetime/optional/optional.go index 6dc7bfbcc..db30049df 100644 --- a/analysis/datetime/optional/optional.go +++ b/analysis/datetime/optional/optional.go @@ -43,5 +43,8 @@ func DateTimeParserConstructor(config map[string]interface{}, cache *registry.Ca } func init() { - registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + err := registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/datetime/percent/percent.go b/analysis/datetime/percent/percent.go index 7e8202f2b..6a2c2eb13 100644 --- a/analysis/datetime/percent/percent.go +++ b/analysis/datetime/percent/percent.go @@ -163,5 +163,8 @@ func DateTimeParserConstructor(config map[string]interface{}, cache *registry.Ca } func init() { - registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + err := registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/datetime/sanitized/sanitized.go b/analysis/datetime/sanitized/sanitized.go index 09eb94d1d..87ad6c7a0 100644 --- a/analysis/datetime/sanitized/sanitized.go +++ b/analysis/datetime/sanitized/sanitized.go @@ -123,5 +123,8 @@ func DateTimeParserConstructor(config map[string]interface{}, cache *registry.Ca } func init() { - registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + err := registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/datetime/timestamp/microseconds/microseconds.go b/analysis/datetime/timestamp/microseconds/microseconds.go index a0e2c9495..88cde758f 100644 --- a/analysis/datetime/timestamp/microseconds/microseconds.go +++ b/analysis/datetime/timestamp/microseconds/microseconds.go @@ -48,5 +48,8 @@ func DateTimeParserConstructor(config map[string]interface{}, cache *registry.Ca } func init() { - registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + err := registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/datetime/timestamp/milliseconds/milliseconds.go b/analysis/datetime/timestamp/milliseconds/milliseconds.go index 63826b451..645c525de 100644 --- a/analysis/datetime/timestamp/milliseconds/milliseconds.go +++ b/analysis/datetime/timestamp/milliseconds/milliseconds.go @@ -48,5 +48,8 @@ func DateTimeParserConstructor(config map[string]interface{}, cache *registry.Ca } func init() { - registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + err := registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/datetime/timestamp/nanoseconds/nanoseconds.go b/analysis/datetime/timestamp/nanoseconds/nanoseconds.go index 8bb1ab1b6..f50eac1aa 100644 --- a/analysis/datetime/timestamp/nanoseconds/nanoseconds.go +++ b/analysis/datetime/timestamp/nanoseconds/nanoseconds.go @@ -48,5 +48,8 @@ func DateTimeParserConstructor(config map[string]interface{}, cache *registry.Ca } func init() { - registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + err := registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/datetime/timestamp/seconds/seconds.go b/analysis/datetime/timestamp/seconds/seconds.go index 58e947c80..10219c9fd 100644 --- a/analysis/datetime/timestamp/seconds/seconds.go +++ b/analysis/datetime/timestamp/seconds/seconds.go @@ -48,5 +48,8 @@ func DateTimeParserConstructor(config map[string]interface{}, cache *registry.Ca } func init() { - registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + err := registry.RegisterDateTimeParser(Name, DateTimeParserConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ar/analyzer_ar.go b/analysis/lang/ar/analyzer_ar.go index e15cd2533..f6bb36bea 100644 --- a/analysis/lang/ar/analyzer_ar.go +++ b/analysis/lang/ar/analyzer_ar.go @@ -61,5 +61,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ar/arabic_normalize.go b/analysis/lang/ar/arabic_normalize.go index 8fdb89904..d737c1433 100644 --- a/analysis/lang/ar/arabic_normalize.go +++ b/analysis/lang/ar/arabic_normalize.go @@ -81,5 +81,8 @@ func NormalizerFilterConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + err := registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ar/stemmer_ar.go b/analysis/lang/ar/stemmer_ar.go index d4540e1dd..0b9f96ff6 100644 --- a/analysis/lang/ar/stemmer_ar.go +++ b/analysis/lang/ar/stemmer_ar.go @@ -114,5 +114,8 @@ func StemmerFilterConstructor(config map[string]interface{}, cache *registry.Cac } func init() { - registry.RegisterTokenFilter(StemmerName, StemmerFilterConstructor) + err := registry.RegisterTokenFilter(StemmerName, StemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ar/stop_filter_ar.go b/analysis/lang/ar/stop_filter_ar.go index d8af36022..2c548f46c 100644 --- a/analysis/lang/ar/stop_filter_ar.go +++ b/analysis/lang/ar/stop_filter_ar.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ar/stop_words_ar.go b/analysis/lang/ar/stop_words_ar.go index 2d1bd56d6..8f23282db 100644 --- a/analysis/lang/ar/stop_words_ar.go +++ b/analysis/lang/ar/stop_words_ar.go @@ -145,5 +145,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/bg/stop_filter_bg.go b/analysis/lang/bg/stop_filter_bg.go index 97bbabe14..cd4eabf63 100644 --- a/analysis/lang/bg/stop_filter_bg.go +++ b/analysis/lang/bg/stop_filter_bg.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/bg/stop_words_bg.go b/analysis/lang/bg/stop_words_bg.go index 0bddc22ce..fde5143c8 100644 --- a/analysis/lang/bg/stop_words_bg.go +++ b/analysis/lang/bg/stop_words_bg.go @@ -213,5 +213,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ca/articles_ca.go b/analysis/lang/ca/articles_ca.go index 09308f39f..51967e7af 100644 --- a/analysis/lang/ca/articles_ca.go +++ b/analysis/lang/ca/articles_ca.go @@ -26,5 +26,8 @@ func ArticlesTokenMapConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenMap(ArticlesName, ArticlesTokenMapConstructor) + err := registry.RegisterTokenMap(ArticlesName, ArticlesTokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ca/elision_ca.go b/analysis/lang/ca/elision_ca.go index 46ee3c622..5c83e376c 100644 --- a/analysis/lang/ca/elision_ca.go +++ b/analysis/lang/ca/elision_ca.go @@ -33,5 +33,8 @@ func ElisionFilterConstructor(config map[string]interface{}, cache *registry.Cac } func init() { - registry.RegisterTokenFilter(ElisionName, ElisionFilterConstructor) + err := registry.RegisterTokenFilter(ElisionName, ElisionFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ca/stop_filter_ca.go b/analysis/lang/ca/stop_filter_ca.go index 2864a4267..1597bfb76 100644 --- a/analysis/lang/ca/stop_filter_ca.go +++ b/analysis/lang/ca/stop_filter_ca.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ca/stop_words_ca.go b/analysis/lang/ca/stop_words_ca.go index 93621df1f..bfa1be732 100644 --- a/analysis/lang/ca/stop_words_ca.go +++ b/analysis/lang/ca/stop_words_ca.go @@ -240,5 +240,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/cjk/analyzer_cjk.go b/analysis/lang/cjk/analyzer_cjk.go index 7e932ce55..ed9d87bfe 100644 --- a/analysis/lang/cjk/analyzer_cjk.go +++ b/analysis/lang/cjk/analyzer_cjk.go @@ -53,5 +53,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/cjk/cjk_bigram.go b/analysis/lang/cjk/cjk_bigram.go index 14fe6594d..a3fab0ade 100644 --- a/analysis/lang/cjk/cjk_bigram.go +++ b/analysis/lang/cjk/cjk_bigram.go @@ -199,5 +199,8 @@ func CJKBigramFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(BigramName, CJKBigramFilterConstructor) + err := registry.RegisterTokenFilter(BigramName, CJKBigramFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/cjk/cjk_width.go b/analysis/lang/cjk/cjk_width.go index d5b15e74c..a9d6171d8 100644 --- a/analysis/lang/cjk/cjk_width.go +++ b/analysis/lang/cjk/cjk_width.go @@ -97,5 +97,8 @@ func CJKWidthFilterConstructor(config map[string]interface{}, cache *registry.Ca } func init() { - registry.RegisterTokenFilter(WidthName, CJKWidthFilterConstructor) + err := registry.RegisterTokenFilter(WidthName, CJKWidthFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ckb/analyzer_ckb.go b/analysis/lang/ckb/analyzer_ckb.go index 9b9532d23..2b44b57cd 100644 --- a/analysis/lang/ckb/analyzer_ckb.go +++ b/analysis/lang/ckb/analyzer_ckb.go @@ -57,5 +57,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ckb/sorani_normalize.go b/analysis/lang/ckb/sorani_normalize.go index a1d6d7378..fade3f516 100644 --- a/analysis/lang/ckb/sorani_normalize.go +++ b/analysis/lang/ckb/sorani_normalize.go @@ -114,5 +114,8 @@ func NormalizerFilterConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + err := registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ckb/sorani_stemmer_filter.go b/analysis/lang/ckb/sorani_stemmer_filter.go index c96b0a1b3..533c4bad7 100644 --- a/analysis/lang/ckb/sorani_stemmer_filter.go +++ b/analysis/lang/ckb/sorani_stemmer_filter.go @@ -144,5 +144,8 @@ func StemmerFilterConstructor(config map[string]interface{}, cache *registry.Cac } func init() { - registry.RegisterTokenFilter(StemmerName, StemmerFilterConstructor) + err := registry.RegisterTokenFilter(StemmerName, StemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ckb/stop_filter_ckb.go b/analysis/lang/ckb/stop_filter_ckb.go index 7584935db..ed4ec8d0b 100644 --- a/analysis/lang/ckb/stop_filter_ckb.go +++ b/analysis/lang/ckb/stop_filter_ckb.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ckb/stop_words_ckb.go b/analysis/lang/ckb/stop_words_ckb.go index e82b6a586..87b9e81ba 100644 --- a/analysis/lang/ckb/stop_words_ckb.go +++ b/analysis/lang/ckb/stop_words_ckb.go @@ -156,5 +156,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/cs/stop_filter_cs.go b/analysis/lang/cs/stop_filter_cs.go index b63b7a040..52f1e93bc 100644 --- a/analysis/lang/cs/stop_filter_cs.go +++ b/analysis/lang/cs/stop_filter_cs.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/cs/stop_words_cs.go b/analysis/lang/cs/stop_words_cs.go index ad8ce9099..5c3143e42 100644 --- a/analysis/lang/cs/stop_words_cs.go +++ b/analysis/lang/cs/stop_words_cs.go @@ -192,5 +192,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/da/analyzer_da.go b/analysis/lang/da/analyzer_da.go index f286fbc4c..8bfd55437 100644 --- a/analysis/lang/da/analyzer_da.go +++ b/analysis/lang/da/analyzer_da.go @@ -52,5 +52,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/da/stemmer_da.go b/analysis/lang/da/stemmer_da.go index ce09f33b7..c53aa21d3 100644 --- a/analysis/lang/da/stemmer_da.go +++ b/analysis/lang/da/stemmer_da.go @@ -45,5 +45,8 @@ func DanishStemmerFilterConstructor(config map[string]interface{}, cache *regist } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, DanishStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, DanishStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/da/stop_filter_da.go b/analysis/lang/da/stop_filter_da.go index e315491af..6dd0e5c85 100644 --- a/analysis/lang/da/stop_filter_da.go +++ b/analysis/lang/da/stop_filter_da.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/da/stop_words_da.go b/analysis/lang/da/stop_words_da.go index 39c5f6a03..caaabf70d 100644 --- a/analysis/lang/da/stop_words_da.go +++ b/analysis/lang/da/stop_words_da.go @@ -130,5 +130,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/de/analyzer_de.go b/analysis/lang/de/analyzer_de.go index 34ded33d5..533026691 100644 --- a/analysis/lang/de/analyzer_de.go +++ b/analysis/lang/de/analyzer_de.go @@ -57,5 +57,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/de/german_normalize.go b/analysis/lang/de/german_normalize.go index 84688f137..a288255f5 100644 --- a/analysis/lang/de/german_normalize.go +++ b/analysis/lang/de/german_normalize.go @@ -91,5 +91,8 @@ func NormalizerFilterConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + err := registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/de/light_stemmer_de.go b/analysis/lang/de/light_stemmer_de.go index 48bcf274d..d263de65c 100644 --- a/analysis/lang/de/light_stemmer_de.go +++ b/analysis/lang/de/light_stemmer_de.go @@ -112,5 +112,8 @@ func GermanLightStemmerFilterConstructor(config map[string]interface{}, cache *r } func init() { - registry.RegisterTokenFilter(LightStemmerName, GermanLightStemmerFilterConstructor) + err := registry.RegisterTokenFilter(LightStemmerName, GermanLightStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/de/stemmer_de_snowball.go b/analysis/lang/de/stemmer_de_snowball.go index 35afdd96b..aa61712c6 100644 --- a/analysis/lang/de/stemmer_de_snowball.go +++ b/analysis/lang/de/stemmer_de_snowball.go @@ -45,5 +45,8 @@ func GermanStemmerFilterConstructor(config map[string]interface{}, cache *regist } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, GermanStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, GermanStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/de/stop_filter_de.go b/analysis/lang/de/stop_filter_de.go index b97d1a185..235f510aa 100644 --- a/analysis/lang/de/stop_filter_de.go +++ b/analysis/lang/de/stop_filter_de.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/de/stop_words_de.go b/analysis/lang/de/stop_words_de.go index 83ea0b557..d72065724 100644 --- a/analysis/lang/de/stop_words_de.go +++ b/analysis/lang/de/stop_words_de.go @@ -314,5 +314,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/el/stop_filter_el.go b/analysis/lang/el/stop_filter_el.go index 17bfd9f27..7b55bf6eb 100644 --- a/analysis/lang/el/stop_filter_el.go +++ b/analysis/lang/el/stop_filter_el.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/el/stop_words_el.go b/analysis/lang/el/stop_words_el.go index 1e8455631..1d2efcb0d 100644 --- a/analysis/lang/el/stop_words_el.go +++ b/analysis/lang/el/stop_words_el.go @@ -98,5 +98,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/en/analyzer_en.go b/analysis/lang/en/analyzer_en.go index 44a8d4c21..b9b53a8fc 100644 --- a/analysis/lang/en/analyzer_en.go +++ b/analysis/lang/en/analyzer_en.go @@ -66,5 +66,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/en/plural_stemmer.go b/analysis/lang/en/plural_stemmer.go index 0de7c1bbf..7aebdc8fa 100644 --- a/analysis/lang/en/plural_stemmer.go +++ b/analysis/lang/en/plural_stemmer.go @@ -63,7 +63,10 @@ func EnglishPluralStemmerFilterConstructor(config map[string]interface{}, cache } func init() { - registry.RegisterTokenFilter(PluralStemmerName, EnglishPluralStemmerFilterConstructor) + err := registry.RegisterTokenFilter(PluralStemmerName, EnglishPluralStemmerFilterConstructor) + if err != nil { + panic(err) + } } // ---------------------------------------------------------------------------- diff --git a/analysis/lang/en/possessive_filter_en.go b/analysis/lang/en/possessive_filter_en.go index 79c2489e2..42d51f0c9 100644 --- a/analysis/lang/en/possessive_filter_en.go +++ b/analysis/lang/en/possessive_filter_en.go @@ -63,5 +63,8 @@ func PossessiveFilterConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenFilter(PossessiveName, PossessiveFilterConstructor) + err := registry.RegisterTokenFilter(PossessiveName, PossessiveFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/en/stemmer_en_snowball.go b/analysis/lang/en/stemmer_en_snowball.go index ab30b8b19..568a2b6a5 100644 --- a/analysis/lang/en/stemmer_en_snowball.go +++ b/analysis/lang/en/stemmer_en_snowball.go @@ -45,5 +45,8 @@ func EnglishStemmerFilterConstructor(config map[string]interface{}, cache *regis } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, EnglishStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, EnglishStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/en/stop_filter_en.go b/analysis/lang/en/stop_filter_en.go index a3f91d226..0015ad603 100644 --- a/analysis/lang/en/stop_filter_en.go +++ b/analysis/lang/en/stop_filter_en.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/en/stop_words_en.go b/analysis/lang/en/stop_words_en.go index 9b6ca86a7..d6ff496fa 100644 --- a/analysis/lang/en/stop_words_en.go +++ b/analysis/lang/en/stop_words_en.go @@ -340,5 +340,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/es/analyzer_es.go b/analysis/lang/es/analyzer_es.go index eea75568d..eb4bca353 100644 --- a/analysis/lang/es/analyzer_es.go +++ b/analysis/lang/es/analyzer_es.go @@ -59,5 +59,8 @@ func AnalyzerConstructor(config map[string]interface{}, } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/es/light_stemmer_es.go b/analysis/lang/es/light_stemmer_es.go index 4be04a4bd..22ed97fdd 100644 --- a/analysis/lang/es/light_stemmer_es.go +++ b/analysis/lang/es/light_stemmer_es.go @@ -71,6 +71,8 @@ func SpanishLightStemmerFilterConstructor(config map[string]interface{}, } func init() { - registry.RegisterTokenFilter(LightStemmerName, - SpanishLightStemmerFilterConstructor) + err := registry.RegisterTokenFilter(LightStemmerName, SpanishLightStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/es/spanish_normalize.go b/analysis/lang/es/spanish_normalize.go index a6f1964ad..8ed42a0a7 100644 --- a/analysis/lang/es/spanish_normalize.go +++ b/analysis/lang/es/spanish_normalize.go @@ -63,5 +63,8 @@ func NormalizerFilterConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + err := registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/es/stemmer_es_snowball.go b/analysis/lang/es/stemmer_es_snowball.go index 883392856..d09a11b58 100644 --- a/analysis/lang/es/stemmer_es_snowball.go +++ b/analysis/lang/es/stemmer_es_snowball.go @@ -45,5 +45,8 @@ func SpanishStemmerFilterConstructor(config map[string]interface{}, cache *regis } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, SpanishStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, SpanishStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/es/stop_filter_es.go b/analysis/lang/es/stop_filter_es.go index 4cb79f870..f0a6d2098 100644 --- a/analysis/lang/es/stop_filter_es.go +++ b/analysis/lang/es/stop_filter_es.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/es/stop_words_es.go b/analysis/lang/es/stop_words_es.go index 0f1e51d93..4c2105bb9 100644 --- a/analysis/lang/es/stop_words_es.go +++ b/analysis/lang/es/stop_words_es.go @@ -376,5 +376,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/eu/stop_filter_eu.go b/analysis/lang/eu/stop_filter_eu.go index 03eb549b2..12d5150c2 100644 --- a/analysis/lang/eu/stop_filter_eu.go +++ b/analysis/lang/eu/stop_filter_eu.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/eu/stop_words_eu.go b/analysis/lang/eu/stop_words_eu.go index 7a24efc9b..372914c51 100644 --- a/analysis/lang/eu/stop_words_eu.go +++ b/analysis/lang/eu/stop_words_eu.go @@ -119,5 +119,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fa/analyzer_fa.go b/analysis/lang/fa/analyzer_fa.go index 104ac6dff..da2cb2887 100644 --- a/analysis/lang/fa/analyzer_fa.go +++ b/analysis/lang/fa/analyzer_fa.go @@ -67,5 +67,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fa/persian_normalize.go b/analysis/lang/fa/persian_normalize.go index 437bd435f..7d73dedce 100644 --- a/analysis/lang/fa/persian_normalize.go +++ b/analysis/lang/fa/persian_normalize.go @@ -73,5 +73,8 @@ func NormalizerFilterConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + err := registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fa/stop_filter_fa.go b/analysis/lang/fa/stop_filter_fa.go index 0277a56a2..bcc237b22 100644 --- a/analysis/lang/fa/stop_filter_fa.go +++ b/analysis/lang/fa/stop_filter_fa.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fa/stop_words_fa.go b/analysis/lang/fa/stop_words_fa.go index 624fd5271..41830044e 100644 --- a/analysis/lang/fa/stop_words_fa.go +++ b/analysis/lang/fa/stop_words_fa.go @@ -333,5 +333,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fi/analyzer_fi.go b/analysis/lang/fi/analyzer_fi.go index c68cc2c1b..b2d8f1dcf 100644 --- a/analysis/lang/fi/analyzer_fi.go +++ b/analysis/lang/fi/analyzer_fi.go @@ -53,5 +53,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fi/stemmer_fi.go b/analysis/lang/fi/stemmer_fi.go index 44d39020d..9b956c74d 100644 --- a/analysis/lang/fi/stemmer_fi.go +++ b/analysis/lang/fi/stemmer_fi.go @@ -45,5 +45,8 @@ func FinnishStemmerFilterConstructor(config map[string]interface{}, cache *regis } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, FinnishStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, FinnishStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fi/stop_filter_fi.go b/analysis/lang/fi/stop_filter_fi.go index 0445d6942..55e463baa 100644 --- a/analysis/lang/fi/stop_filter_fi.go +++ b/analysis/lang/fi/stop_filter_fi.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fi/stop_words_fi.go b/analysis/lang/fi/stop_words_fi.go index 93824f4e2..e7fabf9b6 100644 --- a/analysis/lang/fi/stop_words_fi.go +++ b/analysis/lang/fi/stop_words_fi.go @@ -117,5 +117,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fr/analyzer_fr.go b/analysis/lang/fr/analyzer_fr.go index 6f773a1b1..0808da081 100644 --- a/analysis/lang/fr/analyzer_fr.go +++ b/analysis/lang/fr/analyzer_fr.go @@ -58,5 +58,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fr/articles_fr.go b/analysis/lang/fr/articles_fr.go index 405729b81..540ab9114 100644 --- a/analysis/lang/fr/articles_fr.go +++ b/analysis/lang/fr/articles_fr.go @@ -33,5 +33,8 @@ func ArticlesTokenMapConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenMap(ArticlesName, ArticlesTokenMapConstructor) + err := registry.RegisterTokenMap(ArticlesName, ArticlesTokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fr/elision_fr.go b/analysis/lang/fr/elision_fr.go index 739e2361f..7bd3ac942 100644 --- a/analysis/lang/fr/elision_fr.go +++ b/analysis/lang/fr/elision_fr.go @@ -33,5 +33,8 @@ func ElisionFilterConstructor(config map[string]interface{}, cache *registry.Cac } func init() { - registry.RegisterTokenFilter(ElisionName, ElisionFilterConstructor) + err := registry.RegisterTokenFilter(ElisionName, ElisionFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fr/light_stemmer_fr.go b/analysis/lang/fr/light_stemmer_fr.go index d0e407641..74f9200d2 100644 --- a/analysis/lang/fr/light_stemmer_fr.go +++ b/analysis/lang/fr/light_stemmer_fr.go @@ -302,5 +302,8 @@ func FrenchLightStemmerFilterConstructor(config map[string]interface{}, cache *r } func init() { - registry.RegisterTokenFilter(LightStemmerName, FrenchLightStemmerFilterConstructor) + err := registry.RegisterTokenFilter(LightStemmerName, FrenchLightStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fr/minimal_stemmer_fr.go b/analysis/lang/fr/minimal_stemmer_fr.go index 93d954bf7..ac6bb476c 100644 --- a/analysis/lang/fr/minimal_stemmer_fr.go +++ b/analysis/lang/fr/minimal_stemmer_fr.go @@ -75,5 +75,8 @@ func FrenchMinimalStemmerFilterConstructor(config map[string]interface{}, cache } func init() { - registry.RegisterTokenFilter(MinimalStemmerName, FrenchMinimalStemmerFilterConstructor) + err := registry.RegisterTokenFilter(MinimalStemmerName, FrenchMinimalStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fr/stemmer_fr_snowball.go b/analysis/lang/fr/stemmer_fr_snowball.go index 275d66e96..5b542a3d1 100644 --- a/analysis/lang/fr/stemmer_fr_snowball.go +++ b/analysis/lang/fr/stemmer_fr_snowball.go @@ -45,5 +45,8 @@ func FrenchStemmerFilterConstructor(config map[string]interface{}, cache *regist } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, FrenchStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, FrenchStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fr/stop_filter_fr.go b/analysis/lang/fr/stop_filter_fr.go index ac7abb10e..e2d4612ce 100644 --- a/analysis/lang/fr/stop_filter_fr.go +++ b/analysis/lang/fr/stop_filter_fr.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/fr/stop_words_fr.go b/analysis/lang/fr/stop_words_fr.go index c59757586..6a767d68d 100644 --- a/analysis/lang/fr/stop_words_fr.go +++ b/analysis/lang/fr/stop_words_fr.go @@ -206,5 +206,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ga/articles_ga.go b/analysis/lang/ga/articles_ga.go index 4b859a563..2ccaa3611 100644 --- a/analysis/lang/ga/articles_ga.go +++ b/analysis/lang/ga/articles_ga.go @@ -23,5 +23,8 @@ func ArticlesTokenMapConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenMap(ArticlesName, ArticlesTokenMapConstructor) + err := registry.RegisterTokenMap(ArticlesName, ArticlesTokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ga/elision_ga.go b/analysis/lang/ga/elision_ga.go index 30310014a..988ec50a0 100644 --- a/analysis/lang/ga/elision_ga.go +++ b/analysis/lang/ga/elision_ga.go @@ -33,5 +33,8 @@ func ElisionFilterConstructor(config map[string]interface{}, cache *registry.Cac } func init() { - registry.RegisterTokenFilter(ElisionName, ElisionFilterConstructor) + err := registry.RegisterTokenFilter(ElisionName, ElisionFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ga/stop_filter_ga.go b/analysis/lang/ga/stop_filter_ga.go index d58f55b53..9c34924f9 100644 --- a/analysis/lang/ga/stop_filter_ga.go +++ b/analysis/lang/ga/stop_filter_ga.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ga/stop_words_ga.go b/analysis/lang/ga/stop_words_ga.go index a3fc7ac4c..e49e671dc 100644 --- a/analysis/lang/ga/stop_words_ga.go +++ b/analysis/lang/ga/stop_words_ga.go @@ -130,5 +130,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/gl/stop_filter_gl.go b/analysis/lang/gl/stop_filter_gl.go index 753463df4..5c93816a7 100644 --- a/analysis/lang/gl/stop_filter_gl.go +++ b/analysis/lang/gl/stop_filter_gl.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/gl/stop_words_gl.go b/analysis/lang/gl/stop_words_gl.go index 0d1fb5a0c..766c5ecce 100644 --- a/analysis/lang/gl/stop_words_gl.go +++ b/analysis/lang/gl/stop_words_gl.go @@ -181,5 +181,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hi/analyzer_hi.go b/analysis/lang/hi/analyzer_hi.go index 8d4f62323..4d22cf041 100644 --- a/analysis/lang/hi/analyzer_hi.go +++ b/analysis/lang/hi/analyzer_hi.go @@ -64,5 +64,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hi/hindi_normalize.go b/analysis/lang/hi/hindi_normalize.go index 182c6a101..3ba5ead46 100644 --- a/analysis/lang/hi/hindi_normalize.go +++ b/analysis/lang/hi/hindi_normalize.go @@ -134,5 +134,8 @@ func NormalizerFilterConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + err := registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hi/hindi_stemmer_filter.go b/analysis/lang/hi/hindi_stemmer_filter.go index c1346db88..f54cc57c8 100644 --- a/analysis/lang/hi/hindi_stemmer_filter.go +++ b/analysis/lang/hi/hindi_stemmer_filter.go @@ -145,5 +145,8 @@ func StemmerFilterConstructor(config map[string]interface{}, cache *registry.Cac } func init() { - registry.RegisterTokenFilter(StemmerName, StemmerFilterConstructor) + err := registry.RegisterTokenFilter(StemmerName, StemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hi/stop_filter_hi.go b/analysis/lang/hi/stop_filter_hi.go index d5598ad16..8122b4f16 100644 --- a/analysis/lang/hi/stop_filter_hi.go +++ b/analysis/lang/hi/stop_filter_hi.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hi/stop_words_hi.go b/analysis/lang/hi/stop_words_hi.go index 1ffdec600..844c774a1 100644 --- a/analysis/lang/hi/stop_words_hi.go +++ b/analysis/lang/hi/stop_words_hi.go @@ -255,5 +255,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hr/analyzer_hr.go b/analysis/lang/hr/analyzer_hr.go index b0654a298..7deaeda56 100644 --- a/analysis/lang/hr/analyzer_hr.go +++ b/analysis/lang/hr/analyzer_hr.go @@ -60,5 +60,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hr/stemmer_hr.go b/analysis/lang/hr/stemmer_hr.go index 4f91b4a84..e6e41f56b 100644 --- a/analysis/lang/hr/stemmer_hr.go +++ b/analysis/lang/hr/stemmer_hr.go @@ -149,5 +149,8 @@ func CroatianStemmerFilterConstructor(config map[string]interface{}, cache *regi } func init() { - registry.RegisterTokenFilter(StemmerName, CroatianStemmerFilterConstructor) + err := registry.RegisterTokenFilter(StemmerName, CroatianStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hr/stop_filter_hr.go b/analysis/lang/hr/stop_filter_hr.go index 83c3ceb18..c79015f2c 100644 --- a/analysis/lang/hr/stop_filter_hr.go +++ b/analysis/lang/hr/stop_filter_hr.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hr/stop_words_hr.go b/analysis/lang/hr/stop_words_hr.go index 344f68b8a..3bd3845ce 100644 --- a/analysis/lang/hr/stop_words_hr.go +++ b/analysis/lang/hr/stop_words_hr.go @@ -104,5 +104,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hr/suffix_transformation_hr.go b/analysis/lang/hr/suffix_transformation_hr.go index f29e8fc7f..3223ee485 100644 --- a/analysis/lang/hr/suffix_transformation_hr.go +++ b/analysis/lang/hr/suffix_transformation_hr.go @@ -182,5 +182,8 @@ func SuffixTransformationFilterConstructor(config map[string]interface{}, cache } func init() { - registry.RegisterTokenFilter(SuffixTransformationFilterName, SuffixTransformationFilterConstructor) + err := registry.RegisterTokenFilter(SuffixTransformationFilterName, SuffixTransformationFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hu/analyzer_hu.go b/analysis/lang/hu/analyzer_hu.go index 3f5517d0a..09ba09163 100644 --- a/analysis/lang/hu/analyzer_hu.go +++ b/analysis/lang/hu/analyzer_hu.go @@ -53,5 +53,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hu/stemmer_hu.go b/analysis/lang/hu/stemmer_hu.go index e1a35c157..3aadd6acc 100644 --- a/analysis/lang/hu/stemmer_hu.go +++ b/analysis/lang/hu/stemmer_hu.go @@ -45,5 +45,8 @@ func HungarianStemmerFilterConstructor(config map[string]interface{}, cache *reg } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, HungarianStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, HungarianStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hu/stop_filter_hu.go b/analysis/lang/hu/stop_filter_hu.go index cafaf74ad..ebc689460 100644 --- a/analysis/lang/hu/stop_filter_hu.go +++ b/analysis/lang/hu/stop_filter_hu.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hu/stop_words_hu.go b/analysis/lang/hu/stop_words_hu.go index 3518538ae..effdc04d2 100644 --- a/analysis/lang/hu/stop_words_hu.go +++ b/analysis/lang/hu/stop_words_hu.go @@ -231,5 +231,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hy/stop_filter_hy.go b/analysis/lang/hy/stop_filter_hy.go index 0601002ee..eb6978996 100644 --- a/analysis/lang/hy/stop_filter_hy.go +++ b/analysis/lang/hy/stop_filter_hy.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/hy/stop_words_hy.go b/analysis/lang/hy/stop_words_hy.go index d2a105a88..dcb6603dd 100644 --- a/analysis/lang/hy/stop_words_hy.go +++ b/analysis/lang/hy/stop_words_hy.go @@ -66,5 +66,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/id/stop_filter_id.go b/analysis/lang/id/stop_filter_id.go index 2568a5f21..252f13178 100644 --- a/analysis/lang/id/stop_filter_id.go +++ b/analysis/lang/id/stop_filter_id.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/id/stop_words_id.go b/analysis/lang/id/stop_words_id.go index 97d02ac41..b85a81651 100644 --- a/analysis/lang/id/stop_words_id.go +++ b/analysis/lang/id/stop_words_id.go @@ -379,5 +379,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/in/indic_normalize.go b/analysis/lang/in/indic_normalize.go index 6c2ab2b5a..f3ad7d998 100644 --- a/analysis/lang/in/indic_normalize.go +++ b/analysis/lang/in/indic_normalize.go @@ -44,5 +44,8 @@ func NormalizerFilterConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + err := registry.RegisterTokenFilter(NormalizeName, NormalizerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/it/analyzer_it.go b/analysis/lang/it/analyzer_it.go index 256b22a2b..8531166a1 100644 --- a/analysis/lang/it/analyzer_it.go +++ b/analysis/lang/it/analyzer_it.go @@ -58,5 +58,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/it/articles_it.go b/analysis/lang/it/articles_it.go index 9bd0b6702..08d3c01ce 100644 --- a/analysis/lang/it/articles_it.go +++ b/analysis/lang/it/articles_it.go @@ -41,5 +41,8 @@ func ArticlesTokenMapConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenMap(ArticlesName, ArticlesTokenMapConstructor) + err := registry.RegisterTokenMap(ArticlesName, ArticlesTokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/it/elision_it.go b/analysis/lang/it/elision_it.go index 952608513..022e9c612 100644 --- a/analysis/lang/it/elision_it.go +++ b/analysis/lang/it/elision_it.go @@ -33,5 +33,8 @@ func ElisionFilterConstructor(config map[string]interface{}, cache *registry.Cac } func init() { - registry.RegisterTokenFilter(ElisionName, ElisionFilterConstructor) + err := registry.RegisterTokenFilter(ElisionName, ElisionFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/it/light_stemmer_it.go b/analysis/lang/it/light_stemmer_it.go index daf63a191..57c1564bb 100644 --- a/analysis/lang/it/light_stemmer_it.go +++ b/analysis/lang/it/light_stemmer_it.go @@ -97,5 +97,8 @@ func ItalianLightStemmerFilterConstructor(config map[string]interface{}, cache * } func init() { - registry.RegisterTokenFilter(LightStemmerName, ItalianLightStemmerFilterConstructor) + err := registry.RegisterTokenFilter(LightStemmerName, ItalianLightStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/it/stemmer_it_snowball.go b/analysis/lang/it/stemmer_it_snowball.go index 9faec48ff..fd5164129 100644 --- a/analysis/lang/it/stemmer_it_snowball.go +++ b/analysis/lang/it/stemmer_it_snowball.go @@ -45,5 +45,8 @@ func ItalianStemmerFilterConstructor(config map[string]interface{}, cache *regis } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, ItalianStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, ItalianStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/it/stop_filter_it.go b/analysis/lang/it/stop_filter_it.go index 79d459c18..73e297fff 100644 --- a/analysis/lang/it/stop_filter_it.go +++ b/analysis/lang/it/stop_filter_it.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/it/stop_words_it.go b/analysis/lang/it/stop_words_it.go index 10b3254dc..b167f4d7f 100644 --- a/analysis/lang/it/stop_words_it.go +++ b/analysis/lang/it/stop_words_it.go @@ -323,5 +323,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/nl/analyzer_nl.go b/analysis/lang/nl/analyzer_nl.go index 321aabea2..22a6fbf8a 100644 --- a/analysis/lang/nl/analyzer_nl.go +++ b/analysis/lang/nl/analyzer_nl.go @@ -53,5 +53,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/nl/stemmer_nl.go b/analysis/lang/nl/stemmer_nl.go index b8c529517..561296567 100644 --- a/analysis/lang/nl/stemmer_nl.go +++ b/analysis/lang/nl/stemmer_nl.go @@ -45,5 +45,8 @@ func DutchStemmerFilterConstructor(config map[string]interface{}, cache *registr } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, DutchStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, DutchStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/nl/stop_filter_nl.go b/analysis/lang/nl/stop_filter_nl.go index 75966731b..31fa91e7d 100644 --- a/analysis/lang/nl/stop_filter_nl.go +++ b/analysis/lang/nl/stop_filter_nl.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/nl/stop_words_nl.go b/analysis/lang/nl/stop_words_nl.go index e68486199..bb7e6de1d 100644 --- a/analysis/lang/nl/stop_words_nl.go +++ b/analysis/lang/nl/stop_words_nl.go @@ -139,5 +139,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/no/analyzer_no.go b/analysis/lang/no/analyzer_no.go index f036dc452..64bf71c77 100644 --- a/analysis/lang/no/analyzer_no.go +++ b/analysis/lang/no/analyzer_no.go @@ -53,5 +53,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/no/stemmer_no.go b/analysis/lang/no/stemmer_no.go index cf3fb37a1..97e06d47d 100644 --- a/analysis/lang/no/stemmer_no.go +++ b/analysis/lang/no/stemmer_no.go @@ -45,5 +45,8 @@ func NorwegianStemmerFilterConstructor(config map[string]interface{}, cache *reg } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, NorwegianStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, NorwegianStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/no/stop_filter_no.go b/analysis/lang/no/stop_filter_no.go index 72855bd8f..a698c62cf 100644 --- a/analysis/lang/no/stop_filter_no.go +++ b/analysis/lang/no/stop_filter_no.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/no/stop_words_no.go b/analysis/lang/no/stop_words_no.go index b771091c5..4b58ab9d9 100644 --- a/analysis/lang/no/stop_words_no.go +++ b/analysis/lang/no/stop_words_no.go @@ -214,5 +214,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/pl/analyzer_pl.go b/analysis/lang/pl/analyzer_pl.go index 311815efb..0e202e8ea 100644 --- a/analysis/lang/pl/analyzer_pl.go +++ b/analysis/lang/pl/analyzer_pl.go @@ -53,5 +53,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/pl/stemmer_pl.go b/analysis/lang/pl/stemmer_pl.go index ea3c32da6..c997fb15f 100644 --- a/analysis/lang/pl/stemmer_pl.go +++ b/analysis/lang/pl/stemmer_pl.go @@ -51,5 +51,8 @@ func PolishStemmerFilterConstructor(config map[string]interface{}, cache *regist } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, PolishStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, PolishStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/pl/stop_filter_pl.go b/analysis/lang/pl/stop_filter_pl.go index d032445de..f8b2918cc 100644 --- a/analysis/lang/pl/stop_filter_pl.go +++ b/analysis/lang/pl/stop_filter_pl.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/pl/stop_words_pl.go b/analysis/lang/pl/stop_words_pl.go index 732d78e08..0755da864 100644 --- a/analysis/lang/pl/stop_words_pl.go +++ b/analysis/lang/pl/stop_words_pl.go @@ -361,5 +361,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/pt/analyzer_pt.go b/analysis/lang/pt/analyzer_pt.go index ad99fac39..db6b3a72b 100644 --- a/analysis/lang/pt/analyzer_pt.go +++ b/analysis/lang/pt/analyzer_pt.go @@ -53,5 +53,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/pt/light_stemmer_pt.go b/analysis/lang/pt/light_stemmer_pt.go index cf3371cf3..ddb9d1638 100644 --- a/analysis/lang/pt/light_stemmer_pt.go +++ b/analysis/lang/pt/light_stemmer_pt.go @@ -191,5 +191,8 @@ func PortugueseLightStemmerFilterConstructor(config map[string]interface{}, cach } func init() { - registry.RegisterTokenFilter(LightStemmerName, PortugueseLightStemmerFilterConstructor) + err := registry.RegisterTokenFilter(LightStemmerName, PortugueseLightStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/pt/stop_filter_pt.go b/analysis/lang/pt/stop_filter_pt.go index 7bdca2e61..a0b8886af 100644 --- a/analysis/lang/pt/stop_filter_pt.go +++ b/analysis/lang/pt/stop_filter_pt.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/pt/stop_words_pt.go b/analysis/lang/pt/stop_words_pt.go index e5c5ebba7..b213389fa 100644 --- a/analysis/lang/pt/stop_words_pt.go +++ b/analysis/lang/pt/stop_words_pt.go @@ -273,5 +273,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ro/analyzer_ro.go b/analysis/lang/ro/analyzer_ro.go index 5fff2a984..f138f80c3 100644 --- a/analysis/lang/ro/analyzer_ro.go +++ b/analysis/lang/ro/analyzer_ro.go @@ -53,5 +53,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ro/stemmer_ro.go b/analysis/lang/ro/stemmer_ro.go index b37ae878d..f7efc73c0 100644 --- a/analysis/lang/ro/stemmer_ro.go +++ b/analysis/lang/ro/stemmer_ro.go @@ -45,5 +45,8 @@ func RomanianStemmerFilterConstructor(config map[string]interface{}, cache *regi } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, RomanianStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, RomanianStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ro/stop_filter_ro.go b/analysis/lang/ro/stop_filter_ro.go index ccd7e6bdd..0932d33ff 100644 --- a/analysis/lang/ro/stop_filter_ro.go +++ b/analysis/lang/ro/stop_filter_ro.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ro/stop_words_ro.go b/analysis/lang/ro/stop_words_ro.go index 4eb255a34..8c01a417a 100644 --- a/analysis/lang/ro/stop_words_ro.go +++ b/analysis/lang/ro/stop_words_ro.go @@ -253,5 +253,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ru/analyzer_ru.go b/analysis/lang/ru/analyzer_ru.go index 3126392cc..06092a496 100644 --- a/analysis/lang/ru/analyzer_ru.go +++ b/analysis/lang/ru/analyzer_ru.go @@ -53,5 +53,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ru/stemmer_ru.go b/analysis/lang/ru/stemmer_ru.go index 6f051dc5e..e271bb6e7 100644 --- a/analysis/lang/ru/stemmer_ru.go +++ b/analysis/lang/ru/stemmer_ru.go @@ -45,5 +45,8 @@ func RussianStemmerFilterConstructor(config map[string]interface{}, cache *regis } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, RussianStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, RussianStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ru/stop_filter_ru.go b/analysis/lang/ru/stop_filter_ru.go index e91f1fe2e..a7b9fa1ef 100644 --- a/analysis/lang/ru/stop_filter_ru.go +++ b/analysis/lang/ru/stop_filter_ru.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/ru/stop_words_ru.go b/analysis/lang/ru/stop_words_ru.go index cca2f248c..28ed500aa 100644 --- a/analysis/lang/ru/stop_words_ru.go +++ b/analysis/lang/ru/stop_words_ru.go @@ -263,5 +263,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/sv/analyzer_sv.go b/analysis/lang/sv/analyzer_sv.go index 38ddb308f..e8c76e144 100644 --- a/analysis/lang/sv/analyzer_sv.go +++ b/analysis/lang/sv/analyzer_sv.go @@ -53,5 +53,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/sv/stemmer_sv.go b/analysis/lang/sv/stemmer_sv.go index 39265e7f4..679fc9894 100644 --- a/analysis/lang/sv/stemmer_sv.go +++ b/analysis/lang/sv/stemmer_sv.go @@ -45,5 +45,8 @@ func SwedishStemmerFilterConstructor(config map[string]interface{}, cache *regis } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, SwedishStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, SwedishStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/sv/stop_filter_sv.go b/analysis/lang/sv/stop_filter_sv.go index 6cd09baf9..9d3a57df9 100644 --- a/analysis/lang/sv/stop_filter_sv.go +++ b/analysis/lang/sv/stop_filter_sv.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/sv/stop_words_sv.go b/analysis/lang/sv/stop_words_sv.go index 0943e6941..a420e7d4f 100644 --- a/analysis/lang/sv/stop_words_sv.go +++ b/analysis/lang/sv/stop_words_sv.go @@ -153,5 +153,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/tr/analyzer_tr.go b/analysis/lang/tr/analyzer_tr.go index 401609c4f..69e7537bd 100644 --- a/analysis/lang/tr/analyzer_tr.go +++ b/analysis/lang/tr/analyzer_tr.go @@ -59,5 +59,8 @@ func AnalyzerConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + err := registry.RegisterAnalyzer(AnalyzerName, AnalyzerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/tr/stemmer_tr.go b/analysis/lang/tr/stemmer_tr.go index fa4590631..ce3665544 100644 --- a/analysis/lang/tr/stemmer_tr.go +++ b/analysis/lang/tr/stemmer_tr.go @@ -45,5 +45,8 @@ func TurkishStemmerFilterConstructor(config map[string]interface{}, cache *regis } func init() { - registry.RegisterTokenFilter(SnowballStemmerName, TurkishStemmerFilterConstructor) + err := registry.RegisterTokenFilter(SnowballStemmerName, TurkishStemmerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/tr/stop_filter_tr.go b/analysis/lang/tr/stop_filter_tr.go index d096d7139..0f75ffa48 100644 --- a/analysis/lang/tr/stop_filter_tr.go +++ b/analysis/lang/tr/stop_filter_tr.go @@ -29,5 +29,8 @@ func StopTokenFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + err := registry.RegisterTokenFilter(StopName, StopTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/lang/tr/stop_words_tr.go b/analysis/lang/tr/stop_words_tr.go index 8d0cdc5f0..49116c224 100644 --- a/analysis/lang/tr/stop_words_tr.go +++ b/analysis/lang/tr/stop_words_tr.go @@ -232,5 +232,8 @@ func TokenMapConstructor(config map[string]interface{}, cache *registry.Cache) ( } func init() { - registry.RegisterTokenMap(StopName, TokenMapConstructor) + err := registry.RegisterTokenMap(StopName, TokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/apostrophe/apostrophe.go b/analysis/token/apostrophe/apostrophe.go index 4ab47bf26..20290a341 100644 --- a/analysis/token/apostrophe/apostrophe.go +++ b/analysis/token/apostrophe/apostrophe.go @@ -50,5 +50,8 @@ func ApostropheFilterConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenFilter(Name, ApostropheFilterConstructor) + err := registry.RegisterTokenFilter(Name, ApostropheFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/camelcase/camelcase.go b/analysis/token/camelcase/camelcase.go index 1671d16e0..7aab53fcd 100644 --- a/analysis/token/camelcase/camelcase.go +++ b/analysis/token/camelcase/camelcase.go @@ -74,5 +74,8 @@ func CamelCaseFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(Name, CamelCaseFilterConstructor) + err := registry.RegisterTokenFilter(Name, CamelCaseFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/compound/dict.go b/analysis/token/compound/dict.go index e5065df4d..f4fc8f5f9 100644 --- a/analysis/token/compound/dict.go +++ b/analysis/token/compound/dict.go @@ -137,5 +137,8 @@ func DictionaryCompoundFilterConstructor(config map[string]interface{}, cache *r } func init() { - registry.RegisterTokenFilter(Name, DictionaryCompoundFilterConstructor) + err := registry.RegisterTokenFilter(Name, DictionaryCompoundFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/edgengram/edgengram.go b/analysis/token/edgengram/edgengram.go index 9e079c6c3..d9e4c24ba 100644 --- a/analysis/token/edgengram/edgengram.go +++ b/analysis/token/edgengram/edgengram.go @@ -111,5 +111,8 @@ func EdgeNgramFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(Name, EdgeNgramFilterConstructor) + err := registry.RegisterTokenFilter(Name, EdgeNgramFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/elision/elision.go b/analysis/token/elision/elision.go index 909d24121..721a5468e 100644 --- a/analysis/token/elision/elision.go +++ b/analysis/token/elision/elision.go @@ -70,5 +70,8 @@ func ElisionFilterConstructor(config map[string]interface{}, cache *registry.Cac } func init() { - registry.RegisterTokenFilter(Name, ElisionFilterConstructor) + err := registry.RegisterTokenFilter(Name, ElisionFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/hierarchy/hierarchy.go b/analysis/token/hierarchy/hierarchy.go index 5a4414a23..6e1ea4429 100644 --- a/analysis/token/hierarchy/hierarchy.go +++ b/analysis/token/hierarchy/hierarchy.go @@ -88,5 +88,8 @@ func HierarchyFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(Name, HierarchyFilterConstructor) + err := registry.RegisterTokenFilter(Name, HierarchyFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/keyword/keyword.go b/analysis/token/keyword/keyword.go index 49aa55d49..0f8c84775 100644 --- a/analysis/token/keyword/keyword.go +++ b/analysis/token/keyword/keyword.go @@ -57,5 +57,8 @@ func KeyWordMarkerFilterConstructor(config map[string]interface{}, cache *regist } func init() { - registry.RegisterTokenFilter(Name, KeyWordMarkerFilterConstructor) + err := registry.RegisterTokenFilter(Name, KeyWordMarkerFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/length/length.go b/analysis/token/length/length.go index 6b5cdd84b..109127096 100644 --- a/analysis/token/length/length.go +++ b/analysis/token/length/length.go @@ -73,5 +73,8 @@ func LengthFilterConstructor(config map[string]interface{}, cache *registry.Cach } func init() { - registry.RegisterTokenFilter(Name, LengthFilterConstructor) + err := registry.RegisterTokenFilter(Name, LengthFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/lowercase/lowercase.go b/analysis/token/lowercase/lowercase.go index a1b6dbd05..92b962808 100644 --- a/analysis/token/lowercase/lowercase.go +++ b/analysis/token/lowercase/lowercase.go @@ -47,7 +47,10 @@ func LowerCaseFilterConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(Name, LowerCaseFilterConstructor) + err := registry.RegisterTokenFilter(Name, LowerCaseFilterConstructor) + if err != nil { + panic(err) + } } // toLowerDeferredCopy will function exactly like diff --git a/analysis/token/ngram/ngram.go b/analysis/token/ngram/ngram.go index ba99d9d42..d8967a07c 100644 --- a/analysis/token/ngram/ngram.go +++ b/analysis/token/ngram/ngram.go @@ -90,7 +90,10 @@ func NgramFilterConstructor(config map[string]interface{}, cache *registry.Cache } func init() { - registry.RegisterTokenFilter(Name, NgramFilterConstructor) + err := registry.RegisterTokenFilter(Name, NgramFilterConstructor) + if err != nil { + panic(err) + } } // Expects either an int or a flaot64 value diff --git a/analysis/token/porter/porter.go b/analysis/token/porter/porter.go index 95af0fa72..ed1574bbb 100644 --- a/analysis/token/porter/porter.go +++ b/analysis/token/porter/porter.go @@ -49,5 +49,8 @@ func PorterStemmerConstructor(config map[string]interface{}, cache *registry.Cac } func init() { - registry.RegisterTokenFilter(Name, PorterStemmerConstructor) + err := registry.RegisterTokenFilter(Name, PorterStemmerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/reverse/reverse.go b/analysis/token/reverse/reverse.go index f02e6cdf0..5eb708f33 100644 --- a/analysis/token/reverse/reverse.go +++ b/analysis/token/reverse/reverse.go @@ -44,7 +44,10 @@ func ReverseFilterConstructor(config map[string]interface{}, cache *registry.Cac } func init() { - registry.RegisterTokenFilter(Name, ReverseFilterConstructor) + err := registry.RegisterTokenFilter(Name, ReverseFilterConstructor) + if err != nil { + panic(err) + } } // reverse(..) will generate a reversed version of the provided diff --git a/analysis/token/shingle/shingle.go b/analysis/token/shingle/shingle.go index 59b8ddbfa..29280a74c 100644 --- a/analysis/token/shingle/shingle.go +++ b/analysis/token/shingle/shingle.go @@ -165,5 +165,8 @@ func ShingleFilterConstructor(config map[string]interface{}, cache *registry.Cac } func init() { - registry.RegisterTokenFilter(Name, ShingleFilterConstructor) + err := registry.RegisterTokenFilter(Name, ShingleFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/snowball/snowball.go b/analysis/token/snowball/snowball.go index c608ddc99..02c1a6c6f 100644 --- a/analysis/token/snowball/snowball.go +++ b/analysis/token/snowball/snowball.go @@ -55,5 +55,8 @@ func SnowballStemmerConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenFilter(Name, SnowballStemmerConstructor) + err := registry.RegisterTokenFilter(Name, SnowballStemmerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/stop/stop.go b/analysis/token/stop/stop.go index bf4b98db1..09f2d1c9c 100644 --- a/analysis/token/stop/stop.go +++ b/analysis/token/stop/stop.go @@ -66,5 +66,8 @@ func StopTokensFilterConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenFilter(Name, StopTokensFilterConstructor) + err := registry.RegisterTokenFilter(Name, StopTokensFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/truncate/truncate.go b/analysis/token/truncate/truncate.go index faf65b705..2019358c9 100644 --- a/analysis/token/truncate/truncate.go +++ b/analysis/token/truncate/truncate.go @@ -55,5 +55,8 @@ func TruncateTokenFilterConstructor(config map[string]interface{}, cache *regist } func init() { - registry.RegisterTokenFilter(Name, TruncateTokenFilterConstructor) + err := registry.RegisterTokenFilter(Name, TruncateTokenFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/unicodenorm/unicodenorm.go b/analysis/token/unicodenorm/unicodenorm.go index 01b191bc2..ba0243a15 100644 --- a/analysis/token/unicodenorm/unicodenorm.go +++ b/analysis/token/unicodenorm/unicodenorm.go @@ -75,5 +75,8 @@ func UnicodeNormalizeFilterConstructor(config map[string]interface{}, cache *reg } func init() { - registry.RegisterTokenFilter(Name, UnicodeNormalizeFilterConstructor) + err := registry.RegisterTokenFilter(Name, UnicodeNormalizeFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/token/unique/unique.go b/analysis/token/unique/unique.go index 6fbc663de..e48c4f9a2 100644 --- a/analysis/token/unique/unique.go +++ b/analysis/token/unique/unique.go @@ -49,5 +49,8 @@ func UniqueTermFilterConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenFilter(Name, UniqueTermFilterConstructor) + err := registry.RegisterTokenFilter(Name, UniqueTermFilterConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/tokenizer/exception/exception.go b/analysis/tokenizer/exception/exception.go index 11023e855..30c8eff2b 100644 --- a/analysis/tokenizer/exception/exception.go +++ b/analysis/tokenizer/exception/exception.go @@ -137,5 +137,8 @@ func ExceptionsTokenizerConstructor(config map[string]interface{}, cache *regist } func init() { - registry.RegisterTokenizer(Name, ExceptionsTokenizerConstructor) + err := registry.RegisterTokenizer(Name, ExceptionsTokenizerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/tokenizer/letter/letter.go b/analysis/tokenizer/letter/letter.go index 96a2a664b..ed4dba1e3 100644 --- a/analysis/tokenizer/letter/letter.go +++ b/analysis/tokenizer/letter/letter.go @@ -29,5 +29,8 @@ func TokenizerConstructor(config map[string]interface{}, cache *registry.Cache) } func init() { - registry.RegisterTokenizer(Name, TokenizerConstructor) + err := registry.RegisterTokenizer(Name, TokenizerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/tokenizer/regexp/regexp.go b/analysis/tokenizer/regexp/regexp.go index 61bac6ca6..94c187912 100644 --- a/analysis/tokenizer/regexp/regexp.go +++ b/analysis/tokenizer/regexp/regexp.go @@ -69,7 +69,10 @@ func RegexpTokenizerConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenizer(Name, RegexpTokenizerConstructor) + err := registry.RegisterTokenizer(Name, RegexpTokenizerConstructor) + if err != nil { + panic(err) + } } func detectTokenType(termBytes []byte) analysis.TokenType { diff --git a/analysis/tokenizer/single/single.go b/analysis/tokenizer/single/single.go index a3eac7899..7f3abd2a8 100644 --- a/analysis/tokenizer/single/single.go +++ b/analysis/tokenizer/single/single.go @@ -45,5 +45,8 @@ func SingleTokenTokenizerConstructor(config map[string]interface{}, cache *regis } func init() { - registry.RegisterTokenizer(Name, SingleTokenTokenizerConstructor) + err := registry.RegisterTokenizer(Name, SingleTokenTokenizerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/tokenizer/unicode/unicode.go b/analysis/tokenizer/unicode/unicode.go index ca3cfe76c..b694a3ee4 100644 --- a/analysis/tokenizer/unicode/unicode.go +++ b/analysis/tokenizer/unicode/unicode.go @@ -115,7 +115,10 @@ func UnicodeTokenizerConstructor(config map[string]interface{}, cache *registry. } func init() { - registry.RegisterTokenizer(Name, UnicodeTokenizerConstructor) + err := registry.RegisterTokenizer(Name, UnicodeTokenizerConstructor) + if err != nil { + panic(err) + } } func convertType(segmentWordType int) analysis.TokenType { diff --git a/analysis/tokenizer/web/web.go b/analysis/tokenizer/web/web.go index 545ccd9d6..a534f2055 100644 --- a/analysis/tokenizer/web/web.go +++ b/analysis/tokenizer/web/web.go @@ -43,5 +43,8 @@ func TokenizerConstructor(config map[string]interface{}, cache *registry.Cache) } func init() { - registry.RegisterTokenizer(Name, TokenizerConstructor) + err := registry.RegisterTokenizer(Name, TokenizerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/tokenizer/whitespace/whitespace.go b/analysis/tokenizer/whitespace/whitespace.go index 06134c771..d8b14bbcd 100644 --- a/analysis/tokenizer/whitespace/whitespace.go +++ b/analysis/tokenizer/whitespace/whitespace.go @@ -33,5 +33,8 @@ func notSpace(r rune) bool { } func init() { - registry.RegisterTokenizer(Name, TokenizerConstructor) + err := registry.RegisterTokenizer(Name, TokenizerConstructor) + if err != nil { + panic(err) + } } diff --git a/analysis/tokenmap/custom.go b/analysis/tokenmap/custom.go index ae08d3e17..9567852a0 100644 --- a/analysis/tokenmap/custom.go +++ b/analysis/tokenmap/custom.go @@ -58,5 +58,8 @@ func GenericTokenMapConstructor(config map[string]interface{}, cache *registry.C } func init() { - registry.RegisterTokenMap(Name, GenericTokenMapConstructor) + err := registry.RegisterTokenMap(Name, GenericTokenMapConstructor) + if err != nil { + panic(err) + } } diff --git a/index/scorch/scorch.go b/index/scorch/scorch.go index 2b5408514..8bcbfc103 100644 --- a/index/scorch/scorch.go +++ b/index/scorch/scorch.go @@ -772,7 +772,10 @@ func (s *Scorch) unmarkIneligibleForRemoval(filename string) { } func init() { - registry.RegisterIndexType(Name, NewScorch) + err := registry.RegisterIndexType(Name, NewScorch) + if err != nil { + panic(err) + } } func parseToTimeDuration(i interface{}) (time.Duration, error) { diff --git a/index/upsidedown/store/boltdb/store.go b/index/upsidedown/store/boltdb/store.go index bc99275e1..2ebe9d2ba 100644 --- a/index/upsidedown/store/boltdb/store.go +++ b/index/upsidedown/store/boltdb/store.go @@ -177,5 +177,8 @@ func (bs *Store) Compact() error { } func init() { - registry.RegisterKVStore(Name, New) + err := registry.RegisterKVStore(Name, New) + if err != nil { + panic(err) + } } diff --git a/index/upsidedown/store/goleveldb/store.go b/index/upsidedown/store/goleveldb/store.go index 6e8fbfd12..3607c6da2 100644 --- a/index/upsidedown/store/goleveldb/store.go +++ b/index/upsidedown/store/goleveldb/store.go @@ -145,5 +145,8 @@ func (ldbs *Store) Compact() error { } func init() { - registry.RegisterKVStore(Name, New) + err := registry.RegisterKVStore(Name, New) + if err != nil { + panic(err) + } } diff --git a/index/upsidedown/store/gtreap/store.go b/index/upsidedown/store/gtreap/store.go index 3cc7eb9ae..8050e4d91 100644 --- a/index/upsidedown/store/gtreap/store.go +++ b/index/upsidedown/store/gtreap/store.go @@ -26,7 +26,7 @@ import ( "github.com/blevesearch/bleve/v2/registry" "github.com/blevesearch/gtreap" - "github.com/blevesearch/upsidedown_store_api" + store "github.com/blevesearch/upsidedown_store_api" ) const Name = "gtreap" @@ -78,5 +78,8 @@ func (s *Store) Writer() (store.KVWriter, error) { } func init() { - registry.RegisterKVStore(Name, New) + err := registry.RegisterKVStore(Name, New) + if err != nil { + panic(err) + } } diff --git a/index/upsidedown/store/metrics/store.go b/index/upsidedown/store/metrics/store.go index 8b4f2ad3e..9a89756d4 100644 --- a/index/upsidedown/store/metrics/store.go +++ b/index/upsidedown/store/metrics/store.go @@ -95,7 +95,10 @@ func New(mo store.MergeOperator, config map[string]interface{}) (store.KVStore, } func init() { - registry.RegisterKVStore(Name, New) + err := registry.RegisterKVStore(Name, New) + if err != nil { + panic(err) + } } func (s *Store) Close() error { diff --git a/index/upsidedown/store/moss/store.go b/index/upsidedown/store/moss/store.go index 7c7aa4a06..bccbe1f20 100644 --- a/index/upsidedown/store/moss/store.go +++ b/index/upsidedown/store/moss/store.go @@ -224,5 +224,8 @@ func (s *Store) Collection() moss.Collection { } func init() { - registry.RegisterKVStore(Name, New) + err := registry.RegisterKVStore(Name, New) + if err != nil { + panic(err) + } } diff --git a/index/upsidedown/store/null/null.go b/index/upsidedown/store/null/null.go index fcdfd1930..952e1ebb9 100644 --- a/index/upsidedown/store/null/null.go +++ b/index/upsidedown/store/null/null.go @@ -114,5 +114,8 @@ func (w *writer) Close() error { } func init() { - registry.RegisterKVStore(Name, New) + err := registry.RegisterKVStore(Name, New) + if err != nil { + panic(err) + } } diff --git a/index/upsidedown/upsidedown.go b/index/upsidedown/upsidedown.go index 3756422da..2400776d7 100644 --- a/index/upsidedown/upsidedown.go +++ b/index/upsidedown/upsidedown.go @@ -1042,7 +1042,10 @@ func (udc *UpsideDownCouch) fieldIndexOrNewRow(name string) (uint16, *FieldRow) } func init() { - registry.RegisterIndexType(Name, NewUpsideDownCouch) + err := registry.RegisterIndexType(Name, NewUpsideDownCouch) + if err != nil { + panic(err) + } } func backIndexRowForDoc(kvreader store.KVReader, docID index.IndexInternalID) (*BackIndexRow, error) { diff --git a/mapping/synonym.go b/mapping/synonym.go index 06dee754a..198282194 100644 --- a/mapping/synonym.go +++ b/mapping/synonym.go @@ -64,5 +64,8 @@ func SynonymSourceConstructor(config map[string]interface{}, cache *registry.Cac } func init() { - registry.RegisterSynonymSource(analysis.SynonymSourceType, SynonymSourceConstructor) + err := registry.RegisterSynonymSource(analysis.SynonymSourceType, SynonymSourceConstructor) + if err != nil { + panic(err) + } } diff --git a/registry/analyzer.go b/registry/analyzer.go index f4753bc1c..af95b885d 100644 --- a/registry/analyzer.go +++ b/registry/analyzer.go @@ -20,12 +20,13 @@ import ( "github.com/blevesearch/bleve/v2/analysis" ) -func RegisterAnalyzer(name string, constructor AnalyzerConstructor) { +func RegisterAnalyzer(name string, constructor AnalyzerConstructor) error { _, exists := analyzers[name] if exists { - panic(fmt.Errorf("attempted to register duplicate analyzer named '%s'", name)) + return fmt.Errorf("attempted to register duplicate analyzer named '%s'", name) } analyzers[name] = constructor + return nil } type AnalyzerConstructor func(config map[string]interface{}, cache *Cache) (analysis.Analyzer, error) diff --git a/registry/char_filter.go b/registry/char_filter.go index aa400be68..e888dac4a 100644 --- a/registry/char_filter.go +++ b/registry/char_filter.go @@ -20,12 +20,13 @@ import ( "github.com/blevesearch/bleve/v2/analysis" ) -func RegisterCharFilter(name string, constructor CharFilterConstructor) { +func RegisterCharFilter(name string, constructor CharFilterConstructor) error { _, exists := charFilters[name] if exists { - panic(fmt.Errorf("attempted to register duplicate char filter named '%s'", name)) + return fmt.Errorf("attempted to register duplicate char filter named '%s'", name) } charFilters[name] = constructor + return nil } type CharFilterConstructor func(config map[string]interface{}, cache *Cache) (analysis.CharFilter, error) diff --git a/registry/datetime_parser.go b/registry/datetime_parser.go index a2d8ac24a..ff9a80cb5 100644 --- a/registry/datetime_parser.go +++ b/registry/datetime_parser.go @@ -20,12 +20,13 @@ import ( "github.com/blevesearch/bleve/v2/analysis" ) -func RegisterDateTimeParser(name string, constructor DateTimeParserConstructor) { +func RegisterDateTimeParser(name string, constructor DateTimeParserConstructor) error { _, exists := dateTimeParsers[name] if exists { - panic(fmt.Errorf("attempted to register duplicate date time parser named '%s'", name)) + return fmt.Errorf("attempted to register duplicate date time parser named '%s'", name) } dateTimeParsers[name] = constructor + return nil } type DateTimeParserConstructor func(config map[string]interface{}, cache *Cache) (analysis.DateTimeParser, error) diff --git a/registry/fragment_formatter.go b/registry/fragment_formatter.go index 6699f53ba..f32c5571d 100644 --- a/registry/fragment_formatter.go +++ b/registry/fragment_formatter.go @@ -20,12 +20,13 @@ import ( "github.com/blevesearch/bleve/v2/search/highlight" ) -func RegisterFragmentFormatter(name string, constructor FragmentFormatterConstructor) { +func RegisterFragmentFormatter(name string, constructor FragmentFormatterConstructor) error { _, exists := fragmentFormatters[name] if exists { - panic(fmt.Errorf("attempted to register duplicate fragment formatter named '%s'", name)) + return fmt.Errorf("attempted to register duplicate fragment formatter named '%s'", name) } fragmentFormatters[name] = constructor + return nil } type FragmentFormatterConstructor func(config map[string]interface{}, cache *Cache) (highlight.FragmentFormatter, error) diff --git a/registry/fragmenter.go b/registry/fragmenter.go index cd1e32d28..da2a7b5c1 100644 --- a/registry/fragmenter.go +++ b/registry/fragmenter.go @@ -20,12 +20,13 @@ import ( "github.com/blevesearch/bleve/v2/search/highlight" ) -func RegisterFragmenter(name string, constructor FragmenterConstructor) { +func RegisterFragmenter(name string, constructor FragmenterConstructor) error { _, exists := fragmenters[name] if exists { - panic(fmt.Errorf("attempted to register duplicate fragmenter named '%s'", name)) + return fmt.Errorf("attempted to register duplicate fragmenter named '%s'", name) } fragmenters[name] = constructor + return nil } type FragmenterConstructor func(config map[string]interface{}, cache *Cache) (highlight.Fragmenter, error) diff --git a/registry/highlighter.go b/registry/highlighter.go index 8eb210fb3..75de25482 100644 --- a/registry/highlighter.go +++ b/registry/highlighter.go @@ -20,12 +20,13 @@ import ( "github.com/blevesearch/bleve/v2/search/highlight" ) -func RegisterHighlighter(name string, constructor HighlighterConstructor) { +func RegisterHighlighter(name string, constructor HighlighterConstructor) error { _, exists := highlighters[name] if exists { - panic(fmt.Errorf("attempted to register duplicate highlighter named '%s'", name)) + return fmt.Errorf("attempted to register duplicate highlighter named '%s'", name) } highlighters[name] = constructor + return nil } type HighlighterConstructor func(config map[string]interface{}, cache *Cache) (highlight.Highlighter, error) diff --git a/registry/index_type.go b/registry/index_type.go index 67938c4af..0c2c87f46 100644 --- a/registry/index_type.go +++ b/registry/index_type.go @@ -20,12 +20,13 @@ import ( index "github.com/blevesearch/bleve_index_api" ) -func RegisterIndexType(name string, constructor IndexTypeConstructor) { +func RegisterIndexType(name string, constructor IndexTypeConstructor) error { _, exists := indexTypes[name] if exists { - panic(fmt.Errorf("attempted to register duplicate index encoding named '%s'", name)) + return fmt.Errorf("attempted to register duplicate index encoding named '%s'", name) } indexTypes[name] = constructor + return nil } type IndexTypeConstructor func(storeName string, storeConfig map[string]interface{}, analysisQueue *index.AnalysisQueue) (index.Index, error) @@ -38,7 +39,7 @@ func IndexTypeConstructorByName(name string) IndexTypeConstructor { func IndexTypesAndInstances() ([]string, []string) { var types []string var instances []string - for name := range stores { + for name := range indexTypes { types = append(types, name) } return types, instances diff --git a/registry/store.go b/registry/store.go index 02ebd888c..56840836b 100644 --- a/registry/store.go +++ b/registry/store.go @@ -17,15 +17,16 @@ package registry import ( "fmt" - "github.com/blevesearch/upsidedown_store_api" + store "github.com/blevesearch/upsidedown_store_api" ) -func RegisterKVStore(name string, constructor KVStoreConstructor) { +func RegisterKVStore(name string, constructor KVStoreConstructor) error { _, exists := stores[name] if exists { - panic(fmt.Errorf("attempted to register duplicate store named '%s'", name)) + return fmt.Errorf("attempted to register duplicate store named '%s'", name) } stores[name] = constructor + return nil } // KVStoreConstructor is used to build a KVStore of a specific type when diff --git a/registry/synonym_source.go b/registry/synonym_source.go index cd26d8f01..f1836f8ae 100644 --- a/registry/synonym_source.go +++ b/registry/synonym_source.go @@ -20,12 +20,13 @@ import ( "github.com/blevesearch/bleve/v2/analysis" ) -func RegisterSynonymSource(typ string, constructor SynonymSourceConstructor) { +func RegisterSynonymSource(typ string, constructor SynonymSourceConstructor) error { _, exists := synonymSources[typ] if exists { - panic(fmt.Errorf("attempted to register duplicate synonym source with type '%s'", typ)) + return fmt.Errorf("attempted to register duplicate synonym source with type '%s'", typ) } synonymSources[typ] = constructor + return nil } type SynonymSourceCache struct { diff --git a/registry/token_filter.go b/registry/token_filter.go index df39411ae..533a1030f 100644 --- a/registry/token_filter.go +++ b/registry/token_filter.go @@ -20,12 +20,13 @@ import ( "github.com/blevesearch/bleve/v2/analysis" ) -func RegisterTokenFilter(name string, constructor TokenFilterConstructor) { +func RegisterTokenFilter(name string, constructor TokenFilterConstructor) error { _, exists := tokenFilters[name] if exists { - panic(fmt.Errorf("attempted to register duplicate token filter named '%s'", name)) + return fmt.Errorf("attempted to register duplicate token filter named '%s'", name) } tokenFilters[name] = constructor + return nil } type TokenFilterConstructor func(config map[string]interface{}, cache *Cache) (analysis.TokenFilter, error) diff --git a/registry/token_maps.go b/registry/token_maps.go index 08c9956eb..7fd7886bf 100644 --- a/registry/token_maps.go +++ b/registry/token_maps.go @@ -20,12 +20,13 @@ import ( "github.com/blevesearch/bleve/v2/analysis" ) -func RegisterTokenMap(name string, constructor TokenMapConstructor) { +func RegisterTokenMap(name string, constructor TokenMapConstructor) error { _, exists := tokenMaps[name] if exists { - panic(fmt.Errorf("attempted to register duplicate token map named '%s'", name)) + return fmt.Errorf("attempted to register duplicate token map named '%s'", name) } tokenMaps[name] = constructor + return nil } type TokenMapConstructor func(config map[string]interface{}, cache *Cache) (analysis.TokenMap, error) diff --git a/registry/tokenizer.go b/registry/tokenizer.go index eb954287c..81222b8f5 100644 --- a/registry/tokenizer.go +++ b/registry/tokenizer.go @@ -20,12 +20,13 @@ import ( "github.com/blevesearch/bleve/v2/analysis" ) -func RegisterTokenizer(name string, constructor TokenizerConstructor) { +func RegisterTokenizer(name string, constructor TokenizerConstructor) error { _, exists := tokenizers[name] if exists { - panic(fmt.Errorf("attempted to register duplicate tokenizer named '%s'", name)) + return fmt.Errorf("attempted to register duplicate tokenizer named '%s'", name) } tokenizers[name] = constructor + return nil } type TokenizerConstructor func(config map[string]interface{}, cache *Cache) (analysis.Tokenizer, error) diff --git a/search/highlight/format/ansi/ansi.go b/search/highlight/format/ansi/ansi.go index b9171ae2e..4a0e1eb5f 100644 --- a/search/highlight/format/ansi/ansi.go +++ b/search/highlight/format/ansi/ansi.go @@ -105,5 +105,8 @@ func Constructor(config map[string]interface{}, cache *registry.Cache) (highligh } func init() { - registry.RegisterFragmentFormatter(Name, Constructor) + err := registry.RegisterFragmentFormatter(Name, Constructor) + if err != nil { + panic(err) + } } diff --git a/search/highlight/format/html/html.go b/search/highlight/format/html/html.go index a0658d9c7..92b6f612d 100644 --- a/search/highlight/format/html/html.go +++ b/search/highlight/format/html/html.go @@ -87,5 +87,8 @@ func Constructor(config map[string]interface{}, cache *registry.Cache) (highligh } func init() { - registry.RegisterFragmentFormatter(Name, Constructor) + err := registry.RegisterFragmentFormatter(Name, Constructor) + if err != nil { + panic(err) + } } diff --git a/search/highlight/format/plain/plain.go b/search/highlight/format/plain/plain.go index 79a17ec57..f65d1b760 100644 --- a/search/highlight/format/plain/plain.go +++ b/search/highlight/format/plain/plain.go @@ -85,5 +85,8 @@ func Constructor(config map[string]interface{}, cache *registry.Cache) (highligh } func init() { - registry.RegisterFragmentFormatter(Name, Constructor) + err := registry.RegisterFragmentFormatter(Name, Constructor) + if err != nil { + panic(err) + } } diff --git a/search/highlight/fragmenter/simple/simple.go b/search/highlight/fragmenter/simple/simple.go index 34e5c9597..1c34b010e 100644 --- a/search/highlight/fragmenter/simple/simple.go +++ b/search/highlight/fragmenter/simple/simple.go @@ -149,5 +149,8 @@ func Constructor(config map[string]interface{}, cache *registry.Cache) (highligh } func init() { - registry.RegisterFragmenter(Name, Constructor) + err := registry.RegisterFragmenter(Name, Constructor) + if err != nil { + panic(err) + } } diff --git a/search/highlight/highlighter/ansi/ansi.go b/search/highlight/highlighter/ansi/ansi.go index 39d950b4e..99c1575a2 100644 --- a/search/highlight/highlighter/ansi/ansi.go +++ b/search/highlight/highlighter/ansi/ansi.go @@ -46,5 +46,8 @@ func Constructor(config map[string]interface{}, cache *registry.Cache) (highligh } func init() { - registry.RegisterHighlighter(Name, Constructor) + err := registry.RegisterHighlighter(Name, Constructor) + if err != nil { + panic(err) + } } diff --git a/search/highlight/highlighter/html/html.go b/search/highlight/highlighter/html/html.go index ceb686dce..02eca0a59 100644 --- a/search/highlight/highlighter/html/html.go +++ b/search/highlight/highlighter/html/html.go @@ -46,5 +46,8 @@ func Constructor(config map[string]interface{}, cache *registry.Cache) (highligh } func init() { - registry.RegisterHighlighter(Name, Constructor) + err := registry.RegisterHighlighter(Name, Constructor) + if err != nil { + panic(err) + } } diff --git a/search/highlight/highlighter/simple/highlighter_simple.go b/search/highlight/highlighter/simple/highlighter_simple.go index 19949687d..e898a1e61 100644 --- a/search/highlight/highlighter/simple/highlighter_simple.go +++ b/search/highlight/highlighter/simple/highlighter_simple.go @@ -17,6 +17,7 @@ package simple import ( "container/heap" "fmt" + index "github.com/blevesearch/bleve_index_api" "github.com/blevesearch/bleve/v2/registry" @@ -217,5 +218,8 @@ func Constructor(config map[string]interface{}, cache *registry.Cache) (highligh } func init() { - registry.RegisterHighlighter(Name, Constructor) + err := registry.RegisterHighlighter(Name, Constructor) + if err != nil { + panic(err) + } }