128 lines
2.4 KiB
Go
128 lines
2.4 KiB
Go
package gocmdDaemon
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
|
|
"encoding/json"
|
|
)
|
|
|
|
type MFlag struct {
|
|
flags map[string]interface{}
|
|
RemainArgs []string
|
|
}
|
|
|
|
func (m *MFlag) Int(short string, long string, value int, usage string) {
|
|
var v int
|
|
m.flags[long] = &v
|
|
flag.IntVar(&v, short, value, usage)
|
|
flag.IntVar(&v, long, value, usage)
|
|
}
|
|
|
|
func (m *MFlag) String(short string, long string, value string, usage string) {
|
|
var v string
|
|
m.flags[long] = &v
|
|
flag.StringVar(&v, short, value, usage)
|
|
flag.StringVar(&v, long, value, usage)
|
|
}
|
|
|
|
func (m *MFlag) Bool(short string, long string, value bool, usage string) {
|
|
var v bool
|
|
m.flags[long] = &v
|
|
flag.BoolVar(&v, short, value, usage)
|
|
flag.BoolVar(&v, long, value, usage)
|
|
}
|
|
|
|
func (m *MFlag) Parse() {
|
|
flag.Parse()
|
|
m.RemainArgs = flag.Args()
|
|
}
|
|
|
|
func (m *MFlag) GetIntFlag(name string) int {
|
|
v, ok := m.flags[name]
|
|
if !ok {
|
|
return -1
|
|
}
|
|
r := *(v.(*int))
|
|
return r
|
|
}
|
|
|
|
func (m *MFlag) GetStringFlag(name string) string {
|
|
v, ok := m.flags[name]
|
|
if !ok {
|
|
return ""
|
|
}
|
|
return *(v.(*string))
|
|
}
|
|
|
|
func (m *MFlag) GetBoolFlag(name string) bool {
|
|
v, ok := m.flags[name]
|
|
if !ok {
|
|
return false
|
|
}
|
|
return *(v.(*bool))
|
|
}
|
|
|
|
func (m *MFlag) MarshalJSON() ([]byte, error) {
|
|
result := make(map[string]interface{})
|
|
for k, v := range m.flags {
|
|
// 判断值类型
|
|
name := k
|
|
switch v.(type) {
|
|
case *int:
|
|
result[k] = m.GetIntFlag(name)
|
|
case *string:
|
|
result[k] = m.GetStringFlag(name)
|
|
case *bool:
|
|
result[k] = m.GetBoolFlag(name)
|
|
default:
|
|
continue
|
|
}
|
|
// result[k] = *(v.(*interface{}))
|
|
}
|
|
result["remainArgs"] = m.RemainArgs
|
|
return json.Marshal(result)
|
|
}
|
|
|
|
func (m *MFlag) UnmarshalJSON(data []byte) error {
|
|
var result map[string]interface{}
|
|
err := json.Unmarshal(data, &result)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for k, v := range result {
|
|
if k == "remainArgs" {
|
|
m.RemainArgs = convert2StringSlice(v.([]interface{}))
|
|
continue
|
|
}
|
|
switch v.(type) {
|
|
case float64:
|
|
p := int(v.(float64))
|
|
m.flags[k] = &p
|
|
case string:
|
|
p := v.(string)
|
|
m.flags[k] = &p
|
|
case bool:
|
|
p := v.(bool)
|
|
m.flags[k] = &p
|
|
default:
|
|
continue
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func convertSlice[T any, U any](input []T, convert func(T) U) []U {
|
|
result := make([]U, len(input))
|
|
for i, v := range input {
|
|
result[i] = convert(v)
|
|
}
|
|
return result
|
|
}
|
|
|
|
func convert2StringSlice[T any](input []T) []string {
|
|
return convertSlice(input, func(v T) string {
|
|
return fmt.Sprint(v)
|
|
})
|
|
}
|