Returns map field getter for particular key method name.
199330
public static String mapGetByKeyMethodName(Field field) {
        if (field.isMap()) {
            return GETTER_PREFIX + Formatter.toPascalCase(field.getName());
        }
        throw new IllegalArgumentException(field.toString());
    }
723596
def get_methods_by_name(self, name):
        

        return (m for m in self.methods if m.get_name() == name)
354186
private static String getMethodNameForField(final String prefix, final String fieldName) {
		return prefix + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
	}
1204584
public Map<String,Object> getMap(String name){
        if(variables.containsKey(name))
            return variables;
        else if(parent!=null)
            return parent.getMap(name);
        return null;
    }
464569
def get_field_map(self, cls):
        """"""
        field_map = dict((field, field) for field in self.fields)
        all_fields = dict((f.name, f.attname) for f in cls._meta.fields)
        field_map.update(**dict((k, v) for (k, v) in all_fields.items()
                                if k in field_map))
        return field_map
163742
public MappedField getMappedFieldByJavaField(final String name) {
        for (final MappedField mf : persistenceFields) {
            if (name.equals(mf.getJavaFieldName())) {
                return mf;
            }
        }

        return null;
    }
234621
public String getMethodField()
    {
        //
        // Both the event set and event name must be used for the generated field to avoid
        // conflicts between same-named events in different event sets.
        //
        StringBuffer sb = new StringBuffer();
        sb.append("_");
        sb.append(_eventSet.getShortName());
        sb.append("_");
        sb.append(getName());
        int methodIndex = getIndex();
        if (methodIndex != -1)
            sb.append(methodIndex);
        sb.append("Event");
        return sb.toString();
    }
210872
public static Map<String, Object> getNameFieldMap(Class<? extends Enum<?>> clazz, String fieldName) {
		final Enum<?>[] enums = clazz.getEnumConstants();
		if (null == enums) {
			return null;
		}
		final Map<String, Object> map = MapUtil.newHashMap(enums.length);
		for (Enum<?> e : enums) {
			map.put(e.name(), ReflectUtil.getFieldValue(e, fieldName));
		}
		return map;
	}
669873
protected Object getMethodParam(String methodName, String paramKey) {
        if (CommonUtils.isEmpty(configContext)) {
            return null;
        }
        Object o = configContext.get(buildMethodKey(methodName, paramKey));
        return o == null ? configContext.get(paramKey) : o;
    }
591119
String getterNameFor(Element field) {
        String methodNamePrefix = "get";
        if (field.asType().getKind() == TypeKind.BOOLEAN) {
            methodNamePrefix = "is";
        }
        return methodNamePrefix + NameUtils.capitalize(field.getSimpleName().toString());
    }
996047
public static String getMapGetterName(Field field) {
        if (field.isMap()) {
            return GETTER_PREFIX + Formatter.toPascalCase(field.getName()) + MAP_SUFFIX;
        }
        throw new IllegalArgumentException(field.toString());
    }
1046556
private static Mapping getStringMapping(KeyInformation information) {
        assert AttributeUtil.isString(information.getDataType());
        Mapping map = getMapping(information);
        if (map== DEFAULT) map = TEXT;
        return map;
    }
755159
public static Map<String, Method> getGetters(Class<?> clazz) {
		Map<String, Method> getters = new HashMap<String, Method>();
		Method[] methods = clazz.getMethods();
		for (Method method : methods) {
			String methodName = method.getName();
			if (method.getParameterTypes().length == 0) {
				if (methodName.startsWith("get") && methodName.length() > 3) {
					String propertyName = methodName.substring(3, 4)
							.toLowerCase();
					if (methodName.length() > 4) {
						propertyName += methodName.substring(4);
					}
					getters.put(propertyName, method);
				} else if (methodName.startsWith("is")
						&& methodName.length() > 2
						&& Boolean.TYPE.equals(method.getReturnType())) {
					String propertyName = methodName.substring(2, 3)
							.toLowerCase();
					if (methodName.length() > 3) {
						propertyName += methodName.substring(3);
					}
					getters.put(propertyName, method);
				}
			}
		}
		return getters;
	}
3407
@SuppressWarnings("rawtypes")
public static Object getMappedProperty(Object bean, String name, String key)
       throws IllegalAccessException, InvocationTargetException, NoSuchMethodException,Exception
   {
       if(bean == null)
           throw new IllegalArgumentException("No bean specified");
       if(name == null)
           throw new IllegalArgumentException("No name specified");
       if(key == null)
           throw new IllegalArgumentException("No key specified");
       
       Object result = null;
       PropertyDescriptor descriptor = getPropertyDescriptor(bean, name);
       if(descriptor == null)
           throw new NoSuchMethodException("Unknown property '" + name + "'");
       if(descriptor instanceof JBPropertyDescriber)
       {
           Method readMethod = ((JBPropertyDescriber)descriptor).getMappedReadMethod();
           if(readMethod != null)
           {
               Object keyArray[] = new Object[1];
               keyArray[0] = key;
               result = readMethod.invoke(bean, keyArray);
           } else
           {
               throw new NoSuchMethodException("Property '" + name + "' has no mapped getter method");
           }
       } else
       {
           Method readMethod = descriptor.getReadMethod();
           if(readMethod != null)
           {
               Object invokeResult = readMethod.invoke(bean, new Object[0]);
               if(invokeResult instanceof Map)
                   result = ((Map)invokeResult).get(key);
           } else
           {
               throw new NoSuchMethodException("Property '" + name + "' has no mapped getter method");
           }
       }
       return result;
   }
722932
private static Map<String, Method> getAllMethod(Class<?> clazz, Map<String, Method> methods) {
        if (clazz == null || clazz == Object.class) {
            return methods;
        }

        Arrays.stream(clazz.getDeclaredMethods()).forEach(method -> {
            String key = String.format("%s:%s", method.getName(),
                ByteCodeUtils.getMethodDesc(method));
            Method m = methods.get(key);
            if (m == null || (m.getDeclaringClass().isInterface()
                              && !method.getDeclaringClass().isInterface())) {
                methods.put(key, method);
            }
        });

        Arrays.stream(clazz.getInterfaces()).forEach(c -> getAllMethod(c, methods));

        return getAllMethod(clazz.getSuperclass(), methods);
    }
701661
private static CtMethod getFieldGetter(CtField field, CtClass clazz) throws NotFoundException {
        if (field == null) {
            return null;
        }
        return getFieldGetter(field, clazz, false);
    }
749835
public static String methodKey(Method m)
    {
        StringBuffer result = new StringBuffer(m.getName());

        result.append("(");

        Class<?> argTypes[] = m.getParameterTypes();
        for (int i = 0; i < argTypes.length; i++) {
            result.append(argTypes[i].getName());
            result.append(",");
        }
        result.append(")");
        return result.toString();
    }