/
time.go
137 lines (115 loc) · 2.8 KB
/
time.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
package null
import (
"bytes"
"database/sql/driver"
"encoding/json"
"fmt"
"time"
"github.com/pkg/errors"
"github.com/Gurpartap/null/internal"
)
type Time struct {
hasValue bool
value time.Time
}
func NewTime(value time.Time, hasValue bool) Time {
opt := &Time{}
if hasValue {
opt.SetValue(value)
}
return *opt
}
// SetValue performs the conversion.
func (opt *Time) SetValue(value time.Time) {
opt.value = value
opt.hasValue = true
}
// Unwrap moves the value out of the optional, if it is Some(value).
// This function returns multiple values, and if that's undesirable,
// consider using Some and None functions.
func (opt Time) Unwrap() (time.Time, bool) {
return opt.getValue(), opt.getHasValue()
}
// UnwrapOr returns the contained value or a default.
func (opt Time) UnwrapOr(def time.Time) time.Time {
if opt.getHasValue() {
return opt.getValue()
}
return def
}
// UnwrapOrElse returns the contained value or computes it from a closure.
func (opt Time) UnwrapOrElse(fn func() time.Time) time.Time {
if opt.getHasValue() {
return opt.getValue()
}
return fn()
}
// UnwrapOrDefault returns the contained value or the default.
func (opt Time) UnwrapOrDefault() time.Time {
if opt.getHasValue() {
return opt.getValue()
}
return time.Time{}
}
// UnwrapOrPanic returns the contained value or panics.
func (opt Time) UnwrapOrPanic() time.Time {
if opt.getHasValue() {
return opt.getValue()
}
panic("unable to unwrap Time")
}
func (opt Time) getHasValue() bool {
return opt.hasValue
}
func (opt Time) getValue() time.Time {
return opt.value
}
// String conforms to fmt Stringer interface.
func (opt Time) String() string {
if value, ok := opt.Unwrap(); ok {
return fmt.Sprintf("Some(%v)", value)
}
return "null"
}
// MarshalJSON implements the json Marshaler interface.
func (opt Time) MarshalJSON() ([]byte, error) {
if !opt.getHasValue() {
return []byte("null"), nil
}
return json.Marshal(opt.getValue())
}
// UnmarshalJSON implements the json Unmarshaler interface.
func (opt *Time) UnmarshalJSON(data []byte) error {
if bytes.Equal(data, []byte("null")) || data == nil {
opt.value, opt.hasValue = time.Time{}, false
return nil
}
err := json.Unmarshal(data, &opt.value)
if err != nil {
opt.hasValue = false
return errors.WithStack(err)
}
opt.hasValue = true
return nil
}
// Scan implements the sql Scanner interface.
func (opt *Time) Scan(src interface{}) error {
if src == nil {
opt.value, opt.hasValue = time.Time{}, false
return nil
}
var value time.Time
err := internal.ConvertAssign(&value, src)
if err != nil {
return errors.WithStack(err)
}
opt.SetValue(value)
return nil
}
// Value implements the driver Valuer interface.
func (opt Time) Value() (driver.Value, error) {
if !opt.getHasValue() {
return nil, nil
}
return time.Time(opt.getValue()), nil
}