key.go raw
1 // Copyright 2014 Unknwon
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"): you may
4 // not use this file except in compliance with the License. You may obtain
5 // a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations
13 // under the License.
14
15 package ini
16
17 import (
18 "bytes"
19 "errors"
20 "fmt"
21 "strconv"
22 "strings"
23 "time"
24 )
25
26 // Key represents a key under a section.
27 type Key struct {
28 s *Section
29 Comment string
30 name string
31 value string
32 isAutoIncrement bool
33 isBooleanType bool
34
35 isShadow bool
36 shadows []*Key
37
38 nestedValues []string
39 }
40
41 // newKey simply return a key object with given values.
42 func newKey(s *Section, name, val string) *Key {
43 return &Key{
44 s: s,
45 name: name,
46 value: val,
47 }
48 }
49
50 func (k *Key) addShadow(val string) error {
51 if k.isShadow {
52 return errors.New("cannot add shadow to another shadow key")
53 } else if k.isAutoIncrement || k.isBooleanType {
54 return errors.New("cannot add shadow to auto-increment or boolean key")
55 }
56
57 if !k.s.f.options.AllowDuplicateShadowValues {
58 // Deduplicate shadows based on their values.
59 if k.value == val {
60 return nil
61 }
62 for i := range k.shadows {
63 if k.shadows[i].value == val {
64 return nil
65 }
66 }
67 }
68
69 shadow := newKey(k.s, k.name, val)
70 shadow.isShadow = true
71 k.shadows = append(k.shadows, shadow)
72 return nil
73 }
74
75 // AddShadow adds a new shadow key to itself.
76 func (k *Key) AddShadow(val string) error {
77 if !k.s.f.options.AllowShadows {
78 return errors.New("shadow key is not allowed")
79 }
80 return k.addShadow(val)
81 }
82
83 func (k *Key) addNestedValue(val string) error {
84 if k.isAutoIncrement || k.isBooleanType {
85 return errors.New("cannot add nested value to auto-increment or boolean key")
86 }
87
88 k.nestedValues = append(k.nestedValues, val)
89 return nil
90 }
91
92 // AddNestedValue adds a nested value to the key.
93 func (k *Key) AddNestedValue(val string) error {
94 if !k.s.f.options.AllowNestedValues {
95 return errors.New("nested value is not allowed")
96 }
97 return k.addNestedValue(val)
98 }
99
100 // ValueMapper represents a mapping function for values, e.g. os.ExpandEnv
101 type ValueMapper func(string) string
102
103 // Name returns name of key.
104 func (k *Key) Name() string {
105 return k.name
106 }
107
108 // Value returns raw value of key for performance purpose.
109 func (k *Key) Value() string {
110 return k.value
111 }
112
113 // ValueWithShadows returns raw values of key and its shadows if any. Shadow
114 // keys with empty values are ignored from the returned list.
115 func (k *Key) ValueWithShadows() []string {
116 if len(k.shadows) == 0 {
117 if k.value == "" {
118 return []string{}
119 }
120 return []string{k.value}
121 }
122
123 vals := make([]string, 0, len(k.shadows)+1)
124 if k.value != "" {
125 vals = append(vals, k.value)
126 }
127 for _, s := range k.shadows {
128 if s.value != "" {
129 vals = append(vals, s.value)
130 }
131 }
132 return vals
133 }
134
135 // NestedValues returns nested values stored in the key.
136 // It is possible returned value is nil if no nested values stored in the key.
137 func (k *Key) NestedValues() []string {
138 return k.nestedValues
139 }
140
141 // transformValue takes a raw value and transforms to its final string.
142 func (k *Key) transformValue(val string) string {
143 if k.s.f.ValueMapper != nil {
144 val = k.s.f.ValueMapper(val)
145 }
146
147 // Fail-fast if no indicate char found for recursive value
148 if !strings.Contains(val, "%") {
149 return val
150 }
151 for i := 0; i < depthValues; i++ {
152 vr := varPattern.FindString(val)
153 if len(vr) == 0 {
154 break
155 }
156
157 // Take off leading '%(' and trailing ')s'.
158 noption := vr[2 : len(vr)-2]
159
160 // Search in the same section.
161 // If not found or found the key itself, then search again in default section.
162 nk, err := k.s.GetKey(noption)
163 if err != nil || k == nk {
164 nk, _ = k.s.f.Section("").GetKey(noption)
165 if nk == nil {
166 // Stop when no results found in the default section,
167 // and returns the value as-is.
168 break
169 }
170 }
171
172 // Substitute by new value and take off leading '%(' and trailing ')s'.
173 val = strings.Replace(val, vr, nk.value, -1)
174 }
175 return val
176 }
177
178 // String returns string representation of value.
179 func (k *Key) String() string {
180 return k.transformValue(k.value)
181 }
182
183 // Validate accepts a validate function which can
184 // return modifed result as key value.
185 func (k *Key) Validate(fn func(string) string) string {
186 return fn(k.String())
187 }
188
189 // parseBool returns the boolean value represented by the string.
190 //
191 // It accepts 1, t, T, TRUE, true, True, YES, yes, Yes, y, ON, on, On,
192 // 0, f, F, FALSE, false, False, NO, no, No, n, OFF, off, Off.
193 // Any other value returns an error.
194 func parseBool(str string) (value bool, err error) {
195 switch str {
196 case "1", "t", "T", "true", "TRUE", "True", "YES", "yes", "Yes", "y", "ON", "on", "On":
197 return true, nil
198 case "0", "f", "F", "false", "FALSE", "False", "NO", "no", "No", "n", "OFF", "off", "Off":
199 return false, nil
200 }
201 return false, fmt.Errorf("parsing \"%s\": invalid syntax", str)
202 }
203
204 // Bool returns bool type value.
205 func (k *Key) Bool() (bool, error) {
206 return parseBool(k.String())
207 }
208
209 // Float64 returns float64 type value.
210 func (k *Key) Float64() (float64, error) {
211 return strconv.ParseFloat(k.String(), 64)
212 }
213
214 // Int returns int type value.
215 func (k *Key) Int() (int, error) {
216 v, err := strconv.ParseInt(k.String(), 0, 64)
217 return int(v), err
218 }
219
220 // Int64 returns int64 type value.
221 func (k *Key) Int64() (int64, error) {
222 return strconv.ParseInt(k.String(), 0, 64)
223 }
224
225 // Uint returns uint type valued.
226 func (k *Key) Uint() (uint, error) {
227 u, e := strconv.ParseUint(k.String(), 0, 64)
228 return uint(u), e
229 }
230
231 // Uint64 returns uint64 type value.
232 func (k *Key) Uint64() (uint64, error) {
233 return strconv.ParseUint(k.String(), 0, 64)
234 }
235
236 // Duration returns time.Duration type value.
237 func (k *Key) Duration() (time.Duration, error) {
238 return time.ParseDuration(k.String())
239 }
240
241 // TimeFormat parses with given format and returns time.Time type value.
242 func (k *Key) TimeFormat(format string) (time.Time, error) {
243 return time.Parse(format, k.String())
244 }
245
246 // Time parses with RFC3339 format and returns time.Time type value.
247 func (k *Key) Time() (time.Time, error) {
248 return k.TimeFormat(time.RFC3339)
249 }
250
251 // MustString returns default value if key value is empty.
252 func (k *Key) MustString(defaultVal string) string {
253 val := k.String()
254 if len(val) == 0 {
255 k.value = defaultVal
256 return defaultVal
257 }
258 return val
259 }
260
261 // MustBool always returns value without error,
262 // it returns false if error occurs.
263 func (k *Key) MustBool(defaultVal ...bool) bool {
264 val, err := k.Bool()
265 if len(defaultVal) > 0 && err != nil {
266 k.value = strconv.FormatBool(defaultVal[0])
267 return defaultVal[0]
268 }
269 return val
270 }
271
272 // MustFloat64 always returns value without error,
273 // it returns 0.0 if error occurs.
274 func (k *Key) MustFloat64(defaultVal ...float64) float64 {
275 val, err := k.Float64()
276 if len(defaultVal) > 0 && err != nil {
277 k.value = strconv.FormatFloat(defaultVal[0], 'f', -1, 64)
278 return defaultVal[0]
279 }
280 return val
281 }
282
283 // MustInt always returns value without error,
284 // it returns 0 if error occurs.
285 func (k *Key) MustInt(defaultVal ...int) int {
286 val, err := k.Int()
287 if len(defaultVal) > 0 && err != nil {
288 k.value = strconv.FormatInt(int64(defaultVal[0]), 10)
289 return defaultVal[0]
290 }
291 return val
292 }
293
294 // MustInt64 always returns value without error,
295 // it returns 0 if error occurs.
296 func (k *Key) MustInt64(defaultVal ...int64) int64 {
297 val, err := k.Int64()
298 if len(defaultVal) > 0 && err != nil {
299 k.value = strconv.FormatInt(defaultVal[0], 10)
300 return defaultVal[0]
301 }
302 return val
303 }
304
305 // MustUint always returns value without error,
306 // it returns 0 if error occurs.
307 func (k *Key) MustUint(defaultVal ...uint) uint {
308 val, err := k.Uint()
309 if len(defaultVal) > 0 && err != nil {
310 k.value = strconv.FormatUint(uint64(defaultVal[0]), 10)
311 return defaultVal[0]
312 }
313 return val
314 }
315
316 // MustUint64 always returns value without error,
317 // it returns 0 if error occurs.
318 func (k *Key) MustUint64(defaultVal ...uint64) uint64 {
319 val, err := k.Uint64()
320 if len(defaultVal) > 0 && err != nil {
321 k.value = strconv.FormatUint(defaultVal[0], 10)
322 return defaultVal[0]
323 }
324 return val
325 }
326
327 // MustDuration always returns value without error,
328 // it returns zero value if error occurs.
329 func (k *Key) MustDuration(defaultVal ...time.Duration) time.Duration {
330 val, err := k.Duration()
331 if len(defaultVal) > 0 && err != nil {
332 k.value = defaultVal[0].String()
333 return defaultVal[0]
334 }
335 return val
336 }
337
338 // MustTimeFormat always parses with given format and returns value without error,
339 // it returns zero value if error occurs.
340 func (k *Key) MustTimeFormat(format string, defaultVal ...time.Time) time.Time {
341 val, err := k.TimeFormat(format)
342 if len(defaultVal) > 0 && err != nil {
343 k.value = defaultVal[0].Format(format)
344 return defaultVal[0]
345 }
346 return val
347 }
348
349 // MustTime always parses with RFC3339 format and returns value without error,
350 // it returns zero value if error occurs.
351 func (k *Key) MustTime(defaultVal ...time.Time) time.Time {
352 return k.MustTimeFormat(time.RFC3339, defaultVal...)
353 }
354
355 // In always returns value without error,
356 // it returns default value if error occurs or doesn't fit into candidates.
357 func (k *Key) In(defaultVal string, candidates []string) string {
358 val := k.String()
359 for _, cand := range candidates {
360 if val == cand {
361 return val
362 }
363 }
364 return defaultVal
365 }
366
367 // InFloat64 always returns value without error,
368 // it returns default value if error occurs or doesn't fit into candidates.
369 func (k *Key) InFloat64(defaultVal float64, candidates []float64) float64 {
370 val := k.MustFloat64()
371 for _, cand := range candidates {
372 if val == cand {
373 return val
374 }
375 }
376 return defaultVal
377 }
378
379 // InInt always returns value without error,
380 // it returns default value if error occurs or doesn't fit into candidates.
381 func (k *Key) InInt(defaultVal int, candidates []int) int {
382 val := k.MustInt()
383 for _, cand := range candidates {
384 if val == cand {
385 return val
386 }
387 }
388 return defaultVal
389 }
390
391 // InInt64 always returns value without error,
392 // it returns default value if error occurs or doesn't fit into candidates.
393 func (k *Key) InInt64(defaultVal int64, candidates []int64) int64 {
394 val := k.MustInt64()
395 for _, cand := range candidates {
396 if val == cand {
397 return val
398 }
399 }
400 return defaultVal
401 }
402
403 // InUint always returns value without error,
404 // it returns default value if error occurs or doesn't fit into candidates.
405 func (k *Key) InUint(defaultVal uint, candidates []uint) uint {
406 val := k.MustUint()
407 for _, cand := range candidates {
408 if val == cand {
409 return val
410 }
411 }
412 return defaultVal
413 }
414
415 // InUint64 always returns value without error,
416 // it returns default value if error occurs or doesn't fit into candidates.
417 func (k *Key) InUint64(defaultVal uint64, candidates []uint64) uint64 {
418 val := k.MustUint64()
419 for _, cand := range candidates {
420 if val == cand {
421 return val
422 }
423 }
424 return defaultVal
425 }
426
427 // InTimeFormat always parses with given format and returns value without error,
428 // it returns default value if error occurs or doesn't fit into candidates.
429 func (k *Key) InTimeFormat(format string, defaultVal time.Time, candidates []time.Time) time.Time {
430 val := k.MustTimeFormat(format)
431 for _, cand := range candidates {
432 if val == cand {
433 return val
434 }
435 }
436 return defaultVal
437 }
438
439 // InTime always parses with RFC3339 format and returns value without error,
440 // it returns default value if error occurs or doesn't fit into candidates.
441 func (k *Key) InTime(defaultVal time.Time, candidates []time.Time) time.Time {
442 return k.InTimeFormat(time.RFC3339, defaultVal, candidates)
443 }
444
445 // RangeFloat64 checks if value is in given range inclusively,
446 // and returns default value if it's not.
447 func (k *Key) RangeFloat64(defaultVal, min, max float64) float64 {
448 val := k.MustFloat64()
449 if val < min || val > max {
450 return defaultVal
451 }
452 return val
453 }
454
455 // RangeInt checks if value is in given range inclusively,
456 // and returns default value if it's not.
457 func (k *Key) RangeInt(defaultVal, min, max int) int {
458 val := k.MustInt()
459 if val < min || val > max {
460 return defaultVal
461 }
462 return val
463 }
464
465 // RangeInt64 checks if value is in given range inclusively,
466 // and returns default value if it's not.
467 func (k *Key) RangeInt64(defaultVal, min, max int64) int64 {
468 val := k.MustInt64()
469 if val < min || val > max {
470 return defaultVal
471 }
472 return val
473 }
474
475 // RangeTimeFormat checks if value with given format is in given range inclusively,
476 // and returns default value if it's not.
477 func (k *Key) RangeTimeFormat(format string, defaultVal, min, max time.Time) time.Time {
478 val := k.MustTimeFormat(format)
479 if val.Unix() < min.Unix() || val.Unix() > max.Unix() {
480 return defaultVal
481 }
482 return val
483 }
484
485 // RangeTime checks if value with RFC3339 format is in given range inclusively,
486 // and returns default value if it's not.
487 func (k *Key) RangeTime(defaultVal, min, max time.Time) time.Time {
488 return k.RangeTimeFormat(time.RFC3339, defaultVal, min, max)
489 }
490
491 // Strings returns list of string divided by given delimiter.
492 func (k *Key) Strings(delim string) []string {
493 str := k.String()
494 if len(str) == 0 {
495 return []string{}
496 }
497
498 runes := []rune(str)
499 vals := make([]string, 0, 2)
500 var buf bytes.Buffer
501 escape := false
502 idx := 0
503 for {
504 if escape {
505 escape = false
506 if runes[idx] != '\\' && !strings.HasPrefix(string(runes[idx:]), delim) {
507 buf.WriteRune('\\')
508 }
509 buf.WriteRune(runes[idx])
510 } else {
511 if runes[idx] == '\\' {
512 escape = true
513 } else if strings.HasPrefix(string(runes[idx:]), delim) {
514 idx += len(delim) - 1
515 vals = append(vals, strings.TrimSpace(buf.String()))
516 buf.Reset()
517 } else {
518 buf.WriteRune(runes[idx])
519 }
520 }
521 idx++
522 if idx == len(runes) {
523 break
524 }
525 }
526
527 if buf.Len() > 0 {
528 vals = append(vals, strings.TrimSpace(buf.String()))
529 }
530
531 return vals
532 }
533
534 // StringsWithShadows returns list of string divided by given delimiter.
535 // Shadows will also be appended if any.
536 func (k *Key) StringsWithShadows(delim string) []string {
537 vals := k.ValueWithShadows()
538 results := make([]string, 0, len(vals)*2)
539 for i := range vals {
540 if len(vals) == 0 {
541 continue
542 }
543
544 results = append(results, strings.Split(vals[i], delim)...)
545 }
546
547 for i := range results {
548 results[i] = k.transformValue(strings.TrimSpace(results[i]))
549 }
550 return results
551 }
552
553 // Float64s returns list of float64 divided by given delimiter. Any invalid input will be treated as zero value.
554 func (k *Key) Float64s(delim string) []float64 {
555 vals, _ := k.parseFloat64s(k.Strings(delim), true, false)
556 return vals
557 }
558
559 // Ints returns list of int divided by given delimiter. Any invalid input will be treated as zero value.
560 func (k *Key) Ints(delim string) []int {
561 vals, _ := k.parseInts(k.Strings(delim), true, false)
562 return vals
563 }
564
565 // Int64s returns list of int64 divided by given delimiter. Any invalid input will be treated as zero value.
566 func (k *Key) Int64s(delim string) []int64 {
567 vals, _ := k.parseInt64s(k.Strings(delim), true, false)
568 return vals
569 }
570
571 // Uints returns list of uint divided by given delimiter. Any invalid input will be treated as zero value.
572 func (k *Key) Uints(delim string) []uint {
573 vals, _ := k.parseUints(k.Strings(delim), true, false)
574 return vals
575 }
576
577 // Uint64s returns list of uint64 divided by given delimiter. Any invalid input will be treated as zero value.
578 func (k *Key) Uint64s(delim string) []uint64 {
579 vals, _ := k.parseUint64s(k.Strings(delim), true, false)
580 return vals
581 }
582
583 // Bools returns list of bool divided by given delimiter. Any invalid input will be treated as zero value.
584 func (k *Key) Bools(delim string) []bool {
585 vals, _ := k.parseBools(k.Strings(delim), true, false)
586 return vals
587 }
588
589 // TimesFormat parses with given format and returns list of time.Time divided by given delimiter.
590 // Any invalid input will be treated as zero value (0001-01-01 00:00:00 +0000 UTC).
591 func (k *Key) TimesFormat(format, delim string) []time.Time {
592 vals, _ := k.parseTimesFormat(format, k.Strings(delim), true, false)
593 return vals
594 }
595
596 // Times parses with RFC3339 format and returns list of time.Time divided by given delimiter.
597 // Any invalid input will be treated as zero value (0001-01-01 00:00:00 +0000 UTC).
598 func (k *Key) Times(delim string) []time.Time {
599 return k.TimesFormat(time.RFC3339, delim)
600 }
601
602 // ValidFloat64s returns list of float64 divided by given delimiter. If some value is not float, then
603 // it will not be included to result list.
604 func (k *Key) ValidFloat64s(delim string) []float64 {
605 vals, _ := k.parseFloat64s(k.Strings(delim), false, false)
606 return vals
607 }
608
609 // ValidInts returns list of int divided by given delimiter. If some value is not integer, then it will
610 // not be included to result list.
611 func (k *Key) ValidInts(delim string) []int {
612 vals, _ := k.parseInts(k.Strings(delim), false, false)
613 return vals
614 }
615
616 // ValidInt64s returns list of int64 divided by given delimiter. If some value is not 64-bit integer,
617 // then it will not be included to result list.
618 func (k *Key) ValidInt64s(delim string) []int64 {
619 vals, _ := k.parseInt64s(k.Strings(delim), false, false)
620 return vals
621 }
622
623 // ValidUints returns list of uint divided by given delimiter. If some value is not unsigned integer,
624 // then it will not be included to result list.
625 func (k *Key) ValidUints(delim string) []uint {
626 vals, _ := k.parseUints(k.Strings(delim), false, false)
627 return vals
628 }
629
630 // ValidUint64s returns list of uint64 divided by given delimiter. If some value is not 64-bit unsigned
631 // integer, then it will not be included to result list.
632 func (k *Key) ValidUint64s(delim string) []uint64 {
633 vals, _ := k.parseUint64s(k.Strings(delim), false, false)
634 return vals
635 }
636
637 // ValidBools returns list of bool divided by given delimiter. If some value is not 64-bit unsigned
638 // integer, then it will not be included to result list.
639 func (k *Key) ValidBools(delim string) []bool {
640 vals, _ := k.parseBools(k.Strings(delim), false, false)
641 return vals
642 }
643
644 // ValidTimesFormat parses with given format and returns list of time.Time divided by given delimiter.
645 func (k *Key) ValidTimesFormat(format, delim string) []time.Time {
646 vals, _ := k.parseTimesFormat(format, k.Strings(delim), false, false)
647 return vals
648 }
649
650 // ValidTimes parses with RFC3339 format and returns list of time.Time divided by given delimiter.
651 func (k *Key) ValidTimes(delim string) []time.Time {
652 return k.ValidTimesFormat(time.RFC3339, delim)
653 }
654
655 // StrictFloat64s returns list of float64 divided by given delimiter or error on first invalid input.
656 func (k *Key) StrictFloat64s(delim string) ([]float64, error) {
657 return k.parseFloat64s(k.Strings(delim), false, true)
658 }
659
660 // StrictInts returns list of int divided by given delimiter or error on first invalid input.
661 func (k *Key) StrictInts(delim string) ([]int, error) {
662 return k.parseInts(k.Strings(delim), false, true)
663 }
664
665 // StrictInt64s returns list of int64 divided by given delimiter or error on first invalid input.
666 func (k *Key) StrictInt64s(delim string) ([]int64, error) {
667 return k.parseInt64s(k.Strings(delim), false, true)
668 }
669
670 // StrictUints returns list of uint divided by given delimiter or error on first invalid input.
671 func (k *Key) StrictUints(delim string) ([]uint, error) {
672 return k.parseUints(k.Strings(delim), false, true)
673 }
674
675 // StrictUint64s returns list of uint64 divided by given delimiter or error on first invalid input.
676 func (k *Key) StrictUint64s(delim string) ([]uint64, error) {
677 return k.parseUint64s(k.Strings(delim), false, true)
678 }
679
680 // StrictBools returns list of bool divided by given delimiter or error on first invalid input.
681 func (k *Key) StrictBools(delim string) ([]bool, error) {
682 return k.parseBools(k.Strings(delim), false, true)
683 }
684
685 // StrictTimesFormat parses with given format and returns list of time.Time divided by given delimiter
686 // or error on first invalid input.
687 func (k *Key) StrictTimesFormat(format, delim string) ([]time.Time, error) {
688 return k.parseTimesFormat(format, k.Strings(delim), false, true)
689 }
690
691 // StrictTimes parses with RFC3339 format and returns list of time.Time divided by given delimiter
692 // or error on first invalid input.
693 func (k *Key) StrictTimes(delim string) ([]time.Time, error) {
694 return k.StrictTimesFormat(time.RFC3339, delim)
695 }
696
697 // parseBools transforms strings to bools.
698 func (k *Key) parseBools(strs []string, addInvalid, returnOnInvalid bool) ([]bool, error) {
699 vals := make([]bool, 0, len(strs))
700 parser := func(str string) (interface{}, error) {
701 val, err := parseBool(str)
702 return val, err
703 }
704 rawVals, err := k.doParse(strs, addInvalid, returnOnInvalid, parser)
705 if err == nil {
706 for _, val := range rawVals {
707 vals = append(vals, val.(bool))
708 }
709 }
710 return vals, err
711 }
712
713 // parseFloat64s transforms strings to float64s.
714 func (k *Key) parseFloat64s(strs []string, addInvalid, returnOnInvalid bool) ([]float64, error) {
715 vals := make([]float64, 0, len(strs))
716 parser := func(str string) (interface{}, error) {
717 val, err := strconv.ParseFloat(str, 64)
718 return val, err
719 }
720 rawVals, err := k.doParse(strs, addInvalid, returnOnInvalid, parser)
721 if err == nil {
722 for _, val := range rawVals {
723 vals = append(vals, val.(float64))
724 }
725 }
726 return vals, err
727 }
728
729 // parseInts transforms strings to ints.
730 func (k *Key) parseInts(strs []string, addInvalid, returnOnInvalid bool) ([]int, error) {
731 vals := make([]int, 0, len(strs))
732 parser := func(str string) (interface{}, error) {
733 val, err := strconv.ParseInt(str, 0, 64)
734 return val, err
735 }
736 rawVals, err := k.doParse(strs, addInvalid, returnOnInvalid, parser)
737 if err == nil {
738 for _, val := range rawVals {
739 vals = append(vals, int(val.(int64)))
740 }
741 }
742 return vals, err
743 }
744
745 // parseInt64s transforms strings to int64s.
746 func (k *Key) parseInt64s(strs []string, addInvalid, returnOnInvalid bool) ([]int64, error) {
747 vals := make([]int64, 0, len(strs))
748 parser := func(str string) (interface{}, error) {
749 val, err := strconv.ParseInt(str, 0, 64)
750 return val, err
751 }
752
753 rawVals, err := k.doParse(strs, addInvalid, returnOnInvalid, parser)
754 if err == nil {
755 for _, val := range rawVals {
756 vals = append(vals, val.(int64))
757 }
758 }
759 return vals, err
760 }
761
762 // parseUints transforms strings to uints.
763 func (k *Key) parseUints(strs []string, addInvalid, returnOnInvalid bool) ([]uint, error) {
764 vals := make([]uint, 0, len(strs))
765 parser := func(str string) (interface{}, error) {
766 val, err := strconv.ParseUint(str, 0, 64)
767 return val, err
768 }
769
770 rawVals, err := k.doParse(strs, addInvalid, returnOnInvalid, parser)
771 if err == nil {
772 for _, val := range rawVals {
773 vals = append(vals, uint(val.(uint64)))
774 }
775 }
776 return vals, err
777 }
778
779 // parseUint64s transforms strings to uint64s.
780 func (k *Key) parseUint64s(strs []string, addInvalid, returnOnInvalid bool) ([]uint64, error) {
781 vals := make([]uint64, 0, len(strs))
782 parser := func(str string) (interface{}, error) {
783 val, err := strconv.ParseUint(str, 0, 64)
784 return val, err
785 }
786 rawVals, err := k.doParse(strs, addInvalid, returnOnInvalid, parser)
787 if err == nil {
788 for _, val := range rawVals {
789 vals = append(vals, val.(uint64))
790 }
791 }
792 return vals, err
793 }
794
795 type Parser func(str string) (interface{}, error)
796
797 // parseTimesFormat transforms strings to times in given format.
798 func (k *Key) parseTimesFormat(format string, strs []string, addInvalid, returnOnInvalid bool) ([]time.Time, error) {
799 vals := make([]time.Time, 0, len(strs))
800 parser := func(str string) (interface{}, error) {
801 val, err := time.Parse(format, str)
802 return val, err
803 }
804 rawVals, err := k.doParse(strs, addInvalid, returnOnInvalid, parser)
805 if err == nil {
806 for _, val := range rawVals {
807 vals = append(vals, val.(time.Time))
808 }
809 }
810 return vals, err
811 }
812
813 // doParse transforms strings to different types
814 func (k *Key) doParse(strs []string, addInvalid, returnOnInvalid bool, parser Parser) ([]interface{}, error) {
815 vals := make([]interface{}, 0, len(strs))
816 for _, str := range strs {
817 val, err := parser(str)
818 if err != nil && returnOnInvalid {
819 return nil, err
820 }
821 if err == nil || addInvalid {
822 vals = append(vals, val)
823 }
824 }
825 return vals, nil
826 }
827
828 // SetValue changes key value.
829 func (k *Key) SetValue(v string) {
830 if k.s.f.BlockMode {
831 k.s.f.lock.Lock()
832 defer k.s.f.lock.Unlock()
833 }
834
835 k.value = v
836 k.s.keysHash[k.name] = v
837 }
838