convert.go

Documentation: github.com/go-openapi/swag

     1  // Copyright 2015 go-swagger maintainers
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //    http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package swag
    16  
    17  import (
    18  	"math"
    19  	"strconv"
    20  	"strings"
    21  )
    22  
    23  // same as ECMA Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER
    24  const (
    25  	maxJSONFloat         = float64(1<<53 - 1)  // 9007199254740991.0 	 	 2^53 - 1
    26  	minJSONFloat         = -float64(1<<53 - 1) //-9007199254740991.0	-2^53 - 1
    27  	epsilon      float64 = 1e-9
    28  )
    29  
    30  // IsFloat64AJSONInteger allow for integers [-2^53, 2^53-1] inclusive
    31  func IsFloat64AJSONInteger(f float64) bool {
    32  	if math.IsNaN(f) || math.IsInf(f, 0) || f < minJSONFloat || f > maxJSONFloat {
    33  		return false
    34  	}
    35  	fa := math.Abs(f)
    36  	g := float64(uint64(f))
    37  	ga := math.Abs(g)
    38  
    39  	diff := math.Abs(f - g)
    40  
    41  	// more info: https://floating-point-gui.de/errors/comparison/#look-out-for-edge-cases
    42  	switch {
    43  	case f == g: // best case
    44  		return true
    45  	case f == float64(int64(f)) || f == float64(uint64(f)): // optimistic case
    46  		return true
    47  	case f == 0 || g == 0 || diff < math.SmallestNonzeroFloat64: // very close to 0 values
    48  		return diff < (epsilon * math.SmallestNonzeroFloat64)
    49  	}
    50  	// check the relative error
    51  	return diff/math.Min(fa+ga, math.MaxFloat64) < epsilon
    52  }
    53  
    54  var evaluatesAsTrue map[string]struct{}
    55  
    56  func init() {
    57  	evaluatesAsTrue = map[string]struct{}{
    58  		"true":     {},
    59  		"1":        {},
    60  		"yes":      {},
    61  		"ok":       {},
    62  		"y":        {},
    63  		"on":       {},
    64  		"selected": {},
    65  		"checked":  {},
    66  		"t":        {},
    67  		"enabled":  {},
    68  	}
    69  }
    70  
    71  // ConvertBool turn a string into a boolean
    72  func ConvertBool(str string) (bool, error) {
    73  	_, ok := evaluatesAsTrue[strings.ToLower(str)]
    74  	return ok, nil
    75  }
    76  
    77  // ConvertFloat32 turn a string into a float32
    78  func ConvertFloat32(str string) (float32, error) {
    79  	f, err := strconv.ParseFloat(str, 32)
    80  	if err != nil {
    81  		return 0, err
    82  	}
    83  	return float32(f), nil
    84  }
    85  
    86  // ConvertFloat64 turn a string into a float64
    87  func ConvertFloat64(str string) (float64, error) {
    88  	return strconv.ParseFloat(str, 64)
    89  }
    90  
    91  // ConvertInt8 turn a string into an int8
    92  func ConvertInt8(str string) (int8, error) {
    93  	i, err := strconv.ParseInt(str, 10, 8)
    94  	if err != nil {
    95  		return 0, err
    96  	}
    97  	return int8(i), nil
    98  }
    99  
   100  // ConvertInt16 turn a string into an int16
   101  func ConvertInt16(str string) (int16, error) {
   102  	i, err := strconv.ParseInt(str, 10, 16)
   103  	if err != nil {
   104  		return 0, err
   105  	}
   106  	return int16(i), nil
   107  }
   108  
   109  // ConvertInt32 turn a string into an int32
   110  func ConvertInt32(str string) (int32, error) {
   111  	i, err := strconv.ParseInt(str, 10, 32)
   112  	if err != nil {
   113  		return 0, err
   114  	}
   115  	return int32(i), nil
   116  }
   117  
   118  // ConvertInt64 turn a string into an int64
   119  func ConvertInt64(str string) (int64, error) {
   120  	return strconv.ParseInt(str, 10, 64)
   121  }
   122  
   123  // ConvertUint8 turn a string into an uint8
   124  func ConvertUint8(str string) (uint8, error) {
   125  	i, err := strconv.ParseUint(str, 10, 8)
   126  	if err != nil {
   127  		return 0, err
   128  	}
   129  	return uint8(i), nil
   130  }
   131  
   132  // ConvertUint16 turn a string into an uint16
   133  func ConvertUint16(str string) (uint16, error) {
   134  	i, err := strconv.ParseUint(str, 10, 16)
   135  	if err != nil {
   136  		return 0, err
   137  	}
   138  	return uint16(i), nil
   139  }
   140  
   141  // ConvertUint32 turn a string into an uint32
   142  func ConvertUint32(str string) (uint32, error) {
   143  	i, err := strconv.ParseUint(str, 10, 32)
   144  	if err != nil {
   145  		return 0, err
   146  	}
   147  	return uint32(i), nil
   148  }
   149  
   150  // ConvertUint64 turn a string into an uint64
   151  func ConvertUint64(str string) (uint64, error) {
   152  	return strconv.ParseUint(str, 10, 64)
   153  }
   154  
   155  // FormatBool turns a boolean into a string
   156  func FormatBool(value bool) string {
   157  	return strconv.FormatBool(value)
   158  }
   159  
   160  // FormatFloat32 turns a float32 into a string
   161  func FormatFloat32(value float32) string {
   162  	return strconv.FormatFloat(float64(value), 'f', -1, 32)
   163  }
   164  
   165  // FormatFloat64 turns a float64 into a string
   166  func FormatFloat64(value float64) string {
   167  	return strconv.FormatFloat(value, 'f', -1, 64)
   168  }
   169  
   170  // FormatInt8 turns an int8 into a string
   171  func FormatInt8(value int8) string {
   172  	return strconv.FormatInt(int64(value), 10)
   173  }
   174  
   175  // FormatInt16 turns an int16 into a string
   176  func FormatInt16(value int16) string {
   177  	return strconv.FormatInt(int64(value), 10)
   178  }
   179  
   180  // FormatInt32 turns an int32 into a string
   181  func FormatInt32(value int32) string {
   182  	return strconv.Itoa(int(value))
   183  }
   184  
   185  // FormatInt64 turns an int64 into a string
   186  func FormatInt64(value int64) string {
   187  	return strconv.FormatInt(value, 10)
   188  }
   189  
   190  // FormatUint8 turns an uint8 into a string
   191  func FormatUint8(value uint8) string {
   192  	return strconv.FormatUint(uint64(value), 10)
   193  }
   194  
   195  // FormatUint16 turns an uint16 into a string
   196  func FormatUint16(value uint16) string {
   197  	return strconv.FormatUint(uint64(value), 10)
   198  }
   199  
   200  // FormatUint32 turns an uint32 into a string
   201  func FormatUint32(value uint32) string {
   202  	return strconv.FormatUint(uint64(value), 10)
   203  }
   204  
   205  // FormatUint64 turns an uint64 into a string
   206  func FormatUint64(value uint64) string {
   207  	return strconv.FormatUint(value, 10)
   208  }
   209
View as plain text