ra/ra_flag_float64.go at main · amterp/ra · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
package ra

import "fmt"

type Float64Flag struct {
	Flag[float64]
	min          *float64
	max          *float64
	minInclusive *bool
	maxInclusive *bool
}

func NewFloat64(name string) *Float64Flag {
	return &Float64Flag{Flag: Flag[float64]{BaseFlag: BaseFlag{Name: name, Optional: false}}}
}
func (f *Float64Flag) SetShort(s string) *Float64Flag {
	f.Short = s
	return f
}

func (f *Float64Flag) SetUsage(u string) *Float64Flag {
	f.Usage = u
	return f
}

func (f *Float64Flag) SetDefault(v float64) *Float64Flag {
	f.Default = &v
	return f
}

func (f *Float64Flag) SetOptional(b bool) *Float64Flag {
	f.Optional = b
	return f
}

func (f *Float64Flag) SetHidden(b bool) *Float64Flag {
	f.Hidden = b
	return f
}

func (f *Float64Flag) SetHiddenInShortHelp(b bool) *Float64Flag {
	f.HiddenInShortHelp = b
	return f
}

func (f *Float64Flag) SetPositionalOnly(b bool) *Float64Flag {
	f.PositionalOnly = b
	return f
}

func (f *Float64Flag) SetFlagOnly(b bool) *Float64Flag {
	f.FlagOnly = b
	return f
}

func (f *Float64Flag) SetExcludes(flags []string) *Float64Flag {
	f.Excludes = &flags
	return f
}

func (f *Float64Flag) SetRequires(flags []string) *Float64Flag {
	f.Requires = &flags
	return f
}

func (f *Float64Flag) SetMin(min float64, inclusive bool) *Float64Flag {
	f.min = &min
	f.minInclusive = &inclusive
	return f
}

func (f *Float64Flag) SetMax(max float64, inclusive bool) *Float64Flag {
	f.max = &max
	f.maxInclusive = &inclusive
	return f
}

func (f *Float64Flag) SetCustomUsageType(customType string) *Float64Flag {
	f.CustomUsageType = customType
	return f
}

func (f *Float64Flag) SetCompletionFunc(fn CompletionFunc) *Float64Flag {
	f.CompletionFunc = fn
	return f
}

func (f *Float64Flag) Register(cmd *Cmd, opts ...RegisterOption) (*float64, error) {
	ptr := new(float64)
	return ptr, f.RegisterWithPtr(cmd, ptr, opts...)
}

func (f *Float64Flag) RegisterWithPtr(cmd *Cmd, ptr *float64, opts ...RegisterOption) error {
	regConf := &registerConfig{}
	for _, opt := range opts {
		opt(regConf)
	}

	if _, err := cmd.checkForGlobalFlagOverride(f.Name, f.Short, regConf.global); err != nil {
		return err
	}

	if regConf.global {
		cmd.globalFlags = append(cmd.globalFlags, f.Name)
	}

	// Create copy and set value pointer
	flag := *f
	flag.Value = ptr
	flag.BypassValidation = regConf.bypassValidation

	// Global flags should be flag-only (not positional)
	if regConf.global {
		flag.FlagOnly = true
	}

	// Add to short mapping
	if f.Short != "" {
		if _, exists := cmd.shortToName[f.Short]; exists {
			return fmt.Errorf("short flag %q already defined", f.Short)
		}
		cmd.shortToName[f.Short] = f.Name
	}

	cmd.flags[f.Name] = &flag
	if !flag.FlagOnly {
		// Check for positional-only after variadic error
		if flag.PositionalOnly {
			if err := cmd.validatePositionalOnlyAfterVariadic(f.Name); err != nil {
				return err
			}
		}
		cmd.positional = append(cmd.positional, f.Name)
	} else {
		cmd.nonPositional = append(cmd.nonPositional, f.Name)
	}

	return nil
}