Returns an instance of the <code>IEntityGroup</code> from the data store.

@return org.apereo.portal.groups.IEntityGroup
@param key java.lang.String
542558
@Override
    public IEntityGroup find(String key) throws GroupsException {
        if (log.isDebugEnabled()) {
            log.debug(DEBUG_CLASS_NAME + ".find(): group key: " + key);
        }

        String path = getFilePathFromKey(key);
        File f = new File(path);

        GroupHolder groupHolder = cacheGet(key);

        if (groupHolder == null || (groupHolder.getLastModified() != f.lastModified())) {
            if (log.isDebugEnabled()) {
                log.debug(
                        DEBUG_CLASS_NAME
                                + ".find(): retrieving group from file system for "
                                + path);
            }

            if (!f.exists()) {
                if (log.isDebugEnabled()) {
                    log.debug(DEBUG_CLASS_NAME + ".find(): file does not exist: " + path);
                }
                return null;
            }

            IEntityGroup group = newInstance(f);
            groupHolder = new GroupHolder(group, f.lastModified());
            cachePut(key, groupHolder);
        }
        return groupHolder.getGroup();
    }
96053
public final int get(String key)
  {

    for (int i = 0; i < m_firstFree; i++)
    {
      if (m_map[i].equals(key))
        return m_values[i];
    }

    return INVALID_KEY;
  }
910716
@Override
    public String[] findMemberGroupKeys(IEntityGroup group) throws GroupsException {
        Connection conn = null;
        Collection groupKeys = new ArrayList();
        String groupKey = null;

        try {
            conn = RDBMServices.getConnection();
            String sql = getFindMemberGroupKeysSql();
            PreparedStatement ps = conn.prepareStatement(sql);
            try {
                ps.setString(1, group.getLocalKey());
                if (LOG.isDebugEnabled())
                    LOG.debug(
                            "RDBMEntityGroupStore.findMemberGroupKeys(): "
                                    + ps
                                    + " ("
                                    + group.getLocalKey()
                                    + ")");
                ResultSet rs = ps.executeQuery();
                try {
                    while (rs.next()) {
                        groupKey = rs.getString(1) + groupNodeSeparator + rs.getString(2);
                        groupKeys.add(groupKey);
                    }
                } finally {
                    rs.close();
                }
            } finally {
                ps.close();
            }
        } catch (Exception sqle) {
            LOG.error("RDBMEntityGroupStore.findMemberGroupKeys(): " + sqle);
            throw new GroupsException("Problem retrieving member group keys: " + sqle);
        } finally {
            RDBMServices.releaseConnection(conn);
        }

        return (String[]) groupKeys.toArray(new String[groupKeys.size()]);
    }
445453
public Set<Object> hkeys(Object key) {
		Jedis jedis = getJedis();
		try {
			Set<byte[]> fieldSet = jedis.hkeys(keyToBytes(key));
			Set<Object> result = new HashSet<Object>();
			fieldSetFromBytesSet(fieldSet, result);
			return result;
		}
		finally {close(jedis);}
	}
107676
public RiakRegister getRegister(BinaryValue key)
    {
        if (entries.containsKey(key))
        {
            for (RiakDatatype dt : entries.get(key))
            {
                if (dt.isRegister())
                {
                    return dt.getAsRegister();
                }
            }
        }
        return null;
    }
523864
@Override
    public Iterator findMemberGroups(IEntityGroup eg) throws GroupsException {
        Map groups = new HashMap();
        IEntityGroup group = null;
        for (Iterator itr = findLocalMemberGroups(eg); itr.hasNext(); ) {
            group = (IEntityGroup) itr.next();
            groups.put(group.getKey(), group);
        }

        String[] memberGroupKeys = getGroupStore().findMemberGroupKeys(eg);
        for (int i = 0; i < memberGroupKeys.length; i++) {
            if (!groups.containsKey(memberGroupKeys[i])) {
                group = GroupService.findGroup(memberGroupKeys[i]);
                if (group != null) {
                    groups.put(group.getKey(), group);
                }
            }
        }
        return groups.values().iterator();
    }
