type time.Time
638 uses
time (current package)
format.go#L497: func (t Time) String() string {
format.go#L528: func (t Time) GoString() string {
format.go#L587: func (t Time) Format(layout string) string {
format.go#L603: func (t Time) AppendFormat(b []byte, layout string) []byte {
format.go#L947: func Parse(layout, value string) (Time, error) {
format.go#L956: func ParseInLocation(layout, value string, loc *Location) (Time, error) {
format.go#L960: func parse(layout, value string, defaultLocation, local *Location) (Time, error) {
format.go#L988: return Time{}, &ParseError{alayout, avalue, prefix, value, ""}
format.go#L992: return Time{}, &ParseError{alayout, avalue, "", value, ": extra text: " + quote(value)}
format.go#L1220: return Time{}, &ParseError{alayout, avalue, stdstr, value, ": " + rangeErrString + " out of range"}
format.go#L1223: return Time{}, &ParseError{alayout, avalue, stdstr, value, ""}
format.go#L1245: return Time{}, &ParseError{alayout, avalue, "", value, ": day-of-year out of range"}
format.go#L1257: return Time{}, &ParseError{alayout, avalue, "", value, ": day-of-year does not match month"}
format.go#L1261: return Time{}, &ParseError{alayout, avalue, "", value, ": day-of-year does not match day"}
format.go#L1275: return Time{}, &ParseError{alayout, avalue, "", value, ": day out of range"}
sleep.go#L51: C <-chan Time
sleep.go#L87: c := make(chan Time, 1)
sleep.go#L145: case c.(chan Time) <- Now():
sleep.go#L156: func After(d Duration) <-chan Time {
tick.go#L12: C <-chan Time // The channel on which the ticks are delivered.
tick.go#L29: c := make(chan Time, 1)
tick.go#L68: func Tick(d Duration) <-chan Time {
time.go#L127: type Time struct {
time.go#L163: func (t *Time) nsec() int32 {
time.go#L168: func (t *Time) sec() int64 {
time.go#L176: func (t *Time) unixSec() int64 { return t.sec() + internalToUnix }
time.go#L179: func (t *Time) addSec(d int64) {
time.go#L204: func (t *Time) setLoc(loc *Location) {
time.go#L213: func (t *Time) stripMono() {
time.go#L224: func (t *Time) setMono(m int64) {
time.go#L240: func (t *Time) mono() int64 {
time.go#L248: func (t Time) After(u Time) bool {
time.go#L258: func (t Time) Before(u Time) bool {
time.go#L272: func (t Time) Equal(u Time) bool {
time.go#L432: func (t Time) IsZero() bool {
time.go#L438: func (t Time) abs() uint64 {
time.go#L458: func (t Time) locabs() (name string, offset int, abs uint64) {
time.go#L481: func (t Time) Date() (year int, month Month, day int) {
time.go#L487: func (t Time) Year() int {
time.go#L493: func (t Time) Month() Month {
time.go#L499: func (t Time) Day() int {
time.go#L505: func (t Time) Weekday() Weekday {
time.go#L520: func (t Time) ISOWeek() (year, week int) {
time.go#L544: func (t Time) Clock() (hour, min, sec int) {
time.go#L559: func (t Time) Hour() int {
time.go#L564: func (t Time) Minute() int {
time.go#L569: func (t Time) Second() int {
time.go#L575: func (t Time) Nanosecond() int {
time.go#L581: func (t Time) YearDay() int {
time.go#L819: func (t Time) Add(d Duration) Time {
time.go#L847: func (t Time) Sub(u Time) Duration {
time.go#L874: func Since(t Time) Duration {
time.go#L875: var now Time
time.go#L878: now = Time{hasMonotonic, runtimeNano() - startNano, nil}
time.go#L887: func Until(t Time) Duration {
time.go#L888: var now Time
time.go#L891: now = Time{hasMonotonic, runtimeNano() - startNano, nil}
time.go#L906: func (t Time) AddDate(years int, months int, days int) Time {
time.go#L924: func (t Time) date(full bool) (year int, month Month, day int, yday int) {
time.go#L1072: func Now() Time {
time.go#L1077: return Time{uint64(nsec), sec + minWall, Local}
time.go#L1079: return Time{hasMonotonic | uint64(sec)<<nsecShift | uint64(nsec), mono, Local}
time.go#L1082: func unixTime(sec int64, nsec int32) Time {
time.go#L1083: return Time{uint64(nsec), sec + unixToInternal, Local}
time.go#L1087: func (t Time) UTC() Time {
time.go#L1093: func (t Time) Local() Time {
time.go#L1103: func (t Time) In(loc *Location) Time {
time.go#L1112: func (t Time) Location() *Location {
time.go#L1122: func (t Time) Zone() (name string, offset int) {
time.go#L1133: func (t Time) Unix() int64 {
time.go#L1142: func (t Time) UnixMilli() int64 {
time.go#L1151: func (t Time) UnixMicro() int64 {
time.go#L1161: func (t Time) UnixNano() int64 {
time.go#L1171: func (t Time) MarshalBinary() ([]byte, error) {
time.go#L1219: func (t *Time) UnmarshalBinary(data []byte) error {
time.go#L1251: *t = Time{}
time.go#L1271: func (t Time) GobEncode() ([]byte, error) {
time.go#L1276: func (t *Time) GobDecode(data []byte) error {
time.go#L1282: func (t Time) MarshalJSON() ([]byte, error) {
time.go#L1298: func (t *Time) UnmarshalJSON(data []byte) error {
time.go#L1311: func (t Time) MarshalText() ([]byte, error) {
time.go#L1322: func (t *Time) UnmarshalText(data []byte) error {
time.go#L1334: func Unix(sec int64, nsec int64) Time {
time.go#L1349: func UnixMilli(msec int64) Time {
time.go#L1355: func UnixMicro(usec int64) Time {
time.go#L1360: func (t Time) IsDST() bool {
time.go#L1402: func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time {
time.go#L1463: func (t Time) Truncate(d Duration) Time {
time.go#L1480: func (t Time) Round(d Duration) Time {
time.go#L1495: func div(t Time, d Duration) (qmod2 int, r Duration) {
compress/gzip
gunzip.go#L55: ModTime time.Time // modification time
context
context.go#L66: Deadline() (deadline time.Time, ok bool)
context.go#L173: func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
context.go#L434: func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
context.go#L469: deadline time.Time
context.go#L472: func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
crypto/tls
common.go#L338: receivedAt time.Time // When the session ticket was received from the server
common.go#L344: useBy time.Time // Expiration of the ticket lifetime as set by the server
common.go#L527: Time func() time.Time
common.go#L762: created time.Time
common.go#L955: func (c *Config) time() time.Time {
conn.go#L137: func (c *Conn) SetDeadline(t time.Time) error {
conn.go#L143: func (c *Conn) SetReadDeadline(t time.Time) error {
conn.go#L150: func (c *Conn) SetWriteDeadline(t time.Time) error {
crypto/x509
parser.go#L167: func parseValidity(der cryptobyte.String) (time.Time, time.Time, error) {
parser.go#L168: extract := func() (time.Time, error) {
parser.go#L169: var t time.Time
parser.go#L211: return time.Time{}, time.Time{}, err
parser.go#L215: return time.Time{}, time.Time{}, err
verify.go#L189: CurrentTime time.Time
x509.go#L166: NotBefore, NotAfter time.Time
x509.go#L645: NotBefore, NotAfter time.Time // Validity bounds.
x509.go#L1651: func (c *Certificate) CreateCRL(rand io.Reader, priv any, revokedCerts []pkix.RevokedCertificate, now, expiry time.Time) (crlBytes []byte, err error) {
x509.go#L2107: ThisUpdate time.Time
x509.go#L2111: NextUpdate time.Time
crypto/x509/pkix
pkix.go#L293: func (certList *CertificateList) HasExpired(now time.Time) bool {
pkix.go#L304: ThisUpdate time.Time
pkix.go#L305: NextUpdate time.Time `asn1:"optional"`
pkix.go#L314: RevocationTime time.Time
database/sql
convert.go#L270: case time.Time:
convert.go#L272: case *time.Time:
sql.go#L373: Time time.Time
sql.go#L380: n.Time, n.Valid = time.Time{}, false
sql.go#L512: createdAt time.Time
sql.go#L523: returnedAt time.Time // Time the connection was created or returned.
database/sql/driver
types.go#L181: case []byte, bool, float64, int64, string, time.Time:
embed
embed.go#L233: func (f *file) ModTime() time.Time { return time.Time{} }
encoding/asn1
asn1.go#L339: func parseUTCTime(bytes []byte) (ret time.Time, err error) {
asn1.go#L367: func parseGeneralizedTime(bytes []byte) (ret time.Time, err error) {
asn1.go#L660: timeType = reflect.TypeOf(time.Time{})
asn1.go#L864: case *time.Time:
marshal.go#L366: func outsideUTCRange(t time.Time) bool {
marshal.go#L371: func makeUTCTime(t time.Time) (e encoder, err error) {
marshal.go#L382: func makeGeneralizedTime(t time.Time) (e encoder, err error) {
marshal.go#L393: func appendUTCTime(dst []byte, t time.Time) (ret []byte, err error) {
marshal.go#L408: func appendGeneralizedTime(dst []byte, t time.Time) (ret []byte, err error) {
marshal.go#L419: func appendTimeCommon(dst []byte, t time.Time) []byte {
marshal.go#L466: t := value.Interface().(time.Time)
marshal.go#L656: if params.timeType == TagGeneralizedTime || outsideUTCRange(v.Interface().(time.Time)) {
github.com/aws/aws-sdk-go-v2/aws
context.go#L12: func (s *suppressedContext) Deadline() (deadline time.Time, ok bool) {
context.go#L13: return time.Time{}, false
credentials.go#L92: Expires time.Time
from_ptr.go#L328: func ToTime(p *time.Time) (v time.Time) {
from_ptr.go#L335: func ToTimeSlice(vs []*time.Time) []time.Time {
from_ptr.go#L342: func ToTimeMap(vs map[string]*time.Time) map[string]time.Time {
to_ptr.go#L266: func Time(v time.Time) *time.Time {
to_ptr.go#L272: func TimeSlice(vs []time.Time) []*time.Time {
to_ptr.go#L278: func TimeMap(vs map[string]time.Time) map[string]*time.Time {
github.com/aws/aws-sdk-go-v2/aws/middleware
middleware.go#L61: var serverTime time.Time
middleware.go#L91: func GetResponseAt(metadata middleware.Metadata) (v time.Time, ok bool) {
middleware.go#L92: v, ok = metadata.Get(responseAtKey{}).(time.Time)
middleware.go#L97: func setResponseAt(metadata *middleware.Metadata, v time.Time) {
middleware.go#L104: func GetServerTime(metadata middleware.Metadata) (v time.Time, ok bool) {
middleware.go#L105: v, ok = metadata.Get(serverTimeKey{}).(time.Time)
middleware.go#L110: func setServerTime(metadata *middleware.Metadata, v time.Time) {
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream
header_value.go#L421: type TimestampValue time.Time
header_value.go#L425: return time.Time(v)
header_value.go#L434: nano := time.Time(v).UnixNano()
header_value.go#L470: func timeFromEpochMilli(t int64) time.Time {
github.com/aws/aws-sdk-go-v2/aws/retry
adaptive_ratelimit.go#L21: lastRefilled time.Time
adaptive_ratelimit.go#L26: lastThrottleTime time.Time
adaptive_ratelimit.go#L104: func (a *adaptiveRateLimit) cubicSuccess(t time.Time) float64 {
adaptive_ratelimit.go#L156: func timeFloat64Seconds(v time.Time) float64 {
middleware.go#L25: AttemptTime time.Time
middleware.go#L265: var ttl time.Time
github.com/aws/aws-sdk-go-v2/aws/signer/internal/v4
cache.go#L22: Date time.Time
cache.go#L63: func (s *derivedKeyCache) get(key string, credentials aws.Credentials, signingTime time.Time) ([]byte, bool) {
cache.go#L102: func isSameDay(x, y time.Time) bool {
time.go#L7: time.Time
time.go#L13: func NewSigningTime(t time.Time) SigningTime {
github.com/aws/aws-sdk-go-v2/aws/signer/v4
presign_middleware.go#L21: payloadHash string, service string, region string, signingTime time.Time,
stream.go#L15: GetSignature(ctx context.Context, headers, payload []byte, signingTime time.Time, optFns ...func(*StreamSignerOptions)) ([]byte, error)
stream.go#L53: func (s *StreamSigner) GetSignature(ctx context.Context, headers, payload []byte, signingTime time.Time, optFns ...func(*StreamSignerOptions)) ([]byte, error) {
v4.go#L75: SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*SignerOptions)) error
v4.go#L271: func (s Signer) SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(options *SignerOptions)) error {
v4.go#L344: payloadHash string, service string, region string, signingTime time.Time,
github.com/aws/aws-sdk-go-v2/internal/sdk
time.go#L16: var NowTime func() time.Time
time.go#L67: func TestingUseReferenceTime(referenceTime time.Time) func() {
time.go#L68: NowTime = func() time.Time {
github.com/aws/aws-sdk-go-v2/internal/v4a
credentials.go#L24: Expires time.Time
middleware.go#L17: SignHTTP(ctx context.Context, credentials Credentials, r *http.Request, payloadHash string, service string, regionSet []string, signingTime time.Time, optfns ...func(*SignerOptions)) error
presign_middleware.go#L21: payloadHash string, service string, regionSet []string, signingTime time.Time,
v4a.go#L158: Time time.Time
v4a.go#L176: func (s *Signer) SignHTTP(ctx context.Context, credentials Credentials, r *http.Request, payloadHash string, service string, regionSet []string, signingTime time.Time, optFns ...func(*SignerOptions)) error {
v4a.go#L212: func (s *Signer) PresignHTTP(ctx context.Context, credentials Credentials, r *http.Request, payloadHash string, service string, regionSet []string, signingTime time.Time, optFns ...func(*SignerOptions)) (signedURI string, signedHeaders http.Header, err error) {
github.com/aws/aws-sdk-go-v2/internal/v4a/internal/v4
time.go#L7: time.Time
time.go#L13: func NewSigningTime(t time.Time) SigningTime {
github.com/aws/aws-sdk-go-v2/service/s3
api_client.go#L410: SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
api_client.go#L510: service string, regionSet []string, signingTime time.Time,
api_client.go#L616: payloadHash string, service string, region string, signingTime time.Time,
api_client.go#L626: payloadHash string, service string, regionSet []string, signingTime time.Time,
api_op_CopyObject.go#L278: CopySourceIfModifiedSince *time.Time
api_op_CopyObject.go#L284: CopySourceIfUnmodifiedSince *time.Time
api_op_CopyObject.go#L311: Expires *time.Time
api_op_CopyObject.go#L343: ObjectLockRetainUntilDate *time.Time
api_op_CreateMultipartUpload.go#L319: Expires *time.Time
api_op_CreateMultipartUpload.go#L347: ObjectLockRetainUntilDate *time.Time
api_op_CreateMultipartUpload.go#L423: AbortDate *time.Time
api_op_GetObject.go#L202: IfModifiedSince *time.Time
api_op_GetObject.go#L210: IfUnmodifiedSince *time.Time
api_op_GetObject.go#L248: ResponseExpires *time.Time
api_op_GetObject.go#L354: Expires *time.Time
api_op_GetObject.go#L357: LastModified *time.Time
api_op_GetObject.go#L378: ObjectLockRetainUntilDate *time.Time
api_op_GetObjectAttributes.go#L228: LastModified *time.Time
api_op_HeadObject.go#L168: IfModifiedSince *time.Time
api_op_HeadObject.go#L176: IfUnmodifiedSince *time.Time
api_op_HeadObject.go#L297: Expires *time.Time
api_op_HeadObject.go#L300: LastModified *time.Time
api_op_HeadObject.go#L328: ObjectLockRetainUntilDate *time.Time
api_op_ListParts.go#L162: AbortDate *time.Time
api_op_PutObject.go#L251: Expires *time.Time
api_op_PutObject.go#L282: ObjectLockRetainUntilDate *time.Time
api_op_UploadPartCopy.go#L218: CopySourceIfModifiedSince *time.Time
api_op_UploadPartCopy.go#L224: CopySourceIfUnmodifiedSince *time.Time
api_op_WriteGetObjectResponse.go#L194: Expires *time.Time
api_op_WriteGetObjectResponse.go#L197: LastModified *time.Time
api_op_WriteGetObjectResponse.go#L217: ObjectLockRetainUntilDate *time.Time
github.com/aws/aws-sdk-go-v2/service/s3/types
types.go#L185: CreationDate *time.Time
types.go#L397: LastModified *time.Time
types.go#L441: LastModified *time.Time
types.go#L660: LastModified *time.Time
types.go#L2188: Date *time.Time
types.go#L2507: Initiated *time.Time
types.go#L2651: LastModified *time.Time
types.go#L2714: RetainUntilDate *time.Time
types.go#L2793: LastModified *time.Time
types.go#L2919: LastModified *time.Time
types.go#L3829: Date *time.Time
github.com/aws/smithy-go/auth/bearer
token.go#L13: Expires time.Time
token.go#L18: func (t Token) Expired(now time.Time) bool {
token_cache.go#L139: var lastRefreshAttempt time.Time
token_cache.go#L141: lastRefreshAttempt = v.(time.Time)
token_cache.go#L154: var refreshAttempt time.Time
github.com/aws/smithy-go/ptr
from_ptr.go#L536: func ToTime(p *time.Time) (v time.Time) {
from_ptr.go#L547: func ToTimeSlice(vs []*time.Time) []time.Time {
from_ptr.go#L548: ps := make([]time.Time, len(vs))
from_ptr.go#L559: func ToTimeMap(vs map[string]*time.Time) map[string]time.Time {
from_ptr.go#L560: ps := make(map[string]time.Time, len(vs))
to_ptr.go#L444: func Time(v time.Time) *time.Time {
to_ptr.go#L450: func TimeSlice(vs []time.Time) []*time.Time {
to_ptr.go#L451: ps := make([]*time.Time, len(vs))
to_ptr.go#L462: func TimeMap(vs map[string]time.Time) map[string]*time.Time {
to_ptr.go#L463: ps := make(map[string]*time.Time, len(vs))
github.com/aws/smithy-go/time
time.go#L30: func FormatDateTime(value time.Time) string {
time.go#L37: func ParseDateTime(value string) (time.Time, error) {
time.go#L49: func FormatHTTPDate(value time.Time) string {
time.go#L56: func ParseHTTPDate(value string) (time.Time, error) {
time.go#L69: func FormatEpochSeconds(value time.Time) float64 {
time.go#L77: func ParseEpochSeconds(value float64) time.Time {
time.go#L86: func tryParse(v string, formats ...string) (time.Time, error) {
time.go#L100: return time.Time{}, fmt.Errorf("unable to parse time string, %w", errs)
github.com/aws/smithy-go/transport/http
time.go#L11: func ParseTime(text string) (t time.Time, err error) {
github.com/go-pg/pg/v10
hook.go#L33: StartTime time.Time
github.com/go-pg/pg/v10/internal
context.go#L16: func (UndoneContext) Deadline() (deadline time.Time, ok bool) {
context.go#L17: return time.Time{}, false
github.com/go-pg/pg/v10/internal/pool
conn.go#L11: var noDeadline = time.Time{}
conn.go#L21: createdAt time.Time
conn.go#L36: func (cn *Conn) UsedAt() time.Time {
conn.go#L41: func (cn *Conn) SetUsedAt(tm time.Time) {
conn.go#L132: func (cn *Conn) deadline(ctx context.Context, timeout time.Duration) time.Time {
github.com/go-pg/pg/v10/orm
table.go#L39: timeType = reflect.TypeOf((*time.Time)(nil)).Elem()
table.go#L1473: ptr := fv.Addr().Interface().(*time.Time)
github.com/go-pg/pg/v10/types
append.go#L31: case time.Time:
append_value.go#L216: tm := v.Interface().(time.Time)
null_time.go#L15: time.Time
null_time.go#L34: tm.Time = time.Time{}
null_time.go#L49: tm.Time = time.Time{}
scan.go#L35: case *time.Time:
scan.go#L225: func ScanTime(rd Reader, n int) (time.Time, error) {
scan.go#L227: return time.Time{}, nil
scan.go#L232: return time.Time{}, err
scan_value.go#L20: timeType = reflect.TypeOf((*time.Time)(nil)).Elem()
scan_value.go#L270: ptr := v.Addr().Interface().(*time.Time)
time.go#L18: func ParseTime(b []byte) (time.Time, error) {
time.go#L23: func ParseTimeString(s string) (time.Time, error) {
time.go#L47: func AppendTime(b []byte, tm time.Time, flags int) []byte {
github.com/golang/protobuf/ptypes
timestamp.go#L38: func Timestamp(ts *timestamppb.Timestamp) (time.Time, error) {
timestamp.go#L41: var t time.Time
timestamp.go#L65: func TimestampProto(t time.Time) (*timestamppb.Timestamp, error) {
github.com/robfig/cron/v3
constantdelay.go#L25: func (schedule ConstantDelaySchedule) Next(t time.Time) time.Time {
cron.go#L43: Next(time.Time) time.Time
cron.go#L60: Next time.Time
cron.go#L63: Prev time.Time
cron.go#L317: func (c *Cron) now() time.Time {
logger.go#L80: if t, ok := arg.(time.Time); ok {
spec.go#L58: func (s *SpecSchedule) Next(t time.Time) time.Time {
spec.go#L92: return time.Time{}
spec.go#L179: func dayMatches(s *SpecSchedule, t time.Time) bool {
github.com/vmihailenco/msgpack/v5
decode.go#L260: case *time.Time:
encode.go#L222: case time.Time:
time.go#L15: RegisterExtEncoder(timeExtID, time.Time{}, timeEncoder)
time.go#L16: RegisterExtDecoder(timeExtID, time.Time{}, timeDecoder)
time.go#L20: return e.encodeTime(v.Interface().(time.Time)), nil
time.go#L29: ptr := v.Addr().Interface().(*time.Time)
time.go#L35: func (e *Encoder) EncodeTime(tm time.Time) error {
time.go#L46: func (e *Encoder) encodeTime(tm time.Time) []byte {
time.go#L72: func (d *Decoder) DecodeTime() (time.Time, error) {
time.go#L75: return time.Time{}, err
time.go#L82: return time.Time{}, err
time.go#L87: return time.Time{}, err
time.go#L96: return time.Time{}, err
time.go#L103: return time.Time{}, err
time.go#L107: return time.Time{}, fmt.Errorf("msgpack: invalid time ext id=%d", extID)
time.go#L122: func (d *Decoder) decodeTime(extLen int) (time.Time, error) {
time.go#L125: return time.Time{}, err
time.go#L143: return time.Time{}, err
go.pact.im/x/clock
clock.go#L30: Schedule(d time.Duration, f func(now time.Time)) Event
clock.go#L70: func (c *Clock) Schedule(d time.Duration, f func(now time.Time)) Event {
now.go#L11: Now() time.Time
now.go#L18: func (c *Clock) Now() time.Time {
runtime.go#L29: func (c *runtimeClock) Schedule(d time.Duration, f func(now time.Time)) Event {
runtime.go#L36: func (c *runtimeClock) Now() time.Time {
runtime.go#L56: func (r runtimeTimer) C() <-chan time.Time {
runtime.go#L71: func (r runtimeTicker) C() <-chan time.Time {
ticker.go#L24: C() <-chan time.Time
ticker.go#L60: c chan time.Time
ticker.go#L75: c: make(chan time.Time, 1),
ticker.go#L84: func (t *eventTicker) C() <-chan time.Time {
timer.go#L20: C() <-chan time.Time
timer.go#L74: ch := make(chan time.Time, 1)
timer.go#L75: event := s.Schedule(d, func(now time.Time) {
timer.go#L90: c chan time.Time
timer.go#L94: func (t *eventTimer) C() <-chan time.Time {
go.pact.im/x/clock/fakeclock
fakeclock.go#L23: next(now time.Time) (time.Duration, bool)
fakeclock.go#L40: now time.Time
fakeclock.go#L41: sched map[moment]time.Time
fakeclock.go#L66: func Time(now time.Time) *Clock {
fakeclock.go#L69: sched: map[moment]time.Time{},
fakeclock.go#L74: func (c *Clock) Now() time.Time {
fakeclock.go#L85: func (c *Clock) Next() (time.Time, bool) {
fakeclock.go#L97: func (c *Clock) Set(t time.Time) {
fakeclock.go#L111: func (c *Clock) Add(d time.Duration) time.Time {
fakeclock.go#L127: func (c *Clock) AddDate(years, months, days int) time.Time {
fakeclock.go#L137: func (c *Clock) Schedule(d time.Duration, f func(now time.Time)) clock.Event {
fakeclock.go#L150: ch: make(chan time.Time, 1),
fakeclock.go#L165: ch: make(chan time.Time, 1),
fakeclock.go#L198: func (c *Clock) schedule(m moment, when time.Time) bool {
fakeclock.go#L200: c.sched = map[moment]time.Time{}
fakeclock.go#L209: func (c *Clock) next(now time.Time) time.Time {
fakeclock.go#L213: var min time.Time
fakeclock.go#L231: func (c *Clock) advance(now time.Time) {
fakeclock.go#L248: f func(time.Time)
fakeclock.go#L262: func (t *event) next(now time.Time) (time.Duration, bool) {
fakeclock.go#L270: ch chan time.Time
fakeclock.go#L274: func (t *timer) C() <-chan time.Time {
fakeclock.go#L289: func (t *timer) next(now time.Time) (time.Duration, bool) {
fakeclock.go#L300: ch chan time.Time
fakeclock.go#L305: func (t *ticker) C() <-chan time.Time {
fakeclock.go#L323: func (t *ticker) next(now time.Time) (time.Duration, bool) {
go.pact.im/x/clock/mockclock
mockclock.go#L38: func (m *MockClock) Now() time.Time {
mockclock.go#L41: ret0, _ := ret[0].(time.Time)
mockclock.go#L52: func (m *MockClock) Schedule(d time.Duration, f func(time.Time)) clock.Event {
ticker.go#L37: func (m *MockTicker) C() <-chan time.Time {
ticker.go#L40: ret0, _ := ret[0].(<-chan time.Time)
timer.go#L37: func (m *MockTimer) C() <-chan time.Time {
timer.go#L40: ret0, _ := ret[0].(<-chan time.Time)
go.pact.im/x/clock/observeclock
observeclock.go#L45: func (c *Clock) Schedule(d time.Duration, f func(time.Time)) clock.Event {
go.pact.im/x/flaky
jitter.go#L85: func (j *jitterSchedule) Next(now time.Time) time.Time {
schedule.go#L26: Next(now time.Time) time.Time
schedule.go#L31: until time.Time
schedule.go#L36: func Until(s Schedule, t time.Time) Schedule {
schedule.go#L44: func (t *untilSchedule) Next(now time.Time) time.Time {
schedule.go#L47: return time.Time{}
schedule.go#L70: func (t *midnightSchedule) Next(now time.Time) time.Time {
schedule.go#L103: func (t sleepSchedule) Next(now time.Time) time.Time {
go.pact.im/x/goupdate
tests.go#L22: Time time.Time // encodes as an RFC3339-format string
go.pact.im/x/zapjournal
encoder.go#L202: func (e *varsEncoder) AddTime(key string, value time.Time) {
json.go#L167: func (e *jsonEncoder) AddTime(k string, v time.Time) {
json.go#L172: func (e *jsonEncoder) AppendTime(v time.Time) {
json.go#L177: func (e *jsonEncoder) encodeTime(v time.Time) {
go.pact.im/x/zapjournal/tests
stubs.go#L22: now time.Time
stubs.go#L25: func (c *fakeClock) Now() time.Time {
go.uber.org/atomic
time.go#L36: var _zeroTime time.Time
time.go#L39: func NewTime(val time.Time) *Time {
time.go#L48: func (x *Time) Load() time.Time {
time.go#L53: func (x *Time) Store(val time.Time) {
time_ext.go#L27: func packTime(t time.Time) interface{} {
time_ext.go#L31: func unpackTime(v interface{}) time.Time {
time_ext.go#L32: if t, ok := v.(time.Time); ok {
time_ext.go#L35: return time.Time{}
go.uber.org/zap
array.go#L103: func Times(key string, ts []time.Time) Field {
array.go#L259: type times []time.Time
field.go#L346: func Time(key string, val time.Time) Field {
field.go#L355: func Timep(key string, val *time.Time) Field {
field.go#L528: case time.Time:
field.go#L530: case *time.Time:
field.go#L532: case []time.Time:
time.go#L25: func timeToMillis(t time.Time) int64 {
go.uber.org/zap/buffer
buffer.go#L56: func (b *Buffer) AppendTime(t time.Time, layout string) {
go.uber.org/zap/zapcore
clock.go#L32: Now() time.Time
clock.go#L42: func (systemClock) Now() time.Time {
encoder.go#L93: type TimeEncoder func(time.Time, PrimitiveArrayEncoder)
encoder.go#L97: func EpochTimeEncoder(t time.Time, enc PrimitiveArrayEncoder) {
encoder.go#L105: func EpochMillisTimeEncoder(t time.Time, enc PrimitiveArrayEncoder) {
encoder.go#L113: func EpochNanosTimeEncoder(t time.Time, enc PrimitiveArrayEncoder) {
encoder.go#L117: func encodeTimeLayout(t time.Time, layout string, enc PrimitiveArrayEncoder) {
encoder.go#L119: AppendTimeLayout(time.Time, string)
encoder.go#L135: func ISO8601TimeEncoder(t time.Time, enc PrimitiveArrayEncoder) {
encoder.go#L143: func RFC3339TimeEncoder(t time.Time, enc PrimitiveArrayEncoder) {
encoder.go#L152: func RFC3339NanoTimeEncoder(t time.Time, enc PrimitiveArrayEncoder) {
encoder.go#L159: return func(t time.Time, enc PrimitiveArrayEncoder) {
encoder.go#L369: AddTime(key string, value time.Time)
encoder.go#L396: AppendTime(time.Time)
entry.go#L147: Time time.Time
field.go#L158: enc.AddTime(f.Key, f.Interface.(time.Time))
json_encoder.go#L204: func (enc *jsonEncoder) AddTime(key string, val time.Time) {
json_encoder.go#L303: func (enc *jsonEncoder) AppendTimeLayout(time time.Time, layout string) {
json_encoder.go#L310: func (enc *jsonEncoder) AppendTime(val time.Time) {
memory_encoder.go#L102: func (m MapObjectEncoder) AddTime(k string, v time.Time) { m.cur[k] = v }
memory_encoder.go#L173: func (s *sliceArrayEncoder) AppendTime(v time.Time) { s.elems = append(s.elems, v) }
sampler.go#L65: func (c *counter) IncCheckReset(t time.Time, tick time.Duration) uint64 {
golang.org/x/net/http2
server.go#L438: sc.conn.SetWriteDeadline(time.Time{})
server.go#L2019: sc.conn.SetReadDeadline(time.Time{})
server.go#L2043: sc.conn.SetReadDeadline(time.Time{})
server.go#L2708: func (w *responseWriter) SetReadDeadline(deadline time.Time) error {
server.go#L2734: func (w *responseWriter) SetWriteDeadline(deadline time.Time) error {
transport.go#L324: lastActive time.Time
transport.go#L325: lastIdle time.Time // time last idle
transport.go#L475: sew.conn.SetWriteDeadline(time.Time{})
transport.go#L920: LastIdle time.Time
transport.go#L1425: var respHeaderTimer <-chan time.Time
transport.go#L1580: cc.lastIdle = time.Time{}
golang.org/x/net/internal/timeseries
timeseries.go#L76: Time() time.Time
timeseries.go#L83: func (defaultClock) Time() time.Time { return time.Now() }
timeseries.go#L91: end time.Time // end timestamp for this level
timeseries.go#L100: l.end = time.Time{}
timeseries.go#L127: lastAdd time.Time // time of last Observable tracked
timeseries.go#L131: pendingTime time.Time // what time are we keeping in pending
timeseries.go#L157: ts.lastAdd = time.Time{}
timeseries.go#L160: ts.pendingTime = time.Time{}
timeseries.go#L174: func (ts *timeSeries) AddWithTime(observation Observable, t time.Time) {
timeseries.go#L200: func (ts *timeSeries) mergeValue(observation Observable, t time.Time) {
timeseries.go#L225: func (ts *timeSeries) advance(t time.Time) {
timeseries.go#L333: func (ts *timeSeries) Range(start, finish time.Time) Observable {
timeseries.go#L354: func (ts *timeSeries) ComputeRange(start, finish time.Time, num int) []Observable {
timeseries.go#L394: func (ts *timeSeries) extract(l *tsLevel, start, finish time.Time, num int, results []Observable) {
timeseries.go#L513: func minTime(a, b time.Time) time.Time {
timeseries.go#L520: func maxTime(a, b time.Time) time.Time {
golang.org/x/net/trace
events.go#L190: func (f *eventFamily) Count(now time.Time, maxErrAge time.Duration) (n int) {
events.go#L201: func (f *eventFamily) Copy(now time.Time, maxErrAge time.Duration) (els eventLogs) {
events.go#L230: When time.Time
events.go#L255: Start time.Time
events.go#L266: LastErrorTime time.Time
events.go#L276: el.Start = time.Time{}
events.go#L279: el.LastErrorTime = time.Time{}
events.go#L284: func (el *eventLog) hasRecentError(now time.Time, maxErrAge time.Duration) bool {
events.go#L296: func (el *eventLog) delta(t time.Time) (time.Duration, bool) {
trace.go#L687: When time.Time
trace.go#L722: Start time.Time
trace.go#L745: tr.Start = time.Time{}
trace.go#L768: func (tr *trace) delta(t time.Time) (time.Duration, bool) {
golang.org/x/sys/unix
timestruct.go#L30: func TimeToTimespec(t time.Time) (Timespec, error) {
golang.org/x/tools/go/packages
packages.go#L389: Time *time.Time // time version was created
golang.org/x/tools/internal/event/core
event.go#L17: at time.Time
event.go#L36: func (ev Event) At() time.Time { return ev.at }
event.go#L82: func CloneEvent(ev Event, at time.Time) Event {
golang.org/x/tools/internal/gocommand
invoke.go#L232: defer func(start time.Time) { log("%s for %v", time.Since(start), cmdDebugStr(cmd)) }(time.Now())
vendor.go#L26: Time *time.Time // time version was created
google.golang.org/grpc
clientconn.go#L1198: func (ac *addrConn) tryAllAddrs(addrs []resolver.Address, connectDeadline time.Time) error {
clientconn.go#L1236: func (ac *addrConn) createTransport(addr resolver.Address, copts transport.ConnectOptions, connectDeadline time.Time) error {
rpc_util.go#L659: func outPayload(client bool, msg interface{}, data, payload []byte, t time.Time) *stats.OutPayload {
server.go#L882: rawConn.SetDeadline(time.Time{})
stream.go#L388: var beginTime time.Time
stream.go#L570: beginTime time.Time
google.golang.org/grpc/internal/channelz
types.go#L151: LastCallStartedTimestamp time.Time
types.go#L159: CreationTime time.Time
types.go#L172: Timestamp time.Time
types.go#L453: LastLocalStreamCreatedTimestamp time.Time
types.go#L456: LastRemoteStreamCreatedTimestamp time.Time
types.go#L458: LastMessageSentTimestamp time.Time
types.go#L460: LastMessageReceivedTimestamp time.Time
types.go#L570: LastCallStartedTimestamp time.Time
types.go#L631: createdTime time.Time
google.golang.org/grpc/internal/transport
bdp_estimator.go#L51: sentAt time.Time
bdp_estimator.go#L94: b.sentAt = time.Time{}
http2_server.go#L93: lastPingAt time.Time
http2_server.go#L119: idle time.Time
http2_server.go#L579: t.idle = time.Time{}
google.golang.org/grpc/stats
stats.go#L45: BeginTime time.Time
stats.go#L75: RecvTime time.Time
stats.go#L137: SentTime time.Time
stats.go#L192: BeginTime time.Time
stats.go#L194: EndTime time.Time
google.golang.org/protobuf/types/known/timestamppb
timestamp.pb.go#L201: func New(t time.Time) *Timestamp {
timestamp.pb.go#L206: func (x *Timestamp) AsTime() time.Time {
internal/poll
fd_poll_runtime.go#L131: func (fd *FD) SetDeadline(t time.Time) error {
fd_poll_runtime.go#L136: func (fd *FD) SetReadDeadline(t time.Time) error {
fd_poll_runtime.go#L141: func (fd *FD) SetWriteDeadline(t time.Time) error {
fd_poll_runtime.go#L145: func setDeadlineImpl(fd *FD, t time.Time, mode int) error {
io/fs
fs.go#L154: ModTime() time.Time // modification time
log
log.go#L114: func (l *Logger) formatHeader(buf *[]byte, t time.Time, file string, line int) {
net
dial.go#L46: Deadline time.Time
dial.go#L103: func minNonzeroTime(a, b time.Time) time.Time {
dial.go#L118: func (d *Dialer) deadline(ctx context.Context, now time.Time) (earliest time.Time) {
dial.go#L137: func partialDeadline(now, deadline time.Time, addrsRemaining int) (time.Time, error) {
dial.go#L143: return time.Time{}, errTimeout
dnsclient_unix.go#L327: lastChecked time.Time // last time resolv.conf was checked
dnsclient_unix.go#L368: var mtime time.Time
dnsconfig_unix.go#L33: mtime time.Time // time of resolv.conf modification
fd_posix.go#L137: func (fd *netFD) SetDeadline(t time.Time) error {
fd_posix.go#L141: func (fd *netFD) SetReadDeadline(t time.Time) error {
fd_posix.go#L145: func (fd *netFD) SetWriteDeadline(t time.Time) error {
hosts.go#L46: expire time.Time
hosts.go#L48: mtime time.Time
interface.go#L181: lastFetched time.Time // last time routing information was fetched
net.go#L155: SetDeadline(t time.Time) error
net.go#L160: SetReadDeadline(t time.Time) error
net.go#L167: SetWriteDeadline(t time.Time) error
net.go#L235: func (c *conn) SetDeadline(t time.Time) error {
net.go#L246: func (c *conn) SetReadDeadline(t time.Time) error {
net.go#L257: func (c *conn) SetWriteDeadline(t time.Time) error {
net.go#L355: SetDeadline(t time.Time) error
net.go#L360: SetReadDeadline(t time.Time) error
net.go#L367: SetWriteDeadline(t time.Time) error
net.go#L498: noDeadline = time.Time{}
parse.go#L75: func stat(name string) (mtime time.Time, size int64, err error) {
parse.go#L78: return time.Time{}, 0, err
pipe.go#L31: func (d *pipeDeadline) set(t time.Time) {
pipe.go#L210: func (p *pipe) SetDeadline(t time.Time) error {
pipe.go#L219: func (p *pipe) SetReadDeadline(t time.Time) error {
pipe.go#L227: func (p *pipe) SetWriteDeadline(t time.Time) error {
tcpsock.go#L314: func (l *TCPListener) SetDeadline(t time.Time) error {
unixsock.go#L286: func (l *UnixListener) SetDeadline(t time.Time) error {
net/http
client.go#L170: func (c *Client) send(req *Request, deadline time.Time) (resp *Response, didTimeout func() bool, err error) {
client.go#L188: func (c *Client) deadline() time.Time {
client.go#L192: return time.Time{}
client.go#L204: func send(ireq *Request, rt RoundTripper, deadline time.Time) (resp *Response, didTimeout func() bool, err error) {
client.go#L300: func timeBeforeContextDeadline(t time.Time, ctx context.Context) bool {
client.go#L344: func setRequestCancel(req *Request, rt RoundTripper, deadline time.Time) (stopTimer func(), didTimeout func() bool) {
cookie.go#L29: Expires time.Time // optional
cookie.go#L148: c.Expires = time.Time{}
cookie.go#L322: func validCookieExpires(t time.Time) bool {
fs.go#L192: func ServeContent(w ResponseWriter, req *Request, name string, modtime time.Time, content io.ReadSeeker) {
fs.go#L221: func serveContent(w ResponseWriter, r *Request, name string, modtime time.Time, sizeFunc func() (int64, error), content io.ReadSeeker) {
fs.go#L421: func checkIfUnmodifiedSince(r *Request, modtime time.Time) condResult {
fs.go#L470: func checkIfModifiedSince(r *Request, modtime time.Time) condResult {
fs.go#L491: func checkIfRange(w ResponseWriter, r *Request, modtime time.Time) condResult {
fs.go#L525: func isZeroTime(t time.Time) bool {
fs.go#L529: func setLastModified(w ResponseWriter, modtime time.Time) {
fs.go#L552: func checkPreconditions(w ResponseWriter, r *Request, modtime time.Time) (done bool, rangeHeader string) {
h2_bundle.go#L4111: sc.conn.SetWriteDeadline(time.Time{})
h2_bundle.go#L5630: sc.conn.SetReadDeadline(time.Time{})
h2_bundle.go#L6995: lastActive time.Time
h2_bundle.go#L6996: lastIdle time.Time // time last idle
h2_bundle.go#L7135: sew.conn.SetWriteDeadline(time.Time{})
h2_bundle.go#L7540: LastIdle time.Time
h2_bundle.go#L8025: var respHeaderTimer <-chan time.Time
h2_bundle.go#L8172: cc.lastIdle = time.Time{}
header.go#L122: func ParseTime(text string) (t time.Time, err error) {
server.go#L319: rwc.SetDeadline(time.Time{})
server.go#L667: cr.conn.rwc.SetReadDeadline(time.Time{})
server.go#L722: cr.conn.rwc.SetReadDeadline(time.Time{})
server.go#L935: func appendTime(b []byte, t time.Time) []byte {
server.go#L965: wholeReqDeadline time.Time // or zero if none
server.go#L966: hdrDeadline time.Time // or zero if none
server.go#L1862: c.rwc.SetReadDeadline(time.Time{})
server.go#L1863: c.rwc.SetWriteDeadline(time.Time{})
server.go#L1996: c.rwc.SetReadDeadline(time.Time{})
socks_bundle.go#L23: socksnoDeadline = time.Time{}
transport.go#L1027: var oldTime time.Time
transport.go#L1900: idleAt time.Time // time it last become idle
transport.go#L1961: func (pc *persistConn) gotIdleConnTrace(idleAt time.Time) (t httptrace.GotConnInfo) {
transport.go#L2613: var respHeaderTimer <-chan time.Time
net/http/httputil
dump.go#L49: func (c *dumpConn) SetDeadline(t time.Time) error { return nil }
dump.go#L50: func (c *dumpConn) SetReadDeadline(t time.Time) error { return nil }
dump.go#L51: func (c *dumpConn) SetWriteDeadline(t time.Time) error { return nil }
os
file.go#L569: func (f *File) SetDeadline(t time.Time) error {
file.go#L577: func (f *File) SetReadDeadline(t time.Time) error {
file.go#L587: func (f *File) SetWriteDeadline(t time.Time) error {
file_posix.go#L180: func Chtimes(name string, atime time.Time, mtime time.Time) error {
file_posix.go#L204: func (f *File) setDeadline(t time.Time) error {
file_posix.go#L212: func (f *File) setReadDeadline(t time.Time) error {
file_posix.go#L220: func (f *File) setWriteDeadline(t time.Time) error {
stat_linux.go#L44: func timespecToTime(ts syscall.Timespec) time.Time {
stat_linux.go#L49: func atime(fi FileInfo) time.Time {
types_unix.go#L19: modTime time.Time
types_unix.go#L25: func (fs *fileStat) ModTime() time.Time { return fs.modTime }
runtime/debug
garbage.go#L15: LastGC time.Time // time of last collection
garbage.go#L19: PauseEnd []time.Time // pause end times history, most recent first
garbage.go#L57: stats.PauseEnd = make([]time.Time, 0, maxPause)
runtime/pprof
proto.go#L29: start time.Time
proto.go#L30: end time.Time
testing
fuzz.go#L470: func runFuzzTests(deps testDeps, fuzzTests []InternalFuzzTarget, deadline time.Time) (ran, ok bool) {
testing.go#L515: start time.Time // Time test or benchmark started
testing.go#L1120: start time.Time
testing.go#L1499: func (t *T) Deadline() (deadline time.Time, ok bool) {
testing.go#L1508: deadline time.Time
testing.go#L1799: var deadline time.Time
testing.go#L1810: func runTests(matchString func(pat, str string) (bool, error), tests []InternalTest, deadline time.Time) (ran, ok bool) {
testing.go#L2020: func (m *M) startAlarm() time.Time {
testing.go#L2022: return time.Time{}
vendor/golang.org/x/crypto/cryptobyte
asn1.go#L110: func (b *Builder) AddASN1GeneralizedTime(t time.Time) {
asn1.go#L121: func (b *Builder) AddASN1UTCTime(t time.Time) {
asn1.go#L470: func (s *String) ReadASN1GeneralizedTime(out *time.Time) bool {
asn1.go#L491: func (s *String) ReadASN1UTCTime(out *time.Time) bool {