112 lines
3.4 KiB
Go
112 lines
3.4 KiB
Go
// Copyright 2013 Prometheus Team
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package model
|
|
|
|
import (
|
|
"fmt"
|
|
native_time "time"
|
|
)
|
|
|
|
// TODO(julius): Should this use milliseconds/nanoseconds instead? This is
|
|
// mostly hidden from the user of these types when using the
|
|
// methods below, so it will be easy to change this later
|
|
// without requiring significant user code changes.
|
|
|
|
// Timestamp is the number of seconds since the epoch (1970-01-01 00:00 UTC)
|
|
// without leap seconds.
|
|
type Timestamp int64
|
|
|
|
const (
|
|
// MinimumTick is the minimum supported time resolution. This has to be
|
|
// at least native_time.Second in order for the code below to work.
|
|
MinimumTick = native_time.Millisecond
|
|
// second is the timestamp duration equivalent to one second.
|
|
second = int64(native_time.Second / MinimumTick)
|
|
// The number of nanoseconds per minimum tick.
|
|
nanosPerTick = int64(MinimumTick / native_time.Nanosecond)
|
|
)
|
|
|
|
// Equal reports whether two timestamps represent the same instant.
|
|
func (t Timestamp) Equal(o Timestamp) bool {
|
|
return t == o
|
|
}
|
|
|
|
// Before reports whether the timestamp t is before o.
|
|
func (t Timestamp) Before(o Timestamp) bool {
|
|
return t < o
|
|
}
|
|
|
|
// After reports whether the timestamp t is after o.
|
|
func (t Timestamp) After(o Timestamp) bool {
|
|
return t > o
|
|
}
|
|
|
|
// Add returns the Timestamp t + d.
|
|
func (t Timestamp) Add(d native_time.Duration) Timestamp {
|
|
return t + Timestamp(d/MinimumTick)
|
|
}
|
|
|
|
// Sub returns the Duration t - o.
|
|
func (t Timestamp) Sub(o Timestamp) native_time.Duration {
|
|
return native_time.Duration(t-o) * MinimumTick
|
|
}
|
|
|
|
// Time returns the time.Time representation of t.
|
|
func (t Timestamp) Time() native_time.Time {
|
|
return native_time.Unix(int64(t)/second, (int64(t)%second)*nanosPerTick)
|
|
}
|
|
|
|
// Unix returns t as a Unix time, the number of seconds elapsed
|
|
// since January 1, 1970 UTC.
|
|
func (t Timestamp) Unix() int64 {
|
|
return int64(t) / second
|
|
}
|
|
|
|
// UnixNano returns t as a Unix time, the number of nanoseconds elapsed
|
|
// since January 1, 1970 UTC.
|
|
func (t Timestamp) UnixNano() int64 {
|
|
return int64(t) * nanosPerTick
|
|
}
|
|
|
|
// String returns a string representation of the timestamp.
|
|
func (t Timestamp) String() string {
|
|
return fmt.Sprintf("%f", float64(t)/float64(second))
|
|
}
|
|
|
|
func (t Timestamp) MarshalJSON() ([]byte, error) {
|
|
return []byte(t.String()), nil
|
|
}
|
|
|
|
// Now returns the current time as a Timestamp.
|
|
func Now() Timestamp {
|
|
return TimestampFromTime(native_time.Now())
|
|
}
|
|
|
|
// TimestampFromTime returns the Timestamp equivalent to the time.Time t.
|
|
func TimestampFromTime(t native_time.Time) Timestamp {
|
|
return TimestampFromUnixNano(t.UnixNano())
|
|
}
|
|
|
|
// TimestampFromUnix returns the Timestamp equivalent to the Unix timestamp t
|
|
// provided in seconds.
|
|
func TimestampFromUnix(t int64) Timestamp {
|
|
return Timestamp(t * second)
|
|
}
|
|
|
|
// TimestampFromUnixNano returns the Timestamp equivalent to the Unix timestamp
|
|
// t provided in nanoseconds.
|
|
func TimestampFromUnixNano(t int64) Timestamp {
|
|
return Timestamp(t / nanosPerTick)
|
|
}
|