1
package pflag
2

3
import (
4
	"bytes"
5
	"encoding/csv"
6
	"strings"
7
)
8

9
// -- stringSlice Value
10
type stringSliceValue struct {
11
	value   *[]string
12
	changed bool
13
}
14

15
func newStringSliceValue(val []string, p *[]string) *stringSliceValue {
16
	ssv := new(stringSliceValue)
17
	ssv.value = p
18
	*ssv.value = val
19
	return ssv
20
}
21

22
func readAsCSV(val string) ([]string, error) {
23
	if val == "" {
24
		return []string{}, nil
25
	}
26
	stringReader := strings.NewReader(val)
27
	csvReader := csv.NewReader(stringReader)
28
	return csvReader.Read()
29
}
30

31
func writeAsCSV(vals []string) (string, error) {
32
	b := &bytes.Buffer{}
33
	w := csv.NewWriter(b)
34
	err := w.Write(vals)
35
	if err != nil {
36
		return "", err
37
	}
38
	w.Flush()
39
	return strings.TrimSuffix(b.String(), "\n"), nil
40
}
41

42
func (s *stringSliceValue) Set(val string) error {
43
	v, err := readAsCSV(val)
44
	if err != nil {
45
		return err
46
	}
47
	if !s.changed {
48
		*s.value = v
49
	} else {
50
		*s.value = append(*s.value, v...)
51
	}
52
	s.changed = true
53
	return nil
54
}
55

56
func (s *stringSliceValue) Type() string {
57
	return "stringSlice"
58
}
59

60
func (s *stringSliceValue) String() string {
61
	str, _ := writeAsCSV(*s.value)
62
	return "[" + str + "]"
63
}
64

65
func (s *stringSliceValue) Append(val string) error {
66
	*s.value = append(*s.value, val)
67
	return nil
68
}
69

70
func (s *stringSliceValue) Replace(val []string) error {
71
	*s.value = val
72
	return nil
73
}
74

75
func (s *stringSliceValue) GetSlice() []string {
76
	return *s.value
77
}
78

79
func stringSliceConv(sval string) (interface{}, error) {
80
	sval = sval[1 : len(sval)-1]
81
	// An empty string would cause a slice with one (empty) string
82
	if len(sval) == 0 {
83
		return []string{}, nil
84
	}
85
	return readAsCSV(sval)
86
}
87

88
// GetStringSlice return the []string value of a flag with the given name
89
func (f *FlagSet) GetStringSlice(name string) ([]string, error) {
90
	val, err := f.getFlagType(name, "stringSlice", stringSliceConv)
91
	if err != nil {
92
		return []string{}, err
93
	}
94
	return val.([]string), nil
95
}
96

97
// StringSliceVar defines a string flag with specified name, default value, and usage string.
98
// The argument p points to a []string variable in which to store the value of the flag.
99
// Compared to StringArray flags, StringSlice flags take comma-separated value as arguments and split them accordingly.
100
// For example:
101
//   --ss="v1,v2" --ss="v3"
102
// will result in
103
//   []string{"v1", "v2", "v3"}
104
func (f *FlagSet) StringSliceVar(p *[]string, name string, value []string, usage string) {
105
	f.VarP(newStringSliceValue(value, p), name, "", usage)
106
}
107

108
// StringSliceVarP is like StringSliceVar, but accepts a shorthand letter that can be used after a single dash.
109
func (f *FlagSet) StringSliceVarP(p *[]string, name, shorthand string, value []string, usage string) {
110
	f.VarP(newStringSliceValue(value, p), name, shorthand, usage)
111
}
112

113
// StringSliceVar defines a string flag with specified name, default value, and usage string.
114
// The argument p points to a []string variable in which to store the value of the flag.
115
// Compared to StringArray flags, StringSlice flags take comma-separated value as arguments and split them accordingly.
116
// For example:
117
//   --ss="v1,v2" --ss="v3"
118
// will result in
119
//   []string{"v1", "v2", "v3"}
120
func StringSliceVar(p *[]string, name string, value []string, usage string) {
121
	CommandLine.VarP(newStringSliceValue(value, p), name, "", usage)
122
}
123

124
// StringSliceVarP is like StringSliceVar, but accepts a shorthand letter that can be used after a single dash.
125
func StringSliceVarP(p *[]string, name, shorthand string, value []string, usage string) {
126
	CommandLine.VarP(newStringSliceValue(value, p), name, shorthand, usage)
127
}
128

129
// StringSlice defines a string flag with specified name, default value, and usage string.
130
// The return value is the address of a []string variable that stores the value of the flag.
131
// Compared to StringArray flags, StringSlice flags take comma-separated value as arguments and split them accordingly.
132
// For example:
133
//   --ss="v1,v2" --ss="v3"
134
// will result in
135
//   []string{"v1", "v2", "v3"}
136
func (f *FlagSet) StringSlice(name string, value []string, usage string) *[]string {
137
	p := []string{}
138
	f.StringSliceVarP(&p, name, "", value, usage)
139
	return &p
140
}
141

142
// StringSliceP is like StringSlice, but accepts a shorthand letter that can be used after a single dash.
143
func (f *FlagSet) StringSliceP(name, shorthand string, value []string, usage string) *[]string {
144
	p := []string{}
145
	f.StringSliceVarP(&p, name, shorthand, value, usage)
146
	return &p
147
}
148

149
// StringSlice defines a string flag with specified name, default value, and usage string.
150
// The return value is the address of a []string variable that stores the value of the flag.
151
// Compared to StringArray flags, StringSlice flags take comma-separated value as arguments and split them accordingly.
152
// For example:
153
//   --ss="v1,v2" --ss="v3"
154
// will result in
155
//   []string{"v1", "v2", "v3"}
156
func StringSlice(name string, value []string, usage string) *[]string {
157
	return CommandLine.StringSliceP(name, "", value, usage)
158
}
159

160
// StringSliceP is like StringSlice, but accepts a shorthand letter that can be used after a single dash.
161
func StringSliceP(name, shorthand string, value []string, usage string) *[]string {
162
	return CommandLine.StringSliceP(name, shorthand, value, usage)
163
}
164

165