Skip to content

Commit ea7270d

Browse files
marjune163marjune163
committed
chore: upgrade goNixArgParser
1 parent 4e9e758 commit ea7270d

File tree

2 files changed

+171
-88
lines changed

2 files changed

+171
-88
lines changed

‎src/goNixArgParser/parseResult.go

+64-30
Original file line numberDiff line numberDiff line change
@@ -102,9 +102,7 @@ func (r *ParseResult) GetBool(key string) (value bool, found bool) {
102102
return
103103
}
104104

105-
value, err := toBool(str)
106-
found = err == nil
107-
return
105+
return toBool(str)
108106
}
109107

110108
func (r *ParseResult) GetInt(key string) (value int, found bool) {
@@ -113,9 +111,34 @@ func (r *ParseResult) GetInt(key string) (value int, found bool) {
113111
return
114112
}
115113

116-
value, err := toInt(str)
117-
found = err == nil
118-
return
114+
return toInt(str)
115+
}
116+
117+
func (r *ParseResult) GetUint(key string) (value uint, found bool) {
118+
str, found := r.GetString(key)
119+
if !found {
120+
return
121+
}
122+
123+
return toUint(str)
124+
}
125+
126+
func (r *ParseResult) GetInt32(key string) (value int32, found bool) {
127+
str, found := r.GetString(key)
128+
if !found {
129+
return
130+
}
131+
132+
return toInt32(str)
133+
}
134+
135+
func (r *ParseResult) GetUint32(key string) (value uint32, found bool) {
136+
str, found := r.GetString(key)
137+
if !found {
138+
return
139+
}
140+
141+
return toUint32(str)
119142
}
120143

121144
func (r *ParseResult) GetInt64(key string) (value int64, found bool) {
@@ -124,9 +147,7 @@ func (r *ParseResult) GetInt64(key string) (value int64, found bool) {
124147
return
125148
}
126149

127-
value, err := toInt64(str)
128-
found = err == nil
129-
return
150+
return toInt64(str)
130151
}
131152

132153
func (r *ParseResult) GetUint64(key string) (value uint64, found bool) {
@@ -135,9 +156,7 @@ func (r *ParseResult) GetUint64(key string) (value uint64, found bool) {
135156
return
136157
}
137158

138-
value, err := toUint64(str)
139-
found = err == nil
140-
return
159+
return toUint64(str)
141160
}
142161

143162
func (r *ParseResult) GetFloat64(key string) (value float64, found bool) {
@@ -146,9 +165,7 @@ func (r *ParseResult) GetFloat64(key string) (value float64, found bool) {
146165
return
147166
}
148167

149-
value, err := toFloat64(str)
150-
found = err == nil
151-
return
168+
return toFloat64(str)
152169
}
153170

154171
// =============================
@@ -185,9 +202,7 @@ func (r *ParseResult) GetBools(key string) (values []bool, found bool) {
185202
return
186203
}
187204

188-
values, err := toBools(strs)
189-
found = err == nil
190-
return
205+
return toBools(strs)
191206
}
192207

193208
func (r *ParseResult) GetInts(key string) (values []int, found bool) {
@@ -196,9 +211,34 @@ func (r *ParseResult) GetInts(key string) (values []int, found bool) {
196211
return
197212
}
198213

199-
values, err := toInts(strs)
200-
found = err == nil
201-
return
214+
return toInts(strs)
215+
}
216+
217+
func (r *ParseResult) GetUints(key string) (values []uint, found bool) {
218+
strs, found := r.GetStrings(key)
219+
if !found {
220+
return
221+
}
222+
223+
return toUints(strs)
224+
}
225+
226+
func (r *ParseResult) GetInt32s(key string) (values []int32, found bool) {
227+
strs, found := r.GetStrings(key)
228+
if !found {
229+
return
230+
}
231+
232+
return toInt32s(strs)
233+
}
234+
235+
func (r *ParseResult) GetUint32s(key string) (values []uint32, found bool) {
236+
strs, found := r.GetStrings(key)
237+
if !found {
238+
return
239+
}
240+
241+
return toUint32s(strs)
202242
}
203243

