/
prefix_rule.go
134 lines (121 loc) · 2.79 KB
/
prefix_rule.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
package picker
import (
"encoding/json"
"github.com/chanced/dynamic"
)
type PrefixRuleParams struct {
// (Required) Beginning characters of terms you wish to find in the
// top-level <field>.
Prefix string `json:"prefix"`
// (Optional, string) analyzer used to analyze terms in the query. Defaults
// to the top-level <field>'s analyzer.
Analyzer string `json:"analyzer,omitempty"`
// (Optional) An optional interval filter.
Filter RuleFilterer `json:"filter,omitempty"`
// (Optional) If specified, then match intervals from this field
// rather than the top-level <field>.
//
// The prefix is normalized using the search analyzer from this field,
// unless a separate analyzer is specified.
UseField string `json:"use_field,omitempty"`
}
func (PrefixRuleParams) Type() RuleType {
return RuleTypePrefix
}
func (p PrefixRuleParams) Rule() (Rule, error) {
return p.PrefixRule()
}
func (p PrefixRuleParams) PrefixRule() (*PrefixRule, error) {
r := &PrefixRule{}
r.SetUseField(p.UseField)
r.SetAnalyzer(p.Analyzer)
err := r.SetPrefix(p.Prefix)
if err != nil {
return r, err
}
err = r.SetFilter(p.Filter)
if err != nil {
return r, err
}
return r, nil
}
type PrefixRule struct {
analyzerParam
ruleFilterParam
useFieldParam
prefix string
}
func (p PrefixRule) Prefix() string {
return p.prefix
}
func (p *PrefixRule) Rule() (QueryRule, error) {
return p, nil
}
func (p *PrefixRule) SetPrefix(prefix string) error {
if len(prefix) == 0 {
return ErrPrefixRequired
}
p.prefix = prefix
return nil
}
func (PrefixRule) Type() RuleType {
return RuleTypePrefix
}
func (p *PrefixRule) UnmarshalBSON(data []byte) error {
return p.UnmarshalJSON(data)
}
func (p *PrefixRule) UnmarshalJSON(data []byte) error {
*p = PrefixRule{}
rd := dynamic.JSON(data)
var r prefixRule
if rd.IsString() {
var str string
err := json.Unmarshal(rd, &str)
if err != nil {
return err
}
r = prefixRule{
Prefix: str,
}
} else {
err := json.Unmarshal(rd, &r)
if err != nil {
return err
}
}
mv, err := r.PrefixRule()
*p = *mv
return err
}
func (p PrefixRule) MarshalBSON() ([]byte, error) {
return p.MarshalJSON()
}
func (p PrefixRule) MarshalJSON() ([]byte, error) {
return json.Marshal(prefixRule{
Prefix: p.prefix,
Analyzer: p.analyzer,
Filter: p.filter,
UseField: p.useField,
})
}
//easyjson:json
type prefixRule struct {
Prefix string `json:"prefix"`
Analyzer string `json:"analyzer,omitempty"`
Filter *RuleFilter `json:"filter,omitempty"`
UseField string `json:"use_field,omitempty"`
}
func (p prefixRule) PrefixRule() (*PrefixRule, error) {
r := &PrefixRule{}
r.SetUseField(p.UseField)
r.SetAnalyzer(p.Analyzer)
err := r.SetPrefix(p.Prefix)
if err != nil {
return r, err
}
err = r.SetFilter(p.Filter)
if err != nil {
return r, err
}
return r, nil
}