@@ -681,20 +681,6 @@ func transformAndWrite(api API, ctx Context, status int, ct string, body any) er
681681 return nil
682682}
683683
684- func parseArrElement [T any ](values []string , parse func (string ) (T , error )) ([]T , error ) {
685- result := make ([]T , 0 , len (values ))
686-
687- for i := range values {
688- v , err := parse (values [i ])
689- if err != nil {
690- return nil , err
691- }
692- result = append (result , v )
693- }
694-
695- return result , nil
696- }
697-
698684// writeHeader is a utility function to write a header value to the response.
699685// the `write` function should be either `ctx.SetHeader` or `ctx.AppendHeader`.
700686func writeHeader (write func (string , string ), info * headerInfo , f reflect.Value ) {
@@ -1895,7 +1881,8 @@ func parseInto(ctx Context, f reflect.Value, value string, preSplit []string, p
18951881// parseSliceInto converts a slice of string values into the expected type of f
18961882// and sets the result on f.
18971883func parseSliceInto (f reflect.Value , values []string ) (any , error ) {
1898- switch f .Type ().Elem ().Kind () {
1884+ elemType := f .Type ().Elem ()
1885+ switch elemType .Kind () {
18991886 case reflect .String :
19001887 if f .Type () == stringSliceType {
19011888 f .Set (reflect .ValueOf (values ))
@@ -1912,198 +1899,45 @@ func parseSliceInto(f reflect.Value, values []string) (any, error) {
19121899 }
19131900
19141901 return values , nil
1915- case reflect .Int :
1916- vs , err := parseArrElement (values , func (s string ) (int , error ) {
1917- val , err := strconv .ParseInt (s , 10 , strconv .IntSize )
1918- if err != nil {
1919- return 0 , err
1920- }
1921-
1922- return int (val ), nil
1923- })
1924- if err != nil {
1925- return nil , errors .New ("invalid integer" )
1926- }
1927-
1928- f .Set (reflect .ValueOf (vs ))
1929-
1930- return vs , nil
1931- case reflect .Int8 :
1932- vs , err := parseArrElement (values , func (s string ) (int8 , error ) {
1933- val , err := strconv .ParseInt (s , 10 , 8 )
1934- if err != nil {
1935- return 0 , err
1936- }
1937-
1938- return int8 (val ), nil
1939- })
1940- if err != nil {
1941- return nil , errors .New ("invalid integer" )
1942- }
1943-
1944- f .Set (reflect .ValueOf (vs ))
1945-
1946- return vs , nil
1947- case reflect .Int16 :
1948- vs , err := parseArrElement (values , func (s string ) (int16 , error ) {
1949- val , err := strconv .ParseInt (s , 10 , 16 )
1950- if err != nil {
1951- return 0 , err
1952- }
1953-
1954- return int16 (val ), nil
1955- })
1956- if err != nil {
1957- return nil , errors .New ("invalid integer" )
1958- }
1959-
1960- f .Set (reflect .ValueOf (vs ))
1961-
1962- return vs , nil
1963- case reflect .Int32 :
1964- vs , err := parseArrElement (values , func (s string ) (int32 , error ) {
1965- val , err := strconv .ParseInt (s , 10 , 32 )
1966- if err != nil {
1967- return 0 , err
1968- }
1969-
1970- return int32 (val ), nil
1971- })
1972- if err != nil {
1973- return nil , errors .New ("invalid integer" )
1974- }
1975-
1976- f .Set (reflect .ValueOf (vs ))
1977-
1978- return vs , nil
1979- case reflect .Int64 :
1980- vs , err := parseArrElement (values , func (s string ) (int64 , error ) {
1981- val , err := strconv .ParseInt (s , 10 , 64 )
1982- if err != nil {
1983- return 0 , err
1984- }
1985-
1986- return val , nil
1987- })
1988- if err != nil {
1989- return nil , errors .New ("invalid integer" )
1990- }
1991-
1992- f .Set (reflect .ValueOf (vs ))
1993-
1994- return vs , nil
1995- case reflect .Uint :
1996- vs , err := parseArrElement (values , func (s string ) (uint , error ) {
1997- val , err := strconv .ParseUint (s , 10 , strconv .IntSize )
1998- if err != nil {
1999- return 0 , err
2000- }
2001-
2002- return uint (val ), nil
2003- })
2004- if err != nil {
2005- return nil , errors .New ("invalid integer" )
2006- }
2007-
2008- f .Set (reflect .ValueOf (vs ))
2009-
2010- return vs , nil
2011- case reflect .Uint8 :
2012- vs , err := parseArrElement (values , func (s string ) (uint8 , error ) {
2013- val , err := strconv .ParseUint (s , 10 , 8 )
2014- if err != nil {
2015- return 0 , err
2016- }
2017-
2018- return uint8 (val ), nil
2019- })
2020- if err != nil {
2021- return nil , errors .New ("invalid integer" )
2022- }
2023-
2024- f .Set (reflect .ValueOf (vs ))
2025-
2026- return vs , nil
2027- case reflect .Uint16 :
2028- vs , err := parseArrElement (values , func (s string ) (uint16 , error ) {
2029- val , err := strconv .ParseUint (s , 10 , 16 )
2030- if err != nil {
2031- return 0 , err
2032- }
2033-
2034- return uint16 (val ), nil
2035- })
2036- if err != nil {
2037- return nil , errors .New ("invalid integer" )
2038- }
2039-
2040- f .Set (reflect .ValueOf (vs ))
2041-
2042- return vs , nil
2043- case reflect .Uint32 :
2044- vs , err := parseArrElement (values , func (s string ) (uint32 , error ) {
2045- val , err := strconv .ParseUint (s , 10 , 32 )
2046- if err != nil {
2047- return 0 , err
2048- }
2049-
2050- return uint32 (val ), nil
2051- })
2052- if err != nil {
2053- return nil , errors .New ("invalid integer" )
2054- }
2055-
2056- f .Set (reflect .ValueOf (vs ))
2057-
2058- return vs , nil
2059- case reflect .Uint64 :
2060- vs , err := parseArrElement (values , func (s string ) (uint64 , error ) {
2061- val , err := strconv .ParseUint (s , 10 , 64 )
1902+ case reflect .Int , reflect .Int8 , reflect .Int16 , reflect .Int32 , reflect .Int64 :
1903+ vs := reflect .MakeSlice (reflect .SliceOf (elemType ), len (values ), len (values ))
1904+ for i , s := range values {
1905+ v , err := strconv .ParseInt (s , 10 , elemType .Bits ())
20621906 if err != nil {
2063- return 0 , err
1907+ return nil , errors . New ( "invalid integer" )
20641908 }
2065-
2066- return val , nil
2067- })
2068- if err != nil {
2069- return nil , errors .New ("invalid integer" )
1909+ vs .Index (i ).SetInt (v )
20701910 }
20711911
2072- f .Set (reflect . ValueOf ( vs ) )
1912+ f .Set (vs )
20731913
2074- return vs , nil
2075- case reflect .Float32 :
2076- vs , err := parseArrElement (values , func (s string ) (float32 , error ) {
2077- val , err := strconv .ParseFloat (s , 32 )
1914+ return vs .Interface (), nil
1915+ case reflect .Uint , reflect .Uint8 , reflect .Uint16 , reflect .Uint32 , reflect .Uint64 :
1916+ vs := reflect .MakeSlice (reflect .SliceOf (elemType ), len (values ), len (values ))
1917+ for i , s := range values {
1918+ v , err := strconv .ParseUint (s , 10 , elemType .Bits ())
20781919 if err != nil {
2079- return 0 , err
1920+ return nil , errors . New ( "invalid integer" )
20801921 }
2081-
2082- return float32 (val ), nil
2083- })
2084- if err != nil {
2085- return nil , errors .New ("invalid floating value" )
1922+ vs .Index (i ).SetUint (v )
20861923 }
20871924
2088- f .Set (reflect . ValueOf ( vs ) )
1925+ f .Set (vs )
20891926
2090- return vs , nil
2091- case reflect .Float64 :
2092- vs , err := parseArrElement (values , func (s string ) (float64 , error ) {
2093- val , err := strconv .ParseFloat (s , 64 )
1927+ return vs .Interface (), nil
1928+ case reflect .Float32 , reflect .Float64 :
1929+ vs := reflect .MakeSlice (reflect .SliceOf (elemType ), len (values ), len (values ))
1930+ for i , s := range values {
1931+ v , err := strconv .ParseFloat (s , elemType .Bits ())
20941932 if err != nil {
2095- return 0 , err
1933+ return nil , errors . New ( "invalid floating value" )
20961934 }
2097-
2098- return val , nil
2099- })
2100- if err != nil {
2101- return nil , errors .New ("invalid floating value" )
1935+ vs .Index (i ).SetFloat (v )
21021936 }
21031937
2104- f .Set (reflect . ValueOf ( vs ) )
1938+ f .Set (vs )
21051939
2106- return vs , nil
1940+ return vs . Interface () , nil
21071941 }
21081942
21091943 // Last resort: use the `encoding.TextUnmarshaler` interface.
0 commit comments