summaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/text/search/search.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/golang.org/x/text/search/search.go')
-rw-r--r--vendor/golang.org/x/text/search/search.go237
1 files changed, 0 insertions, 237 deletions
diff --git a/vendor/golang.org/x/text/search/search.go b/vendor/golang.org/x/text/search/search.go
deleted file mode 100644
index 894b6c6..0000000
--- a/vendor/golang.org/x/text/search/search.go
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:generate go run ../collate/maketables.go -cldr=23 -unicode=6.2.0 -types=search,searchjl -package=search
-
-// Package search provides language-specific search and string matching.
-//
-// Natural language matching can be intricate. For example, Danish will insist
-// "Århus" and "Aarhus" are the same name and Turkish will match I to ı (note
-// the lack of a dot) in a case-insensitive match. This package handles such
-// language-specific details.
-//
-// Text passed to any of the calls in this message does not need to be
-// normalized.
-package search // import "golang.org/x/text/search"
-
-import (
- "strings"
-
- "golang.org/x/text/internal/colltab"
- "golang.org/x/text/language"
-)
-
-// An Option configures a Matcher.
-type Option func(*Matcher)
-
-var (
- // WholeWord restricts matches to complete words. The default is to match at
- // the character level.
- WholeWord Option = nil
-
- // Exact requires that two strings are their exact equivalent. For example
- // å would not match aa in Danish. It overrides any of the ignore options.
- Exact Option = nil
-
- // Loose causes case, diacritics and width to be ignored.
- Loose Option = loose
-
- // IgnoreCase enables case-insensitive search.
- IgnoreCase Option = ignoreCase
-
- // IgnoreDiacritics causes diacritics to be ignored ("ö" == "o").
- IgnoreDiacritics Option = ignoreDiacritics
-
- // IgnoreWidth equates narrow with wide variants.
- IgnoreWidth Option = ignoreWidth
-)
-
-func ignoreDiacritics(m *Matcher) { m.ignoreDiacritics = true }
-func ignoreCase(m *Matcher) { m.ignoreCase = true }
-func ignoreWidth(m *Matcher) { m.ignoreWidth = true }
-func loose(m *Matcher) {
- ignoreDiacritics(m)
- ignoreCase(m)
- ignoreWidth(m)
-}
-
-var (
- // Supported lists the languages for which search differs from its parent.
- Supported language.Coverage
-
- tags []language.Tag
-)
-
-func init() {
- ids := strings.Split(availableLocales, ",")
- tags = make([]language.Tag, len(ids))
- for i, s := range ids {
- tags[i] = language.Raw.MustParse(s)
- }
- Supported = language.NewCoverage(tags)
-}
-
-// New returns a new Matcher for the given language and options.
-func New(t language.Tag, opts ...Option) *Matcher {
- m := &Matcher{
- w: getTable(locales[colltab.MatchLang(t, tags)]),
- }
- for _, f := range opts {
- f(m)
- }
- return m
-}
-
-// A Matcher implements language-specific string matching.
-type Matcher struct {
- w colltab.Weighter
- ignoreCase bool
- ignoreWidth bool
- ignoreDiacritics bool
-}
-
-// An IndexOption specifies how the Index methods of Pattern or Matcher should
-// match the input.
-type IndexOption byte
-
-const (
- // Anchor restricts the search to the start (or end for Backwards) of the
- // text.
- Anchor IndexOption = 1 << iota
-
- // Backwards starts the search from the end of the text.
- Backwards
-
- anchorBackwards = Anchor | Backwards
-)
-
-// Index reports the start and end position of the first occurrence of pat in b
-// or -1, -1 if pat is not present.
-func (m *Matcher) Index(b, pat []byte, opts ...IndexOption) (start, end int) {
- // TODO: implement optimized version that does not use a pattern.
- return m.Compile(pat).Index(b, opts...)
-}
-
-// IndexString reports the start and end position of the first occurrence of pat
-// in s or -1, -1 if pat is not present.
-func (m *Matcher) IndexString(s, pat string, opts ...IndexOption) (start, end int) {
- // TODO: implement optimized version that does not use a pattern.
- return m.CompileString(pat).IndexString(s, opts...)
-}
-
-// Equal reports whether a and b are equivalent.
-func (m *Matcher) Equal(a, b []byte) bool {
- _, end := m.Index(a, b, Anchor)
- return end == len(a)
-}
-
-// EqualString reports whether a and b are equivalent.
-func (m *Matcher) EqualString(a, b string) bool {
- _, end := m.IndexString(a, b, Anchor)
- return end == len(a)
-}
-
-// Compile compiles and returns a pattern that can be used for faster searching.
-func (m *Matcher) Compile(b []byte) *Pattern {
- p := &Pattern{m: m}
- iter := colltab.Iter{Weighter: m.w}
- for iter.SetInput(b); iter.Next(); {
- }
- p.ce = iter.Elems
- p.deleteEmptyElements()
- return p
-}
-
-// CompileString compiles and returns a pattern that can be used for faster
-// searching.
-func (m *Matcher) CompileString(s string) *Pattern {
- p := &Pattern{m: m}
- iter := colltab.Iter{Weighter: m.w}
- for iter.SetInputString(s); iter.Next(); {
- }
- p.ce = iter.Elems
- p.deleteEmptyElements()
- return p
-}
-
-// A Pattern is a compiled search string. It is safe for concurrent use.
-type Pattern struct {
- m *Matcher
- ce []colltab.Elem
-}
-
-// Design note (TODO remove):
-// The cost of retrieving collation elements for each rune, which is used for
-// search as well, is not trivial. Also, algorithms like Boyer-Moore and
-// Sunday require some additional precomputing.
-
-// Index reports the start and end position of the first occurrence of p in b
-// or -1, -1 if p is not present.
-func (p *Pattern) Index(b []byte, opts ...IndexOption) (start, end int) {
- // Pick a large enough buffer such that we likely do not need to allocate
- // and small enough to not cause too much overhead initializing.
- var buf [8]colltab.Elem
-
- it := &colltab.Iter{
- Weighter: p.m.w,
- Elems: buf[:0],
- }
- it.SetInput(b)
-
- var optMask IndexOption
- for _, o := range opts {
- optMask |= o
- }
-
- switch optMask {
- case 0:
- return p.forwardSearch(it)
- case Anchor:
- return p.anchoredForwardSearch(it)
- case Backwards, anchorBackwards:
- panic("TODO: implement")
- default:
- panic("unrecognized option")
- }
-}
-
-// IndexString reports the start and end position of the first occurrence of p
-// in s or -1, -1 if p is not present.
-func (p *Pattern) IndexString(s string, opts ...IndexOption) (start, end int) {
- // Pick a large enough buffer such that we likely do not need to allocate
- // and small enough to not cause too much overhead initializing.
- var buf [8]colltab.Elem
-
- it := &colltab.Iter{
- Weighter: p.m.w,
- Elems: buf[:0],
- }
- it.SetInputString(s)
-
- var optMask IndexOption
- for _, o := range opts {
- optMask |= o
- }
-
- switch optMask {
- case 0:
- return p.forwardSearch(it)
- case Anchor:
- return p.anchoredForwardSearch(it)
- case Backwards, anchorBackwards:
- panic("TODO: implement")
- default:
- panic("unrecognized option")
- }
-}
-
-// TODO:
-// - Maybe IndexAll methods (probably not necessary).
-// - Some way to match patterns in a Reader (a bit tricky).
-// - Some fold transformer that folds text to comparable text, based on the
-// search options. This is a common technique, though very different from the
-// collation-based design of this package. It has a somewhat different use
-// case, so probably makes sense to support both. Should probably be in a
-// different package, though, as it uses completely different kind of tables
-// (based on norm, cases, width and range tables.)