init

internal/cliutil/optflag.go

@@ -0,0 +1,169 @@
+package cliutil
+
+import (
+	"strconv"
+	"time"
+)
+
+// The Opt* types are flag.Value implementations that remember whether they were
+// given on the command line.
+//
+// They exist for PATCH: api.ProjectPatch uses a pointer per field so the server
+// can tell "leave this alone" from "set it to the zero value". A plain
+// fs.StringVar cannot express that difference — an unset --not-found-file and
+// an explicit --not-found-file="" both arrive as "". Each type's Ptr method
+// produces exactly the pointer the patch field wants.
+
+// OptString is an optional string flag.
+type OptString struct {
+	Val     string
+	Present bool
+}
+
+func (o *OptString) String() string {
+	if o == nil {
+		return ""
+	}
+	return o.Val
+}
+
+func (o *OptString) Set(s string) error {
+	o.Val, o.Present = s, true
+	return nil
+}
+
+// Ptr returns nil unless the flag was given.
+func (o *OptString) Ptr() *string {
+	if !o.Present {
+		return nil
+	}
+	return &o.Val
+}
+
+// OptBool is an optional boolean flag. It may be written as --flag as well as
+// --flag=false.
+type OptBool struct {
+	Val     bool
+	Present bool
+}
+
+func (o *OptBool) String() string {
+	if o == nil {
+		return "false"
+	}
+	return strconv.FormatBool(o.Val)
+}
+
+func (o *OptBool) Set(s string) error {
+	v, err := strconv.ParseBool(s)
+	if err != nil {
+		return err
+	}
+	o.Val, o.Present = v, true
+	return nil
+}
+
+// IsBoolFlag lets flag accept "--spa" without an explicit value.
+func (o *OptBool) IsBoolFlag() bool { return true }
+
+// Ptr returns nil unless the flag was given.
+func (o *OptBool) Ptr() *bool {
+	if !o.Present {
+		return nil
+	}
+	return &o.Val
+}
+
+// OptInt is an optional integer flag.
+type OptInt struct {
+	Val     int
+	Present bool
+}
+
+func (o *OptInt) String() string {
+	if o == nil {
+		return ""
+	}
+	return strconv.Itoa(o.Val)
+}
+
+func (o *OptInt) Set(s string) error {
+	v, err := strconv.Atoi(s)
+	if err != nil {
+		return err
+	}
+	o.Val, o.Present = v, true
+	return nil
+}
+
+// Ptr returns nil unless the flag was given.
+func (o *OptInt) Ptr() *int {
+	if !o.Present {
+		return nil
+	}
+	return &o.Val
+}
+
+// OptBytes is an optional byte count, written as a plain number or with a unit
+// suffix ("256MiB").
+type OptBytes struct {
+	Val     int64
+	Present bool
+}
+
+func (o *OptBytes) String() string {
+	if o == nil {
+		return ""
+	}
+	return strconv.FormatInt(o.Val, 10)
+}
+
+func (o *OptBytes) Set(s string) error {
+	v, err := ParseBytes(s)
+	if err != nil {
+		return err
+	}
+	o.Val, o.Present = v, true
+	return nil
+}
+
+// Ptr returns nil unless the flag was given.
+func (o *OptBytes) Ptr() *int64 {
+	if !o.Present {
+		return nil
+	}
+	return &o.Val
+}
+
+// OptDuration is an optional duration, accepting the same suffixes as
+// ParseDuration.
+type OptDuration struct {
+	Val     time.Duration
+	Present bool
+}
+
+func (o *OptDuration) String() string {
+	if o == nil {
+		return ""
+	}
+	return o.Val.String()
+}
+
+func (o *OptDuration) Set(s string) error {
+	v, err := ParseDuration(s)
+	if err != nil {
+		return err
+	}
+	o.Val, o.Present = v, true
+	return nil
+}
+
+// SecondsPtr returns the duration in whole seconds, or nil if the flag was not
+// given. The API expresses grace periods as an integer number of seconds.
+func (o *OptDuration) SecondsPtr() *int {
+	if !o.Present {
+		return nil
+	}
+	s := int(o.Val / time.Second)
+	return &s
+}