1 package date
2 3 // Copyright 2017 Microsoft Corporation
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 17 import (
18 "bytes"
19 "encoding/binary"
20 "encoding/json"
21 "time"
22 )
23 24 // unixEpoch is the moment in time that should be treated as timestamp 0.
25 var unixEpoch = time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC)
26 27 // UnixTime marshals and unmarshals a time that is represented as the number
28 // of seconds (ignoring skip-seconds) since the Unix Epoch.
29 type UnixTime time.Time
30 31 // Duration returns the time as a Duration since the UnixEpoch.
32 func (t UnixTime) Duration() time.Duration {
33 return time.Time(t).Sub(unixEpoch)
34 }
35 36 // NewUnixTimeFromSeconds creates a UnixTime as a number of seconds from the UnixEpoch.
37 func NewUnixTimeFromSeconds(seconds float64) UnixTime {
38 return NewUnixTimeFromDuration(time.Duration(seconds * float64(time.Second)))
39 }
40 41 // NewUnixTimeFromNanoseconds creates a UnixTime as a number of nanoseconds from the UnixEpoch.
42 func NewUnixTimeFromNanoseconds(nanoseconds int64) UnixTime {
43 return NewUnixTimeFromDuration(time.Duration(nanoseconds))
44 }
45 46 // NewUnixTimeFromDuration creates a UnixTime as a duration of time since the UnixEpoch.
47 func NewUnixTimeFromDuration(dur time.Duration) UnixTime {
48 return UnixTime(unixEpoch.Add(dur))
49 }
50 51 // UnixEpoch retreives the moment considered the Unix Epoch. I.e. The time represented by '0'
52 func UnixEpoch() time.Time {
53 return unixEpoch
54 }
55 56 // MarshalJSON preserves the UnixTime as a JSON number conforming to Unix Timestamp requirements.
57 // (i.e. the number of seconds since midnight January 1st, 1970 not considering leap seconds.)
58 func (t UnixTime) MarshalJSON() ([]byte, error) {
59 buffer := &bytes.Buffer{}
60 enc := json.NewEncoder(buffer)
61 err := enc.Encode(float64(time.Time(t).UnixNano()) / 1e9)
62 if err != nil {
63 return nil, err
64 }
65 return buffer.Bytes(), nil
66 }
67 68 // UnmarshalJSON reconstitures a UnixTime saved as a JSON number of the number of seconds since
69 // midnight January 1st, 1970.
70 func (t *UnixTime) UnmarshalJSON(text []byte) error {
71 dec := json.NewDecoder(bytes.NewReader(text))
72 73 var secondsSinceEpoch float64
74 if err := dec.Decode(&secondsSinceEpoch); err != nil {
75 return err
76 }
77 78 *t = NewUnixTimeFromSeconds(secondsSinceEpoch)
79 80 return nil
81 }
82 83 // MarshalText stores the number of seconds since the Unix Epoch as a textual floating point number.
84 func (t UnixTime) MarshalText() ([]byte, error) {
85 cast := time.Time(t)
86 return cast.MarshalText()
87 }
88 89 // UnmarshalText populates a UnixTime with a value stored textually as a floating point number of seconds since the Unix Epoch.
90 func (t *UnixTime) UnmarshalText(raw []byte) error {
91 var unmarshaled time.Time
92 93 if err := unmarshaled.UnmarshalText(raw); err != nil {
94 return err
95 }
96 97 *t = UnixTime(unmarshaled)
98 return nil
99 }
100 101 // MarshalBinary converts a UnixTime into a binary.LittleEndian float64 of nanoseconds since the epoch.
102 func (t UnixTime) MarshalBinary() ([]byte, error) {
103 buf := &bytes.Buffer{}
104 105 payload := int64(t.Duration())
106 107 if err := binary.Write(buf, binary.LittleEndian, &payload); err != nil {
108 return nil, err
109 }
110 111 return buf.Bytes(), nil
112 }
113 114 // UnmarshalBinary converts a from a binary.LittleEndian float64 of nanoseconds since the epoch into a UnixTime.
115 func (t *UnixTime) UnmarshalBinary(raw []byte) error {
116 var nanosecondsSinceEpoch int64
117 118 if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, &nanosecondsSinceEpoch); err != nil {
119 return err
120 }
121 *t = NewUnixTimeFromNanoseconds(nanosecondsSinceEpoch)
122 return nil
123 }
124