// OpenGroup opens a private group
773402
func (api *Client) OpenGroup(group string) (bool, bool, error) {
	return api.OpenGroupContext(context.Background(), group)
}
1307975
func (s *DB) Group(query string) *DB {
	return s.clone().search.Group(query).db
}
374059
func (s *LDAPGroupSyncer) updateOpenShiftGroup(openshiftGroup *userv1.Group) error {
	if len(openshiftGroup.UID) > 0 {
		_, err := s.GroupClient.Update(openshiftGroup)
		return err
	}

	_, err := s.GroupClient.Create(openshiftGroup)
	return err
}
631433
func (c *conn) JoinGroup(group uint32) error {
	return os.NewSyscallError("setsockopt", c.s.SetSockoptInt(
		unix.SOL_NETLINK,
		unix.NETLINK_ADD_MEMBERSHIP,
		int(group),
	))
}
1153698
func (b *Broker) LeaveGroup(request *LeaveGroupRequest) (*LeaveGroupResponse, error) {
	response := new(LeaveGroupResponse)

	err := b.sendAndReceive(request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}
298892
func (a *GenerateTestReportArgs) SetGroup(group string) *GenerateTestReportArgs {
	a.Group = &group
	return a
}
963251
func (client *Client) AuthorizeSecurityGroup(args *AuthorizeSecurityGroupArgs) error {
	response := AuthorizeSecurityGroupResponse{}
	err := client.Invoke("AuthorizeSecurityGroup", args, &response)
	return err
}
1270143
func (a *authenticator) AddPermissionGroup(group ...*access.PermissionGroup) {
	for _, newPermissionGroup := range group {
		if _, ok := a.groupDb[newPermissionGroup.Name]; ok {
			a.log.Warnf("permission group %s already exists, skipped")
			continue
		}
		a.log.Debugf("added HTTP permission group %s", newPermissionGroup.Name)
		a.groupDb[newPermissionGroup.Name] = newPermissionGroup.Permissions
	}
}
890915
func (c *Client) QueryGroup(id int32) (*GroupNode, error) {
	if err := c.oscConn.Send(osc.Message{
		Address: groupQueryTreeAddress,
		Arguments: osc.Arguments{
			osc.Int(id),
			osc.Int(1),
		},
	}); err != nil {
		return nil, err
	}
	// wait for response
	var resp osc.Message
	select {
	case resp = <-c.gqueryTreeChan:
	case <-time.After(2 * time.Second):
		return nil, errors.New("timeout waiting for response")
	}
	if numArgs := len(resp.Arguments); numArgs < 3 {
		return nil, fmt.Errorf("expected 3 arguments for message, got %d", numArgs)
	}
	// Throw away the flag that tells us we want to include synth controls in the reply.
	// We already know we requested that!
	resp.Arguments = resp.Arguments[1:]
	return c.parseGroup(resp)
}
1234525
func (s *DimensionGroup) SetGroup(v string) *DimensionGroup {
	s.Group = &v
	return s
}
1350720
func (n *nessusImpl) CreateGroup(name string) (Group, error) {
	if n.verbose {
		log.Println("Creating a group...")
	}

	req := createGroupRequest{
		Name: name,
	}
	resp, err := n.doRequest("POST", "/groups", req, []int{http.StatusOK})
	if err != nil {
		return Group{}, err
	}
	defer resp.Body.Close()
	var reply Group
	if err = json.NewDecoder(resp.Body).Decode(&reply); err != nil {
		return Group{}, err
	}
	return reply, nil
}
357317
func (c *Config) OpenLevel(parent *Config, level ConfigLevel) (*Config, error) {
	config := new(Config)

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	ret := C.git_config_open_level(&config.ptr, parent.ptr, C.git_config_level_t(level))
	runtime.KeepAlive(c)
	runtime.KeepAlive(parent)
	if ret < 0 {
		return nil, MakeGitError(ret)
	}

	return config, nil
}
1365632
func (g *Group) Group(prefix string, filters ...Filter) *Group {
	return g.server.Group(g.prefix+prefix, g.mergeFilters(filters)...)
}
761880
func (g *routeGroup) Group(prefix string) IRouteGroup {
	rg := &routeGroup{
		prefix:     g.prefix + prefix,
		lars:       g.lars,
		middleware: make(HandlersChain, len(g.middleware)),
	}
	copy(rg.middleware, g.middleware)
	return rg
}
445903
func NewGroup(name string, members []string) (*Group, error) {
	g, err := newGroup(name, members)
	if err != nil {
		return nil, err
	}
	return g, sendUpdate(g)
}
1307892
func (b *Broker) JoinGroup(request *JoinGroupRequest) (*JoinGroupResponse, error) {
	response := new(JoinGroupResponse)

	err := b.sendAndReceive(request, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}
893761
func (l *Log) Group() Group {
	return &group{
		lines: make([]*line, 0),
		log:   l,
		quiet: l.quiet,
	}
}