Creates a reference to a group by its id. Virtual groups "Anyone" can't be returned
as they can't be referenced by an id.
486957
static GroupWsRef fromId(int id) {
    checkArgument(id > -1, "Group id must be positive: %s", id);
    return new GroupWsRef(id, null, null);
  }
208369
def group_id(self, resource_id):
        
        if self._name != 'group':
            self._request_uri = '{}/{}'.format(self._api_uri, resource_id)
441457
def build_id_references_tree(id_references)
      tree = {}

      id_references.each do |id_reference|
        array_of_refs = id_reference.split('/')

        t = tree
        array_of_refs.each do |ref|
          t[ref] ||= {}
          t = t[ref]
        end
      end

      tree
    end
705353
def insertTopLevelGroup(self, groupName, position=None):
        
        groupCti = GroupCti(groupName)
        return self._invisibleRootItem.insertChild(groupCti, position=position)
443
def group_id(self):
        
        if self.derived_from is not None:
            return self.derived_from.group_id()
        if self.file_uuid is None:
            return None
        return utils.GROUP_ID_PREFIX + self.file_uuid
1296556
def xgroup_setid(self, name, groupname, id):
        
        return self.execute_command('XGROUP SETID', name, groupname, id)
1079323
def create_group(cls, prefix: str, name: str) -> ErrorGroup:
        """"""
        group = cls.ErrorGroup(prefix, name)
        cls.groups.append(group)
        return group
824154
public void addTemplateRefGroup( String refGroupName, Map/*< String, String >*/ templateRefGroup )
    {
        if ( refGroupName == null || refGroupName.length() == 0 )
        {
            throw new IllegalArgumentException( "Template Reference Group name cannot be null or empty." );
        }

        if ( templateRefGroup == null || templateRefGroup.size() == 0 )
        {
            throw new IllegalArgumentException( "Template Reference Group cannot be null or empty." );
        }

        _templateRefGroups.put( refGroupName, templateRefGroup );
    }
729104
protected IEntityGroup getGroupFromCache(String key) throws CachingException {
        return (IEntityGroup)
                EntityCachingService.instance().get(ICompositeGroupService.GROUP_ENTITY_TYPE, key);
    }
942392
def batch_id(transaction_reference)
      grouped_transactions.each do |group, transactions|
        if transactions.select { |transaction| transaction.reference == transaction_reference }.any?
          return payment_information_identification(group)
        end
      end
    end
458406
private IEntityGroup igetDistinguishedGroup(String name) throws GroupsException {
        try {
            String key = getDistinguishedGroupKey(name);
            return compositeGroupService.findGroup(key);
        } catch (Exception ex) {
            throw new GroupsException(
                    "GroupService.getDistinguishedGroup(): " + "could not find key for: " + name,
                    ex);
        }
    }
765054
def individual(self, ind_id=None):
        
        for ind_obj in self.individuals:
            if ind_obj.ind_id == ind_id:
                return ind_obj
        return None
108426
def create
      group = Group.find_by(id: membership_params[:group_id])

      Group::Services::Join.new(group: group, person: current_user).call

      redirect_to group
    end
308984
def group(self, id, expand=None):
        
        group = Group(self._options, self._session)
        params = {}
        if expand is not None:
            params['expand'] = expand
        group.find(id, params=params)
        return group
182510
def getReference(self, id_):
        
        if id_ not in self._referenceIdMap:
            raise exceptions.ReferenceNotFoundException(id_)
        return self._referenceIdMap[id_]
979631
function createGroup(name, done) {
  return getModels(function(m) {
    return m.collections.group.create({ name }, done);
  });
}
1221205
def key_for_entity_group(cls, key):
    
    return model.Key(cls.KIND_NAME, cls.ID, parent=key.root())