type Time … const hasMonotonic … const maxWall … const minWall … const nsecMask … const nsecShift … // nsec returns the time's nanoseconds. func (t *Time) nsec() int32 { … } // sec returns the time's seconds since Jan 1 year 1. func (t *Time) sec() int64 { … } // unixSec returns the time's seconds since Jan 1 1970 (Unix time). func (t *Time) unixSec() int64 { … } // addSec adds d seconds to the time. func (t *Time) addSec(d int64) { … } // setLoc sets the location associated with the time. func (t *Time) setLoc(loc *Location) { … } // stripMono strips the monotonic clock reading in t. func (t *Time) stripMono() { … } // setMono sets the monotonic clock reading in t. // If t cannot hold a monotonic clock reading, // because its wall time is too large, // setMono is a no-op. func (t *Time) setMono(m int64) { … } // mono returns t's monotonic clock reading. // It returns 0 for a missing reading. // This function is used only for testing, // so it's OK that technically 0 is a valid // monotonic clock reading as well. func (t *Time) mono() int64 { … } // IsZero reports whether t represents the zero time instant, // January 1, year 1, 00:00:00 UTC. func (t Time) IsZero() bool { … } // After reports whether the time instant t is after u. func (t Time) After(u Time) bool { … } // Before reports whether the time instant t is before u. func (t Time) Before(u Time) bool { … } // Compare compares the time instant t with u. If t is before u, it returns -1; // if t is after u, it returns +1; if they're the same, it returns 0. func (t Time) Compare(u Time) int { … } // Equal reports whether t and u represent the same time instant. // Two times can be equal even if they are in different locations. // For example, 6:00 +0200 and 4:00 UTC are Equal. // See the documentation on the Time type for the pitfalls of using == with // Time values; most code should use Equal instead. func (t Time) Equal(u Time) bool { … } type Month … const January … const February … const March … const April … const May … const June … const July … const August … const September … const October … const November … const December … // String returns the English name of the month ("January", "February", ...). func (m Month) String() string { … } type Weekday … const Sunday … const Monday … const Tuesday … const Wednesday … const Thursday … const Friday … const Saturday … // String returns the English name of the day ("Sunday", "Monday", ...). func (d Weekday) String() string { … } const secondsPerMinute … const secondsPerHour … const secondsPerDay … const secondsPerWeek … const daysPer400Years … const marchThruDecember … const absoluteYears … const internalYear … const absoluteToInternal … const internalToAbsolute … const unixToInternal … const internalToUnix … const absoluteToUnix … const unixToAbsolute … const wallToInternal … type absSeconds … type absDays … type absCentury … type absCyear … type absYday … type absMonth … type absLeap … type absJanFeb … // dateToAbsDays takes a standard year/month/day and returns the // number of days from the absolute epoch to that day. // The days argument can be out of range and in particular can be negative. func dateToAbsDays(year int64, month Month, day int) absDays { … } // days converts absolute seconds to absolute days. func (abs absSeconds) days() absDays { … } // split splits days into century, cyear, ayday. func (days absDays) split() (century absCentury, cyear absCyear, ayday absYday) { … } // split splits ayday into absolute month and standard (1-based) day-in-month. func (ayday absYday) split() (m absMonth, mday int) { … } // janFeb returns 1 if the March 1-based ayday is in January or February, 0 otherwise. func (ayday absYday) janFeb() absJanFeb { … } // month returns the standard Month for (m, janFeb) func (m absMonth) month(janFeb absJanFeb) Month { … } // leap returns 1 if (century, cyear) is a leap year, 0 otherwise. func (century absCentury) leap(cyear absCyear) absLeap { … } // year returns the standard year for (century, cyear, janFeb). func (century absCentury) year(cyear absCyear, janFeb absJanFeb) int { … } // yday returns the standard 1-based yday for (ayday, janFeb, leap). func (ayday absYday) yday(janFeb absJanFeb, leap absLeap) int { … } // date converts days into standard year, month, day. func (days absDays) date() (year int, month Month, day int) { … } // yearYday converts days into the standard year and 1-based yday. func (days absDays) yearYday() (year, yday int) { … } // absSec returns the time t as an absolute seconds, adjusted by the zone offset. // It is called when computing a presentation property like Month or Hour. // We'd rather call it abs, but there are linknames to abs that make that problematic. // See timeAbs below. func (t Time) absSec() absSeconds { … } // locabs is a combination of the Zone and abs methods, // extracting both return values from a single zone lookup. func (t Time) locabs() (name string, offset int, abs absSeconds) { … } // Date returns the year, month, and day in which t occurs. func (t Time) Date() (year int, month Month, day int) { … } // Year returns the year in which t occurs. func (t Time) Year() int { … } // Month returns the month of the year specified by t. func (t Time) Month() Month { … } // Day returns the day of the month specified by t. func (t Time) Day() int { … } // Weekday returns the day of the week specified by t. func (t Time) Weekday() Weekday { … } // weekday returns the day of the week specified by days. func (days absDays) weekday() Weekday { … } // ISOWeek returns the ISO 8601 year and week number in which t occurs. // Week ranges from 1 to 53. Jan 01 to Jan 03 of year n might belong to // week 52 or 53 of year n-1, and Dec 29 to Dec 31 might belong to week 1 // of year n+1. func (t Time) ISOWeek() (year, week int) { … } // Clock returns the hour, minute, and second within the day specified by t. func (t Time) Clock() (hour, min, sec int) { … } // clock returns the hour, minute, and second within the day specified by abs. func (abs absSeconds) clock() (hour, min, sec int) { … } // Hour returns the hour within the day specified by t, in the range [0, 23]. func (t Time) Hour() int { … } // Minute returns the minute offset within the hour specified by t, in the range [0, 59]. func (t Time) Minute() int { … } // Second returns the second offset within the minute specified by t, in the range [0, 59]. func (t Time) Second() int { … } // Nanosecond returns the nanosecond offset within the second specified by t, // in the range [0, 999999999]. func (t Time) Nanosecond() int { … } // YearDay returns the day of the year specified by t, in the range [1,365] for non-leap years, // and [1,366] in leap years. func (t Time) YearDay() int { … } type Duration … const minDuration … const maxDuration … const Nanosecond … const Microsecond … const Millisecond … const Second … const Minute … const Hour … // String returns a string representing the duration in the form "72h3m0.5s". // Leading zero units are omitted. As a special case, durations less than one // second format use a smaller unit (milli-, micro-, or nanoseconds) to ensure // that the leading digit is non-zero. The zero duration formats as 0s. func (d Duration) String() string { … } // format formats the representation of d into the end of buf and // returns the offset of the first character. func (d Duration) format(buf *[32]byte) int { … } // fmtFrac formats the fraction of v/10**prec (e.g., ".12345") into the // tail of buf, omitting trailing zeros. It omits the decimal // point too when the fraction is 0. It returns the index where the // output bytes begin and the value v/10**prec. func fmtFrac(buf []byte, v uint64, prec int) (nw int, nv uint64) { … } // fmtInt formats v into the tail of buf. // It returns the index where the output begins. func fmtInt(buf []byte, v uint64) int { … } // Nanoseconds returns the duration as an integer nanosecond count. func (d Duration) Nanoseconds() int64 { … } // Microseconds returns the duration as an integer microsecond count. func (d Duration) Microseconds() int64 { … } // Milliseconds returns the duration as an integer millisecond count. func (d Duration) Milliseconds() int64 { … } // Seconds returns the duration as a floating point number of seconds. func (d Duration) Seconds() float64 { … } // Minutes returns the duration as a floating point number of minutes. func (d Duration) Minutes() float64 { … } // Hours returns the duration as a floating point number of hours. func (d Duration) Hours() float64 { … } // Truncate returns the result of rounding d toward zero to a multiple of m. // If m <= 0, Truncate returns d unchanged. func (d Duration) Truncate(m Duration) Duration { … } // lessThanHalf reports whether x+x < y but avoids overflow, // assuming x and y are both positive (Duration is signed). func lessThanHalf(x, y Duration) bool { … } // Round returns the result of rounding d to the nearest multiple of m. // The rounding behavior for halfway values is to round away from zero. // If the result exceeds the maximum (or minimum) // value that can be stored in a [Duration], // Round returns the maximum (or minimum) duration. // If m <= 0, Round returns d unchanged. func (d Duration) Round(m Duration) Duration { … } // Abs returns the absolute value of d. // As a special case, Duration([math.MinInt64]) is converted to Duration([math.MaxInt64]), // reducing its magnitude by 1 nanosecond. func (d Duration) Abs() Duration { … } // Add returns the time t+d. func (t Time) Add(d Duration) Time { … } // Sub returns the duration t-u. If the result exceeds the maximum (or minimum) // value that can be stored in a [Duration], the maximum (or minimum) duration // will be returned. // To compute t-d for a duration d, use t.Add(-d). func (t Time) Sub(u Time) Duration { … } func subMono(t, u int64) Duration { … } // Since returns the time elapsed since t. // It is shorthand for time.Now().Sub(t). func Since(t Time) Duration { … } // Until returns the duration until t. // It is shorthand for t.Sub(time.Now()). func Until(t Time) Duration { … } // AddDate returns the time corresponding to adding the // given number of years, months, and days to t. // For example, AddDate(-1, 2, 3) applied to January 1, 2011 // returns March 4, 2010. // // Note that dates are fundamentally coupled to timezones, and calendrical // periods like days don't have fixed durations. AddDate uses the Location of // the Time value to determine these durations. That means that the same // AddDate arguments can produce a different shift in absolute time depending on // the base Time value and its Location. For example, AddDate(0, 0, 1) applied // to 12:00 on March 27 always returns 12:00 on March 28. At some locations and // in some years this is a 24 hour shift. In others it's a 23 hour shift due to // daylight savings time transitions. // // AddDate normalizes its result in the same way that Date does, // so, for example, adding one month to October 31 yields // December 1, the normalized form for November 31. func (t Time) AddDate(years int, months int, days int) Time { … } // daysBefore returns the number of days in a non-leap year before month m. // daysBefore(December+1) returns 365. func daysBefore(m Month) int { … } func daysIn(m Month, year int) int { … } // Provided by package runtime. func now() (sec int64, nsec int32, mono int64) // runtimeNano returns the current value of the runtime clock in nanoseconds. // //go:linkname runtimeNano runtime.nanotime func runtimeNano() int64 var startNano … // Now returns the current local time. func Now() Time { … } func unixTime(sec int64, nsec int32) Time { … } // UTC returns t with the location set to UTC. func (t Time) UTC() Time { … } // Local returns t with the location set to local time. func (t Time) Local() Time { … } // In returns a copy of t representing the same time instant, but // with the copy's location information set to loc for display // purposes. // // In panics if loc is nil. func (t Time) In(loc *Location) Time { … } // Location returns the time zone information associated with t. func (t Time) Location() *Location { … } // Zone computes the time zone in effect at time t, returning the abbreviated // name of the zone (such as "CET") and its offset in seconds east of UTC. func (t Time) Zone() (name string, offset int) { … } // ZoneBounds returns the bounds of the time zone in effect at time t. // The zone begins at start and the next zone begins at end. // If the zone begins at the beginning of time, start will be returned as a zero Time. // If the zone goes on forever, end will be returned as a zero Time. // The Location of the returned times will be the same as t. func (t Time) ZoneBounds() (start, end Time) { … } // Unix returns t as a Unix time, the number of seconds elapsed // since January 1, 1970 UTC. The result does not depend on the // location associated with t. // Unix-like operating systems often record time as a 32-bit // count of seconds, but since the method here returns a 64-bit // value it is valid for billions of years into the past or future. func (t Time) Unix() int64 { … } // UnixMilli returns t as a Unix time, the number of milliseconds elapsed since // January 1, 1970 UTC. The result is undefined if the Unix time in // milliseconds cannot be represented by an int64 (a date more than 292 million // years before or after 1970). The result does not depend on the // location associated with t. func (t Time) UnixMilli() int64 { … } // UnixMicro returns t as a Unix time, the number of microseconds elapsed since // January 1, 1970 UTC. The result is undefined if the Unix time in // microseconds cannot be represented by an int64 (a date before year -290307 or // after year 294246). The result does not depend on the location associated // with t. func (t Time) UnixMicro() int64 { … } // UnixNano returns t as a Unix time, the number of nanoseconds elapsed // since January 1, 1970 UTC. The result is undefined if the Unix time // in nanoseconds cannot be represented by an int64 (a date before the year // 1678 or after 2262). Note that this means the result of calling UnixNano // on the zero Time is undefined. The result does not depend on the // location associated with t. func (t Time) UnixNano() int64 { … } const timeBinaryVersionV1 … const timeBinaryVersionV2 … // AppendBinary implements the [encoding.BinaryAppender] interface. func (t Time) AppendBinary(b []byte) ([]byte, error) { … } // MarshalBinary implements the [encoding.BinaryMarshaler] interface. func (t Time) MarshalBinary() ([]byte, error) { … } // UnmarshalBinary implements the [encoding.BinaryUnmarshaler] interface. func (t *Time) UnmarshalBinary(data []byte) error { … } // GobEncode implements the gob.GobEncoder interface. func (t Time) GobEncode() ([]byte, error) { … } // GobDecode implements the gob.GobDecoder interface. func (t *Time) GobDecode(data []byte) error { … } // MarshalJSON implements the [encoding/json.Marshaler] interface. // The time is a quoted string in the RFC 3339 format with sub-second precision. // If the timestamp cannot be represented as valid RFC 3339 // (e.g., the year is out of range), then an error is reported. func (t Time) MarshalJSON() ([]byte, error) { … } // UnmarshalJSON implements the [encoding/json.Unmarshaler] interface. // The time must be a quoted string in the RFC 3339 format. func (t *Time) UnmarshalJSON(data []byte) error { … } func (t Time) appendTo(b []byte, errPrefix string) ([]byte, error) { … } // AppendText implements the [encoding.TextAppender] interface. // The time is formatted in RFC 3339 format with sub-second precision. // If the timestamp cannot be represented as valid RFC 3339 // (e.g., the year is out of range), then an error is returned. func (t Time) AppendText(b []byte) ([]byte, error) { … } // MarshalText implements the [encoding.TextMarshaler] interface. The output // matches that of calling the [Time.AppendText] method. // // See [Time.AppendText] for more information. func (t Time) MarshalText() ([]byte, error) { … } // UnmarshalText implements the [encoding.TextUnmarshaler] interface. // The time must be in the RFC 3339 format. func (t *Time) UnmarshalText(data []byte) error { … } // Unix returns the local Time corresponding to the given Unix time, // sec seconds and nsec nanoseconds since January 1, 1970 UTC. // It is valid to pass nsec outside the range [0, 999999999]. // Not all sec values have a corresponding time value. One such // value is 1<<63-1 (the largest int64 value). func Unix(sec int64, nsec int64) Time { … } // UnixMilli returns the local Time corresponding to the given Unix time, // msec milliseconds since January 1, 1970 UTC. func UnixMilli(msec int64) Time { … } // UnixMicro returns the local Time corresponding to the given Unix time, // usec microseconds since January 1, 1970 UTC. func UnixMicro(usec int64) Time { … } // IsDST reports whether the time in the configured location is in Daylight Savings Time. func (t Time) IsDST() bool { … } func isLeap(year int) bool { … } // norm returns nhi, nlo such that // // hi * base + lo == nhi * base + nlo // 0 <= nlo < base func norm(hi, lo, base int) (nhi, nlo int) { … } // Date returns the Time corresponding to // // yyyy-mm-dd hh:mm:ss + nsec nanoseconds // // in the appropriate zone for that time in the given location. // // The month, day, hour, min, sec, and nsec values may be outside // their usual ranges and will be normalized during the conversion. // For example, October 32 converts to November 1. // // A daylight savings time transition skips or repeats times. // For example, in the United States, March 13, 2011 2:15am never occurred, // while November 6, 2011 1:15am occurred twice. In such cases, the // choice of time zone, and therefore the time, is not well-defined. // Date returns a time that is correct in one of the two zones involved // in the transition, but it does not guarantee which. // // Date panics if loc is nil. func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time { … } // Truncate returns the result of rounding t down to a multiple of d (since the zero time). // If d <= 0, Truncate returns t stripped of any monotonic clock reading but otherwise unchanged. // // Truncate operates on the time as an absolute duration since the // zero time; it does not operate on the presentation form of the // time. Thus, Truncate(Hour) may return a time with a non-zero // minute, depending on the time's Location. func (t Time) Truncate(d Duration) Time { … } // Round returns the result of rounding t to the nearest multiple of d (since the zero time). // The rounding behavior for halfway values is to round up. // If d <= 0, Round returns t stripped of any monotonic clock reading but otherwise unchanged. // // Round operates on the time as an absolute duration since the // zero time; it does not operate on the presentation form of the // time. Thus, Round(Hour) may return a time with a non-zero // minute, depending on the time's Location. func (t Time) Round(d Duration) Time { … } // div divides t by d and returns the quotient parity and remainder. // We don't use the quotient parity anymore (round half up instead of round to even) // but it's still here in case we change our minds. func div(t Time, d Duration) (qmod2 int, r Duration) { … } //go:linkname legacyTimeTimeAbs time.Time.abs func legacyTimeTimeAbs(t Time) uint64 { … } //go:linkname legacyAbsClock time.absClock func legacyAbsClock(abs uint64) (hour, min, sec int) { … } //go:linkname legacyAbsDate time.absDate func legacyAbsDate(abs uint64, full bool) (year int, month Month, day int, yday int) { … }
Codebase Browser
go