204244
func (r *ParseResult) GetInt64s(key string) (values []int64, found bool) {
@@ -207,9 +247,7 @@ func (r *ParseResult) GetInt64s(key string) (values []int64, found bool) {
207247
return
208248
}
209249

210-
values, err := toInt64s(strs)
211-
found = err == nil
212-
return
250+
return toInt64s(strs)
213251
}
214252

215253
func (r *ParseResult) GetUint64s(key string) (values []uint64, found bool) {
@@ -218,9 +256,7 @@ func (r *ParseResult) GetUint64s(key string) (values []uint64, found bool) {
218256
return
219257
}
220258

221-
values, err := toUint64s(strs)
222-
found = err == nil
223-
return
259+
return toUint64s(strs)
224260
}
225261

226262
func (r *ParseResult) GetFloat64s(key string) (values []float64, found bool) {
@@ -229,9 +265,7 @@ func (r *ParseResult) GetFloat64s(key string) (values []float64, found bool) {
229265
return
230266
}
231267

232-
values, err := toFloat64s(strs)
233-
found = err == nil
234-
return
268+
return toFloat64s(strs)
235269
}
236270

237271
func (r *ParseResult) GetRests() (rests []string) {

‎src/goNixArgParser/util.go

+107-58
Original file line numberDiff line numberDiff line change
@@ -40,102 +40,151 @@ func stringToSlice(input string) []string {
4040
return []string{input}
4141
}
4242

43-
func toBool(input string) (bool, error) {
43+
func toBool(input string) (bool, bool) {
4444
if len(input) == 0 {
45-
return false, nil
45+
return false, false
4646
}
47-
return strconv.ParseBool(input)
47+
v, err := strconv.ParseBool(input)
48+
return v, err == nil
4849
}
4950

50-
func toBools(input []string) ([]bool, error) {
51-
inputLen := len(input)
52-
53-
output := make([]bool, inputLen)
54-
for i, l := 0, inputLen; i < l; i++ {
55-
v, err := toBool(input[i])
56-
if err != nil {
57-
return nil, err
51+
func toBools(inputs []string) (outputs []bool, ok bool) {
52+
l := len(inputs)
53+
values := make([]bool, l)
54+
for i := 0; i < l; i++ {
55+
values[i], ok = toBool(inputs[i])
56+
if !ok {
57+
return
5858
}
59-
output[i] = v
6059
}
6160

62-
return output, nil
61+
return values, true
6362
}
6463

65-
func toInt(input string) (int, error) {
66-
return strconv.Atoi(input)
64+
func toInt(input string) (int, bool) {
65+
v, err := strconv.Atoi(input)
66+
return v, err == nil
6767
}
6868

69-
func toInts(input []string) ([]int, error) {
70-
inputLen := len(input)
71-
72-
output := make([]int, inputLen)
73-
for i, l := 0, inputLen; i < l; i++ {
74-
v, err := toInt(input[i])
75-
if err != nil {
76-
return nil, err
69+
func toInts(inputs []string) (outputs []int, ok bool) {
70+
l := len(inputs)
71+
values := make([]int, l)
72+
for i := 0; i < l; i++ {
73+
values[i], ok = toInt(inputs[i])
74+
if !ok {
75+
return
7776
}
78-
output[i] = v
7977
}
8078

81-
return output, nil
79+
return values, true
8280
}
8381

84-
func toInt64(input string) (int64, error) {
85-
return strconv.ParseInt(input, 10, 64)
82+
func toUint(input string) (uint, bool) {
83+
v, err := strconv.ParseUint(input, 10, 0)
84+
return uint(v), err == nil
85+
}
86+
87+
func toUints(inputs []string) (outputs []uint, ok bool) {
88+
l := len(inputs)
89+
values := make([]uint, l)
90+
for i := 0; i < l; i++ {
91+
values[i], ok = toUint(inputs[i])
92+
if !ok {
93+
return
94+
}
95+
}
96+
97+
return values, true
8698
}
8799

88-
func toInt64s(input []string) ([]int64, error) {
89-
inputLen := len(input)
100+
func toInt32(input string) (int32, bool) {
101+
v, err := strconv.ParseInt(input, 10, 32)
102+
return int32(v), err == nil
103+
}
90104

91-
output := make([]int64, inputLen)
92-
for i, l := 0, inputLen; i < l; i++ {
93-
v, err := toInt64(input[i])
94-
if err != nil {
95-
return nil, err
105+
func toInt32s(inputs []string) (outputs []int32, ok bool) {
106+
l := len(inputs)
107+
values := make([]int32, l)
108+
for i := 0; i < l; i++ {
109+
values[i], ok = toInt32(inputs[i])
110+
if !ok {
111+
return
96112
}
97-
output[i] = v
98113
}
99114

100-
return output, nil
115+
return values, true
116+
}
117+
118+
func toUint32(input string) (uint32, bool) {
119+
v, err := strconv.ParseUint(input, 10, 32)
120+
return uint32(v), err == nil
101121
}
102122

103-
func toUint64(input string) (uint64, error) {
104-
return strconv.ParseUint(input, 10, 64)
123+
func toUint32s(inputs []string) (outputs []uint32, ok bool) {
124+
l := len(inputs)
125+
values := make([]uint32, l)
126+
for i := 0; i < l; i++ {
127+
values[i], ok = toUint32(inputs[i])
128+
if !ok {
129+
return
130+
}
131+
}
132+
133+
return values, true
105134
}
106135

107-
func toUint64s(input []string) ([]uint64, error) {
108-
inputLen := len(input)
136+
func toInt64(input string) (int64, bool) {
137+
v, err := strconv.ParseInt(input, 10, 64)
138+
return v, err == nil
139+
}
109140

110-
output := make([]uint64, inputLen)
111-
for i, l := 0, inputLen; i < l; i++ {
112-
v, err := toUint64(input[i])
113-
if err != nil {
114-
return nil, err
141+
func toInt64s(inputs []string) (outputs []int64, ok bool) {
142+
l := len(inputs)
143+
values := make([]int64, l)
144+
for i := 0; i < l; i++ {
145+
values[i], ok = toInt64(inputs[i])
146+
if !ok {
147+
return
115148
}
116-
output[i] = v
117149
}
118150

119-
return output, nil
151+
return values, true
152+
}
153+
154+
func toUint64(input string) (uint64, bool) {
155+
v, err := strconv.ParseUint(input, 10, 64)
156+
return v, err == nil
120157
}
121158

122-
func toFloat64(input string) (float64, error) {
123-
return strconv.ParseFloat(input, 64)
159+
func toUint64s(inputs []string) (outputs []uint64, ok bool) {
160+
l := len(inputs)
161+
values := make([]uint64, l)
162+
for i := 0; i < l; i++ {
163+
values[i], ok = toUint64(inputs[i])
164+
if !ok {
165+
return
166+
}
167+
}
168+
169+
return values, true
124170
}
125171

126-
func toFloat64s(input []string) ([]float64, error) {
127-
inputLen := len(input)
172+
func toFloat64(input string) (float64, bool) {
173+
v, err := strconv.ParseFloat(input, 64)
174+
return v, err == nil
175+
}
128176

129-
output := make([]float64, inputLen)
130-
for i, l := 0, inputLen; i < l; i++ {
131-
v, err := toFloat64(input[i])
132-
if err != nil {
133-
return nil, err
177+
func toFloat64s(inputs []string) (outputs []float64, ok bool) {
178+
l := len(inputs)
179+
values := make([]float64, l)
180+
for i := 0; i < l; i++ {
181+
values[i], ok = toFloat64(inputs[i])
182+
if !ok {
183+
return
134184
}
135-
output[i] = v
136185
}
137186

138-
return output, nil
187+
return values, true
139188
}
140189

141190
func contains(collection []string, find string) bool {

0 commit comments

Comments
 (0)