// Get - returns the provider for the given providerID, if not found
// returns an error.
977980
func (list *Validators) Get(id ID) (p Validator, err error) {
	list.RLock()
	defer list.RUnlock()
	var ok bool
	if p, ok = list.providers[id]; !ok {
		return nil, fmt.Errorf("provider %v doesn't exist", id)
	}
	return p, nil
}
1087738
func (ctx *ResourceContext) Get(name string) interface{} {
	if ctx.Values != nil {
		if v, ok := ctx.Values[name]; ok {
			return v
		}
	}
	return nil
}
812568
func (api *NetworksAPI) Get(id string) (network *Network, err error) {
	res, err := api.client.restClient.Get(api.client.Endpoint+networkUrl+id, api.client.options.TokenOptions)
	if err != nil {
		return
	}
	defer res.Body.Close()
	res, err = getError(res)
	if err != nil {
		return
	}
	var result Network
	err = json.NewDecoder(res.Body).Decode(&result)
	return &result, err
}
428929
func (e *ErrorHolder) Get() (err error) {
	err, _ = e.value.Load().(error)
	return
}
112583
func (c Client) Get(id string, params *stripe.SourceObjectParams) (*stripe.Source, error) {
	path := stripe.FormatURLPath("/v1/sources/%s", id)
	source := &stripe.Source{}
	err := c.B.Call(http.MethodGet, path, c.Key, params, source)
	return source, err
}
976431
func (l *Client) GetProvider(id string) (Provider, error) {
	res := ApiResp{}
	data := Provider{}

	// make the request
	err := l.Get(parseLyticsURL(providerEndpoint, map[string]string{"id": id}), nil, nil, &res, &data)
	if err != nil {
		return data, err
	}

	return data, nil
}
327740
func (prv *ProcessorProvider) Get(params imageserver.Params) (image.Image, error) {
	nim, err := prv.Provider.Get(params)
	if err != nil {
		return nil, err
	}
	nim, err = prv.Processor.Process(nim, params)
	if err != nil {
		return nil, err
	}
	return nim, nil
}
1049000
func (r Resource) Get(request *restful.Request, response *restful.Response) {
	if resource, ok := r.Parent.(GetSupported); ok {
		context := r.Context.NewAPIContext()
		if resource.GetAuthRequired() {
			auth, err := context.Authentication(request)
			if err != nil || auth == nil {
				ErrorResponseHandler(request, response, err, NewErrorResponse(
					http.StatusUnauthorized,
					"Invalid accesstoken",
					"GET"))
				return
			}
		}

		params, err := Validate(request, resource.GetParams())
		if err != nil {
			ErrorResponseHandler(request, response, err, NewErrorResponse(
				http.StatusBadRequest,
				err,
				"validate"))
			return
		}

		if _, ok := r.Parent.(GetIDSupported); ok {
			//if _, ok := params["ids[]"]; ok { //FIXME
			if _, ok := request.Request.URL.Query()["ids[]"]; ok {
				r.GetByIDs(request, response)
				return
			}
		}

		resource.Get(context, request, response, params)
		request.SetAttribute("context", context)
	}
}
306292
func (client *Instance) GET() (statusCode int, body []byte, err error) {
	api, err := client.nextServer()
	if err != nil {
		return 0, nil, err
	}

	return api.HostClient.Get(nil, api.Addr)
}
334832
func (d *Dispatch) Get(name string, params ...interface{}) (result *VARIANT, err error) {
	id, err := d.GetId(name)
	if err != nil {
		return
	}
	result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params)
	return
}
601134
func Get(url string, v ...interface{}) (*Resp, error) {
	return std.Get(url, v...)
}
1124925
func (s *Session) Get(key string) interface{} {
	return s.provider.db.Get(s.sid, key)
}
261458
func (networkApi *NetworkApi) Get(id string) (*Network, error) {
	data, err := networkApi.entityService.Get(id, map[string]string{})
	if err != nil {
		return nil, err
	}
	return parseNetwork(data), nil
}
1125866
func (l *ShardedNoTS) Get(tenantID, key string) (interface{}, error) {
	cache, ok := l.cache[tenantID]
	if !ok {
		return nil, ErrNotFound
	}

	return cache.Get(key)
}
99534
func (p *Pubring) Get(id string) *PublicKey {
	p.Lock()
	defer p.Unlock()

	xpk := p.fetch(id)
	if xpk == nil {
		if p.secring != nil {
			if pk := p.secring.Get(id); pk != nil {
				return &pk.PublicKey
			}
		}
		return nil
	}

	return pubPBToKR(xpk)
}
10013
func (s *customResourceDefinitionLister) Get(name string) (*apiextensions.CustomResourceDefinition, error) {
	obj, exists, err := s.indexer.GetByKey(name)
	if err != nil {
		return nil, err
	}
	if !exists {
		return nil, errors.NewNotFound(apiextensions.Resource("customresourcedefinition"), name)
	}
	return obj.(*apiextensions.CustomResourceDefinition), nil
}
875228
func (idserv *V1IDService) Get(v1ID, registry string) (layer.DiffID, error) {
	if idserv.store == nil {
		return "", errors.New("no v1IDService storage")
	}
	if err := v1.ValidateID(v1ID); err != nil {
		return layer.DiffID(""), err
	}

	idBytes, err := idserv.store.Get(idserv.namespace(), registry+","+v1ID)
	if err != nil {
		return layer.DiffID(""), err
	}
	return layer.DiffID(idBytes), nil
}