// RepositoryGroup returns a representation of the given repository group ID.
3855
func (client NexusClient) RepositoryGroup(groupID GroupID) (RepositoryGroup, int, error) {
	repoGroup, rc, err := client.repositoryGroup(groupID)
	if err != nil {
		return RepositoryGroup{}, rc, err
	}
	if rc != 200 {
		return RepositoryGroup{}, rc, nil
	}
	return canonicalize(repoGroup), rc, nil
}
1362416
func (s *SnapshotDeleteRepositoryService) Repository(repositories ...string) *SnapshotDeleteRepositoryService {
	s.repository = append(s.repository, repositories...)
	return s
}
1307975
func (s *DB) Group(query string) *DB {
	return s.clone().search.Group(query).db
}
204751
func (s *GlobalTable) SetReplicationGroup(v []*Replica) *GlobalTable {
	s.ReplicationGroup = v
	return s
}
874376
func (cr *Context) PushGroup() {
	C.cairo_push_group(cr.Ptr)
	if err := cr.status(); err != nil {
		panic(err)
	}
}
1286316
func (m *MockVolumeDriver) SnapshotGroup(arg0 string, arg1 map[string]string, arg2 []string) (*api.GroupSnapCreateResponse, error) {
	ret := m.ctrl.Call(m, "SnapshotGroup", arg0, arg1, arg2)
	ret0, _ := ret[0].(*api.GroupSnapCreateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
1324750
func (c *CombinedStatus) GetRepositoryURL() string {
	if c == nil || c.RepositoryURL == nil {
		return ""
	}
	return *c.RepositoryURL
}
505354
func (e *Echo) Group(prefix string, m ...interface{}) *Group {
	g, y := e.groups[prefix]
	if !y {
		g = &Group{prefix: prefix, echo: e}
		e.groups[prefix] = g
	}
	if len(m) > 0 {
		g.Use(m...)
	}
	return g
}
1314978
func (s *Snapshot) SetReplicationGroupId(v string) *Snapshot {
	s.ReplicationGroupId = &v
	return s
}
385690
func RegisterGroup(groupMeta apimachinery.GroupMeta) error {
	groupName := groupMeta.GroupVersion.Group
	if _, found := groupMetaMap[groupName]; found {
		return fmt.Errorf("group %v is already registered", groupMetaMap)
	}
	groupMetaMap[groupName] = &groupMeta
	return nil
}
1179134
func (b *Backend) InitGroup(groupUUID string, taskUUIDs []string) error {
	tasks := make([]string, 0, len(taskUUIDs))
	// copy every task
	for _, v := range taskUUIDs {
		tasks = append(tasks, v)
	}

	b.groups[groupUUID] = tasks
	return nil
}
266840
func (c *WS2Client) LookupReleaseGroup(id MBID, inc ...string) (*ReleaseGroup, error) {
	a := &ReleaseGroup{ID: id}
	err := c.Lookup(a, inc...)

	return a, err
}
54622
func (c *Crowd) GetGroup(name string) (*Group, error) {
	attrURL := fmt.Sprintf("rest/usermanagement/1/group?groupname=%s&expand=attributes", name)
	url := c.url + attrURL

	c.Client.Jar = c.cookies

	req, err := http.NewRequest("GET", url, nil)
	req.SetBasicAuth(c.user, c.passwd)
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "application/json")
	if err != nil {
		panic(err)
	}

	resp, err := c.Client.Do(req)
	if err != nil {
		panic(err)
	}

	defer resp.Body.Close()
	groupInformation, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}

	groupAttributes := new(Group)
	err = json.Unmarshal(groupInformation, groupAttributes)
	if err != nil {
		panic(err)
	}

	return groupAttributes, err
}
211477
func (d *DiscoveryClient) ServerGroups() (apiGroupList *metav1.APIGroupList, err error) {
	// Get the groupVersions exposed at /api
	v := &metav1.APIVersions{}
	err = d.restClient.Get().AbsPath(d.LegacyPrefix).Do().Into(v)
	apiGroup := metav1.APIGroup{}
	if err == nil && len(v.Versions) != 0 {
		apiGroup = apiVersionsToAPIGroup(v)
	}
	if err != nil && !errors.IsNotFound(err) && !errors.IsForbidden(err) {
		return nil, err
	}

	// Get the groupVersions exposed at /apis
	apiGroupList = &metav1.APIGroupList{}
	err = d.restClient.Get().AbsPath("/apis").Do().Into(apiGroupList)
	if err != nil && !errors.IsNotFound(err) && !errors.IsForbidden(err) {
		return nil, err
	}
	// to be compatible with a v1.0 server, if it's a 403 or 404, ignore and return whatever we got from /api
	if err != nil && (errors.IsNotFound(err) || errors.IsForbidden(err)) {
		apiGroupList = &metav1.APIGroupList{}
	}

	// prepend the group retrieved from /api to the list if not empty
	if len(v.Versions) != 0 {
		apiGroupList.Groups = append([]metav1.APIGroup{apiGroup}, apiGroupList.Groups...)
	}
	return apiGroupList, nil
}
201874
func (g *SearchService) Repositories(uri *Hyperlink, uriParams M) (repositorySearchResults *RepositorySearchResults, result *Result) {
	url, err := ExpandWithDefault(uri, &RepositorySearchURL, uriParams)
	if err != nil {
		return nil, &Result{Err: err}
	}

	result = g.client.get(url, &repositorySearchResults)
	return
}
693874
func Repository(repo eh.ReadRepo) *Repo {
	if repo == nil {
		return nil
	}

	if r, ok := repo.(*Repo); ok {
		return r
	}

	return Repository(repo.Parent())
}
1149740
func (b *Backend) InitGroup(groupUUID string, taskUUIDs []string) error {
	groupMeta := &tasks.GroupMeta{
		GroupUUID: groupUUID,
		TaskUUIDs: taskUUIDs,
		CreatedAt: time.Now().UTC(),
	}

	encoded, err := json.Marshal(&groupMeta)
	if err != nil {
		return err
	}

	return b.getClient().Set(&gomemcache.Item{
		Key:        groupUUID,
		Value:      encoded,
		Expiration: b.getExpirationTimestamp(),
	})
}