// FormattedSecondsToMax8Chars ... func FormattedSecondsToMax8Chars(t time.Duration) (string, error) { sec := t.Seconds() min := t.Minutes() hour := t.Hours() if sec < 1.0 { // 0.999999 sec -> 0.99 sec return fmt.Sprintf("%.2f sec", sec), nil // 8 } else if sec < 10.0 { // 9.99999 sec -> 9.99 sec return fmt.Sprintf("%.2f sec", sec), nil // 8 } else if sec < 600 { // 599,999 sec -> 599 sec return fmt.Sprintf("%.f sec", sec), nil // 7 } else if min < 60 { // 59,999 min -> 59.9 min return fmt.Sprintf("%.1f min", min), nil // 8 } else if hour < 10 { // 9.999 hour -> 9.9 hour return fmt.Sprintf("%.1f hour", hour), nil // 8 } else if hour < 1000 { // 999,999 hour -> 999 hour return fmt.Sprintf("%.f hour", hour), nil // 8 } return "", fmt.Errorf("time (%f hour) greater then max allowed (999 hour)", hour) }
// LogFetches processes all the Fetch items are writes the log to S3 for the parsers to start working. func LogFetches(logChan <-chan *Fetch, errChan <-chan *FetchError, duration *time.Duration) { report := &Report{Novel: 0, Errors: 0, Total: 0} fetchDuration := &FetchDuration{Hours: duration.Hours(), Minutes: duration.Minutes(), Seconds: duration.Seconds()} fetches := &Fetches{} for fetch := range logChan { fetches.Fetch = append(fetches.Fetch, fetch) if fetch.Novel { report.Novel++ } report.Total++ } for err := range errChan { fetches.FetchError = append(fetches.FetchError, err) report.Errors++ report.Total++ } fetches.Meta = &Meta{FetchDuration: fetchDuration, Report: report} content, _ := xml.MarshalIndent(fetches, "", "\t") // Write to S3. logPath := logFilePath() s3content := []byte(xml.Header + string(content)) S3BucketFromOS().Put(logPath, s3content, "application/xml", s3.Private) }
func (this *ProgressBarSimple) renderFixedSizeDuration(dur time.Duration) string { h := dur.Hours() m := dur.Minutes() if h > pbYear*10 { y := int(h / pbYear) h -= float64(y) * pbYear w := h / pbWeek return fmt.Sprintf("%02dy%02dw", y, int(w)) } else if h > pbWeek*10 { return fmt.Sprintf("%05dw", int(h/pbWeek)) } else if h > pbDay*2 { d := int(h / pbDay) h -= pbDay * float64(d) return fmt.Sprintf("%02dd%02dh", d, int(h)) } else if h > 1 { o := int(h) i := m - float64(o)*60 return fmt.Sprintf("%02dh%02dm", o, int(i)) } else if dur.Seconds() < 0 { return "00m00s" } else { i := int(m) s := dur.Seconds() - float64(i)*60 return fmt.Sprintf("%02dm%02ds", i, int(s)) } }
func relativeTime(duration time.Duration) string { hours := int64(math.Abs(duration.Hours())) minutes := int64(math.Abs(duration.Minutes())) when := "" switch { case hours >= (365 * 24): when = "Over an year ago" case hours > (30 * 24): when = fmt.Sprintf("%d months ago", int64(hours/(30*24))) case hours == (30 * 24): when = "a month ago" case hours > 24: when = fmt.Sprintf("%d days ago", int64(hours/24)) case hours == 24: when = "yesterday" case hours >= 2: when = fmt.Sprintf("%d hours ago", hours) case hours > 1: when = "over an hour ago" case hours == 1: when = "an hour ago" case minutes >= 2: when = fmt.Sprintf("%d minutes ago", minutes) case minutes > 1: when = "a minute ago" default: when = "just now" } return when }
func FriendlyDuration(d time.Duration) string { switch { case d.Hours() >= 24: days := int(d.Hours() / 24) hours := int(d.Hours()) - days*24 return joinpair(plural(days, "day"), plural(hours, "hour")) case d.Hours() >= 1: hours := int(d.Hours()) mins := int(int(d.Minutes()) - 60*hours) return joinpair(plural(hours, "hour"), plural(mins, "minute")) case d.Minutes() >= 1: mins := int(d.Minutes()) secs := int(int(d.Seconds()) - 60*mins) return joinpair(plural(mins, "minute"), plural(secs, "second")) case d.Seconds() >= 1: secs := int(d.Seconds()) return plural(secs, "second") case d.Nanoseconds() >= 1000: ms := int(d.Seconds() * 1000) return plural(ms, "millisecond") case d.Nanoseconds() > 0: ns := d.Nanoseconds() return plural(int(ns), "nanosecond") } return "0 seconds" }
func RenderFixedSizeDuration(dur time.Duration) string { h := dur.Hours() m := dur.Minutes() s := dur.Seconds() if h > pbYear*10 { y := int(h / pbYear) h -= float64(y) * pbYear w := h / pbWeek return fmt.Sprintf("%02dy%02dw", y, int(w)) } else if h > pbWeek*10 { return fmt.Sprintf("%05dw", int(h/pbWeek)) } else if h > pbDay*2 { d := int(h / pbDay) h -= pbDay * float64(d) return fmt.Sprintf("%02dd%02dh", d, int(h)) } else if h > 1 { o := int(h) i := m - float64(o)*60 return fmt.Sprintf("%02dh%02dm", o, int(i)) } else if s > 99 { i := int(m) o := s - float64(i)*60 return fmt.Sprintf("%02dm%02ds", i, int(o)) } else if s < 1 { return "00m00s" } else { ms := (s - float64(int(s))) * 1000 return fmt.Sprintf("%02ds%03d", int(s), int(ms)) } }
// list request all entries from the database, and the displays them. func list() { // get all the entries var entries []entry.Entry jsonRequest("GET", "/entries", &entries) fmt.Println("\nAll Entries") fmt.Println("-------------------------------------") var total time.Duration for _, e := range entries { if e.Ended() { fmt.Printf("-- %d\t%s\t%s\n", e.Id, e.TimeString(), e.Msg) } else { fmt.Printf("-- \033[033m%d\t%s\t%s%s\n", e.Id, e.TimeString(), e.Msg, " <= active \033[0m") } total = total + e.Duration() } fmt.Println("-------------------------------------") fmt.Printf("Total - %dh %dm %ds\n\n", int(total.Hours()), int(total.Minutes())%60, int(total.Seconds())%60) }
func dur2secs(dur time.Duration) (secs float32) { secs = float32(dur.Hours() * 3600) secs += float32(dur.Minutes() * 60) secs += float32(dur.Seconds()) secs += float32(dur.Nanoseconds()) * float32(0.000000001) return secs }
// Formats the given duration as more readable string. func FormatDuration(dur *time.Duration) string { var days int = int(dur.Hours() / 24) var hrs int = int(dur.Hours()) % 24 var mins int = int(dur.Minutes()) % 60 var secs int = int(dur.Seconds()) % 60 return fmt.Sprintf("%d days, %d hours, %d minutes and %d seconds", days, hrs, mins, secs) }
func getDurationString(duration time.Duration) string { return fmt.Sprintf( "%0.2d:%02d:%02d", int(duration.Hours()), int(duration.Minutes())%60, int(duration.Seconds())%60, ) }
func fmtDuration(d time.Duration) string { if d.Hours() >= 1 { return fmt.Sprintf("%vh%vm", int(d.Hours()), int(d.Minutes())%60) } else if d.Minutes() >= 1 { return fmt.Sprintf("%vm%vs", int(d.Minutes()), int(d.Seconds())%60) } else { return fmt.Sprintf("%vs", int(d.Seconds())) } }
func deltaNow(t time.Time) (time.Duration, string) { var suff string var d time.Duration now := time.Now() if now.Before(t) { suff = "ahead" d = t.Sub(now) } else { suff = "ago" d = now.Sub(t) } if d < 1*time.Second { return time.Duration(0), "right now" } interv := []struct { d time.Duration desc string }{ {time.Minute, "minute"}, {time.Hour, "hour"}, {24 * time.Hour, "day"}, {7 * 24 * time.Hour, "week"}, } var roughly string for _, i := range interv { if d < i.d { roughly = "within the " + i.desc + ", " break } } days, hours, minutes, seconds := 0, int(d.Hours()), int(d.Minutes()), int(d.Seconds()) minutes -= 60 * hours seconds -= 3600*hours + 60*minutes for hours >= 24 { days += 1 hours -= 24 } exact := suff plural := map[bool]string{true: "s", false: ""} if seconds != 0 { exact = fmt.Sprintf("%d second%s %s", seconds, plural[seconds > 1], exact) } if minutes != 0 { exact = fmt.Sprintf("%d minute%s %s", minutes, plural[minutes > 1], exact) } if hours != 0 { exact = fmt.Sprintf("%d hour%s %s", hours, plural[hours > 1], exact) } if days != 0 { exact = fmt.Sprintf("%d day%s %s", days, plural[days > 1], exact) } return d, roughly + exact }
// Writes a duration formatted as hours:minues:seconds,milliseconds func writeTime(w io.Writer, dur time.Duration) (nbytes int, err error) { hoursToPrint := int(math.Floor(dur.Hours())) minutesToPrint := int(math.Floor(dur.Minutes() - (time.Duration(hoursToPrint) * time.Hour).Minutes())) secondsToPrint := int(math.Floor(dur.Seconds() - (time.Duration(hoursToPrint)*time.Hour + time.Duration(minutesToPrint)*time.Minute).Seconds())) millisecondsToPrint := int(math.Floor(float64(dur/time.Millisecond - (time.Duration(hoursToPrint)*time.Hour+time.Duration(minutesToPrint)*time.Minute+time.Duration(secondsToPrint)*time.Second)/time.Millisecond))) nbytes, err = fmt.Fprintf(w, "%02d:%02d:%02d,%03d", hoursToPrint, minutesToPrint, secondsToPrint, millisecondsToPrint) return }
// durationStr returns duration d in a human readable simple format: // "2.5 hours", "1 hour", "30 minutes", etc. func durationStr(d time.Duration) string { if d < time.Hour { return fmt.Sprintf("%d minutes", int(d.Minutes())) } v, u := d.Hours(), "hour" if v > 1.5 { u += "s" } return fmt.Sprintf("%g %s", d.Hours(), u) }
func durationToString(d time.Duration) string { hours := int(math.Trunc(d.Hours())) minutes := int(math.Trunc(d.Minutes())) - 60*hours seconds := int(d.Seconds()) % 60 if hours > 0 { return fmt.Sprintf("%d:%d:%02d", hours, minutes, seconds) } return fmt.Sprintf("%d:%02d", minutes, seconds) }
// This is the calculation of the exponential smoothing factor. It tries to // make sure that if we get lots of fast merges we don't race the 'daily' // avg really high really fast. But more importantly it means that if merges // start going slowly the 'daily' average will get pulled down a lot by one // slow merge instead of requiring numerous merges to get pulled down func getSmoothFactor(dur time.Duration) float64 { hours := dur.Hours() smooth := .155*math.Log(hours) + .422 if smooth < .1 { return .1 } if smooth > .999 { return .999 } return smooth }
// DescDuration returns a human-readable string describing the duration. func DescDuration(d time.Duration) string { if d < time.Minute { return fmt.Sprintf("%0.1f sec ago", d.Seconds()) } else if d < time.Hour { return fmt.Sprintf("%0.1f min ago", d.Minutes()) } else if d < time.Hour*24 { return fmt.Sprintf("%0.1f hrs ago", d.Hours()) } else { return fmt.Sprintf("%0.1f days ago", d.Hours()/24.0) } }
////////////////// // Utility ////////////////// func PrintDuration(t time.Duration) { if hours := math.Floor(t.Hours()); hours > 0 { fmt.Printf("%vh ", int(hours)) } if minutes := math.Mod(math.Floor(t.Minutes()), 60); minutes > 0 { fmt.Printf("%1.0vm ", int(minutes)) } if seconds := math.Mod(t.Seconds(), 60); seconds > 0 { fmt.Printf("%2.3vs", seconds) } }
func (d internalDist) print(device, name string, duration time.Duration) DurationStats { ds := DurationStats{ Name: name, NumRate: float64(d.Num) / duration.Hours(), DurationRate: d.TotalDuration.Seconds() / duration.Hours(), Num: d.Num, TotalDuration: d.TotalDuration, MaxDuration: d.MaxDuration, } return ds }
func main() { fmt.Println("xxxxxxx", int64(int64(time.Now().Nanosecond())/time.Millisecond.Nanoseconds()*time.Millisecond.Nanoseconds()), int(time.Millisecond), int(time.Millisecond.Nanoseconds())) return tt := &Test{} fmt.Println(tt.offset) fmt.Println(tt.Add()) fmt.Println(tt.offset) fmt.Println(unibase.Atoi("192.158.68.2")) d, e := time.ParseDuration("1s") fmt.Println(d, e) fmt.Println("xxxxxxx", int(time.Millisecond), int(time.Millisecond.Nanoseconds())) year, month, day := time.Now().Date() fmt.Println(year, month, day) ip := net.ParseIP("1.1.1.11").To4() fmt.Println(uint32(ip[0])<<24 + uint32(ip[1])<<16) loc, _ := time.LoadLocation("") fmt.Println(time.Now().Unix(), time.Now().Local().Unix(), time.Now().Second(), time.Now().Location().String(), loc.String()) pt, err := ParseTime("2012-12-12 12:12:12") fmt.Println(pt.Unix(), err) now := time.Now() _, offset := now.Zone() fmt.Println(int(time.Duration(offset))) begin := time.Duration(offset) * time.Second zonenow := now.Add(-begin) fmt.Println(now.Unix(), zonenow.Unix()) fmt.Println("GOTRACEBACK:", os.Getenv("RACEBACK")) //now := time.Now() //time.Sleep(1000000000) fmt.Println(time.Now().UnixNano(), time.Now().Unix()) t := time.Date(2009, time.December, 30, 13, 13, 13, 13, time.UTC) fmt.Printf("%s,%d\n", t.Local(), time.Millisecond) seconds := 10 var dur time.Duration fmt.Println(dur.Hours()) fmt.Printf("%d\n", time.Duration(seconds)*time.Second) //zone, sec := now.Zone() //fmt.Println(now.Unix(), now.Sub(1111), zone, sec) go func() { for { select { case <-time.After(2 * time.Second): fmt.Println("2time.After:", time.Now().Unix()) case <-time.After(1 * time.Second): fmt.Println("1time.After:", time.Now().Unix()) } } }() timer := time.AfterFunc(time.Second*2, timefunc) defer timer.Stop() for i := 0; i < 30; i++ { time.Sleep(time.Second * 2) fmt.Println("sleep:", time.Now().Unix()) } }
// sumWakelockInfo sums the Count and Duration fields of the given WakelockInfos. // CountPerHour and SecondsPerHour will be filled in if r is not 0. func sumWakelockInfo(d []*checkinparse.WakelockInfo, r time.Duration) ActivityData { wd := ActivityData{} for _, w := range d { wd.Count += w.Count wd.Duration += w.Duration } if r != 0 { wd.CountPerHour = wd.Count / float32(r.Hours()) wd.SecondsPerHr = float32(wd.Duration.Seconds()) / float32(r.Hours()) } return wd }
func shortHumanDuration(d time.Duration) string { if seconds := int(d.Seconds()); seconds < 60 { return fmt.Sprintf("%ds", seconds) } else if minutes := int(d.Minutes()); minutes < 60 { return fmt.Sprintf("%dm", minutes) } else if hours := int(d.Hours()); hours < 24 { return fmt.Sprintf("%dh", hours) } else if hours < 24*364 { return fmt.Sprintf("%dd", hours/24) } return fmt.Sprintf("%dy", int(d.Hours()/24/365)) }
func TestDuration(t *testing.T) { var t1 Quantity t1 = Q(1.5, "d") var t2 time.Duration t2, err := Duration(t1) if err != nil { t.Error(err) } if t2.Hours() != 36 { t.Error("expected:", 36, "actual:", t2.Hours()) } }
func DurationToString(d time.Duration) string { minutes := int(d.Minutes()) % 60 hours := int(d.Hours()) days := hours / 24 hours = hours % 24 if days > 0 { return fmt.Sprintf("%dd %dhr", days, hours) } if hours > 0 { return fmt.Sprintf("%dhr %dm", hours, minutes) } return fmt.Sprintf("%dm", minutes) }
// timeDurationToHumanizedDuration convert golang time.Duration to a custom more readable humanizedDuration. func timeDurationToHumanizedDuration(duration time.Duration) humanizedDuration { r := humanizedDuration{} if duration.Seconds() < 60.0 { r.Seconds = int64(duration.Seconds()) return r } if duration.Minutes() < 60.0 { remainingSeconds := math.Mod(duration.Seconds(), 60) r.Seconds = int64(remainingSeconds) r.Minutes = int64(duration.Minutes()) return r } if duration.Hours() < 24.0 { remainingMinutes := math.Mod(duration.Minutes(), 60) remainingSeconds := math.Mod(duration.Seconds(), 60) r.Seconds = int64(remainingSeconds) r.Minutes = int64(remainingMinutes) r.Hours = int64(duration.Hours()) return r } remainingHours := math.Mod(duration.Hours(), 24) remainingMinutes := math.Mod(duration.Minutes(), 60) remainingSeconds := math.Mod(duration.Seconds(), 60) r.Hours = int64(remainingHours) r.Minutes = int64(remainingMinutes) r.Seconds = int64(remainingSeconds) r.Days = int64(duration.Hours() / 24) return r }
func reducePrecision(dur time.Duration, unit time.Duration) float64 { switch unit { case time.Hour: return dur.Hours() case time.Minute: return dur.Minutes() case time.Second: return dur.Seconds() case time.Nanosecond: return float64(dur.Nanoseconds()) default: return float64(dur) } }
func formatDuration(d time.Duration) string { h := int64(d.Hours()) if h >= 24 { days := h / 24 return pluralize(days, "day") } else if h >= 1 { return pluralize(h, "hour") } m := int64(d.Minutes()) if m >= 1 { return pluralize(m, "minute") } s := int64(d.Seconds()) return pluralize(s, "second") }
// HumanDuration returns a human-readable approximation of a duration // This function is taken from the Docker project, and slightly modified // to cap units at days. // (eg. "About a minute", "4 hours ago", etc.) // (c) 2013 Docker, inc. and the Docker authors (http://docker.io) func HumanDuration(d time.Duration) string { if seconds := int(d.Seconds()); seconds < 1 { return "Less than a second" } else if seconds < 60 { return fmt.Sprintf("%d seconds", seconds) } else if minutes := int(d.Minutes()); minutes == 1 { return "About a minute" } else if minutes < 60 { return fmt.Sprintf("%d minutes", minutes) } else if hours := int(d.Hours()); hours == 1 { return "About an hour" } else if hours < 48 { return fmt.Sprintf("%d hours", hours) } return fmt.Sprintf("%d days", int(d.Hours()/24)) }
func DurString(dur time.Duration) string { minutes := int(dur.Minutes()) hours := int(dur.Hours()) days := int(hours / 24) if days > 0 { return fmt.Sprintf("%d days ago", days) } if hours > 0 { return fmt.Sprintf("%d hours ago", hours) } if minutes > 0 { return fmt.Sprintf("%d minutes ago", minutes) } return "just now" }
// there is a better way to do this func formatDuration(d time.Duration) (str string) { hours := int(d.Hours()) d -= (time.Duration(hours) * time.Hour) minutes := int(d.Minutes()) d -= (time.Duration(minutes) * time.Minute) seconds := int(d.Seconds()) if hours == 0 { str += fmt.Sprintf("%d:%02d", minutes, seconds) } else { str += fmt.Sprintf("%d:%02d:%02d", hours, minutes, seconds) } return }