// Get registers a new GET route for a path with matching handler in the router.
551398
func (r *Router) Get(pattern string, handlers ...Middleware) *Router {
	return r.Handle(http.MethodGet, pattern, handlers...)
}
40771
func (s *Server) Get(route string, handler interface{}) {
	s.addRoute(route, "GET", handler)
}
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)
}
1194054
func (g *Group) Get(url string, c interface{}, middlewares ...Handler) {
	g.Route([]string{"GET", "HEAD:Get"}, url, c, middlewares...)
}
596582
func (p *Imports) Get(prev, path string) ([]byte, error) {
	p.RLock()
	defer p.RUnlock()
	for _, imp := range p.m {
		if imp.Prev == prev && imp.Path == path {
			return imp.bytes, nil
		}
	}
	return nil, ErrImportNotFound
}
1324156
func (res *Resource) Get(storage store.Get) {
	res.HandleFunc(
		pat.Get(patID),
		func(w http.ResponseWriter, r *http.Request) {
			res.getHandler(w, r, storage)
		},
	)

	res.addRoute(get, patID)
}
104896
func Get(path, name string) ([]byte, error) {
	return get(path, name, func(name string, data []byte) (int, error) {
		return getxattr(path, name, data)
	})
}
854932
func GET(path string, dsl ...func()) *design.RouteDefinition {
	route := &design.RouteDefinition{Verb: "GET", Path: path}
	if len(dsl) != 0 {
		if !dslengine.Execute(dsl[0], route) {
			return nil
		}
	}
	return route
}
969509
func Get(path string, h interface{}, m ...interface{}) {
	Default.Get(path, h, m...)
}
128415
func (c *routes) Get(name string, options v1.GetOptions) (result *route.Route, err error) {
	result = &route.Route{}
	err = c.client.Get().
		Namespace(c.ns).
		Resource("routes").
		Name(name).
		VersionedParams(&options, scheme.ParameterCodec).
		Do().
		Into(result)
	return
}
183224
func (c *Client) Get(ctx context.Context, dest interface{}, route string, queryParams ...string) error {
	u, err := transport.MakeURL(c.endpoint, c.router, route, queryParams...)
	if err != nil {
		return errors.Wrap(err, "constructing URL")
	}

	req, err := http.NewRequest("GET", u.String(), nil)
	if err != nil {
		return errors.Wrapf(err, "constructing request %s", u)
	}
	req = req.WithContext(ctx)

	c.token.Set(req)
	req.Header.Set("Accept", "application/json")

	resp, err := c.executeRequest(req)
	if err != nil {
		return errors.Wrap(err, "executing HTTP request")
	}
	defer resp.Body.Close()

	if err := json.NewDecoder(resp.Body).Decode(dest); err != nil {
		return errors.Wrap(err, "decoding response from server")
	}
	return nil
}
672208
func (app *App) GET(route string, handler interface{}) *App {
	app.defaultRouter.Handle(MethodGET, route, handler)
	return app
}
1079253
func (f *Fibre) Get(p string, h HandlerFunc) {
	f.router.Add(GET, p, h)
}
244647
func (c *Client) Get(ctx context.Context, url string, id string, payload interface{}) error {
	url = fmt.Sprintf("%s/%s", url, id)
	req, err := c.NewRequest("GET", url, nil)
	if err != nil {
		return err
	}

	_, err = c.Do(ctx, req, payload)
	return err
}
842336
func (c *Client) Get(path string, out interface{}) error {
	return c.Send("GET", path, nil, out)
}
216656
func Get(url string) (resp *http.Response, err error) {
	c := New()
	return c.Get(url)
}
709888
func (c ConnAdapter) Get(path string) ([]byte, *zk.Stat, error) {
	return c.GetF(path)
}