1203485
public CmsXmlGroupContainer getCacheGroupContainer(String key, boolean online) {

        try {
            m_lock.readLock().lock();
            CmsXmlGroupContainer retValue;
            if (online) {
                retValue = m_groupContainersOnline.get(key);
                if (LOG.isDebugEnabled()) {
                    if (retValue == null) {
                        LOG.debug(
                            Messages.get().getBundle().key(
                                Messages.LOG_DEBUG_CACHE_MISSED_ONLINE_1,
                                new Object[] {key}));

                    } else {
                        LOG.debug(
                            Messages.get().getBundle().key(
                                Messages.LOG_DEBUG_CACHE_MATCHED_ONLINE_2,
                                new Object[] {key, retValue}));
                    }
                }
            } else {
                retValue = m_groupContainersOffline.get(key);
                if (LOG.isDebugEnabled()) {
                    if (retValue == null) {
                        LOG.debug(
                            Messages.get().getBundle().key(
                                Messages.LOG_DEBUG_CACHE_MISSED_OFFLINE_1,
                                new Object[] {key}));

                    } else {
                        LOG.debug(
                            Messages.get().getBundle().key(
                                Messages.LOG_DEBUG_CACHE_MATCHED_OFFLINE_2,
                                new Object[] {key, retValue}));
                    }
                }
            }
            return retValue;
        } finally {
            m_lock.readLock().unlock();
        }
    }
402141
protected static final <T, K extends Serializable>
    K _key2Id(
                    final Key<T> key
                    )
    {
        K  id = null;
        try {
            @SuppressWarnings( "unchecked" )
            K  obj = (K)key.getId();
            id = obj;
        } catch (Exception ex) {
            throw new RepositoryException( ex );
        }

        return id;
    }
318668
public static ILockableEntityGroup findLockableGroup(String key, String lockOwner)
            throws GroupsException {
        LOGGER.trace("Invoking findLockableGroup for key='{}', lockOwner='{}'", key, lockOwner);
        return instance().ifindLockableGroup(key, lockOwner);
    }
72693
public Result<V,E> get(K key) {
		CacheEntry entry = map.get(key);
		if(entry == null) {
			return null;
		} else {
			return entry.getResult();
		}
	}
1221205
def key_for_entity_group(cls, key):
    
    return model.Key(cls.KIND_NAME, cls.ID, parent=key.root())
338281
public Object get(Object key) {
      NonSyncHashtableEntry tab[] = table;
      int hash = key.hashCode();
      int index = (hash & 0x7FFFFFFF) % tab.length;
      for (NonSyncHashtableEntry e = tab[index]; e != null; e = e.next) {
         if ((e.hash == hash) && e.key.equals(key)) {
            return e.value;
         }
      }
      return null;
   }
650713
public JSONObject getJSONObject( String key ) {
      verifyIsNull();
      Object o = get( key );
      if( JSONNull.getInstance()
            .equals( o ) ){
         return new JSONObject( true );
      }else if( o instanceof JSONObject ){
         return (JSONObject) o;
      }
      throw new JSONException( "JSONObject[" + JSONUtils.quote( key ) + "] is not a JSONObject." );
   }
1176364
public OvhGroup identity_group_group_GET(String group) throws IOException {
		String qPath = "/me/identity/group/{group}";
		StringBuilder sb = path(qPath, group);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhGroup.class);
	}
1009149
static public Object getByIdentity(Object[] array, Object key)
    {
        if (array != null)
        {
            int length = array.length;
            for (int i = 0; i < length; i += 2)
            {
                if (array[i] == key)
                {
                    return array[i + 1];
                }
            }
        }

        return null;
    }
571148
public static IGroupMember getGroupMember(String key, Class<?> type) throws GroupsException {
        /*
         * WARNING:  The 'type' parameter is not the leafType;  you're obligated
         * to say whether you want a group or a non-group (i.e. some type of
         * entity).  In fact, the underlying implementation blindly instantiates
         * whatever you tell it to.
         */

        LOGGER.trace("Invoking getEntity for key='{}', type='{}'", key, type);
        return instance().igetGroupMember(key, type);
    }
1258636
protected IEntity primGetEntity(String key, Class type) throws GroupsException {
        return entityFactory.newInstance(key, type);
    }