// GET Oper REST call
765276
func httpInspectNetwork(w http.ResponseWriter, r *http.Request, vars map[string]string) (interface{}, error) {
	var obj NetworkInspect
	log.Debugf("Received httpInspectNetwork: %+v", vars)

	key := vars["key"]

	collections.networkMutex.Lock()
	defer collections.networkMutex.Unlock()
	objConfig := collections.networks[key]
	if objConfig == nil {
		log.Errorf("network %s not found", key)
		return nil, errors.New("network not found")
	}
	obj.Config = *objConfig

	if err := GetOperNetwork(&obj); err != nil {
		log.Errorf("GetNetwork error for: %+v. Err: %v", obj, err)
		return nil, err
	}

	// Return the obj
	return &obj, nil
}
845622
func (r *RestClient) Get(path string, v interface{}, options ...RequestOption) error {
	return r.Do("GET", path, nil, v, options...)
}
909877
func (cli *OpsGenieHeartbeatClient) Get(req heartbeat.GetHeartbeatRequest) (*heartbeat.GetHeartbeatResponse, error) {
	var response heartbeat.HeartbeatResponseV2

	err := cli.sendGetRequest(&req, &response)
	if err != nil {
		return nil, err
	}

	return convertGetToV1Response(&response), nil
}
339155
func (mr *MockStorageV1InterfaceMockRecorder) RESTClient() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RESTClient", reflect.TypeOf((*MockStorageV1Interface)(nil).RESTClient))
}
68930
func (c *OauthClient) RESTClient() rest.Interface {
	if c == nil {
		return nil
	}
	return c.restClient
}
42599
func (mr *MockInterfaceMockRecorder) Get(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockInterface)(nil).Get), arg0)
}
467001
func (r *GroupPercentService) Get(appId string, id string) *GroupPercentGetCall {
	c := &GroupPercentGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.appId = appId
	c.id = id
	return c
}
706984
func (g *synchronizedOpenAPIGetter) Get() (Resources, error) {
	g.Do(func() {
		s, err := g.openAPIClient.OpenAPISchema()
		if err != nil {
			g.err = err
			return
		}

		g.openAPISchema, g.err = NewOpenAPIData(s)
	})

	// Return the save result
	return g.openAPISchema, g.err
}
332021
func getRequest(d logrus.Fields, key string) (req *http.Request, ok bool) {
	v, ok := d[key]
	if !ok {
		return nil, false
	}
	req, ok = v.(*http.Request)
	if !ok || req == nil {
		return nil, false
	}
	return req, true
}
461322
func (p *OPpool) Get() *ObservePersistJob {
	var o *ObservePersistJob
	select {
	case o = <-p.pool:
	default:
		o = &ObservePersistJob{}
	}
	return o
}
135677
func (c *Context) GetUniform(program, location *js.Object) *js.Object {
	return c.Call("getUniform", program, location)
}
440983
func httpGetVolume(w http.ResponseWriter, r *http.Request, vars map[string]string) (interface{}, error) {
	log.Debugf("Received httpGetVolume: %+v", vars)

	key := vars["key"]

	collections.volumeMutex.Lock()
	defer collections.volumeMutex.Unlock()
	obj := collections.volumes[key]
	if obj == nil {
		log.Infof("volume %s not found", key)
		return nil, errors.New("volume not found")
	}

	// Return the obj
	return obj, nil
}
1136573
func (r *Req) Get(url string, v ...interface{}) (*Resp, error) {
	return r.Do("GET", url, v...)
}
1078781
func callGetUserEmailService(userId uint) (rest.ResponseDTOUserInfo, apihelper.ApiErrors, int) {

	// call api
	req, err := http.NewRequest("GET", userBaseUrl+"/id/"+strconv.Itoa(int(userId)), nil)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	// read response
	body, _ := ioutil.ReadAll(resp.Body)

	userInfo := rest.ResponseDTOUserInfo{}
	apiErrors := apihelper.ApiErrors{}
	json.Unmarshal(body, &userInfo)
	json.Unmarshal(body, &apiErrors)

	return userInfo, apiErrors, resp.StatusCode
}
1083320
func (mr *MockAppsV1InterfaceMockRecorder) RESTClient() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RESTClient", reflect.TypeOf((*MockAppsV1Interface)(nil).RESTClient))
}
195575
func Get(urlStr string, params map[string]interface{}) (*HttpResponse, error) {
	resp, err := DefaultClient.Get(URLWithParams(urlStr, params).String())
	if err == nil {
		return &HttpResponse{*resp}, nil
	} else {
		CloseResponse(resp)
		return nil, err
	}
}
1300057
func (s *ServicesService) GetService(serviceIdentifier string) (*serviceResponse, error) {
	path := versioned(servicePath(serviceIdentifier))
	serviceResponse := &serviceResponse{}

	resp, err := s.client.get(path, serviceResponse)
	if err != nil {
		return nil, err
	}

	serviceResponse.HttpResponse = resp
	return serviceResponse, nil
}