// Get gets a context value from req.
// Returns nil if key not found in the request context.
768479
func Get(req *http.Request, key interface{}) interface{} {
	crc := getContextReadCloser(req)
	return crc.Context()[key]
}
580767
func (r *FastHttpRequest) Get(key int) (value interface{}, err error) {
	switch key {
	case revel.HTTP_SERVER_HEADER:
		value = r.GetHeader()
	case revel.HTTP_MULTIPART_FORM:
		value, err = r.GetMultipartForm()
	case revel.HTTP_QUERY:
		value = r.GetQuery()
	case revel.HTTP_FORM:
		value, err = r.GetForm()
	case revel.HTTP_REQUEST_URI:
		value = string(r.Original.RequestURI())
	case revel.HTTP_REMOTE_ADDR:
		value = r.Original.RemoteAddr().String()
	case revel.HTTP_METHOD:
		value = string(r.Original.Method())
	case revel.HTTP_PATH:
		value = string(r.Original.Path())
	case revel.HTTP_HOST:
		value = string(r.Original.Request.Host())
	case revel.HTTP_URL:
		if r.url == nil {
			r.url, _ = url.Parse(string(r.Original.Request.URI().FullURI()))
		}
		value = r.url
	case revel.HTTP_BODY:
		value = bytes.NewBuffer(r.Original.Request.Body())
	default:
		err = revel.ENGINE_UNKNOWN_GET
	}

	return
}
693002
func (cm *ContextMux) GET(path string, handler http.HandlerFunc) {
	cm.ContextGroup.Handle("GET", path, handler)
}
573111
func (c *Client) Get(url string) (*Response, error) {
	req, err := c.NewRequest("GET", url, nil)

	if err != nil {
		return nil, err
	}

	req = c.Config.AddRequestHeader(req)
	response, err := c.Do(req)

	if err != nil {
		return nil, err
	}

	return response, nil
}
634409
func (c *InMemoryCache) Get(_ context.Context, key Key) (Thunk, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()

	item, found := c.items[key.String()]
	if !found {
		return nil, false
	}

	return item, true
}
672794
func (f *Request) Get(url string) *Request {
	f.Url(url).Method("GET")
	return f
}
925533
func (c *Context) Get(key string) (value interface{}, exists bool) {
	value, exists = c.Keys[key]
	return
}
243366
func (scope *ArgScope) Get(key string) (interface{}, error) {
	return scope.data[key], nil
}
772435
func (req *Request) Context() (c context.Context) {
	c, _ = req.GetValue(HTTP_REQUEST_CONTEXT).(context.Context)
	return
}
508694
func (rc *RequestConfig) GET(path string) *RequestConfig {
	rc.Path = path
	rc.Method = "GET"

	return rc
}
1139476
func (c *Context) Get(key interface{}) interface{} {
	store := c.getStore()
	if store == nil {
		return store
	}
	if value, ok := store[key]; ok {
		return value
	}
	if c.Parent != nil {
		return c.Parent.Get(key)
	}
	return nil
}
1136573
func (r *Req) Get(url string, v ...interface{}) (*Resp, error) {
	return r.Do("GET", url, v...)
}
697069
func (m *MockContext) Get(arg0 string, arg1 interface{}) error {
	ret := m.ctrl.Call(m, "Get", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}
1257708
func Get(key string, args ...interface{}) data.Value {
	return defaultCacher().Get(key, args...)
}
616508
func (c *Ctx) Get(key interface{}) (value interface{}, exists bool) {
	value = c.request.Context().Value(key)
	exists = value != nil
	return
}
1104355
func (context Context) Get(name string) (interface{}, bool) {
	if value, ok := context.Options[name]; ok {
		return value, true
	}

	return nil, false
}
1203522
func (c *httpClient) get(ctx context.Context, url string) (*http.Response, error) {
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}

	// Take the trace ID to group all outbound requests together.
	req = req.WithContext(ctx)
	for k, vs := range c.header {
		req.Header[k] = vs
	}
	resp, err := c.client.Do(req)
	if err != nil {
		return nil, &RemoteError{req.URL.Host, err}
	}
	return resp, err
}