Get a list value for this entity by name.

@param valuesClass class type of T.
@return list value for this entity.
340320
<T extends ListValue> IListValueProperty getListValue(Class<T> valuesClass,
            String name) {
        return new ListValueProperty<T>(valuesClass, name);
    }
1296974
public static List<EntityField> getAll(Class<?> entityClass) {
        List<EntityField> fields = fieldHelper.getFields(entityClass);
        List<EntityField> properties = fieldHelper.getProperties(entityClass);
        //拼到一起，名字相同的合并
        List<EntityField> all = new ArrayList<EntityField>();
        Set<EntityField> usedSet = new HashSet<EntityField>();
        for (EntityField field : fields) {
            for (EntityField property : properties) {
                if (!usedSet.contains(property) && field.getName().equals(property.getName())) {
                    field.copyFromPropertyDescriptor(property);
                    usedSet.add(property);
                    break;
                }
            }
            all.add(field);
        }
        for (EntityField property : properties) {
            if (!usedSet.contains(property)) {
                all.add(property);
            }
        }
        return all;
    }
1168390
public static Object[] getDefaultValues(Class<?>... classes) {
		final Object[] values = new Object[classes.length];
		for (int i = 0; i < classes.length; i++) {
			values[i] = getDefaultValue(classes[i]);
		}
		return values;
	}
1108226
@SuppressWarnings("unchecked")
    public <T> List<T> getList(Class<T> clazz) {
        return (List<T>) objects;
    }
851142
<T extends ValueDescriptor<?>> T getValueDescriptor(Class<T> valueDescriptorType) {
        return scannerContext.getStore().create(valueDescriptorType);
    }
1231735
public static <V extends Value> ValueList<V> getInstance(V... value) {
        ValueList<V> result = new ValueList<>(value.length);
        for (V val : value) {
            result.add(val);
        }
        return result;
    }
1237830
def get_name_value(self):
        
        name, value = self.get()
        if not isinstance(name, list):
            name = [name]
        if not isinstance(value, list):
            value = [value]
        return list(zip(name, value))
636538
public @Nonnull final <T> T getRequiredValue(Class<T> type) {
        return getRequiredValue(AnnotationMetadata.VALUE_MEMBER, type);
    }
146903
private static List<PropertyDescriptor> getPropertyDescriptorsOptional(
        Class<?> beanClass)
    {
        BeanInfo beanInfo = getBeanInfoOptional(beanClass);
        if (beanInfo == null)
        {
            return Collections.emptyList();
        }
        PropertyDescriptor propertyDescriptors[] = 
            beanInfo.getPropertyDescriptors();
        if (propertyDescriptors == null)
        {
            return Collections.emptyList();
        }
        return Collections.unmodifiableList(
            new ArrayList<PropertyDescriptor>(
                Arrays.asList(propertyDescriptors)));
    }
388674
private ClassRecord getClassRecord(EntityIdValue entityIdValue) {
		if (!this.classRecords.containsKey(entityIdValue)) {
			ClassRecord classRecord = new ClassRecord();
			this.classRecords.put(entityIdValue, classRecord);
			return classRecord;
		} else {
			return this.classRecords.get(entityIdValue);
		}
	}
352323
private String createValueFromList(List<String> valueList) {

        if (valueList == null) {
            return null;
        }
        StringBuffer result = new StringBuffer(valueList.size() * 32);
        Iterator<String> i = valueList.iterator();
        while (i.hasNext()) {
            result.append(
                replaceDelimiter(i.next().toString(), VALUE_LIST_DELIMITER, VALUE_LIST_DELIMITER_REPLACEMENT));
            if (i.hasNext()) {
                result.append(VALUE_LIST_DELIMITER);
            }
        }
        return result.toString();
    }
1298921
public <T> List<T> find(Entity where, Class<T> beanClass) throws SQLException {
		return find(where.getFieldNames(), where, BeanListHandler.create(beanClass));
	}
349262
public org.tensorflow.framework.AttrValue.ListValueOrBuilder getListOrBuilder() {
    if (valueCase_ == 1) {
       return (org.tensorflow.framework.AttrValue.ListValue) value_;
    }
    return org.tensorflow.framework.AttrValue.ListValue.getDefaultInstance();
  }
