forked from aws/aws-sdk-go
-
Notifications
You must be signed in to change notification settings - Fork 0
/
types.go
99 lines (78 loc) · 2.16 KB
/
types.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
package aws
import (
"math"
"strconv"
"time"
)
// A StringValue is a string which may or may not be present.
type StringValue *string
// String converts a Go string into a StringValue.
func String(v string) *string {
return &v
}
// A BooleanValue is a boolean which may or may not be present.
type BooleanValue *bool
// Boolean converts a Go bool into a BooleanValue.
func Boolean(v bool) *bool {
return &v
}
// True is the BooleanValue equivalent of the Go literal true.
func True() BooleanValue {
return Boolean(true)
}
// False is the BooleanValue equivalent of the Go literal false.
func False() BooleanValue {
return Boolean(false)
}
// An IntegerValue is an integer which may or may not be present.
type IntegerValue *int
// Integer converts a Go int into an IntegerValue.
func Integer(v int) *int {
return &v
}
// A LongValue is a 64-bit integer which may or may not be present.
type LongValue *int64
// Long converts a Go int64 into a LongValue.
func Long(v int64) *int64 {
return &v
}
// A FloatValue is a 32-bit floating point number which may or may not be
// present.
type FloatValue *float32
// Float converts a Go float32 into a FloatValue.
func Float(v float32) *float32 {
return &v
}
// A DoubleValue is a 64-bit floating point number which may or may not be
// present.
type DoubleValue *float64
// Double converts a Go float64 into a DoubleValue.
func Double(v float64) *float64 {
return &v
}
// Time converts a Go time.Time into a TimeValue
func Time(t time.Time) *time.Time {
return &t
}
// A UnixTimestamp is a Unix timestamp represented as fractional seconds since
// the Unix epoch.
type UnixTimestamp struct {
Time time.Time
}
// MarshalJSON marshals the timestamp as a float.
func (t UnixTimestamp) MarshalJSON() (text []byte, err error) {
n := float64(t.Time.UnixNano()) / 1e9
s := strconv.FormatFloat(n, 'f', -1, 64)
return []byte(s), nil
}
// UnmarshalJSON unmarshals the timestamp from a float.
func (t *UnixTimestamp) UnmarshalJSON(text []byte) error {
f, err := strconv.ParseFloat(string(text), 64)
if err != nil {
return err
}
sec := math.Floor(f)
nsec := (f - sec) * 1e9
t.Time = time.Unix(int64(sec), int64(nsec)).UTC()
return nil
}