Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
237 lines (199 sloc) 6.73 KB
// 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.)
You can’t perform that action at this time.