forked from bytedance/go-tagexpr
/
uint32.go
180 lines (150 loc) · 3.74 KB
/
uint32.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
package ameda_loc
import (
"math"
"strconv"
)
// Uint32ToInterface converts uint32 to interface.
func Uint32ToInterface(v uint32) interface{} {
return v
}
// Uint32ToInterfacePtr converts uint32 to *interface.
func Uint32ToInterfacePtr(v uint32) *interface{} {
r := Uint32ToInterface(v)
return &r
}
// Uint32ToString converts uint32 to string.
func Uint32ToString(v uint32) string {
return strconv.FormatUint(uint64(v), 10)
}
// Uint32ToStringPtr converts uint32 to *string.
func Uint32ToStringPtr(v uint32) *string {
r := Uint32ToString(v)
return &r
}
// Uint32ToBool converts uint32 to bool.
func Uint32ToBool(v uint32) bool {
return v != 0
}
// Uint32ToBoolPtr converts uint32 to *bool.
func Uint32ToBoolPtr(v uint32) *bool {
r := Uint32ToBool(v)
return &r
}
// Uint32ToFloat32 converts uint32 to float32.
func Uint32ToFloat32(v uint32) float32 {
return float32(v)
}
// Uint32ToFloat32Ptr converts uint32 to *float32.
func Uint32ToFloat32Ptr(v uint32) *float32 {
r := Uint32ToFloat32(v)
return &r
}
// Uint32ToFloat64 converts uint32 to float64.
func Uint32ToFloat64(v uint32) float64 {
return float64(v)
}
// Uint32ToFloat64Ptr converts uint32 to *float64.
func Uint32ToFloat64Ptr(v uint32) *float64 {
r := Uint32ToFloat64(v)
return &r
}
// Uint32ToInt converts uint32 to int.
func Uint32ToInt(v uint32) int {
return int(v)
}
// Uint32ToIntPtr converts uint32 to *int.
func Uint32ToIntPtr(v uint32) *int {
r := Uint32ToInt(v)
return &r
}
// Uint32ToInt8 converts uint32 to int8.
func Uint32ToInt8(v uint32) (int8, error) {
if v > math.MaxInt8 {
return 0, errOverflowValue
}
return int8(v), nil
}
// Uint32ToInt8Ptr converts uint32 to *int8.
func Uint32ToInt8Ptr(v uint32) (*int8, error) {
r, err := Uint32ToInt8(v)
return &r, err
}
// Uint32ToInt16 converts uint32 to int16.
func Uint32ToInt16(v uint32) (int16, error) {
if v > math.MaxInt16 {
return 0, errOverflowValue
}
return int16(v), nil
}
// Uint32ToInt16Ptr converts uint32 to *int16.
func Uint32ToInt16Ptr(v uint32) (*int16, error) {
r, err := Uint32ToInt16(v)
return &r, err
}
// Uint32ToInt32 converts uint32 to int32.
func Uint32ToInt32(v uint32) (int32, error) {
if v > math.MaxInt32 {
return 0, errOverflowValue
}
return int32(v), nil
}
// Uint32ToInt32Ptr converts uint32 to *int32.
func Uint32ToInt32Ptr(v uint32) (*int32, error) {
r, err := Uint32ToInt32(v)
return &r, err
}
// Uint32ToInt64 converts uint32 to int64.
func Uint32ToInt64(v uint32) int64 {
return int64(v)
}
// Uint32ToInt64Ptr converts uint32 to *int64.
func Uint32ToInt64Ptr(v uint32) *int64 {
r := Uint32ToInt64(v)
return &r
}
// Uint32ToUint converts uint32 to uint.
func Uint32ToUint(v uint32) uint {
return uint(v)
}
// Uint32ToUintPtr converts uint32 to *uint.
func Uint32ToUintPtr(v uint32) *uint {
r := Uint32ToUint(v)
return &r
}
// Uint32ToUint8 converts uint32 to uint8.
func Uint32ToUint8(v uint32) (uint8, error) {
if v > math.MaxUint8 {
return 0, errOverflowValue
}
return uint8(v), nil
}
// Uint32ToUint8Ptr converts uint32 to *uint8.
func Uint32ToUint8Ptr(v uint32) (*uint8, error) {
r, err := Uint32ToUint8(v)
return &r, err
}
// Uint32ToUint16 converts uint32 to uint16.
func Uint32ToUint16(v uint32) (uint16, error) {
if v > math.MaxUint16 {
return 0, errOverflowValue
}
return uint16(v), nil
}
// Uint32ToUint16Ptr converts uint32 to *uint16.
func Uint32ToUint16Ptr(v uint32) (*uint16, error) {
r, err := Uint32ToUint16(v)
return &r, err
}
// Uint32ToUint32Ptr converts uint32 to *uint32.
func Uint32ToUint32Ptr(v uint32) *uint32 {
return &v
}
// Uint32ToUint64 converts uint32 to uint64.
func Uint32ToUint64(v uint32) uint64 {
return uint64(v)
}
// Uint32ToUint64Ptr converts uint32 to *uint64.
func Uint32ToUint64Ptr(v uint32) *uint64 {
r := Uint32ToUint64(v)
return &r
}