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
15package swag
16
17import (
18	"math"
19	"strconv"
20	"strings"
21)
22
23// same as ECMA Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER
24const (
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
31func 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
54var evaluatesAsTrue map[string]struct{}
55
56func 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
72func 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
78func 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
87func ConvertFloat64(str string) (float64, error) {
88	return strconv.ParseFloat(str, 64)
89}
90
91// ConvertInt8 turn a string into an int8
92func 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
101func 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
110func 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
119func ConvertInt64(str string) (int64, error) {
120	return strconv.ParseInt(str, 10, 64)
121}
122
123// ConvertUint8 turn a string into an uint8
124func 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
133func 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
142func 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
151func ConvertUint64(str string) (uint64, error) {
152	return strconv.ParseUint(str, 10, 64)
153}
154
155// FormatBool turns a boolean into a string
156func FormatBool(value bool) string {
157	return strconv.FormatBool(value)
158}
159
160// FormatFloat32 turns a float32 into a string
161func FormatFloat32(value float32) string {
162	return strconv.FormatFloat(float64(value), 'f', -1, 32)
163}
164
165// FormatFloat64 turns a float64 into a string
166func FormatFloat64(value float64) string {
167	return strconv.FormatFloat(value, 'f', -1, 64)
168}
169
170// FormatInt8 turns an int8 into a string
171func FormatInt8(value int8) string {
172	return strconv.FormatInt(int64(value), 10)
173}
174
175// FormatInt16 turns an int16 into a string
176func FormatInt16(value int16) string {
177	return strconv.FormatInt(int64(value), 10)
178}
179
180// FormatInt32 turns an int32 into a string
181func FormatInt32(value int32) string {
182	return strconv.Itoa(int(value))
183}
184
185// FormatInt64 turns an int64 into a string
186func FormatInt64(value int64) string {
187	return strconv.FormatInt(value, 10)
188}
189
190// FormatUint8 turns an uint8 into a string
191func FormatUint8(value uint8) string {
192	return strconv.FormatUint(uint64(value), 10)
193}
194
195// FormatUint16 turns an uint16 into a string
196func FormatUint16(value uint16) string {
197	return strconv.FormatUint(uint64(value), 10)
198}
199
200// FormatUint32 turns an uint32 into a string
201func FormatUint32(value uint32) string {
202	return strconv.FormatUint(uint64(value), 10)
203}
204
205// FormatUint64 turns an uint64 into a string
206func FormatUint64(value uint64) string {
207	return strconv.FormatUint(value, 10)
208}
209