Get list of possible getter names for a field (without ability to assume type).
Method is protected to allow test access.

@param fieldName name of field to get possible getters for
@return list of possible getter names
186595
protected List<String> getGetterNameAlternatives(String fieldName) {
        String base = capitalize(fieldName);
        List<String> res = new ArrayList<>();
        res.add("get" + capitalize(fieldName));
        res.add(fieldName);
        String alt = "is" + base;
        if (alt.startsWith("isIs")) {
            res.add("i" + alt.substring(3));
        }
        res.add(alt);
        alt = "has" + base;
        if (!alt.startsWith("hasIs")) {
            if (alt.startsWith("hasHas")) {
                res.add("h" + alt.substring(4));
            } else {
                res.add(alt);
            }
        }
        return res;
    }
1122609
public String getFieldLiteral(String fieldName){
        String fieldLiteral =  getLiteral(StringUtil.camelize(fieldName));

        Method parentModelgetter = getReflector().getReferredModelGetterFor(getReflector().getFieldGetter(fieldName));
        if (parentModelgetter != null) {
            fieldLiteral = getLiteral(parentModelgetter.getName().substring("get".length())) ;
        }
        return fieldLiteral;
        
    }
1344639
public static String extractFieldName(final String fieldDefinition) {
    String[] fieldNameParts = FILED_NAME_PATTERN.split(fieldDefinition);
    if (fieldNameParts.length == 1)
      return fieldDefinition;
    if (fieldNameParts.length == 3 && "by".equalsIgnoreCase(fieldNameParts[1]))
      return fieldNameParts[0];

    throw new IllegalArgumentException("Illegal field name format, should be '<property> [by key|value]' but was '"
        + fieldDefinition + '\'');
  }
347515
@Override
    public Map<String, FieldTypes> get(final Collection<String> fieldNames) {
        return get(fieldNames, ImmutableSet.of());
    }
566358
public static <T> List<T> getFieldValues(Iterable<?> collection, final String fieldName, final Class<T> elementType) {
		List<Object> fieldValues = getFieldValues(collection, fieldName);
		return Convert.toList(elementType, fieldValues);
	}
730117
public static List<Object> getFieldValues(Class<? extends Enum<?>> clazz, String fieldName) {
		final Enum<?>[] enums = clazz.getEnumConstants();
		if (null == enums) {
			return null;
		}
		final List<Object> list = new ArrayList<>(enums.length);
		for (Enum<?> e : enums) {
			list.add(ReflectUtil.getFieldValue(e, fieldName));
		}
		return list;
	}
1317057
public List<String> getDeclaredFieldNames() {
		if (this.declaredFieldNames == null) {
			this.declaredFieldNames = new ArrayList<String>(this.declaredFields.size());
			for (DOField f : this.declaredFields) {
				this.declaredFieldNames.add(f.getName());
			}
		}
		return this.declaredFieldNames;
	}
1306430
private static String[] fieldNames(Class<?> beanType) {
        Field[] fields = Stream.of(beanType.getDeclaredFields())
                .filter(f -> !Modifier.isStatic(f.getModifiers()) && f.getAnnotation(PropertyDefinition.class) != null)
                .toArray(Field[]::new);
        List<String> fieldNames = new ArrayList<>();
        for (int i = 0; i < fields.length; i++) {
            fieldNames.add(fields[i].getName());
        }
        return fieldNames.toArray(new String[fieldNames.size()]);
    }
192819
@Override
    public Optional<FieldTypes> get(final String fieldName) {
        return Optional.ofNullable(get(ImmutableSet.of(fieldName)).get(fieldName));
    }
1080525
public FieldInfo getFieldInfo(final String fieldName) {
        for(FieldInfo item : fieldInfos) {
            if(item.getFieldName().equals(fieldName)) {
                return item;
            }
        }
        
        return null;
    }
97955
public static List<String> getParameterNames(MethodNode node) {
        ArrayList<String> result = new ArrayList<String>();

        if (node.getParameters() != null) {
            for (Parameter parameter : node.getParameters()) {
                result.add(parameter.getName());
            }
        }
        return result;
    }
16583
public static List<Field> getAllFields(Class<?> clazz) {
        final List<Field> ret = new ArrayList<>();
        do {
            ret.addAll(Arrays.asList(clazz.getDeclaredFields()));
            clazz = clazz.getSuperclass();
        } while (clazz != null);
        return ret;
    }
701817
public FieldValue lookup(FieldName name){
		Map<FieldName, FieldValue> values = getValues();

		FieldValue value = values.getOrDefault(name, EvaluationContext.UNDECLARED_VALUE);
		if(value != EvaluationContext.UNDECLARED_VALUE){
			return value;
		}

		throw new MissingValueException(name);
	}
1198608
public Reflect get(@NonNull String fieldName) throws ReflectionException {
      Field f = getField(fieldName);

      if (f == null) {
         throw new ReflectionException(new NoSuchFieldException(fieldName + " is not a valid field for " + clazz));
      }

      boolean isAccessible = f.isAccessible();
      try {
         if (accessAll) {
            f.setAccessible(true);
         }
         return onObject(f.get(object));
      } catch (IllegalAccessException e) {
         e.printStackTrace();
         throw new ReflectionException(e);
      } finally {
         f.setAccessible(isAccessible);
      }

   }
123785
public Attribute<T, Serializable> getAttribute(String fieldname) {
        if (fieldname == null) return null;
        return this.attributeMap.get(fieldname);
    }
1087004
public boolean hasField(@NonNull String fieldName) {
      return ClassDescriptorCache.getInstance()
                                 .getClassDescriptor(clazz)
                                 .getFields(accessAll)
                                 .stream()
                                 .anyMatch(f -> f.getName().equals(fieldName));
   }
238692
@Override
  public Collection<String> getNames(final String name) throws OptionsException {
    if (useSystemwideValues) {
      return getNames(optionsRoot, makePathElements(name), -1);
    }

    return getNames(localOptionsRoot, makePathElements(name), -1);
  }