Gets the group.

@param groupName
the group name
@return the group
512608
public GroupEntity getGroup(String groupName) {
		return restClient.get("groups/" + groupName, GroupEntity.class, new HashMap<String, String>());
	}
690600
public Observable<Page<ClusterInner>> listByResourceGroupAsync(final String resourceGroupName) {
        return listByResourceGroupWithServiceResponseAsync(resourceGroupName)
            .map(new Func1<ServiceResponse<Page<ClusterInner>>, Page<ClusterInner>>() {
                @Override
                public Page<ClusterInner> call(ServiceResponse<Page<ClusterInner>> response) {
                    return response.body();
                }
            });
    }
576050
public function getGroupByName($name)
    {
        return $this->getGroups()->then(function (array $groups) use ($name) {
            foreach ($groups as $group) {
                if ($group->getName() === $name) {
                    return $group;
                }
            }

            throw new ApiException('Group ' . $name . ' not found.');
        });
    }
770917
public function addGroup($groupName)
    {
        if (true === is_string($groupName) && false === in_array($groupName, $this->groups)) {
            $this->groups[] = $groupName;
        }
        return $this;
    }
303719
def get_group(self, name, default=NoGroupError):
        '''
        
        '''

        if name in self.groups:
            return self.groups[name]

        if default is NoGroupError:
            raise NoGroupError('No such group: {0}'.format(name))

        return default
57362
def get_group_by_name(self, group_name: str) -> typing.Optional['Group']:
        
        VALID_STR.validate(group_name, 'get_group_by_name')
        for group in self.groups:

            if group.group_name == group_name:
                return group
        return None
364745
public Response deleteGroup(String groupName) {
		return restClient.delete("groups/" + groupName, new HashMap<String, String>());
	}
393692
public static String[] getXhash(String groupName, String unitName) {
        try {
            return UnitRouter.SINGLETON.newestDefinition(Unit.fullName(groupName, unitName)).getInput().getXhashNames();
        } catch (UnitUndefinedException e) {
            throw new RuntimeException("Please call UnitJudge.defined() first.", e);
        }
    }
697543
public CmsGroup readGroup(CmsRequestContext context, String groupname) throws CmsException {

        CmsDbContext dbc = m_dbContextFactory.getDbContext(context);
        CmsGroup result = null;
        try {
            result = m_driverManager.readGroup(dbc, CmsOrganizationalUnit.removeLeadingSeparator(groupname));
        } catch (Exception e) {
            dbc.report(null, Messages.get().container(Messages.ERR_READ_GROUP_FOR_NAME_1, groupname), e);
        } finally {
            dbc.clear();
        }
        return result;
    }
302730
def get_group(group_or_groupname):
    
    if not group_or_groupname:

        return None
    if hasattr(group_or_groupname, "_getGroup"):
        return group_or_groupname
    gtool = get_tool("portal_groups")
    return gtool.getGroupById(group_or_groupname)
1082640
@Override
    public IEntityGroup find(String key) throws GroupsException {

        try {

            // Search the Grouper server for groups with the specified local
            // key
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Searching Grouper for a direct match for key: " + key);
            }
            WsGroup wsGroup = findGroupFromKey(key);
            if (wsGroup == null) {
                return null;
            }
            IEntityGroup group = createUportalGroupFromGrouperGroup(wsGroup);

            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug(
                        "Retrieved group from the Grouper server matching key "
                                + key
                                + ": "
                                + group.toString());
            }

            // return the group
            return group;

        } catch (Exception e) {
            LOGGER.warn(
                    "Exception while attempting to retrieve "
                            + "group with key "
                            + key
                            + " from Grouper web services: "
                            + e.getMessage());
            return null;
        }
    }
1094981
public static boolean available(String groupName) {
        return LocalUnitsManager.getGroupByName(groupName) != null ||
                (GroupDiscovery.singleton != null && GroupDiscovery.singleton.firstInstance(groupName) != null);
    }
60859
public static IEntityGroup getDistinguishedGroup(String name) throws GroupsException {
        LOGGER.trace("Invoking getDistinguishedGroup for name='{}'", name);
        return instance().igetDistinguishedGroup(name);
    }
519475
public static systemgroup_systemcmdpolicy_binding[] get(nitro_service service, String groupname) throws Exception{
		systemgroup_systemcmdpolicy_binding obj = new systemgroup_systemcmdpolicy_binding();
		obj.set_groupname(groupname);
		systemgroup_systemcmdpolicy_binding response[] = (systemgroup_systemcmdpolicy_binding[]) obj.get_resources(service);
		return response;
	}
1372178
public boolean belongsTo(String groupname) {
        if (groupname == null) {
            return false;
        }
        for (PMSecurityUserGroup g : getGroups()) {
            if (groupname.equalsIgnoreCase(g.getName())) {
                return true;
            }
        }
        return false;
    }
710907
def get_group(self, group_name):
        
        response = self.client.get_group(GroupName=group_name,
                                         UserPoolId=self.user_pool_id)
        return self.get_group_obj(response.get('Group'))
278181
public Observable<ResourceGroupInner> getAsync(String resourceGroupName) {
        return getWithServiceResponseAsync(resourceGroupName).map(new Func1<ServiceResponse<ResourceGroupInner>, ResourceGroupInner>() {
            @Override
            public ResourceGroupInner call(ServiceResponse<ResourceGroupInner> response) {
                return response.body();
            }
        });
    }