// Same as Get but with custom source type.
545605
func (c *Conn) GetCustom(index string, _type string, id string, args map[string]interface{}, source *json.RawMessage) (BaseResponse, error) {
	return c.get(index, _type, id, args, source)
}
1043446
func (c Client) get(url string) (*http.Response, error) {
	return c.request("GET", url, nil)
}
823799
func (r *Client) GetDatasource(id uint) (Datasource, error) {
	var (
		raw  []byte
		ds   Datasource
		code int
		err  error
	)
	if raw, code, err = r.get(fmt.Sprintf("api/datasources/%d", id), nil); err != nil {
		return ds, err
	}
	if code != 200 {
		return ds, fmt.Errorf("HTTP error %d: returns %s", code, raw)
	}
	err = json.Unmarshal(raw, &ds)
	return ds, err
}
319991
func Get(typ, format string) ([]byte, error) {
	switch typ {
	case "date-only":
		return get("date_only.go")
	case "time-only":
		return get("time_only.go")
	case "datetime-only":
		return get("datetime_only.go")
	case "datetime":
		if format == "" || strings.ToUpper(format) == "RFC3339" {
			return get("datetime.go")
		} else if strings.ToUpper(format) == "RFC2616" {
			return get("datetime_rfc2616.go")
		}
	}
	return []byte{}, fmt.Errorf("unrecognized combination of type :%v format : %v", typ, format)
}
677306
func (a A) Get(vals ...interface{}) (val interface{}) {
	val = get(a(nil).arg(), vals)
	return
}
1069260
func (store *SourcesStore) Get(ctx context.Context, id int) (chronograf.Source, error) {
	if store.Source == nil || store.Source.ID != id {
		return chronograf.Source{}, fmt.Errorf("unable to find Source with id %d", id)
	}
	return *store.Source, nil
}
317103
func Get(ctx context.Context) string {
	httpVersion := make([]VersionInfo, 0, 4)
	httpVersion = append(httpVersion, VersionInfo{Name: "cri-o", Version: version.Version})
	httpVersion = append(httpVersion, VersionInfo{Name: "go", Version: runtime.Version()})
	httpVersion = append(httpVersion, VersionInfo{Name: "os", Version: runtime.GOOS})
	httpVersion = append(httpVersion, VersionInfo{Name: "arch", Version: runtime.GOARCH})

	return AppendVersions("", httpVersion...)
}
1150125
func (c *FakeExamples) Get(name string, options v1.GetOptions) (result *crv1.Example, err error) {
	obj, err := c.Fake.
		Invokes(testing.NewGetAction(examplesResource, c.ns, name), &crv1.Example{})

	if obj == nil {
		return nil, err
	}
	return obj.(*crv1.Example), err
}
778217
func (f FakeGetter) Get(name string) (*api.Service, error) {
	return f.Svc, f.Err
}
780456
func (c *Client) Get(fs afero.Fs, filename string) (resource.Resource, error) {
	filename = filepath.Clean(filename)
	return c.rs.ResourceCache.GetOrCreate(resources.ResourceKeyPartition(filename), filename, func() (resource.Resource, error) {
		return c.rs.NewForFs(fs,
			resources.ResourceSourceDescriptor{
				LazyPublish:    true,
				SourceFilename: filename})
	})

}
858647
func Get(format FormatType) (string, error) {
	// Load Superb words
	sp, err := Asset(SuperbFilePath)
	if err != nil {
		return "", err
	}

	var spa JSONData
	json.Unmarshal(sp, &spa)

	// Load Superheroes words
	sh, err := Asset(SuperheroesFilePath)
	if err != nil {
		return "", err
	}
	var sha JSONData
	json.Unmarshal(sh, &sha)

	// Seed the randomizer
	rand.Seed(time.Now().UTC().UnixNano())

	// Pick random items from each list
	fw := spa[rand.Intn(len(spa))]
	sw := sha[rand.Intn(len(sha))]

	codename := fmt.Sprintf("%s %s", fw, sw)

	switch format {
	case SpacedString:
		upperCaseFirst := func(s string) string {
			if len(s) == 0 {
				return ""
			}
			r, n := utf8.DecodeRuneInString(s)
			return string(unicode.ToUpper(r)) + s[n:]
		}

		cs, csn := strings.Split(codename, " "), []string{}
		for _, csi := range cs {
			csn = append(csn, upperCaseFirst(csi))
		}
		codename = strings.Join(csn, " ")
		break
	case Sanitized:
		codename = strings.ToLower(strings.TrimSpace(codename))
		codename = strings.Replace(codename, " ", "-", -1)
		reg, err := regexp.Compile("[^a-z0-9-]+")
		if err != nil {
			return "", err
		}
		codename = reg.ReplaceAllString(codename, "")
		break
	}

	return codename, nil
}
1045517
func (multi *SourcesStore) Get(ctx context.Context, id int) (chronograf.Source, error) {
	var err error
	for _, store := range multi.Stores {
		var s chronograf.Source
		s, err = store.Get(ctx, id)
		if err == nil {
			return s, nil
		}
	}
	return chronograf.Source{}, err
}
1029536
func (s *SourcesStore) Get(ctx context.Context, id int) (chronograf.Source, error) {
	var src chronograf.Source
	if err := s.client.db.View(func(tx *bolt.Tx) error {
		var err error
		src, err = s.get(ctx, id, tx)
		if err != nil {
			return err
		}
		return nil
	}); err != nil {
		return chronograf.Source{}, err
	}

	return src, nil
}
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
}
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)
}
177483
func (r *RepositoryContent) GetType() string {
	if r == nil || r.Type == nil {
		return ""
	}
	return *r.Type
}
855322
func (s *SourcesStore) Get(ctx context.Context, id int) (chronograf.Source, error) {
	err := validOrganization(ctx)
	if err != nil {
		return chronograf.Source{}, err
	}

	d, err := s.store.Get(ctx, id)
	if err != nil {
		return chronograf.Source{}, err
	}

	if d.Organization != s.organization {
		return chronograf.Source{}, chronograf.ErrSourceNotFound
	}

	return d, nil
}