Load the list of related entities.
@param propertyName the name of the properties to be used as Key
@return the list of retrieved entities
332612
public Map<Key, Object> loadRelatedEntities(String... propertyName) {
		EntityManager entityManager = EntityManagerFactory.getEntityManager();
		Class<J> persistentClass = (Class<J>) query.getClassMetadata().getPersistentClass();
		Set<Key> keys = Sets.newHashSet();
		for (String p : propertyName) {
			keys.addAll(Collections2.transform(data, new EntityToPropertyFunction(persistentClass, p)));
		}
		return entityManager.get(keys);
	}
834685
private static void loadClientProperties(String propertiesPath, String clazzName,
            Map<?, Map<String, String>> clientProperties, Map<String, Map<String, String>> entityConfigurations)
    {

        InputStream inputStream = PropertyReader.class.getClassLoader().getResourceAsStream(propertiesPath);
        clientProperties = JsonUtil.readJson(inputStream, Map.class);

        if (clientProperties != null)
        {
            if (clientProperties.get("all") != null)
            {
                entityConfigurations.put(clazzName, clientProperties.get("all"));
            }
            else
            {

                Iterator iter = clientProperties.keySet().iterator();

                while (iter.hasNext())
                {
                    Object key = iter.next();
                    if (((String) key).indexOf(',') > 0)
                    {
                        StringTokenizer tokenizer = new StringTokenizer((String) key, ",");
                        while (tokenizer.hasMoreElements())
                        {
                            String token = tokenizer.nextToken();
                            entityConfigurations.put(token, clientProperties.get(key));
                        }
                    }
                    else
                    {
                        entityConfigurations.put((String) key, clientProperties.get(key));
                    }
                }
            }
        }

    }
207379
public List<Entity> findAll(Connection conn, String tableName) throws SQLException{
		return findAll(conn, Entity.create(tableName));
	}
777453
public function entityTo(string $propertyName)
    {
        $idString = implode(':', [$this->definition->getClassName(), __CLASS__, $this->relationCount++]);
        $this->readDefinition->relation($propertyName)
            ->asCustom(new EmbeddedObjectRelation($idString, new EmbeddedMapperProxy($this->mapper)));
    }
567318
public function getByName($propertyName)
    {
        $foundList = new self();
        $list = $this->getIterator();
        foreach ($list as $property) {
            if ((is_array($propertyName) && in_array($property->getName(), $propertyName))
                || ($property->getName() === $propertyName)
            ) {
                $foundList->add($property);
            }
        }

        return $foundList;
    }
908237
public void loadChoices(String propertyName) {
        if (propertyName == null || propertyName.isEmpty()) {
            loadChoices(DEFAULT_CHOICES);
        } else {
            loadChoices(PropertyUtil.getValues(propertyName, null));
        }
    }
1069887
@Override
    protected List<Object> recursivelyPopulateEntities(EntityMetadata m, Client client)
    {
        List result = populateEntities(m, client);
        return setRelationEntities(result, client, m);
    }
1257673
public GrProperty getProperty(String propertyName) {
		for (GrProperty prop : getProperties()) {
			if (prop.getName().equals(propertyName))
				return prop;
		}
		return null;
	}
126928
public final <C extends Property> PropertyList<C> getProperties(final String name) {
        return getProperties().getProperties(name);
    }
278369
public Map<String, Object> load() throws PropertyException {
		try {
			return mReader.load();
		} catch (IOException e) {
			throw new PropertyException(e.getMessage());
		}
	}
1171296
public final LinkedProperties
    loadPropertiesXml(final String pFileName)
        throws Exception {
    LinkedProperties props = null;
    URL urlSettingXml = UtlProperties.class
      .getResource(pFileName);
    if (urlSettingXml != null) {
      props = new LinkedProperties();
      InputStream inputStream = null;
      try {
        inputStream = UtlProperties.class.getResourceAsStream(pFileName);
        props.loadFromXML(inputStream);
      } finally {
        if (inputStream != null) {
          inputStream.close();
        }
      }
    }
    return props;
  }
1145485
public function indexByProperty($propertyName)
    {
        $results = [];
        foreach ($this->toArray() as $item) {
            $key = mp\getValue($item, $propertyName);
            if ($key) {
                $results[$key] = $item;
            }
        }
        return $results;
    }
447700
def [](key)
      entity = new_entity
      key_property = entity.get_property(entity.primary_key)
      key_property.value = key

      result = service.execute("#{name}(#{key_property.url_value})")
      entities = service.find_entities(result)
      single_entity_from_xml(entities)
    end
620562
private Properties loadProperties() {

        props = new Properties();

        try {
            InputStream in = Version.class.getResourceAsStream("version.properties");
            props.load(in);
            in.close();
        } catch (Exception e) {
            throw new Error("Missing version.properties");
        }

        return props;
    }
1373988
@Override
    public void loadProperties(String restClientName){
        enableDynamicProperties = true;
        setClientName(restClientName);
        loadDefaultValues();
        Configuration props = ConfigurationManager.getConfigInstance().subset(restClientName);
        for (Iterator<String> keys = props.getKeys(); keys.hasNext(); ){
            String key = keys.next();
            String prop = key;
            try {
                if (prop.startsWith(getNameSpace())){
                    prop = prop.substring(getNameSpace().length() + 1);
                }
                setPropertyInternal(prop, getStringValue(props, key));
            } catch (Exception ex) {
                throw new RuntimeException(String.format("Property %s is invalid", prop));
            }
        }
    }
14528
private String getProperty(String propertyName) {
            return propertyName == null ? null : (String) getPropertyValue(propertyName);
        }
495615
private void loadProperties(String propFileName) {
		if (propFileName != null) {
			loadProperties(getClass().getResourceAsStream(propFileName), propFileName);
		}
	}