type time.Time
717 uses
time (current package)
format.go#L450: func (t Time) String() string {
format.go#L495: func (t Time) Format(layout string) string {
format.go#L511: func (t Time) AppendFormat(b []byte, layout string) []byte {
format.go#L814: func Parse(layout, value string) (Time, error) {
format.go#L823: func ParseInLocation(layout, value string, loc *Location) (Time, error) {
format.go#L827: func parse(layout, value string, defaultLocation, local *Location) (Time, error) {
format.go#L855: return Time{}, &ParseError{alayout, avalue, prefix, value, ""}
format.go#L859: return Time{}, &ParseError{alayout, avalue, "", value, ": extra text: " + quote(value)}
format.go#L1087: return Time{}, &ParseError{alayout, avalue, stdstr, value, ": " + rangeErrString + " out of range"}
format.go#L1090: return Time{}, &ParseError{alayout, avalue, stdstr, value, ""}
format.go#L1112: return Time{}, &ParseError{alayout, avalue, "", value, ": day-of-year out of range"}
format.go#L1124: return Time{}, &ParseError{alayout, avalue, "", value, ": day-of-year does not match month"}
format.go#L1128: return Time{}, &ParseError{alayout, avalue, "", value, ": day-of-year does not match day"}
format.go#L1142: 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#L149: case c.(chan Time) <- Now():
sleep.go#L160: 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#L64: 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#L197: func (t *Time) setLoc(loc *Location) {
time.go#L206: func (t *Time) stripMono() {
time.go#L217: func (t *Time) setMono(m int64) {
time.go#L233: func (t *Time) mono() int64 {
time.go#L241: func (t Time) After(u Time) bool {
time.go#L251: func (t Time) Before(u Time) bool {
time.go#L265: func (t Time) Equal(u Time) bool {
time.go#L426: func (t Time) IsZero() bool {
time.go#L432: func (t Time) abs() uint64 {
time.go#L452: func (t Time) locabs() (name string, offset int, abs uint64) {
time.go#L475: func (t Time) Date() (year int, month Month, day int) {
time.go#L481: func (t Time) Year() int {
time.go#L487: func (t Time) Month() Month {
time.go#L493: func (t Time) Day() int {
time.go#L499: func (t Time) Weekday() Weekday {
time.go#L514: func (t Time) ISOWeek() (year, week int) {
time.go#L538: func (t Time) Clock() (hour, min, sec int) {
time.go#L553: func (t Time) Hour() int {
time.go#L558: func (t Time) Minute() int {
time.go#L563: func (t Time) Second() int {
time.go#L569: func (t Time) Nanosecond() int {
time.go#L575: func (t Time) YearDay() int {
time.go#L813: func (t Time) Add(d Duration) Time {
time.go#L841: func (t Time) Sub(u Time) Duration {
time.go#L868: func Since(t Time) Duration {
time.go#L869: var now Time
time.go#L872: now = Time{hasMonotonic, runtimeNano() - startNano, nil}
time.go#L881: func Until(t Time) Duration {
time.go#L882: var now Time
time.go#L885: now = Time{hasMonotonic, runtimeNano() - startNano, nil}
time.go#L900: func (t Time) AddDate(years int, months int, days int) Time {
time.go#L918: func (t Time) date(full bool) (year int, month Month, day int, yday int) {
time.go#L1066: func Now() Time {
time.go#L1071: return Time{uint64(nsec), sec + minWall, Local}
time.go#L1073: return Time{hasMonotonic | uint64(sec)<time.go#L1076: func unixTime(sec int64, nsec int32) Time {
time.go#L1077: return Time{uint64(nsec), sec + unixToInternal, Local}
time.go#L1081: func (t Time) UTC() Time {
time.go#L1087: func (t Time) Local() Time {
time.go#L1097: func (t Time) In(loc *Location) Time {
time.go#L1106: func (t Time) Location() *Location {
time.go#L1116: func (t Time) Zone() (name string, offset int) {
time.go#L1127: func (t Time) Unix() int64 {
time.go#L1137: func (t Time) UnixNano() int64 {
time.go#L1144: func (t Time) MarshalBinary() ([]byte, error) {
time.go#L1185: func (t *Time) UnmarshalBinary(data []byte) error {
time.go#L1209: *t = Time{}
time.go#L1229: func (t Time) GobEncode() ([]byte, error) {
time.go#L1234: func (t *Time) GobDecode(data []byte) error {
time.go#L1240: func (t Time) MarshalJSON() ([]byte, error) {
time.go#L1256: func (t *Time) UnmarshalJSON(data []byte) error {
time.go#L1269: func (t Time) MarshalText() ([]byte, error) {
time.go#L1280: func (t *Time) UnmarshalText(data []byte) error {
time.go#L1292: func Unix(sec int64, nsec int64) Time {
time.go#L1342: func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time {
time.go#L1403: func (t Time) Truncate(d Duration) Time {
time.go#L1420: func (t Time) Round(d Duration) Time {
time.go#L1435: func div(t Time, d Duration) (qmod2 int, r Duration) {
archive/zip
reader.go#L327: var modified time.Time
reader.go#L652: func (f *fileListEntry) ModTime() time.Time { return time.Time{} }
struct.go#L127: Modified time.Time
struct.go#L158: func (fi headerFileInfo) ModTime() time.Time {
struct.go#L222: func msDosTimeToTime(dosDate, dosTime uint16) time.Time {
struct.go#L242: func timeToMsDosTime(t time.Time) (fDate uint16, fTime uint16) {
struct.go#L252: func (h *FileHeader) ModTime() time.Time {
struct.go#L260: func (h *FileHeader) SetModTime(t time.Time) {
cloud.google.com/go/logging
logging.go#L563: Timestamp time.Time
cloud.google.com/go/storage
bucket.go#L286: Created time.Time
bucket.go#L342: LockedTime time.Time
bucket.go#L353: LockedTime time.Time
bucket.go#L383: EffectiveTime time.Time
bucket.go#L456: CreatedBefore time.Time
hmac.go#L76: CreatedTime time.Time
hmac.go#L79: UpdatedTime time.Time
post_policy_v4.go#L75: Expires time.Time
post_policy_v4.go#L344: func validatePostPolicyV4Options(opts *PostPolicyV4Options, now time.Time) error {
reader.go#L62: LastModified time.Time
reader.go#L262: var lm time.Time
reader.go#L433: func (r *Reader) LastModified() (time.Time, error) {
storage.go#L295: Expires time.Time
storage.go#L475: func validateOptions(opts *SignedURLOptions, now time.Time) error {
storage.go#L520: var utcNow = func() time.Time {
storage.go#L551: func signedURLV4(bucket, name string, opts *SignedURLOptions, now time.Time) (string, error) {
storage.go#L1100: RetentionExpirationTime time.Time
storage.go#L1167: Created time.Time
storage.go#L1171: Deleted time.Time
storage.go#L1176: Updated time.Time
storage.go#L1206: func convertTime(t string) time.Time {
storage.go#L1207: var r time.Time
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#L430: func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
context.go#L465: deadline time.Time
context.go#L468: func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
contrib.go.opencensus.io/exporter/stackdriver
stats.go#L447: func newPoint(v *view.View, row *view.Row, start, end time.Time) *monitoringpb.Point {
stats.go#L456: func newCumulativePoint(v *view.View, row *view.Row, start, end time.Time) *monitoringpb.Point {
stats.go#L472: func newGaugePoint(v *view.View, row *view.Row, end time.Time) *monitoringpb.Point {
trace_proto.go#L172: func timestampProto(t time.Time) *timestamppb.Timestamp {
crypto/tls
common.go#L339: receivedAt time.Time // When the session ticket was received from the server
common.go#L345: useBy time.Time // Expiration of the ticket lifetime as set by the server
common.go#L508: Time func() time.Time
common.go#L726: created time.Time
common.go#L919: func (c *Config) time() time.Time {
conn.go#L136: func (c *Conn) SetDeadline(t time.Time) error {
conn.go#L142: func (c *Conn) SetReadDeadline(t time.Time) error {
conn.go#L149: func (c *Conn) SetWriteDeadline(t time.Time) error {
crypto/x509
verify.go#L212: CurrentTime time.Time
x509.go#L167: NotBefore, NotAfter time.Time
x509.go#L646: NotBefore, NotAfter time.Time // Validity bounds.
x509.go#L2292: func (c *Certificate) CreateCRL(rand io.Reader, priv interface{}, revokedCerts []pkix.RevokedCertificate, now, expiry time.Time) (crlBytes []byte, err error) {
x509.go#L2748: ThisUpdate time.Time
x509.go#L2752: 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#L319: Time time.Time
sql.go#L326: n.Time, n.Valid = time.Time{}, false
sql.go#L458: createdAt time.Time
sql.go#L469: returnedAt time.Time // Time the connection was created or returned.
database/sql/driver
types.go#L181: case []byte, bool, float64, int64, string, 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/aws
convert_types.go#L832: func Time(v time.Time) *time.Time {
convert_types.go#L838: func TimeValue(v *time.Time) time.Time {
convert_types.go#L842: return time.Time{}
convert_types.go#L847: func SecondsTimeValue(v *int64) time.Time {
convert_types.go#L851: return time.Time{}
convert_types.go#L856: func MillisecondsTimeValue(v *int64) time.Time {
convert_types.go#L860: return time.Time{}
convert_types.go#L871: func TimeUnixMilli(t time.Time) int64 {
convert_types.go#L877: func TimeSlice(src []time.Time) []*time.Time {
convert_types.go#L878: dst := make([]*time.Time, len(src))
convert_types.go#L887: func TimeValueSlice(src []*time.Time) []time.Time {
convert_types.go#L888: dst := make([]time.Time, len(src))
convert_types.go#L899: func TimeMap(src map[string]time.Time) map[string]*time.Time {
convert_types.go#L900: dst := make(map[string]*time.Time)
convert_types.go#L910: func TimeValueMap(src map[string]*time.Time) map[string]time.Time {
convert_types.go#L911: dst := make(map[string]time.Time)
github.com/aws/aws-sdk-go/aws/awsutil
copy.go#L53: if _, ok := src.Interface().(*time.Time); !ok {
github.com/aws/aws-sdk-go/aws/credentials
credentials.go#L122: ExpiresAt() time.Time
credentials.go#L159: expiration time.Time
credentials.go#L164: CurrentTime func() time.Time
credentials.go#L175: func (e *Expiry) SetExpiration(expiration time.Time, window time.Duration) {
credentials.go#L192: func (e *Expiry) ExpiresAt() time.Time {
credentials.go#L311: func (c *Credentials) ExpiresAt() (time.Time, error) {
credentials.go#L314: return time.Time{}, awserr.New("ProviderNotExpirer",
credentials.go#L320: return time.Time{}, nil
credentials.go#L329: func (s *suppressedContext) Deadline() (deadline time.Time, ok bool) {
credentials.go#L330: return time.Time{}, false
github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds
ec2_role_provider.go#L127: Expiration time.Time
github.com/aws/aws-sdk-go/aws/credentials/endpointcreds
provider.go#L146: Expiration *time.Time
github.com/aws/aws-sdk-go/aws/credentials/processcreds
provider.go#L234: Expiration *time.Time
github.com/aws/aws-sdk-go/aws/csm
metric.go#L10: type metricTime time.Time
metric.go#L13: ns := time.Duration(time.Time(t).UnixNano())
github.com/aws/aws-sdk-go/aws/ec2metadata
api.go#L227: LastUpdated time.Time
api.go#L245: PendingTime time.Time `json:"pendingTime"`
github.com/aws/aws-sdk-go/aws/request
request.go#L52: AttemptTime time.Time
request.go#L53: Time time.Time
request.go#L69: LastSignedAt time.Time
github.com/aws/aws-sdk-go/aws/signer/v4
stream.go#L36: func (s *StreamSigner) GetSignature(headers, payload []byte, date time.Time) ([]byte, error) {
stream.go#L54: func buildEventStreamStringToSign(headers, payload, prevSig []byte, scope string, date time.Time) string {
v4.go#L203: currentTimeFn func() time.Time
v4.go#L231: Time time.Time
v4.go#L276: func (v4 Signer) Sign(r *http.Request, body io.ReadSeeker, service, region string, signTime time.Time) (http.Header, error) {
v4.go#L310: func (v4 Signer) Presign(r *http.Request, body io.ReadSeeker, service, region string, exp time.Duration, signTime time.Time) (http.Header, error) {
v4.go#L314: func (v4 Signer) signWithBody(r *http.Request, body io.ReadSeeker, service, region string, exp time.Duration, isPresign bool, signTime time.Time) (http.Header, error) {
v4.go#L444: func SignSDKRequestWithCurrentTime(req *request.Request, curTimeFn func() time.Time, opts ...func(*Signer)) {
v4.go#L823: func buildSigningScope(region, service string, dt time.Time) string {
v4.go#L832: func deriveSigningKey(region, service, secretKey string, dt time.Time) []byte {
v4.go#L840: func formatShortTime(dt time.Time) string {
v4.go#L844: func formatTime(dt time.Time) string {
github.com/aws/aws-sdk-go/private/protocol
timestamp.go#L50: func FormatTime(name string, t time.Time) string {
timestamp.go#L68: func ParseTime(formatName, value string) (time.Time, error) {
timestamp.go#L79: return time.Time{}, err
github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
build.go#L19: var timeType = reflect.ValueOf(time.Time{}).Type()
build.go#L218: case time.Time:
unmarshal.go#L91: if _, ok := value.Interface().(*time.Time); !ok {
unmarshal.go#L243: case *time.Time:
unmarshal.go#L281: case *time.Time:
github.com/aws/aws-sdk-go/private/protocol/query/queryutil
queryutil.go#L234: case time.Time:
github.com/aws/aws-sdk-go/private/protocol/rest
build.go#L284: case time.Time:
unmarshal.go#L232: case *time.Time:
github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
build.go#L295: case time.Time:
unmarshal.go#L85: if _, ok := r.Interface().(*time.Time); !ok {
unmarshal.go#L284: case *time.Time:
github.com/aws/aws-sdk-go/service/sts
api.go#L2351: Expiration *time.Time `type:"timestamp" required:"true"`
api.go#L2381: func (s *Credentials) SetExpiration(v time.Time) *Credentials {
github.com/emirpasic/gods/utils
comparator.go#L240: aAsserted := a.(time.Time)
comparator.go#L241: bAsserted := b.(time.Time)
github.com/evanw/esbuild/internal/logger
logger.go#L611: func PrintSummary(osArgs []string, table SummaryTable, start time.Time) {
github.com/go-git/go-billy/v5
fs.go#L148: Chtimes(name string, atime time.Time, mtime time.Time) error
github.com/go-git/go-git/v5
blame.go#L111: Date time.Time
blame.go#L116: func newLine(author, text string, date time.Time, hash plumbing.Hash) *Line {
options.go#L365: Since *time.Time
options.go#L369: Until *time.Time
prune.go#L15: OnlyObjectsOlderThan time.Time
repository.go#L1529: OnlyDeletePacksOlderThan time.Time
github.com/go-git/go-git/v5/internal/revision
parser.go#L77: Date time.Time
github.com/go-git/go-git/v5/plumbing/format/index
encoder.go#L123: func (e *Encoder) timeToUint32(t *time.Time) (uint32, uint32, error) {
index.go#L131: CreatedAt time.Time
index.go#L133: ModifiedAt time.Time
github.com/go-git/go-git/v5/plumbing/object
commit_walker_limit.go#L16: Since *time.Time
commit_walker_limit.go#L17: Until *time.Time
object.go#L87: When time.Time
github.com/go-git/go-git/v5/plumbing/protocol/packp
ulreq.go#L41: type DepthSince time.Time
ulreq.go#L46: return time.Time(d).IsZero()
ulreq_encode.go#L119: when := time.Time(depth).UTC()
github.com/go-git/go-git/v5/plumbing/storer
object.go#L74: LooseObjectTime(plumbing.Hash) (time.Time, error)
object.go#L87: DeleteOldObjectPackAndIndex(plumbing.Hash, time.Time) error
github.com/go-git/go-git/v5/storage/filesystem
object.go#L799: func (s *ObjectStorage) LooseObjectTime(hash plumbing.Hash) (time.Time, error) {
object.go#L802: return time.Time{}, err
object.go#L815: func (s *ObjectStorage) DeleteOldObjectPackAndIndex(h plumbing.Hash, t time.Time) error {
github.com/go-git/go-git/v5/storage/filesystem/dotgit
dotgit.go#L305: func (d *DotGit) DeleteOldObjectPackAndIndex(hash plumbing.Hash, t time.Time) error {
github.com/go-git/go-git/v5/storage/memory
storage.go#L192: func (o *ObjectStorage) DeleteOldObjectPackAndIndex(plumbing.Hash, time.Time) error {
storage.go#L198: func (s *ObjectStorage) LooseObjectTime(hash plumbing.Hash) (time.Time, error) {
storage.go#L199: return time.Time{}, errNotSupported
github.com/go-redis/redis/v8
cluster.go#L442: createdAt time.Time
command.go#L546: val time.Time
command.go#L560: func (cmd *TimeCmd) Val() time.Time {
command.go#L564: func (cmd *TimeCmd) Result() (time.Time, error) {
command.go#L721: func (cmd *StringCmd) Time() (time.Time, error) {
command.go#L723: return time.Time{}, cmd.err
command.go#L2175: Time time.Time
commands.go#L86: ExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd
commands.go#L95: PExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd
commands.go#L467: func (c cmdable) ExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd {
commands.go#L530: func (c cmdable) PExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd {
result.go#L102: func NewTimeCmdResult(val time.Time, err error) *TimeCmd {
github.com/go-redis/redis/v8/internal
arg.go#L47: case time.Time:
github.com/go-redis/redis/v8/internal/pool
conn.go#L14: var noDeadline = time.Time{}
conn.go#L26: createdAt time.Time
conn.go#L41: func (cn *Conn) UsedAt() time.Time {
conn.go#L46: func (cn *Conn) SetUsedAt(tm time.Time) {
conn.go#L106: func (cn *Conn) deadline(ctx context.Context, timeout time.Duration) time.Time {
github.com/go-redis/redis/v8/internal/proto
writer.go#L98: case time.Time:
github.com/golang-migrate/migrate/v4
migration.go#L44: Scheduled time.Time
migration.go#L47: StartedBuffering time.Time
migration.go#L50: FinishedBuffering time.Time
migration.go#L53: FinishedReading time.Time
github.com/golang/protobuf/ptypes
timestamp.go#L36: func Timestamp(ts *timestamppb.Timestamp) (time.Time, error) {
timestamp.go#L39: var t time.Time
timestamp.go#L59: func TimestampProto(t time.Time) (*timestamppb.Timestamp, error) {
github.com/google/go-cmp/cmp/cmpopts
equate.go#L105: func areNonZeroTimes(x, y time.Time) bool {
equate.go#L113: func (a timeApproximator) compare(x, y time.Time) bool {
github.com/jackc/pgconn
pgconn.go#L235: func() { pgConn.conn.SetDeadline(time.Time{}) },
pgconn.go#L843: func() { cancelConn.SetDeadline(time.Time{}) },
pgconn.go#L1707: func() { pgConn.conn.SetDeadline(time.Time{}) },
github.com/jackc/pgtype
convert.go#L158: timeType := reflect.TypeOf(time.Time{})
convert.go#L173: return time.Time{}, false
date.go#L14: Time time.Time
date.go#L38: case time.Time:
date.go#L42: case *time.Time:
date.go#L82: case *time.Time:
date.go#L211: case time.Time:
date_array.go#L38: case []time.Time:
date_array.go#L57: case []*time.Time:
date_array.go#L200: case *[]time.Time:
date_array.go#L201: *v = make([]time.Time, len(src.Elements))
date_array.go#L209: case *[]*time.Time:
date_array.go#L210: *v = make([]*time.Time, len(src.Elements))
pgtype.go#L350: registerDefaultPgTypeVariants("timestamptz", "_timestamptz", time.Time{})
time.go#L38: case time.Time:
time.go#L44: case *time.Time:
time.go#L75: case *time.Time:
time.go#L221: case time.Time:
timestamp.go#L20: Time time.Time // Time must always be in UTC.
timestamp.go#L41: case time.Time:
timestamp.go#L43: case *time.Time:
timestamp.go#L79: case *time.Time:
timestamp.go#L220: case time.Time:
timestamp_array.go#L38: case []time.Time:
timestamp_array.go#L57: case []*time.Time:
timestamp_array.go#L200: case *[]time.Time:
timestamp_array.go#L201: *v = make([]time.Time, len(src.Elements))
timestamp_array.go#L209: case *[]*time.Time:
timestamp_array.go#L210: *v = make([]*time.Time, len(src.Elements))
timestamptz.go#L24: Time time.Time
timestamptz.go#L43: case time.Time:
timestamptz.go#L45: case *time.Time:
timestamptz.go#L81: case *time.Time:
timestamptz.go#L217: case time.Time:
timestamptz_array.go#L38: case []time.Time:
timestamptz_array.go#L57: case []*time.Time:
timestamptz_array.go#L200: case *[]time.Time:
timestamptz_array.go#L201: *v = make([]time.Time, len(src.Elements))
timestamptz_array.go#L209: case *[]*time.Time:
timestamptz_array.go#L210: *v = make([]*time.Time, len(src.Elements))
github.com/jackc/pgx/v4
rows.go#L104: startTime time.Time
values.go#L81: case time.Time:
github.com/jackc/pgx/v4/internal/sanitize
sanitize.go#L49: case time.Time:
github.com/jackc/pgx/v4/stdlib
sql.go#L513: return reflect.TypeOf(time.Time{})
github.com/lib/pq
conn.go#L324: err = cn.c.SetDeadline(time.Time{})
encode.go#L48: case time.Time:
encode.go#L148: case time.Time:
encode.go#L197: func mustParse(f string, typ oid.Oid, s []byte) time.Time {
encode.go#L281: var infinityTsNegative time.Time
encode.go#L282: var infinityTsPositive time.Time
encode.go#L309: func EnableInfinityTs(negative time.Time, positive time.Time) {
encode.go#L356: func ParseTimestamp(currentLocation *time.Location, str string) (time.Time, error) {
encode.go#L417: return time.Time{}, fmt.Errorf("expected '-' or '+' at position %v; got %v", tzStart, c)
encode.go#L441: return time.Time{}, fmt.Errorf("expected end of input, got %v", str[remainderIdx:])
encode.go#L462: func formatTs(t time.Time) []byte {
encode.go#L477: func FormatTimestamp(t time.Time) []byte {
encode.go#L586: Time time.Time
encode.go#L592: nt.Time, nt.Valid = value.(time.Time)
notify.go#L743: var nextReconnect time.Time
rows.go#L37: return reflect.TypeOf(time.Time{})
github.com/prometheus/client_golang/prometheus
go_collector.go#L31: msLastTimestamp time.Time
metric.go#L151: t time.Time
metric.go#L173: func NewMetricWithTimestamp(t time.Time, m Metric) Metric {
summary.go#L269: headStreamExpTime, hotBufExpTime time.Time
summary.go#L334: func (s *summary) asyncFlush(now time.Time) {
summary.go#L374: func (s *summary) swapBufs(now time.Time) {
timer.go#L21: begin time.Time
github.com/prometheus/common/model
alert.go#L38: StartsAt time.Time `json:"startsAt,omitempty"`
alert.go#L39: EndsAt time.Time `json:"endsAt,omitempty"`
alert.go#L69: func (a *Alert) ResolvedAt(ts time.Time) bool {
silence.go#L69: StartsAt time.Time `json:"startsAt"`
silence.go#L70: EndsAt time.Time `json:"endsAt"`
silence.go#L72: CreatedAt time.Time `json:"createdAt,omitempty"`
time.go#L94: func (t Time) Time() time.Time {
github.com/sergi/go-diff/diffmatchpatch
diff.go#L91: var deadline time.Time
diff.go#L98: func (dmp *DiffMatchPatch) diffMainRunes(text1, text2 []rune, checklines bool, deadline time.Time) []Diff {
diff.go#L133: func (dmp *DiffMatchPatch) diffCompute(text1, text2 []rune, checklines bool, deadline time.Time) []Diff {
diff.go#L194: func (dmp *DiffMatchPatch) diffLineMode(text1, text2 []rune, deadline time.Time) []Diff {
diff.go#L254: func (dmp *DiffMatchPatch) DiffBisect(text1, text2 string, deadline time.Time) []Diff {
diff.go#L261: func (dmp *DiffMatchPatch) diffBisect(runes1, runes2 []rune, deadline time.Time) []Diff {
diff.go#L377: deadline time.Time) []Diff {
go.opencensus.io/internal
internal.go#L35: func MonotonicEndTime(start time.Time) time.Time {
go.opencensus.io/metric/metricdata
exemplar.go#L33: Timestamp time.Time // the time the value was recorded
metric.go#L45: StartTime time.Time // time we started recording this time series
point.go#L24: Time time.Time
point.go#L33: func NewFloat64Point(t time.Time, val float64) Point {
point.go#L41: func NewInt64Point(t time.Time, val int64) Point {
point.go#L49: func NewDistributionPoint(t time.Time, val *Distribution) Point {
point.go#L57: func NewSummaryPoint(t time.Time, val *Summary) Point {
go.opencensus.io/plugin/ocgrpc
stats_common.go#L49: startTime time.Time
go.opencensus.io/plugin/ochttp
client_stats.go#L92: start time.Time
server.go#L173: start time.Time
go.opencensus.io/stats/view
aggregation_data.go#L30: addSample(v float64, attachments map[string]interface{}, t time.Time)
aggregation_data.go#L33: toPoint(t metricdata.Type, time time.Time) metricdata.Point
aggregation_data.go#L48: func (a *CountData) addSample(_ float64, _ map[string]interface{}, _ time.Time) {
aggregation_data.go#L65: func (a *CountData) toPoint(metricType metricdata.Type, t time.Time) metricdata.Point {
aggregation_data.go#L84: func (a *SumData) addSample(v float64, _ map[string]interface{}, _ time.Time) {
aggregation_data.go#L100: func (a *SumData) toPoint(metricType metricdata.Type, t time.Time) metricdata.Point {
aggregation_data.go#L155: func (a *DistributionData) addSample(v float64, attachments map[string]interface{}, t time.Time) {
aggregation_data.go#L175: func (a *DistributionData) addToBucket(v float64, attachments map[string]interface{}, t time.Time) {
aggregation_data.go#L195: func getExemplar(v float64, attachments map[string]interface{}, t time.Time) *metricdata.Exemplar {
aggregation_data.go#L232: func (a *DistributionData) toPoint(metricType metricdata.Type, t time.Time) metricdata.Point {
aggregation_data.go#L268: func (l *LastValueData) addSample(v float64, _ map[string]interface{}, _ time.Time) {
aggregation_data.go#L284: func (l *LastValueData) toPoint(metricType metricdata.Type, t time.Time) metricdata.Point {
collector.go#L35: func (c *collector) addSample(s string, v float64, attachments map[string]interface{}, t time.Time) {
view.go#L156: func (v *viewInternal) addSample(m *tag.Map, val float64, attachments map[string]interface{}, t time.Time) {
view.go#L168: Start, End time.Time
view_to_metric.go#L122: func rowToTimeseries(v *viewInternal, row *Row, now time.Time, startTime time.Time) *metricdata.TimeSeries {
view_to_metric.go#L130: func viewToMetric(v *viewInternal, r *resource.Resource, now time.Time, startTime time.Time) *metricdata.Metric {
view_to_metric.go#L133: startTime = time.Time{}
worker.go#L46: startTimes map[*viewInternal]time.Time
worker.go#L249: startTimes: make(map[*viewInternal]time.Time),
worker.go#L369: func (w *worker) toMetric(v *viewInternal, now time.Time) *metricdata.Metric {
worker.go#L374: var startTime time.Time
worker.go#L377: startTime = time.Time{}
worker_commands.go#L113: now time.Time
worker_commands.go#L154: t time.Time
go.opencensus.io/trace
basetypes.go#L40: Time time.Time
basetypes.go#L104: Time time.Time
export.go#L79: StartTime time.Time
export.go#L82: EndTime time.Time
spanbucket.go#L39: nextTime time.Time // next time we can accept a span
go.opencensus.io/zpages
tracez.go#L190: var ti time.Time
tracez.go#L212: wholeTime := func(t time.Time) string {
tracez.go#L215: formatTime := func(t time.Time) string {
tracez.go#L225: formatElapsed := func(t time.Time) string {
go.opencensus.io/zpages/internal
resources.go#L122: func (f *_escFile) ModTime() time.Time {
go.opentelemetry.io/otel/api/trace
api.go#L61: EndTime time.Time
api.go#L68: func WithEndTime(t time.Time) EndOption {
api.go#L76: Timestamp time.Time
api.go#L84: func WithErrorTime(t time.Time) ErrorOption {
api.go#L109: AddEventWithTimestamp(ctx context.Context, timestamp time.Time, name string, attrs ...label.KeyValue)
api.go#L147: StartTime time.Time
api.go#L226: func WithStartTime(t time.Time) StartOption {
noop_span.go#L74: func (NoopSpan) AddEventWithTimestamp(ctx context.Context, timestamp time.Time, name string, attrs ...label.KeyValue) {
golang.org/x/crypto/openpgp
keys.go#L91: func (e *Entity) encryptionKey(now time.Time) (Key, bool) {
keys.go#L95: var maxTime time.Time
keys.go#L129: func (e *Entity) signingKey(now time.Time) (Key, bool) {
write.go#L102: ModTime time.Time
golang.org/x/crypto/openpgp/packet
config.go#L28: Time func() time.Time
config.go#L72: func (c *Config) Now() time.Time {
private_key.go#L39: func NewRSAPrivateKey(creationTime time.Time, priv *rsa.PrivateKey) *PrivateKey {
private_key.go#L46: func NewDSAPrivateKey(creationTime time.Time, priv *dsa.PrivateKey) *PrivateKey {
private_key.go#L53: func NewElGamalPrivateKey(creationTime time.Time, priv *elgamal.PrivateKey) *PrivateKey {
private_key.go#L60: func NewECDSAPrivateKey(creationTime time.Time, priv *ecdsa.PrivateKey) *PrivateKey {
private_key.go#L69: func NewSignerPrivateKey(creationTime time.Time, signer crypto.Signer) *PrivateKey {
public_key.go#L154: CreationTime time.Time
public_key.go#L183: func NewRSAPublicKey(creationTime time.Time, pub *rsa.PublicKey) *PublicKey {
public_key.go#L197: func NewDSAPublicKey(creationTime time.Time, pub *dsa.PublicKey) *PublicKey {
public_key.go#L213: func NewElGamalPublicKey(creationTime time.Time, pub *elgamal.PublicKey) *PublicKey {
public_key.go#L227: func NewECDSAPublicKey(creationTime time.Time, pub *ecdsa.PublicKey) *PublicKey {
public_key_v3.go#L27: CreationTime time.Time
public_key_v3.go#L41: func newRSAPublicKeyV3(creationTime time.Time, pub *rsa.PublicKey) *PublicKeyV3 {
signature.go#L43: CreationTime time.Time
signature.go#L459: func (sig *Signature) KeyExpired(currentTime time.Time) bool {
signature_v3.go#L25: CreationTime time.Time
golang.org/x/crypto/ssh
certs.go#L288: Clock func() time.Time
tcpip.go#L453: func (t *chanConn) SetDeadline(deadline time.Time) error {
tcpip.go#L464: func (t *chanConn) SetReadDeadline(deadline time.Time) error {
tcpip.go#L472: func (t *chanConn) SetWriteDeadline(deadline time.Time) error {
golang.org/x/crypto/ssh/agent
keyring.go#L22: expire *time.Time
golang.org/x/net/context
go17.go#L47: func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) {
golang.org/x/net/http2
server.go#L401: sc.conn.SetWriteDeadline(time.Time{})
server.go#L1895: sc.conn.SetReadDeadline(time.Time{})
transport.go#L259: lastActive time.Time
transport.go#L260: lastIdle time.Time // time last idle
transport.go#L1121: var respHeaderTimer <-chan time.Time
transport.go#L1237: cc.lastIdle = time.Time{}
golang.org/x/net/internal/socks
client.go#L17: noDeadline = 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/oauth2
token.go#L50: Expiry time.Time `json:"expiry,omitempty"`
golang.org/x/oauth2/google
appengine.go#L15: var appengineTokenFunc func(c context.Context, scopes ...string) (token string, expiry time.Time, err error)
sdk.go#L32: TokenExpiry *time.Time `json:"token_expiry"`
sdk.go#L100: var expiry time.Time
golang.org/x/oauth2/internal
token.go#L52: Expiry time.Time
token.go#L68: func (e *tokenJSON) expiry() (t time.Time) {
golang.org/x/pkgsite/cmd/prober
main.go#L277: Start time.Time
golang.org/x/pkgsite/internal
discovery.go#L47: CommitTime time.Time
discovery.go#L71: UpdatedAt time.Time
discovery.go#L170: Timestamp time.Time
discovery.go#L181: IndexTimestamp time.Time
discovery.go#L184: CreatedAt time.Time
discovery.go#L198: LastProcessedAt *time.Time
discovery.go#L201: NextProcessedAfter time.Time
discovery.go#L239: CommitTime time.Time
golang.org/x/pkgsite/internal/fetch
fetch.go#L292: func processZipFile(ctx context.Context, modulePath string, resolvedVersion string, commitTime time.Time, zipReader *zip.Reader, sourceClient *source.Client) (_ *internal.Module, _ []*internal.PackageVersionState, err error) {
fetch.go#L387: Start time.Time
fetch.go#L388: Finish time.Time
fetchlocal.go#L29: LocalCommitTime = time.Time{}
golang.org/x/pkgsite/internal/frontend
fetch.go#L127: updatedAt time.Time
header.go#L101: func absoluteTime(date time.Time) string {
search.go#L323: func elapsedTime(date time.Time) string {
server.go#L162: http.ServeContent(w, r, "", time.Time{}, strings.NewReader(`User-agent: *
golang.org/x/pkgsite/internal/index
index.go#L48: func (c *Client) pollURL(since time.Time, limit int) string {
index.go#L58: func (c *Client) GetVersions(ctx context.Context, since time.Time, limit int) (_ []*internal.IndexVersion, err error) {
golang.org/x/pkgsite/internal/middleware
stats.go#L66: start time.Time // start time of request
golang.org/x/pkgsite/internal/postgres
postgres.go#L87: func (db *DB) StalenessTimestamp(ctx context.Context) (time.Time, error) {
postgres.go#L88: var ts time.Time
postgres.go#L109: return time.Time{}, derrors.NotFound
postgres.go#L111: return time.Time{}, err
search.go#L689: func (db *DB) GetPackagesForSearchDocumentUpsert(ctx context.Context, before time.Time, limit int) (argsList []UpsertSearchDocumentArgs, err error) {
versionstate.go#L49: Timestamp time.Time
versionstate.go#L210: func (db *DB) LatestIndexTimestamp(ctx context.Context) (_ time.Time, err error) {
versionstate.go#L218: var ts time.Time
versionstate.go#L222: return time.Time{}, nil
versionstate.go#L226: return time.Time{}, err
versionstate.go#L418: LatestTimestamp time.Time
versionstate.go#L443: indexTimestamp time.Time
golang.org/x/pkgsite/internal/proxy
client.go#L52: Time time.Time
golang.org/x/pkgsite/internal/stdlib
stdlib.go#L306: func Zip(resolvedVersion string) (_ *zip.Reader, resolvedVersion2 string, commitTime time.Time, err error) {
stdlib.go#L318: return nil, "", time.Time{}, err
stdlib.go#L324: return nil, "", time.Time{}, err
stdlib.go#L328: return nil, "", time.Time{}, err
stdlib.go#L335: return nil, "", time.Time{}, err
stdlib.go#L340: return nil, "", time.Time{}, err
stdlib.go#L347: return nil, "", time.Time{}, err
stdlib.go#L351: return nil, "", time.Time{}, err
stdlib.go#L354: return nil, "", time.Time{}, err
stdlib.go#L359: return nil, "", time.Time{}, err
stdlib.go#L364: func newPseudoVersion(version string, commitTime time.Time, hash plumbing.Hash) string {
golang.org/x/pkgsite/internal/testing/sample
sample.go#L171: func NowTruncated() time.Time {
golang.org/x/pkgsite/internal/worker
pages.go#L94: LatestTimestamp *time.Time
pages.go#L97: StartTime time.Time
pages.go#L194: LatestTimestamp *time.Time
server.go#L652: "timeSince": func(t time.Time) time.Duration {
server.go#L655: "timeSub": func(t1, t2 time.Time) time.Duration {
server.go#L683: func formatTime(t *time.Time) string {
golang.org/x/pkgsite/internal/xcontext
xcontext.go#L20: func (v detachedContext) Deadline() (time.Time, bool) { return time.Time{}, false }
golang.org/x/sys/unix
timestruct.go#L31: func TimeToTimespec(t time.Time) (Timespec, error) {
google.golang.org/api/idtoken
cache.go#L23: clock func() time.Time
cache.go#L38: exp time.Time
cache.go#L68: func (c *cachingClient) now() time.Time {
cache.go#L98: func (c *cachingClient) calculateExpireTime(headers http.Header) time.Time {
google.golang.org/grpc
clientconn.go#L1191: func (ac *addrConn) tryAllAddrs(addrs []resolver.Address, connectDeadline time.Time) (transport.ClientTransport, resolver.Address, *grpcsync.Event, error) {
clientconn.go#L1229: func (ac *addrConn) createTransport(addr resolver.Address, copts transport.ConnectOptions, connectDeadline time.Time) (transport.ClientTransport, *grpcsync.Event, error) {
rpc_util.go#L601: func outPayload(client bool, msg interface{}, data, payload []byte, t time.Time) *stats.OutPayload {
server.go#L787: rawConn.SetDeadline(time.Time{})
server.go#L797: rawConn.SetDeadline(time.Time{})
stream.go#L249: var beginTime time.Time
stream.go#L404: 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_client.go#L1279: t.conn.SetReadDeadline(time.Time{}) // reset deadline once we get the settings frame (we didn't time out, yay!)
http2_server.go#L91: lastPingAt time.Time
http2_server.go#L117: idle time.Time
http2_server.go#L407: t.idle = time.Time{}
google.golang.org/grpc/stats
stats.go#L45: BeginTime time.Time
stats.go#L68: RecvTime time.Time
stats.go#L130: SentTime time.Time
stats.go#L185: BeginTime time.Time
stats.go#L187: EndTime time.Time
google.golang.org/protobuf/types/known/timestamppb
timestamp.pb.go#L192: func New(t time.Time) *Timestamp {
timestamp.pb.go#L197: func (x *Timestamp) AsTime() time.Time {
gopkg.in/yaml.v2
decode.go#L243: timeType = reflect.TypeOf(time.Time{})
decode.go#L244: ptrTimeType = reflect.TypeOf(&time.Time{})
encode.go#L120: case time.Time, *time.Time:
encode.go#L358: t := in.Interface().(time.Time)
resolve.go#L238: func parseTimestamp(s string) (time.Time, bool) {
resolve.go#L250: return time.Time{}, false
resolve.go#L257: return time.Time{}, false
internal/poll
fd_poll_runtime.go#L135: func (fd *FD) SetDeadline(t time.Time) error {
fd_poll_runtime.go#L140: func (fd *FD) SetReadDeadline(t time.Time) error {
fd_poll_runtime.go#L145: func (fd *FD) SetWriteDeadline(t time.Time) error {
fd_poll_runtime.go#L149: func setDeadlineImpl(fd *FD, t time.Time, mode int) error {
io/fs
fs.go#L154: ModTime() time.Time // modification time
log
log.go#L103: 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#L322: lastChecked time.Time // last time resolv.conf was checked
dnsclient_unix.go#L363: var mtime time.Time
dnsconfig_unix.go#L33: mtime time.Time // time of resolv.conf modification
fd_posix.go#L90: func (fd *netFD) SetDeadline(t time.Time) error {
fd_posix.go#L94: func (fd *netFD) SetReadDeadline(t time.Time) error {
fd_posix.go#L98: func (fd *netFD) SetWriteDeadline(t time.Time) error {
hosts.go#L46: expire time.Time
hosts.go#L48: mtime time.Time
interface.go#L180: 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#L494: 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#L287: func (l *TCPListener) SetDeadline(t time.Time) error {
unixsock.go#L286: func (l *UnixListener) SetDeadline(t time.Time) error {
net/http
client.go#L169: func (c *Client) send(req *Request, deadline time.Time) (resp *Response, didTimeout func() bool, err error) {
client.go#L187: func (c *Client) deadline() time.Time {
client.go#L191: return time.Time{}
client.go#L203: func send(ireq *Request, rt RoundTripper, deadline time.Time) (resp *Response, didTimeout func() bool, err error) {
client.go#L299: func timeBeforeContextDeadline(t time.Time, ctx context.Context) bool {
client.go#L343: func setRequestCancel(req *Request, rt RoundTripper, deadline time.Time) (stopTimer func(), didTimeout func() bool) {
cookie.go#L26: Expires time.Time // optional
cookie.go#L141: c.Expires = time.Time{}
cookie.go#L291: 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#L3967: sc.conn.SetWriteDeadline(time.Time{})
h2_bundle.go#L5450: sc.conn.SetReadDeadline(time.Time{})
h2_bundle.go#L6761: lastActive time.Time
h2_bundle.go#L6762: lastIdle time.Time // time last idle
h2_bundle.go#L7624: var respHeaderTimer <-chan time.Time
h2_bundle.go#L7740: cc.lastIdle = time.Time{}
header.go#L119: func ParseTime(text string) (t time.Time, err error) {
server.go#L319: rwc.SetDeadline(time.Time{})
server.go#L687: cr.conn.rwc.SetReadDeadline(time.Time{})
server.go#L742: cr.conn.rwc.SetReadDeadline(time.Time{})
server.go#L933: func appendTime(b []byte, t time.Time) []byte {
server.go#L963: wholeReqDeadline time.Time // or zero if none
server.go#L964: hdrDeadline time.Time // or zero if none
server.go#L1981: c.rwc.SetReadDeadline(time.Time{})
socks_bundle.go#L23: socksnoDeadline = time.Time{}
transport.go#L1020: var oldTime time.Time
transport.go#L1893: idleAt time.Time // time it last become idle
transport.go#L1954: func (pc *persistConn) gotIdleConnTrace(idleAt time.Time) (t httptrace.GotConnInfo) {
transport.go#L2603: 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#L562: func (f *File) SetDeadline(t time.Time) error {
file.go#L570: func (f *File) SetReadDeadline(t time.Time) error {
file.go#L580: 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_darwin.go#L44: func timespecToTime(ts syscall.Timespec) time.Time {
stat_darwin.go#L49: func atime(fi FileInfo) time.Time {
types_unix.go#L20: modTime time.Time
types_unix.go#L26: 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#L32: start time.Time
proto.go#L33: end time.Time
testing
testing.go#L410: start time.Time // Time test or benchmark started
testing.go#L1251: func (t *T) Deadline() (deadline time.Time, ok bool) {
testing.go#L1260: deadline time.Time
testing.go#L1477: var deadline time.Time
testing.go#L1488: func runTests(matchString func(pat, str string) (bool, error), tests []InternalTest, deadline time.Time) (ran, ok bool) {
testing.go#L1691: func (m *M) startAlarm() time.Time {
testing.go#L1693: return time.Time{}
vendor/golang.org/x/crypto/cryptobyte
asn1.go#L110: func (b *Builder) AddASN1GeneralizedTime(t time.Time) {
asn1.go#L452: func (s *String) ReadASN1GeneralizedTime(out *time.Time) bool {
 |
The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds. |