type Context … var Canceled … var DeadlineExceeded … type deadlineExceededError … func (deadlineExceededError) Error() string { … } func (deadlineExceededError) Timeout() bool { … } func (deadlineExceededError) Temporary() bool { … } type emptyCtx … func (emptyCtx) Deadline() (deadline time.Time, ok bool) { … } func (emptyCtx) Done() <-chan struct{ … } func (emptyCtx) Err() error { … } func (emptyCtx) Value(key any) any { … } type backgroundCtx … func (backgroundCtx) String() string { … } type todoCtx … func (todoCtx) String() string { … } // Background returns a non-nil, empty [Context]. It is never canceled, has no // values, and has no deadline. It is typically used by the main function, // initialization, and tests, and as the top-level Context for incoming // requests. func Background() Context { … } // TODO returns a non-nil, empty [Context]. Code should use context.TODO when // it's unclear which Context to use or it is not yet available (because the // surrounding function has not yet been extended to accept a Context // parameter). func TODO() Context { … } type CancelFunc … // WithCancel returns a derived context that points to the parent context // but has a new Done channel. The returned context's Done channel is closed // when the returned cancel function is called or when the parent context's // Done channel is closed, whichever happens first. // // Canceling this context releases resources associated with it, so code should // call cancel as soon as the operations running in this [Context] complete. func WithCancel(parent Context) (ctx Context, cancel CancelFunc) { … } type CancelCauseFunc … // WithCancelCause behaves like [WithCancel] but returns a [CancelCauseFunc] instead of a [CancelFunc]. // Calling cancel with a non-nil error (the "cause") records that error in ctx; // it can then be retrieved using Cause(ctx). // Calling cancel with nil sets the cause to Canceled. // // Example use: // // ctx, cancel := context.WithCancelCause(parent) // cancel(myError) // ctx.Err() // returns context.Canceled // context.Cause(ctx) // returns myError func WithCancelCause(parent Context) (ctx Context, cancel CancelCauseFunc) { … } func withCancel(parent Context) *cancelCtx { … } // Cause returns a non-nil error explaining why c was canceled. // The first cancellation of c or one of its parents sets the cause. // If that cancellation happened via a call to CancelCauseFunc(err), // then [Cause] returns err. // Otherwise Cause(c) returns the same value as c.Err(). // Cause returns nil if c has not been canceled yet. func Cause(c Context) error { … } // AfterFunc arranges to call f in its own goroutine after ctx is done // (canceled or timed out). // If ctx is already done, AfterFunc calls f immediately in its own goroutine. // // Multiple calls to AfterFunc on a context operate independently; // one does not replace another. // // Calling the returned stop function stops the association of ctx with f. // It returns true if the call stopped f from being run. // If stop returns false, // either the context is done and f has been started in its own goroutine; // or f was already stopped. // The stop function does not wait for f to complete before returning. // If the caller needs to know whether f is completed, // it must coordinate with f explicitly. // // If ctx has a "AfterFunc(func()) func() bool" method, // AfterFunc will use it to schedule the call. func AfterFunc(ctx Context, f func()) (stop func() bool) { … } type afterFuncer … type afterFuncCtx … func (a *afterFuncCtx) cancel(removeFromParent bool, err, cause error) { … } type stopCtx … var goroutines … var cancelCtxKey … // parentCancelCtx returns the underlying *cancelCtx for parent. // It does this by looking up parent.Value(&cancelCtxKey) to find // the innermost enclosing *cancelCtx and then checking whether // parent.Done() matches that *cancelCtx. (If not, the *cancelCtx // has been wrapped in a custom implementation providing a // different done channel, in which case we should not bypass it.) func parentCancelCtx(parent Context) (*cancelCtx, bool) { … } // removeChild removes a context from its parent. func removeChild(parent Context, child canceler) { … } type canceler … var closedchan … func init() { … } type cancelCtx … func (c *cancelCtx) Value(key any) any { … } func (c *cancelCtx) Done() <-chan struct{ … } func (c *cancelCtx) Err() error { … } // propagateCancel arranges for child to be canceled when parent is. // It sets the parent context of cancelCtx. func (c *cancelCtx) propagateCancel(parent Context, child canceler) { … } type stringer … func contextName(c Context) string { … } func (c *cancelCtx) String() string { … } // cancel closes c.done, cancels each of c's children, and, if // removeFromParent is true, removes c from its parent's children. // cancel sets c.cause to cause if this is the first time c is canceled. func (c *cancelCtx) cancel(removeFromParent bool, err, cause error) { … } // WithoutCancel returns a derived context that points to the parent context // and is not canceled when parent is canceled. // The returned context returns no Deadline or Err, and its Done channel is nil. // Calling [Cause] on the returned context returns nil. func WithoutCancel(parent Context) Context { … } type withoutCancelCtx … func (withoutCancelCtx) Deadline() (deadline time.Time, ok bool) { … } func (withoutCancelCtx) Done() <-chan struct{ … } func (withoutCancelCtx) Err() error { … } func (c withoutCancelCtx) Value(key any) any { … } func (c withoutCancelCtx) String() string { … } // WithDeadline returns a derived context that points to the parent context // but has the deadline adjusted to be no later than d. If the parent's // deadline is already earlier than d, WithDeadline(parent, d) is semantically // equivalent to parent. The returned [Context.Done] channel is closed when // the deadline expires, when the returned cancel function is called, // or when the parent context's Done channel is closed, whichever happens first. // // Canceling this context releases resources associated with it, so code should // call cancel as soon as the operations running in this [Context] complete. func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) { … } // WithDeadlineCause behaves like [WithDeadline] but also sets the cause of the // returned Context when the deadline is exceeded. The returned [CancelFunc] does // not set the cause. func WithDeadlineCause(parent Context, d time.Time, cause error) (Context, CancelFunc) { … } type timerCtx … func (c *timerCtx) Deadline() (deadline time.Time, ok bool) { … } func (c *timerCtx) String() string { … } func (c *timerCtx) cancel(removeFromParent bool, err, cause error) { … } // WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)). // // Canceling this context releases resources associated with it, so code should // call cancel as soon as the operations running in this [Context] complete: // // func slowOperationWithTimeout(ctx context.Context) (Result, error) { // ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond) // defer cancel() // releases resources if slowOperation completes before timeout elapses // return slowOperation(ctx) // } func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) { … } // WithTimeoutCause behaves like [WithTimeout] but also sets the cause of the // returned Context when the timeout expires. The returned [CancelFunc] does // not set the cause. func WithTimeoutCause(parent Context, timeout time.Duration, cause error) (Context, CancelFunc) { … } // WithValue returns a derived context that points to the parent Context. // In the derived context, the value associated with key is val. // // Use context Values only for request-scoped data that transits processes and // APIs, not for passing optional parameters to functions. // // The provided key must be comparable and should not be of type // string or any other built-in type to avoid collisions between // packages using context. Users of WithValue should define their own // types for keys. To avoid allocating when assigning to an // interface{}, context keys often have concrete type // struct{}. Alternatively, exported context key variables' static // type should be a pointer or interface. func WithValue(parent Context, key, val any) Context { … } type valueCtx … // stringify tries a bit to stringify v, without using fmt, since we don't // want context depending on the unicode tables. This is only used by // *valueCtx.String(). func stringify(v any) string { … } func (c *valueCtx) String() string { … } func (c *valueCtx) Value(key any) any { … } func value(c Context, key any) any { … }
Codebase Browser
go