dynamic/uint.go at master · pkg-ru/dynamic · GitHub

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
package dynamic

import (
	"math"
	"strconv"
)

// Uint64 — «снисходительная» обёртка над беззнаковым 64-битным целым числом.
type Uint64 uint64

// ParseUint64 разбирает произвольное значение в Uint64. Принимаются целые
// числа, числовые строки, []byte и json.Number. При невозможности разбора
// возвращается нулевое значение (0).
func ParseUint64(v any) Uint64 {
	switch t := v.(type) {
	case int:
		if t < 0 {
			return 0
		}
		return Uint64(t)
	case int32:
		if t < 0 {
			return 0
		}
		return Uint64(t)
	case int64:
		if t < 0 {
			return 0
		}
		return Uint64(t)
	case uint:
		return Uint64(t)
	case uint32:
		return Uint64(t)
	case uint64:
		return Uint64(t)
	default:
		return parseScalar(v, 0, func(s string) (Uint64, error) {
			n, err := parseIntStr[uint64](s)
			return Uint64(n), err
		})
	}
}

// NewUint64 создаёт Uint64 из произвольного значения, делегируя ParseUint64.
func NewUint64(v any) Uint64 { return ParseUint64(v) }

// Unwrap возвращает нативное значение uint64.
func (u Uint64) Unwrap() uint64 { return uint64(u) }

// ToString реализует scalarFormatter.
func (u Uint64) ToString() string { return strconv.FormatUint(uint64(u), 10) }

func (u Uint64) formatString() string { return u.ToString() }

func (u *Uint64) setFromString(s string) error {
	v, err := parseIntStr[uint64](s)
	if err != nil {
		return newConversionError("Uint64", s, err)
	}
	*u = Uint64(v)
	return nil
}

func (u *Uint64) setNull() { *u = 0 }

// Uint32 — «снисходительная» обёртка над беззнаковым 32-битным целым числом.
type Uint32 uint32

// ParseUint32 разбирает произвольное значение в Uint32; правила те же, что
// у ParseUint64. При невозможности разбора возвращается 0.
func ParseUint32(v any) Uint32 {
	switch t := v.(type) {
	case int:
		if t < 0 || t > math.MaxUint32 {
			return 0
		}
		return Uint32(t)
	case int32:
		if t < 0 {
			return 0
		}
		return Uint32(t)
	case int64:
		if t < 0 || t > math.MaxUint32 {
			return 0
		}
		return Uint32(t)
	case uint:
		if uint64(t) > math.MaxUint32 {
			return 0
		}
		return Uint32(t)
	case uint32:
		return Uint32(t)
	case uint64:
		if t > math.MaxUint32 {
			return 0
		}
		return Uint32(t)
	default:
		return parseScalar(v, 0, func(s string) (Uint32, error) {
			n, err := parseIntStr[uint32](s)
			return Uint32(n), err
		})
	}
}

// NewUint32 создаёт Uint32 из произвольного значения, делегируя ParseUint32.
func NewUint32(v any) Uint32 { return ParseUint32(v) }

// Unwrap возвращает нативное значение uint32.
func (u Uint32) Unwrap() uint32 { return uint32(u) }

// ToString реализует scalarFormatter.
func (u Uint32) ToString() string { return strconv.FormatUint(uint64(u), 10) }

func (u Uint32) formatString() string { return u.ToString() }

func (u *Uint32) setFromString(s string) error {
	v, err := parseIntStr[uint32](s)
	if err != nil {
		return newConversionError("Uint32", s, err)
	}
	*u = Uint32(v)
	return nil
}

func (u *Uint32) setNull() { *u = 0 }

func (u Uint64) typeName() string { return "Uint64" }

func (u Uint32) typeName() string { return "Uint32" }