forked from guregu/null
-
Notifications
You must be signed in to change notification settings - Fork 34
/
uint.go
139 lines (120 loc) · 2.71 KB
/
uint.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
package null
import (
"bytes"
"database/sql/driver"
"encoding/json"
"strconv"
"github.com/volatiletech/null/v9/convert"
)
// Uint is an nullable uint.
type Uint struct {
Uint uint
Valid bool
Set bool
}
// NewUint creates a new Uint
func NewUint(i uint, valid bool) Uint {
return Uint{
Uint: i,
Valid: valid,
Set: true,
}
}
// UintFrom creates a new Uint that will always be valid.
func UintFrom(i uint) Uint {
return NewUint(i, true)
}
// UintFromPtr creates a new Uint that be null if i is nil.
func UintFromPtr(i *uint) Uint {
if i == nil {
return NewUint(0, false)
}
return NewUint(*i, true)
}
// IsValid returns true if this carries and explicit value and
// is not null.
func (u Uint) IsValid() bool {
return u.Set && u.Valid
}
// IsSet returns true if this carries an explicit value (null inclusive)
func (u Uint) IsSet() bool {
return u.Set
}
// UnmarshalJSON implements json.Unmarshaler.
func (u *Uint) UnmarshalJSON(data []byte) error {
u.Set = true
if bytes.Equal(data, NullBytes) {
u.Valid = false
u.Uint = 0
return nil
}
var x uint64
if err := json.Unmarshal(data, &x); err != nil {
return err
}
u.Uint = uint(x)
u.Valid = true
return nil
}
// UnmarshalText implements encoding.TextUnmarshaler.
func (u *Uint) UnmarshalText(text []byte) error {
u.Set = true
if len(text) == 0 {
u.Valid = false
return nil
}
var err error
res, err := strconv.ParseUint(string(text), 10, 0)
u.Valid = err == nil
if u.Valid {
u.Uint = uint(res)
}
return err
}
// MarshalJSON implements json.Marshaler.
func (u Uint) MarshalJSON() ([]byte, error) {
if !u.Valid {
return NullBytes, nil
}
return []byte(strconv.FormatUint(uint64(u.Uint), 10)), nil
}
// MarshalText implements encoding.TextMarshaler.
func (u Uint) MarshalText() ([]byte, error) {
if !u.Valid {
return []byte{}, nil
}
return []byte(strconv.FormatUint(uint64(u.Uint), 10)), nil
}
// SetValid changes this Uint's value and also sets it to be non-null.
func (u *Uint) SetValid(n uint) {
u.Uint = n
u.Valid = true
u.Set = true
}
// Ptr returns a pointer to this Uint's value, or a nil pointer if this Uint is null.
func (u Uint) Ptr() *uint {
if !u.Valid {
return nil
}
return &u.Uint
}
// IsZero returns true for invalid Uints, for future omitempty support (Go 1.4?)
func (u Uint) IsZero() bool {
return !u.Valid
}
// Scan implements the Scanner interface.
func (u *Uint) Scan(value interface{}) error {
if value == nil {
u.Uint, u.Valid, u.Set = 0, false, false
return nil
}
u.Valid, u.Set = true, true
return convert.ConvertAssign(&u.Uint, value)
}
// Value implements the driver Valuer interface.
func (u Uint) Value() (driver.Value, error) {
if !u.Valid {
return nil, nil
}
return int64(u.Uint), nil
}