// AccessTime returns the last time the file was accessed. It's not part of the
// os.FileInfo interface.
547355
func (fi *FileInfo) AccessTime() time.Time {
	return time.Unix(int64(fi.status.GetAccessTime())/1000, 0)
}
51673
func AccessLog(rw http.ResponseWriter, req *http.Request, next http.HandlerFunc) {
	start := time.Now()
	w := &responseWriter{
		ResponseWriter: rw,
	}
	next(w, req)
	end := time.Now()

	webgo.LOGHANDLER.Info(
		fmt.Sprintf(
			"%s %s %s %s %d",
			end.Format("2006-01-02 15:04:05 -0700 MST"),
			req.Method,
			req.URL.String(),
			end.Sub(start).String(),
			w.code,
		),
	)
}
346216
func (s *sessionImpl) Access() {
	s.mux.Lock()
	defer s.mux.Unlock()

	s.AccessedF = time.Now()
}
1252792
func LoadFileTime(path string) (FileTime, error) {
	var ft = FileTime{}
	var st = unix.Stat_t{}

	err := unix.Stat(path, &st)
	if err != nil {
		return ft, err
	}

	ft.Changed = timeSpecToTime(st.Ctimespec)
	ft.Modified = timeSpecToTime(st.Mtimespec)
	ft.Accessed = timeSpecToTime(st.Atimespec)
	return ft, nil
}
1073931
func (g *Generator) Time(from time.Time, maxDelta time.Duration) time.Time {
	delta, ok := g.times[from]
	if !ok {
		delta = time.Duration(g.r.Uint64() % uint64(maxDelta))
		g.times[from] = delta
	} else {
		delta += time.Duration(g.r.Uint64() % uint64(maxDelta))
		g.times[from] = delta
	}
	return from.Add(delta)
}
506005
func FiletimeToDuration(ft *syscall.Filetime) time.Duration {
	n := int64(ft.HighDateTime)<<32 + int64(ft.LowDateTime) // in 100-nanosecond intervals
	return time.Duration(n * 100)
}
1110479
func (c *Cache) LastWriteTime() time.Time {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.lastWriteTime
}
336472
func (pt *PlaylistTrack) Time() time.Time {
	t := C.sp_playlist_track_create_time(pt.playlist.sp_playlist, C.int(pt.index))
	return time.Unix(int64(t), 0)
}
608253
func (p *Peer) LastPingTime() time.Time {
	p.statsMtx.RLock()
	lastPingTime := p.lastPingTime
	p.statsMtx.RUnlock()

	return lastPingTime
}
1138601
func (m *Manager) GetTime(key string) time.Time {
	return cast.ToTime(m.Get(key))
}
874702
func Time(ctx *cli.Context) command.Command {
	usage := "time"
	desc := "Returns the server time"

	return command.NewCommand("time", usage, desc, func(args ...string) ([]byte, error) {
		t := time.Now().Format(time.RFC1123)
		return []byte("Server time is: " + t), nil
	})
}
1299731
func (c *Client) Time(stat string, rate float64, f func()) error {
	ts := time.Now()
	f()
	return c.Duration(stat, time.Since(ts), rate)
}
936980
func (ts TimeStamp) AsTime() (tm time.Time) {
	tm = time.Unix(int64(ts), 0).Local()
	return
}
972649
func (t *StandardResettingTimer) Time(f func()) {
	ts := time.Now()
	f()
	t.Update(time.Since(ts))
}
332122
func (c *Cell) GetTime(date1904 bool) (t time.Time, err error) {
	f, err := c.Float()
	if err != nil {
		return t, err
	}
	return TimeFromExcelTime(f, date1904), nil
}
508742
func (a *Allocation) LastEventTime() time.Time {
	var lastEventTime time.Time
	if a.TaskStates != nil {
		for _, s := range a.TaskStates {
			if lastEventTime.IsZero() || s.FinishedAt.After(lastEventTime) {
				lastEventTime = s.FinishedAt
			}
		}
	}

	if lastEventTime.IsZero() {
		return time.Unix(0, a.ModifyTime).UTC()
	}
	return lastEventTime
}
1102003
func LoadFileTime(path string) (FileTime, error) {
	var ft = FileTime{}
	var st = unix.Stat_t{}

	err := unix.Stat(path, &st)
	if err != nil {
		return ft, err
	}

	ft.Changed = timeSpecToTime(st.Ctim)
	ft.Modified = timeSpecToTime(st.Mtim)
	ft.Accessed = timeSpecToTime(st.Atim)
	return ft, nil
}