pre_go19.go (4065B)
1 // Copyright 2014 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 //go:build !go1.9 6 // +build !go1.9 7 8 package context 9 10 import "time" 11 12 // A Context carries a deadline, a cancelation signal, and other values across 13 // API boundaries. 14 // 15 // Context's methods may be called by multiple goroutines simultaneously. 16 type Context interface { 17 // Deadline returns the time when work done on behalf of this context 18 // should be canceled. Deadline returns ok==false when no deadline is 19 // set. Successive calls to Deadline return the same results. 20 Deadline() (deadline time.Time, ok bool) 21 22 // Done returns a channel that's closed when work done on behalf of this 23 // context should be canceled. Done may return nil if this context can 24 // never be canceled. Successive calls to Done return the same value. 25 // 26 // WithCancel arranges for Done to be closed when cancel is called; 27 // WithDeadline arranges for Done to be closed when the deadline 28 // expires; WithTimeout arranges for Done to be closed when the timeout 29 // elapses. 30 // 31 // Done is provided for use in select statements: 32 // 33 // // Stream generates values with DoSomething and sends them to out 34 // // until DoSomething returns an error or ctx.Done is closed. 35 // func Stream(ctx context.Context, out chan<- Value) error { 36 // for { 37 // v, err := DoSomething(ctx) 38 // if err != nil { 39 // return err 40 // } 41 // select { 42 // case <-ctx.Done(): 43 // return ctx.Err() 44 // case out <- v: 45 // } 46 // } 47 // } 48 // 49 // See http://blog.golang.org/pipelines for more examples of how to use 50 // a Done channel for cancelation. 51 Done() <-chan struct{} 52 53 // Err returns a non-nil error value after Done is closed. Err returns 54 // Canceled if the context was canceled or DeadlineExceeded if the 55 // context's deadline passed. No other values for Err are defined. 56 // After Done is closed, successive calls to Err return the same value. 57 Err() error 58 59 // Value returns the value associated with this context for key, or nil 60 // if no value is associated with key. Successive calls to Value with 61 // the same key returns the same result. 62 // 63 // Use context values only for request-scoped data that transits 64 // processes and API boundaries, not for passing optional parameters to 65 // functions. 66 // 67 // A key identifies a specific value in a Context. Functions that wish 68 // to store values in Context typically allocate a key in a global 69 // variable then use that key as the argument to context.WithValue and 70 // Context.Value. A key can be any type that supports equality; 71 // packages should define keys as an unexported type to avoid 72 // collisions. 73 // 74 // Packages that define a Context key should provide type-safe accessors 75 // for the values stores using that key: 76 // 77 // // Package user defines a User type that's stored in Contexts. 78 // package user 79 // 80 // import "golang.org/x/net/context" 81 // 82 // // User is the type of value stored in the Contexts. 83 // type User struct {...} 84 // 85 // // key is an unexported type for keys defined in this package. 86 // // This prevents collisions with keys defined in other packages. 87 // type key int 88 // 89 // // userKey is the key for user.User values in Contexts. It is 90 // // unexported; clients use user.NewContext and user.FromContext 91 // // instead of using this key directly. 92 // var userKey key = 0 93 // 94 // // NewContext returns a new Context that carries value u. 95 // func NewContext(ctx context.Context, u *User) context.Context { 96 // return context.WithValue(ctx, userKey, u) 97 // } 98 // 99 // // FromContext returns the User value stored in ctx, if any. 100 // func FromContext(ctx context.Context) (*User, bool) { 101 // u, ok := ctx.Value(userKey).(*User) 102 // return u, ok 103 // } 104 Value(key interface{}) interface{} 105 } 106 107 // A CancelFunc tells an operation to abandon its work. 108 // A CancelFunc does not wait for the work to stop. 109 // After the first call, subsequent calls to a CancelFunc do nothing. 110 type CancelFunc func()