"Fossies" - the Fresh Open Source Software Archive

Member "gdrive-2.1.1/vendor/golang.org/x/net/context/context.go" (28 May 2021, 6169 Bytes) of package /linux/misc/old/gdrive-2.1.1.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Go source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    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 // Package context defines the Context type, which carries deadlines,
    6 // cancelation signals, and other request-scoped values across API boundaries
    7 // and between processes.
    8 //
    9 // Incoming requests to a server should create a Context, and outgoing calls to
   10 // servers should accept a Context.  The chain of function calls between must
   11 // propagate the Context, optionally replacing it with a modified copy created
   12 // using WithDeadline, WithTimeout, WithCancel, or WithValue.
   13 //
   14 // Programs that use Contexts should follow these rules to keep interfaces
   15 // consistent across packages and enable static analysis tools to check context
   16 // propagation:
   17 //
   18 // Do not store Contexts inside a struct type; instead, pass a Context
   19 // explicitly to each function that needs it.  The Context should be the first
   20 // parameter, typically named ctx:
   21 //
   22 //  func DoSomething(ctx context.Context, arg Arg) error {
   23 //      // ... use ctx ...
   24 //  }
   25 //
   26 // Do not pass a nil Context, even if a function permits it.  Pass context.TODO
   27 // if you are unsure about which Context to use.
   28 //
   29 // Use context Values only for request-scoped data that transits processes and
   30 // APIs, not for passing optional parameters to functions.
   31 //
   32 // The same Context may be passed to functions running in different goroutines;
   33 // Contexts are safe for simultaneous use by multiple goroutines.
   34 //
   35 // See http://blog.golang.org/context for example code for a server that uses
   36 // Contexts.
   37 package context
   38 
   39 import "time"
   40 
   41 // A Context carries a deadline, a cancelation signal, and other values across
   42 // API boundaries.
   43 //
   44 // Context's methods may be called by multiple goroutines simultaneously.
   45 type Context interface {
   46     // Deadline returns the time when work done on behalf of this context
   47     // should be canceled.  Deadline returns ok==false when no deadline is
   48     // set.  Successive calls to Deadline return the same results.
   49     Deadline() (deadline time.Time, ok bool)
   50 
   51     // Done returns a channel that's closed when work done on behalf of this
   52     // context should be canceled.  Done may return nil if this context can
   53     // never be canceled.  Successive calls to Done return the same value.
   54     //
   55     // WithCancel arranges for Done to be closed when cancel is called;
   56     // WithDeadline arranges for Done to be closed when the deadline
   57     // expires; WithTimeout arranges for Done to be closed when the timeout
   58     // elapses.
   59     //
   60     // Done is provided for use in select statements:
   61     //
   62     //  // Stream generates values with DoSomething and sends them to out
   63     //  // until DoSomething returns an error or ctx.Done is closed.
   64     //  func Stream(ctx context.Context, out <-chan Value) error {
   65     //      for {
   66     //          v, err := DoSomething(ctx)
   67     //          if err != nil {
   68     //              return err
   69     //          }
   70     //          select {
   71     //          case <-ctx.Done():
   72     //              return ctx.Err()
   73     //          case out <- v:
   74     //          }
   75     //      }
   76     //  }
   77     //
   78     // See http://blog.golang.org/pipelines for more examples of how to use
   79     // a Done channel for cancelation.
   80     Done() <-chan struct{}
   81 
   82     // Err returns a non-nil error value after Done is closed.  Err returns
   83     // Canceled if the context was canceled or DeadlineExceeded if the
   84     // context's deadline passed.  No other values for Err are defined.
   85     // After Done is closed, successive calls to Err return the same value.
   86     Err() error
   87 
   88     // Value returns the value associated with this context for key, or nil
   89     // if no value is associated with key.  Successive calls to Value with
   90     // the same key returns the same result.
   91     //
   92     // Use context values only for request-scoped data that transits
   93     // processes and API boundaries, not for passing optional parameters to
   94     // functions.
   95     //
   96     // A key identifies a specific value in a Context.  Functions that wish
   97     // to store values in Context typically allocate a key in a global
   98     // variable then use that key as the argument to context.WithValue and
   99     // Context.Value.  A key can be any type that supports equality;
  100     // packages should define keys as an unexported type to avoid
  101     // collisions.
  102     //
  103     // Packages that define a Context key should provide type-safe accessors
  104     // for the values stores using that key:
  105     //
  106     //  // Package user defines a User type that's stored in Contexts.
  107     //  package user
  108     //
  109     //  import "golang.org/x/net/context"
  110     //
  111     //  // User is the type of value stored in the Contexts.
  112     //  type User struct {...}
  113     //
  114     //  // key is an unexported type for keys defined in this package.
  115     //  // This prevents collisions with keys defined in other packages.
  116     //  type key int
  117     //
  118     //  // userKey is the key for user.User values in Contexts.  It is
  119     //  // unexported; clients use user.NewContext and user.FromContext
  120     //  // instead of using this key directly.
  121     //  var userKey key = 0
  122     //
  123     //  // NewContext returns a new Context that carries value u.
  124     //  func NewContext(ctx context.Context, u *User) context.Context {
  125     //      return context.WithValue(ctx, userKey, u)
  126     //  }
  127     //
  128     //  // FromContext returns the User value stored in ctx, if any.
  129     //  func FromContext(ctx context.Context) (*User, bool) {
  130     //      u, ok := ctx.Value(userKey).(*User)
  131     //      return u, ok
  132     //  }
  133     Value(key interface{}) interface{}
  134 }
  135 
  136 // Background returns a non-nil, empty Context. It is never canceled, has no
  137 // values, and has no deadline.  It is typically used by the main function,
  138 // initialization, and tests, and as the top-level Context for incoming
  139 // requests.
  140 func Background() Context {
  141     return background
  142 }
  143 
  144 // TODO returns a non-nil, empty Context.  Code should use context.TODO when
  145 // it's unclear which Context to use or it is not yet available (because the
  146 // surrounding function has not yet been extended to accept a Context
  147 // parameter).  TODO is recognized by static analysis tools that determine
  148 // whether Contexts are propagated correctly in a program.
  149 func TODO() Context {
  150     return todo
  151 }
  152 
  153 // A CancelFunc tells an operation to abandon its work.
  154 // A CancelFunc does not wait for the work to stop.
  155 // After the first call, subsequent calls to a CancelFunc do nothing.
  156 type CancelFunc func()