1
package pflag
2

3
// -- stringArray Value
4
type stringArrayValue struct {
5
	value   *[]string
6
	changed bool
7
}
8

9
func newStringArrayValue(val []string, p *[]string) *stringArrayValue {
10
	ssv := new(stringArrayValue)
11
	ssv.value = p
12
	*ssv.value = val
13
	return ssv
14
}
15

16
func (s *stringArrayValue) Set(val string) error {
17
	if !s.changed {
18
		*s.value = []string{val}
19
		s.changed = true
20
	} else {
21
		*s.value = append(*s.value, val)
22
	}
23
	return nil
24
}
25

26
func (s *stringArrayValue) Append(val string) error {
27
	*s.value = append(*s.value, val)
28
	return nil
29
}
30

31
func (s *stringArrayValue) Replace(val []string) error {
32
	out := make([]string, len(val))
33
	for i, d := range val {
34
		out[i] = d
35
	}
36
	*s.value = out
37
	return nil
38
}
39

40
func (s *stringArrayValue) GetSlice() []string {
41
	out := make([]string, len(*s.value))
42
	for i, d := range *s.value {
43
		out[i] = d
44
	}
45
	return out
46
}
47

48
func (s *stringArrayValue) Type() string {
49
	return "stringArray"
50
}
51

52
func (s *stringArrayValue) String() string {
53
	str, _ := writeAsCSV(*s.value)
54
	return "[" + str + "]"
55
}
56

57
func stringArrayConv(sval string) (interface{}, error) {
58
	sval = sval[1 : len(sval)-1]
59
	// An empty string would cause a array with one (empty) string
60
	if len(sval) == 0 {
61
		return []string{}, nil
62
	}
63
	return readAsCSV(sval)
64
}
65

66
// GetStringArray return the []string value of a flag with the given name
67
func (f *FlagSet) GetStringArray(name string) ([]string, error) {
68
	val, err := f.getFlagType(name, "stringArray", stringArrayConv)
69
	if err != nil {
70
		return []string{}, err
71
	}
72
	return val.([]string), nil
73
}
74

75
// StringArrayVar defines a string flag with specified name, default value, and usage string.
76
// The argument p points to a []string variable in which to store the values of the multiple flags.
77
// The value of each argument will not try to be separated by comma. Use a StringSlice for that.
78
func (f *FlagSet) StringArrayVar(p *[]string, name string, value []string, usage string) {
79
	f.VarP(newStringArrayValue(value, p), name, "", usage)
80
}
81

82
// StringArrayVarP is like StringArrayVar, but accepts a shorthand letter that can be used after a single dash.
83
func (f *FlagSet) StringArrayVarP(p *[]string, name, shorthand string, value []string, usage string) {
84
	f.VarP(newStringArrayValue(value, p), name, shorthand, usage)
85
}
86

87
// StringArrayVar defines a string flag with specified name, default value, and usage string.
88
// The argument p points to a []string variable in which to store the value of the flag.
89
// The value of each argument will not try to be separated by comma. Use a StringSlice for that.
90
func StringArrayVar(p *[]string, name string, value []string, usage string) {
91
	CommandLine.VarP(newStringArrayValue(value, p), name, "", usage)
92
}
93

94
// StringArrayVarP is like StringArrayVar, but accepts a shorthand letter that can be used after a single dash.
95
func StringArrayVarP(p *[]string, name, shorthand string, value []string, usage string) {
96
	CommandLine.VarP(newStringArrayValue(value, p), name, shorthand, usage)
97
}
98

99
// StringArray defines a string flag with specified name, default value, and usage string.
100
// The return value is the address of a []string variable that stores the value of the flag.
101
// The value of each argument will not try to be separated by comma. Use a StringSlice for that.
102
func (f *FlagSet) StringArray(name string, value []string, usage string) *[]string {
103
	p := []string{}
104
	f.StringArrayVarP(&p, name, "", value, usage)
105
	return &p
106
}
107

108
// StringArrayP is like StringArray, but accepts a shorthand letter that can be used after a single dash.
109
func (f *FlagSet) StringArrayP(name, shorthand string, value []string, usage string) *[]string {
110
	p := []string{}
111
	f.StringArrayVarP(&p, name, shorthand, value, usage)
112
	return &p
113
}
114

115
// StringArray defines a string flag with specified name, default value, and usage string.
116
// The return value is the address of a []string variable that stores the value of the flag.
117
// The value of each argument will not try to be separated by comma. Use a StringSlice for that.
118
func StringArray(name string, value []string, usage string) *[]string {
119
	return CommandLine.StringArrayP(name, "", value, usage)
120
}
121

122
// StringArrayP is like StringArray, but accepts a shorthand letter that can be used after a single dash.
123
func StringArrayP(name, shorthand string, value []string, usage string) *[]string {
124
	return CommandLine.StringArrayP(name, shorthand, value, usage)
125
}
126

127