1157953
@SuppressWarnings("unchecked")
  @Override
  public <T> List<T> getCollection(Class<T> entityClass) {
    String collectionName = Util.determineCollectionName(entityClass);
    Map<Object, T> collection = (Map<Object, T>) collectionsRef.get().get(collectionName);
    if (null == collection) {
      createCollection(collectionName);
      collection = (Map<Object, T>) collectionsRef.get().get(collectionName);
    }

    CollectionMetaData cmd = cmdMap.get(collectionName);
    List<T> newCollection = new ArrayList<T>();
    try {
      for (T document : collection.values()) {
        Object obj = Util.deepCopy(document);
        if(encrypted && cmd.hasSecret() && null != obj) {
          CryptoUtil.decryptFields(obj, cmd, dbConfig.getCipher());
        }
        newCollection.add((T) obj);
      }
    } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
      logger.error("Error when decrypting value for a @Secret annotated field for entity: " + collectionName, e);
      throw new JsonDBException("Error when decrypting value for a @Secret annotated field for entity: " + collectionName, e);
    }
    return newCollection;
  }
1182093
public static Object getTypedValue(String valueStr, Attribute attr, EntityManager entityManager) {
    if (valueStr == null) return null;
    switch (attr.getDataType()) {
      case BOOL:
        return Boolean.valueOf(valueStr);
      case CATEGORICAL:
      case FILE:
      case XREF:
        EntityType xrefEntity = attr.getRefEntity();
        Object xrefIdValue = getTypedValue(valueStr, xrefEntity.getIdAttribute(), entityManager);
        return entityManager.getReference(xrefEntity, xrefIdValue);
      case CATEGORICAL_MREF:
      case MREF:
      case ONE_TO_MANY:
        EntityType mrefEntity = attr.getRefEntity();
        List<String> mrefIdStrValues = ListEscapeUtils.toList(valueStr);
        return mrefIdStrValues
            .stream()
            .map(
                mrefIdStrValue ->
                    getTypedValue(mrefIdStrValue, mrefEntity.getIdAttribute(), entityManager))
            .map(mrefIdValue -> entityManager.getReference(mrefEntity, mrefIdValue))
            .collect(toList());
      case COMPOUND:
        throw new IllegalArgumentException("Compound attribute has no value");
      case DATE:
        try {
          return parseLocalDate(valueStr);
        } catch (DateTimeParseException e) {
          throw new MolgenisDataException(
              format(FAILED_TO_PARSE_ATTRIBUTE_AS_DATE_MESSAGE, attr.getName(), valueStr), e);
        }
      case DATE_TIME:
        try {
          return parseInstant(valueStr);
        } catch (DateTimeParseException e) {
          throw new MolgenisDataException(
              format(FAILED_TO_PARSE_ATTRIBUTE_AS_DATETIME_MESSAGE, attr.getName(), valueStr), e);
        }
      case DECIMAL:
        return Double.valueOf(valueStr);
      case EMAIL:
      case ENUM:
      case HTML:
      case HYPERLINK:
      case SCRIPT:
      case STRING:
      case TEXT:
        return valueStr;
      case INT:
        return Integer.valueOf(valueStr);
      case LONG:
        return Long.valueOf(valueStr);
      default:
        throw new UnexpectedEnumException(attr.getDataType());
    }
  }
126928
public final <C extends Property> PropertyList<C> getProperties(final String name) {
        return getProperties().getProperties(name);
    }
395608
public function getListElements( core_kernel_classes_Class $listClass, $sort = true)
    {
        $returnValue = array();

    	if($sort){
        	$levelProperty = new core_kernel_classes_Property(TaoOntology::PROPERTY_LIST_LEVEL);
        	foreach ($listClass->getInstances(false) as $element) {
        	    $literal = $element->getOnePropertyValue($levelProperty);
        	    $level = is_null($literal) ? 0 : (string) $literal;
        	    while (isset($returnValue[$level])) {
        	        $level++;
        	    }
        	    $returnValue[$level] = $element;
        	}
			uksort($returnValue, 'strnatcasecmp');
    	}
    	else{
    		$returnValue = $listClass->getInstances(false);
    	}

        return (array) $returnValue;
    }