vendor/github.com/prometheus/common/model/time.go - voltha-go - Gitiles

 // Copyright 2013 The Prometheus Authors
 // 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 (
 	"encoding/json"
 	"errors"
 	"fmt"
 	"math"
 	"strconv"
 	"strings"
 	"time"
 )

 const (
 	// MinimumTick is the minimum supported time resolution. This has to be
 	// at least time.Second in order for the code below to work.
 	minimumTick = time.Millisecond
 	// second is the Time duration equivalent to one second.
 	second = int64(time.Second / minimumTick)
 	// The number of nanoseconds per minimum tick.
 	nanosPerTick = int64(minimumTick / time.Nanosecond)

 	// Earliest is the earliest Time representable. Handy for
 	// initializing a high watermark.
 	Earliest = Time(math.MinInt64)
 	// Latest is the latest Time representable. Handy for initializing
 	// a low watermark.
 	Latest = Time(math.MaxInt64)
 )

 // Time is the number of milliseconds since the epoch
 // (1970-01-01 00:00 UTC) excluding leap seconds.
 type Time int64

 // Interval describes an interval between two timestamps.
 type Interval struct {
 	Start, End Time
 }

 // Now returns the current time as a Time.
 func Now() Time {
 	return TimeFromUnixNano(time.Now().UnixNano())
 }

 // TimeFromUnix returns the Time equivalent to the Unix Time t
 // provided in seconds.
 func TimeFromUnix(t int64) Time {
 	return Time(t * second)
 }

 // TimeFromUnixNano returns the Time equivalent to the Unix Time
 // t provided in nanoseconds.
 func TimeFromUnixNano(t int64) Time {
 	return Time(t / nanosPerTick)
 }

 // Equal reports whether two Times represent the same instant.
 func (t Time) Equal(o Time) bool {
 	return t == o
 }

 // Before reports whether the Time t is before o.
 func (t Time) Before(o Time) bool {
 	return t < o
 }

 // After reports whether the Time t is after o.
 func (t Time) After(o Time) bool {
 	return t > o
 }

 // Add returns the Time t + d.
 func (t Time) Add(d time.Duration) Time {
 	return t + Time(d/minimumTick)
 }

 // Sub returns the Duration t - o.
 func (t Time) Sub(o Time) time.Duration {
 	return time.Duration(t-o) * minimumTick
 }

 // Time returns the time.Time representation of t.
 func (t Time) Time() time.Time {
 	return 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 Time) 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 Time) UnixNano() int64 {
 	return int64(t) * nanosPerTick
 }

 // The number of digits after the dot.
 var dotPrecision = int(math.Log10(float64(second)))

 // String returns a string representation of the Time.
 func (t Time) String() string {
 	return strconv.FormatFloat(float64(t)/float64(second), 'f', -1, 64)
 }

 // MarshalJSON implements the json.Marshaler interface.
 func (t Time) MarshalJSON() ([]byte, error) {
 	return []byte(t.String()), nil
 }

 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (t *Time) UnmarshalJSON(b []byte) error {
 	p := strings.Split(string(b), ".")
 	switch len(p) {
 	case 1:
 		v, err := strconv.ParseInt(p[0], 10, 64)
 		if err != nil {
 			return err
 		}
 		*t = Time(v * second)

 	case 2:
 		v, err := strconv.ParseInt(p[0], 10, 64)
 		if err != nil {
 			return err
 		}
 		v *= second

 		prec := dotPrecision - len(p[1])
 		if prec < 0 {
 			p[1] = p[1][:dotPrecision]
 		} else if prec > 0 {
 			p[1] += strings.Repeat("0", prec)
 		}

 		va, err := strconv.ParseInt(p[1], 10, 32)
 		if err != nil {
 			return err
 		}

 		// If the value was something like -0.1 the negative is lost in the
 		// parsing because of the leading zero, this ensures that we capture it.
 		if len(p[0]) > 0 && p[0][0] == '-' && v+va > 0 {
 			*t = Time(v+va) * -1
 		} else {
 			*t = Time(v + va)
 		}

 	default:
 		return fmt.Errorf("invalid time %q", string(b))
 	}
 	return nil
 }

 // Duration wraps time.Duration. It is used to parse the custom duration format
 // from YAML.
 // This type should not propagate beyond the scope of input/output processing.
 type Duration time.Duration

 // Set implements pflag/flag.Value.
 func (d *Duration) Set(s string) error {
 	var err error
 	*d, err = ParseDuration(s)
 	return err
 }

 // Type implements pflag.Value.
 func (*Duration) Type() string {
 	return "duration"
 }

 func isdigit(c byte) bool { return c >= '0' && c <= '9' }

 // Units are required to go in order from biggest to smallest.
 // This guards against confusion from "1m1d" being 1 minute + 1 day, not 1 month + 1 day.
 var unitMap = map[string]struct {
 	pos  int
 	mult uint64
 }{
 	"ms": {7, uint64(time.Millisecond)},
 	"s":  {6, uint64(time.Second)},
 	"m":  {5, uint64(time.Minute)},
 	"h":  {4, uint64(time.Hour)},
 	"d":  {3, uint64(24 * time.Hour)},
 	"w":  {2, uint64(7 * 24 * time.Hour)},
 	"y":  {1, uint64(365 * 24 * time.Hour)},
 }

 // ParseDuration parses a string into a time.Duration, assuming that a year
 // always has 365d, a week always has 7d, and a day always has 24h.
 // Negative durations are not supported.
 func ParseDuration(s string) (Duration, error) {
 	switch s {
 	case "0":
 		// Allow 0 without a unit.
 		return 0, nil
 	case "":
 		return 0, errors.New("empty duration string")
 	}

 	orig := s
 	var dur uint64
 	lastUnitPos := 0

 	for s != "" {
 		if !isdigit(s[0]) {
 			return 0, fmt.Errorf("not a valid duration string: %q", orig)
 		}
 		// Consume [0-9]*
 		i := 0
 		for ; i < len(s) && isdigit(s[i]); i++ {
 		}
 		v, err := strconv.ParseUint(s[:i], 10, 0)
 		if err != nil {
 			return 0, fmt.Errorf("not a valid duration string: %q", orig)
 		}
 		s = s[i:]

 		// Consume unit.
 		for i = 0; i < len(s) && !isdigit(s[i]); i++ {
 		}
 		if i == 0 {
 			return 0, fmt.Errorf("not a valid duration string: %q", orig)
 		}
 		u := s[:i]
 		s = s[i:]
 		unit, ok := unitMap[u]
 		if !ok {
 			return 0, fmt.Errorf("unknown unit %q in duration %q", u, orig)
 		}
 		if unit.pos <= lastUnitPos { // Units must go in order from biggest to smallest.
 			return 0, fmt.Errorf("not a valid duration string: %q", orig)
 		}
 		lastUnitPos = unit.pos
 		// Check if the provided duration overflows time.Duration (> ~ 290years).
 		if v > 1<<63/unit.mult {
 			return 0, errors.New("duration out of range")
 		}
 		dur += v * unit.mult
 		if dur > 1<<63-1 {
 			return 0, errors.New("duration out of range")
 		}
 	}

 	return Duration(dur), nil
 }

 // ParseDurationAllowNegative is like ParseDuration but also accepts negative durations.
 func ParseDurationAllowNegative(s string) (Duration, error) {
 	if s == "" || s[0] != '-' {
 		return ParseDuration(s)
 	}

 	d, err := ParseDuration(s[1:])

 	return -d, err
 }

 func (d Duration) String() string {
 	var (
 		ms   = int64(time.Duration(d) / time.Millisecond)
 		r    = ""
 		sign = ""
 	)

 	if ms == 0 {
 		return "0s"
 	}

 	if ms < 0 {
 		sign, ms = "-", -ms
 	}

 	f := func(unit string, mult int64, exact bool) {
 		if exact && ms%mult != 0 {
 			return
 		}
 		if v := ms / mult; v > 0 {
 			r += fmt.Sprintf("%d%s", v, unit)
 			ms -= v * mult
 		}
 	}

 	// Only format years and weeks if the remainder is zero, as it is often
 	// easier to read 90d than 12w6d.
 	f("y", 1000*60*60*24*365, true)
 	f("w", 1000*60*60*24*7, true)

 	f("d", 1000*60*60*24, false)
 	f("h", 1000*60*60, false)
 	f("m", 1000*60, false)
 	f("s", 1000, false)
 	f("ms", 1, false)

 	return sign + r
 }

 // MarshalJSON implements the json.Marshaler interface.
 func (d Duration) MarshalJSON() ([]byte, error) {
 	return json.Marshal(d.String())
 }

 // UnmarshalJSON implements the json.Unmarshaler interface.
 func (d *Duration) UnmarshalJSON(bytes []byte) error {
 	var s string
 	if err := json.Unmarshal(bytes, &s); err != nil {
 		return err
 	}
 	dur, err := ParseDuration(s)
 	if err != nil {
 		return err
 	}
 	*d = dur
 	return nil
 }

 // MarshalText implements the encoding.TextMarshaler interface.
 func (d *Duration) MarshalText() ([]byte, error) {
 	return []byte(d.String()), nil
 }

 // UnmarshalText implements the encoding.TextUnmarshaler interface.
 func (d *Duration) UnmarshalText(text []byte) error {
 	var err error
 	*d, err = ParseDuration(string(text))
 	return err
 }

 // MarshalYAML implements the yaml.Marshaler interface.
 func (d Duration) MarshalYAML() (interface{}, error) {
 	return d.String(), nil
 }

 // UnmarshalYAML implements the yaml.Unmarshaler interface.
 func (d *Duration) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	var s string
 	if err := unmarshal(&s); err != nil {
 		return err
 	}
 	dur, err := ParseDuration(s)
 	if err != nil {
 		return err
 	}
 	*d = dur
 	return nil
 }
	// Copyright 2013 The Prometheus Authors
	// 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 (
	"encoding/json"
	"errors"
	"fmt"
	"math"
	"strconv"
	"strings"
	"time"
	)

	const (
	// MinimumTick is the minimum supported time resolution. This has to be
	// at least time.Second in order for the code below to work.
	minimumTick = time.Millisecond
	// second is the Time duration equivalent to one second.
	second = int64(time.Second / minimumTick)
	// The number of nanoseconds per minimum tick.
	nanosPerTick = int64(minimumTick / time.Nanosecond)

	// Earliest is the earliest Time representable. Handy for
	// initializing a high watermark.
	Earliest = Time(math.MinInt64)
	// Latest is the latest Time representable. Handy for initializing
	// a low watermark.
	Latest = Time(math.MaxInt64)
	)

	// Time is the number of milliseconds since the epoch
	// (1970-01-01 00:00 UTC) excluding leap seconds.
	type Time int64

	// Interval describes an interval between two timestamps.
	type Interval struct {
	Start, End Time
	}

	// Now returns the current time as a Time.
	func Now() Time {
	return TimeFromUnixNano(time.Now().UnixNano())
	}

	// TimeFromUnix returns the Time equivalent to the Unix Time t
	// provided in seconds.
	func TimeFromUnix(t int64) Time {
	return Time(t * second)
	}

	// TimeFromUnixNano returns the Time equivalent to the Unix Time
	// t provided in nanoseconds.
	func TimeFromUnixNano(t int64) Time {
	return Time(t / nanosPerTick)
	}

	// Equal reports whether two Times represent the same instant.
	func (t Time) Equal(o Time) bool {
	return t == o
	}

	// Before reports whether the Time t is before o.
	func (t Time) Before(o Time) bool {
	return t < o
	}

	// After reports whether the Time t is after o.
	func (t Time) After(o Time) bool {
	return t > o
	}

	// Add returns the Time t + d.
	func (t Time) Add(d time.Duration) Time {
	return t + Time(d/minimumTick)
	}

	// Sub returns the Duration t - o.
	func (t Time) Sub(o Time) time.Duration {
	return time.Duration(t-o) * minimumTick
	}

	// Time returns the time.Time representation of t.
	func (t Time) Time() time.Time {
	return 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 Time) 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 Time) UnixNano() int64 {
	return int64(t) * nanosPerTick
	}

	// The number of digits after the dot.
	var dotPrecision = int(math.Log10(float64(second)))

	// String returns a string representation of the Time.
	func (t Time) String() string {
	return strconv.FormatFloat(float64(t)/float64(second), 'f', -1, 64)
	}

	// MarshalJSON implements the json.Marshaler interface.
	func (t Time) MarshalJSON() ([]byte, error) {
	return []byte(t.String()), nil
	}

	// UnmarshalJSON implements the json.Unmarshaler interface.
	func (t *Time) UnmarshalJSON(b []byte) error {
	p := strings.Split(string(b), ".")
	switch len(p) {
	case 1:
	v, err := strconv.ParseInt(p[0], 10, 64)
	if err != nil {
	return err
	}
	t = Time(v second)

	case 2:
	v, err := strconv.ParseInt(p[0], 10, 64)
	if err != nil {
	return err
	}
	v *= second

	prec := dotPrecision - len(p[1])
	if prec < 0 {
	p[1] = p[1][:dotPrecision]
	} else if prec > 0 {
	p[1] += strings.Repeat("0", prec)
	}

	va, err := strconv.ParseInt(p[1], 10, 32)
	if err != nil {
	return err
	}

	// If the value was something like -0.1 the negative is lost in the
	// parsing because of the leading zero, this ensures that we capture it.
	if len(p[0]) > 0 && p[0][0] == '-' && v+va > 0 {
	t = Time(v+va) -1
	} else {
	*t = Time(v + va)
	}

	default:
	return fmt.Errorf("invalid time %q", string(b))
	}
	return nil
	}

	// Duration wraps time.Duration. It is used to parse the custom duration format
	// from YAML.
	// This type should not propagate beyond the scope of input/output processing.
	type Duration time.Duration

	// Set implements pflag/flag.Value.
	func (d *Duration) Set(s string) error {
	var err error
	*d, err = ParseDuration(s)
	return err
	}

	// Type implements pflag.Value.
	func (*Duration) Type() string {
	return "duration"
	}

	func isdigit(c byte) bool { return c >= '0' && c <= '9' }

	// Units are required to go in order from biggest to smallest.
	// This guards against confusion from "1m1d" being 1 minute + 1 day, not 1 month + 1 day.
	var unitMap = map[string]struct {
	pos int
	mult uint64
	}{
	"ms": {7, uint64(time.Millisecond)},
	"s": {6, uint64(time.Second)},
	"m": {5, uint64(time.Minute)},
	"h": {4, uint64(time.Hour)},
	"d": {3, uint64(24 * time.Hour)},
	"w": {2, uint64(7 * 24 * time.Hour)},
	"y": {1, uint64(365 * 24 * time.Hour)},
	}

	// ParseDuration parses a string into a time.Duration, assuming that a year
	// always has 365d, a week always has 7d, and a day always has 24h.
	// Negative durations are not supported.
	func ParseDuration(s string) (Duration, error) {
	switch s {
	case "0":
	// Allow 0 without a unit.
	return 0, nil
	case "":
	return 0, errors.New("empty duration string")
	}

	orig := s
	var dur uint64
	lastUnitPos := 0

	for s != "" {
	if !isdigit(s[0]) {
	return 0, fmt.Errorf("not a valid duration string: %q", orig)
	}
	// Consume [0-9]*
	i := 0
	for ; i < len(s) && isdigit(s[i]); i++ {
	}
	v, err := strconv.ParseUint(s[:i], 10, 0)
	if err != nil {
	return 0, fmt.Errorf("not a valid duration string: %q", orig)
	}
	s = s[i:]

	// Consume unit.
	for i = 0; i < len(s) && !isdigit(s[i]); i++ {
	}
	if i == 0 {
	return 0, fmt.Errorf("not a valid duration string: %q", orig)
	}
	u := s[:i]
	s = s[i:]
	unit, ok := unitMap[u]
	if !ok {
	return 0, fmt.Errorf("unknown unit %q in duration %q", u, orig)
	}
	if unit.pos <= lastUnitPos { // Units must go in order from biggest to smallest.
	return 0, fmt.Errorf("not a valid duration string: %q", orig)
	}
	lastUnitPos = unit.pos
	// Check if the provided duration overflows time.Duration (> ~ 290years).
	if v > 1<<63/unit.mult {
	return 0, errors.New("duration out of range")
	}
	dur += v * unit.mult
	if dur > 1<<63-1 {
	return 0, errors.New("duration out of range")
	}
	}

	return Duration(dur), nil
	}

	// ParseDurationAllowNegative is like ParseDuration but also accepts negative durations.
	func ParseDurationAllowNegative(s string) (Duration, error) {
	if s == "" \|\| s[0] != '-' {
	return ParseDuration(s)
	}

	d, err := ParseDuration(s[1:])

	return -d, err
	}

	func (d Duration) String() string {
	var (
	ms = int64(time.Duration(d) / time.Millisecond)
	r = ""
	sign = ""
	)

	if ms == 0 {
	return "0s"
	}

	if ms < 0 {
	sign, ms = "-", -ms
	}

	f := func(unit string, mult int64, exact bool) {
	if exact && ms%mult != 0 {
	return
	}
	if v := ms / mult; v > 0 {
	r += fmt.Sprintf("%d%s", v, unit)
	ms -= v * mult
	}
	}

	// Only format years and weeks if the remainder is zero, as it is often
	// easier to read 90d than 12w6d.
	f("y", 1000606024365, true)
	f("w", 10006060247, true)

	f("d", 10006060*24, false)
	f("h", 10006060, false)
	f("m", 1000*60, false)
	f("s", 1000, false)
	f("ms", 1, false)

	return sign + r
	}

	// MarshalJSON implements the json.Marshaler interface.
	func (d Duration) MarshalJSON() ([]byte, error) {
	return json.Marshal(d.String())
	}

	// UnmarshalJSON implements the json.Unmarshaler interface.
	func (d *Duration) UnmarshalJSON(bytes []byte) error {
	var s string
	if err := json.Unmarshal(bytes, &s); err != nil {
	return err
	}
	dur, err := ParseDuration(s)
	if err != nil {
	return err
	}
	*d = dur
	return nil
	}

	// MarshalText implements the encoding.TextMarshaler interface.
	func (d *Duration) MarshalText() ([]byte, error) {
	return []byte(d.String()), nil
	}

	// UnmarshalText implements the encoding.TextUnmarshaler interface.
	func (d *Duration) UnmarshalText(text []byte) error {
	var err error
	*d, err = ParseDuration(string(text))
	return err
	}

	// MarshalYAML implements the yaml.Marshaler interface.
	func (d Duration) MarshalYAML() (interface{}, error) {
	return d.String(), nil
	}

	// UnmarshalYAML implements the yaml.Unmarshaler interface.
	func (d *Duration) UnmarshalYAML(unmarshal func(interface{}) error) error {
	var s string
	if err := unmarshal(&s); err != nil {
	return err
	}
	dur, err := ParseDuration(s)
	if err != nil {
	return err
	}
	*d = dur
	return nil
	}