// GET registers a handler for GET requests to a particular path
517786
func (s *Server) GET(path string, handle http.HandlerFunc) {
	s.router.GET(path, s.wrapHandler(handle))
}
842336
func (c *Client) Get(path string, out interface{}) error {
	return c.Send("GET", path, nil, out)
}
351856
func (s *Service) Get(ctx context.Context, v interface{}, path string, query interface{}, lr *ListRange) error {
	return s.Do(ctx, v, "GET", path, nil, query, lr)
}
1306481
func (api *APIBuilder) Get(relativePath string, handlers ...context.Handler) *Route {
	return api.Handle(http.MethodGet, relativePath, handlers...)
}
896936
func (r *Response) Get(key string) string {
	return r.handlerHeader.Get(key)
}
1184302
func (c *Connection) Get(path string, node client.Node) error {
	c.RLock()
	defer c.RUnlock()
	if err := c.isClosed(); err != nil {
		return err
	}
	return c.get(path, node)
}
515135
func (c *Client) Get(url string) (resp *http.Response, err error) {
	return c.pester(params{method: "Get", url: url, verb: "GET"})
}
818654
func (p *Process) Get(path string) ([]byte, error) {
	client := &http.Client{
		Timeout: 30 * time.Second,
		Transport: &http.Transport{
			Dial:              dialer.Dial,
			Proxy:             http.ProxyFromEnvironment,
			DisableKeepAlives: true,
		},
	}

	url := fmt.Sprintf("http://%s%s", p.addr, path)
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}

	req.Header.Add("X-API-Key", APIKey)

	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}

	return p.readResponse(resp)
}
1239000
func (p *PathStruct) Get(ctx context.Context, s logical.Storage) (map[string]interface{}, error) {
	entry, err := s.Get(ctx, fmt.Sprintf("struct/%s", p.Name))
	if err != nil {
		return nil, err
	}
	if entry == nil {
		return nil, nil
	}

	var result map[string]interface{}
	if err := jsonutil.DecodeJSON(entry.Value, &result); err != nil {
		return nil, err
	}

	return result, nil
}
1013129
func (c *Client) Get(ctx context.Context, url string) (*http.Response, error) {
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}

	return c.Do(ctx, req)
}
798746
func (r *Route) Get(fn http.HandlerFunc) *Route {
	return r.Method(http.MethodGet, fn)
}
739785
func (r *Router) GET(pattern string, handler func(Context)) Route {
	return r.Handle("GET", pattern, wrap(handler))
}
825343
func (r *router) GET(path string, handler Route) {
	r.group.GET(path, handler)
}
611136
func (r *SubRouter) GET(route string, handler interface{}) *SubRouter {
	route = r.prefixedRoute(route)
	if r.parent != nil {
		r.parent.handleReg(MethodGET, route, handler, r.prefixes)
	}
	return r
}
124040
func (res *Resource) Get(storage store.Get) {
	res.HandleFuncC(
		pat.Get(patID),
		func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
			res.getHandler(ctx, w, r, storage)
		},
	)

	res.addRoute(get, patID)
}
881369
func (t *Tango) Get(url string, c interface{}, middlewares ...Handler) {
	t.Route([]string{"GET", "HEAD:Get"}, url, c, middlewares...)
}
656561
func (h *syncHandler) Get(key string, args ...interface{}) (interface{}, error) {
	defer h.mutex.RUnlock()
	h.mutex.RLock()
	return h.handler.Get(key, args...)
}