vanity

vanity - A tiny server for golang vanity redirects
Log | Files | Refs | README | LICENSE

int32_slice.go (4863B)

      1 package pflag
      2 
      3 import (
      4 	"fmt"
      5 	"strconv"
      6 	"strings"
      7 )
      8 
      9 // -- int32Slice Value
     10 type int32SliceValue struct {
     11 	value   *[]int32
     12 	changed bool
     13 }
     14 
     15 func newInt32SliceValue(val []int32, p *[]int32) *int32SliceValue {
     16 	isv := new(int32SliceValue)
     17 	isv.value = p
     18 	*isv.value = val
     19 	return isv
     20 }
     21 
     22 func (s *int32SliceValue) Set(val string) error {
     23 	ss := strings.Split(val, ",")
     24 	out := make([]int32, len(ss))
     25 	for i, d := range ss {
     26 		var err error
     27 		var temp64 int64
     28 		temp64, err = strconv.ParseInt(d, 0, 32)
     29 		if err != nil {
     30 			return err
     31 		}
     32 		out[i] = int32(temp64)
     33 
     34 	}
     35 	if !s.changed {
     36 		*s.value = out
     37 	} else {
     38 		*s.value = append(*s.value, out...)
     39 	}
     40 	s.changed = true
     41 	return nil
     42 }
     43 
     44 func (s *int32SliceValue) Type() string {
     45 	return "int32Slice"
     46 }
     47 
     48 func (s *int32SliceValue) String() string {
     49 	out := make([]string, len(*s.value))
     50 	for i, d := range *s.value {
     51 		out[i] = fmt.Sprintf("%d", d)
     52 	}
     53 	return "[" + strings.Join(out, ",") + "]"
     54 }
     55 
     56 func (s *int32SliceValue) fromString(val string) (int32, error) {
     57 	t64, err := strconv.ParseInt(val, 0, 32)
     58 	if err != nil {
     59 		return 0, err
     60 	}
     61 	return int32(t64), nil
     62 }
     63 
     64 func (s *int32SliceValue) toString(val int32) string {
     65 	return fmt.Sprintf("%d", val)
     66 }
     67 
     68 func (s *int32SliceValue) Append(val string) error {
     69 	i, err := s.fromString(val)
     70 	if err != nil {
     71 		return err
     72 	}
     73 	*s.value = append(*s.value, i)
     74 	return nil
     75 }
     76 
     77 func (s *int32SliceValue) Replace(val []string) error {
     78 	out := make([]int32, len(val))
     79 	for i, d := range val {
     80 		var err error
     81 		out[i], err = s.fromString(d)
     82 		if err != nil {
     83 			return err
     84 		}
     85 	}
     86 	*s.value = out
     87 	return nil
     88 }
     89 
     90 func (s *int32SliceValue) GetSlice() []string {
     91 	out := make([]string, len(*s.value))
     92 	for i, d := range *s.value {
     93 		out[i] = s.toString(d)
     94 	}
     95 	return out
     96 }
     97 
     98 func int32SliceConv(val string) (interface{}, error) {
     99 	val = strings.Trim(val, "[]")
    100 	// Empty string would cause a slice with one (empty) entry
    101 	if len(val) == 0 {
    102 		return []int32{}, nil
    103 	}
    104 	ss := strings.Split(val, ",")
    105 	out := make([]int32, len(ss))
    106 	for i, d := range ss {
    107 		var err error
    108 		var temp64 int64
    109 		temp64, err = strconv.ParseInt(d, 0, 32)
    110 		if err != nil {
    111 			return nil, err
    112 		}
    113 		out[i] = int32(temp64)
    114 
    115 	}
    116 	return out, nil
    117 }
    118 
    119 // GetInt32Slice return the []int32 value of a flag with the given name
    120 func (f *FlagSet) GetInt32Slice(name string) ([]int32, error) {
    121 	val, err := f.getFlagType(name, "int32Slice", int32SliceConv)
    122 	if err != nil {
    123 		return []int32{}, err
    124 	}
    125 	return val.([]int32), nil
    126 }
    127 
    128 // Int32SliceVar defines a int32Slice flag with specified name, default value, and usage string.
    129 // The argument p points to a []int32 variable in which to store the value of the flag.
    130 func (f *FlagSet) Int32SliceVar(p *[]int32, name string, value []int32, usage string) {
    131 	f.VarP(newInt32SliceValue(value, p), name, "", usage)
    132 }
    133 
    134 // Int32SliceVarP is like Int32SliceVar, but accepts a shorthand letter that can be used after a single dash.
    135 func (f *FlagSet) Int32SliceVarP(p *[]int32, name, shorthand string, value []int32, usage string) {
    136 	f.VarP(newInt32SliceValue(value, p), name, shorthand, usage)
    137 }
    138 
    139 // Int32SliceVar defines a int32[] flag with specified name, default value, and usage string.
    140 // The argument p points to a int32[] variable in which to store the value of the flag.
    141 func Int32SliceVar(p *[]int32, name string, value []int32, usage string) {
    142 	CommandLine.VarP(newInt32SliceValue(value, p), name, "", usage)
    143 }
    144 
    145 // Int32SliceVarP is like Int32SliceVar, but accepts a shorthand letter that can be used after a single dash.
    146 func Int32SliceVarP(p *[]int32, name, shorthand string, value []int32, usage string) {
    147 	CommandLine.VarP(newInt32SliceValue(value, p), name, shorthand, usage)
    148 }
    149 
    150 // Int32Slice defines a []int32 flag with specified name, default value, and usage string.
    151 // The return value is the address of a []int32 variable that stores the value of the flag.
    152 func (f *FlagSet) Int32Slice(name string, value []int32, usage string) *[]int32 {
    153 	p := []int32{}
    154 	f.Int32SliceVarP(&p, name, "", value, usage)
    155 	return &p
    156 }
    157 
    158 // Int32SliceP is like Int32Slice, but accepts a shorthand letter that can be used after a single dash.
    159 func (f *FlagSet) Int32SliceP(name, shorthand string, value []int32, usage string) *[]int32 {
    160 	p := []int32{}
    161 	f.Int32SliceVarP(&p, name, shorthand, value, usage)
    162 	return &p
    163 }
    164 
    165 // Int32Slice defines a []int32 flag with specified name, default value, and usage string.
    166 // The return value is the address of a []int32 variable that stores the value of the flag.
    167 func Int32Slice(name string, value []int32, usage string) *[]int32 {
    168 	return CommandLine.Int32SliceP(name, "", value, usage)
    169 }
    170 
    171 // Int32SliceP is like Int32Slice, but accepts a shorthand letter that can be used after a single dash.
    172 func Int32SliceP(name, shorthand string, value []int32, usage string) *[]int32 {
    173 	return CommandLine.Int32SliceP(name, shorthand, value, usage)
    174 }