cmd/bpa-operator/vendor/github.com/Azure/go-autorest/autorest/date/unixtime.go

   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 }