Get this {@link MethodInfoList} as a map from method name to a {@link MethodInfoList} of methods with that
name.

@return This {@link MethodInfoList} as a map from method name to a {@link MethodInfoList} of methods with
that name.
332801
public Map<String, MethodInfoList> asMap() {
        // Note that MethodInfoList extends InfoList rather than MappableInfoList, because one
        // name can be shared by multiple MethodInfo objects (so asMap() needs to be of type
        // Map<String, MethodInfoList> rather than Map<String, MethodInfo>)
        final Map<String, MethodInfoList> methodNameToMethodInfoList = new HashMap<>();
        for (final MethodInfo methodInfo : this) {
            final String name = methodInfo.getName();
            MethodInfoList methodInfoList = methodNameToMethodInfoList.get(name);
            if (methodInfoList == null) {
                methodInfoList = new MethodInfoList(1);
                methodNameToMethodInfoList.put(name, methodInfoList);
            }
            methodInfoList.add(methodInfo);
        }
        return methodNameToMethodInfoList;
    }
80248
public Collection<Method> getAllMethods(String name) {
        final Map<ParamList, Map<Class<?>, Method>> nameMap = methods.get(name);
        if (nameMap == null) {
            return Collections.emptySet();
        }
        final Collection<Method> methods = new ArrayList<Method>();
        for (Map<Class<?>, Method> map : nameMap.values()) {
            methods.addAll(map.values());
        }
        return methods;
    }
301060
private static Map<String, Method> serviceMethods(Class<?> serviceInterface) {
    Map<String, Method> methods =
        Arrays.stream(serviceInterface.getMethods())
            .filter(method -> method.isAnnotationPresent(ServiceMethod.class))
            .collect(
                Collectors.toMap(
                    method -> {
                      ServiceMethod methodAnnotation = method.getAnnotation(ServiceMethod.class);
                      return isNullOrEmpty(methodAnnotation.value())
                          ? method.getName()
                          : methodAnnotation.value();
                    },
                    Function.identity()));

    return Collections.unmodifiableMap(methods);
  }
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);
    }
75507
static Map<String, List<Method>> getBusinessMethodsByName(BeanMetaData bmd) {
        Map<String, List<Method>> methodsByName = new HashMap<String, List<Method>>();
        collectBusinessMethodsByName(methodsByName, bmd.methodInfos);
        collectBusinessMethodsByName(methodsByName, bmd.localMethodInfos);
        return methodsByName;
    }
78325
public Map<String, IndexInformation> getIndexInformation() {
        ImmutableMap.Builder<String, IndexInformation> copy = ImmutableMap.builder();
        copy.putAll(indexes);
        return copy.build();
    }
365028
private List<Method> paramSetMethods() {

        List<Method> list = new ArrayList<Method>();
        Method[] methods = getClass().getMethods();
        int length = methods.length;
        for (int i = 0; i < length; i++) {
            Method method = methods[i];
            if (method.getName().startsWith("setParam")
                && (method.getParameterTypes().length == 1)
                && (method.getParameterTypes()[0].equals(java.lang.String.class))) {
                if (DEBUG) {
                    System.err.println("setMethod: " + method.getName());
                }
                list.add(method);
            }
        }
        return list;
    }
936656
static Set<String> getAmbiguousMethods(List<InterfaceInfo> interfaceInfoList) {
        Set<String> ambiguousNames = new HashSet<>();
        Set<String> dummy = new HashSet<>();
        List<String> interfaceMethods = getAllInterfaceMethodInfo(interfaceInfoList);

        interfaceMethods.forEach(interfaceMethod -> {
            boolean methodNameAlreadyPresent = dummy.add(interfaceMethod);

            if (!methodNameAlreadyPresent){
                ambiguousNames.add(interfaceMethod);
            }
        });

        return ambiguousNames;
    }
657828
public List<String> parseMethodList(String methods) {

        String[] methodArray = StringUtils.delimitedListToStringArray(methods, ",");

        List<String> methodList = new ArrayList<String>();

        for (String methodName : methodArray) {
            methodList.add(methodName.trim());
        }
        return methodList;
    }
1198141
public Map<K, V> getMap() {
        if (mode == StorageMode.LIST) {
            synchronized (this) {
                if (mode == StorageMode.LIST) {
                    mapData = convertListToMap(listData);
                    mode = StorageMode.BOTH;
                }
            }
        }
        return Collections.unmodifiableMap(mapData);
    }
840380
public Object[] getMethods() {
        Method[] methods = getClassUnderInspection().getMethods();
        Constructor[] ctors = getClassUnderInspection().getConstructors();
        Object[] result = new Object[methods.length + ctors.length];
        int resultIndex = 0;
        for (; resultIndex < methods.length; resultIndex++) {
            Method method = methods[resultIndex];
            result[resultIndex] = methodInfo(method);
        }
        for (int i = 0; i < ctors.length; i++, resultIndex++) {
            Constructor ctor = ctors[i];
            result[resultIndex] = methodInfo(ctor);
        }
        return result;
    }
325416
public FacesConfigFlowDefinitionFacesMethodCallType<FacesConfigFlowDefinitionType<T>> getOrCreateMethodCall()
   {
      List<Node> nodeList = childNode.get("method-call");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigFlowDefinitionFacesMethodCallTypeImpl<FacesConfigFlowDefinitionType<T>>(this, "method-call", childNode, nodeList.get(0));
      }
      return createMethodCall();
   }
1281515
public List<MetaMethod> getMethods() {
        List<MetaMethod> methodList = new ArrayList<MetaMethod>();
        methodList.addAll(this.expandoMethods.values());
        methodList.addAll(super.getMethods());
        return methodList;
    }
960319
public MethodInfo[] getConstructors() {
        int size = mMethods.size();
        List<MethodInfo> ctorsOnly = new ArrayList<MethodInfo>(size);

        for (int i=0; i<size; i++) {
            MethodInfo method = mMethods.get(i);
            if ("<init>".equals(method.getName())) {
                ctorsOnly.add(method);
            }
        }

        MethodInfo[] ctorsArray = new MethodInfo[ctorsOnly.size()];
        return ctorsOnly.toArray(ctorsArray);
    }
188665
private Map<Class<?>, Formatter> findFormatMethods()
    {
        final Map<Class<?>, Formatter> formats = new HashMap<Class<?>, Formatter>();
        for (Method method : this.getClass().getMethods())
        {
            Format formatAnnotation = method.getAnnotation(Format.class);
            if (formatAnnotation != null)
            {
                Class<?>[] parameterTypes = method.getParameterTypes();
                if (parameterTypes.length == 0)
                {
                    throw new InvalidFormatMethodException(getClass(), method, "Format methods must take at least 1 parameter!");
                }
                formats.put(parameterTypes[0], createFormatter(method, parameterTypes, formatAnnotation.value()));
            }
        }
        return formats;
    }
889198
public Collection<AnnotatedMethod> getMethods() {
        for (Method method : type.getDeclaredMethods()) {
            // only consider methods which have been explicitly declared in the
            // interface
            if (!method.isSynthetic()) {
                Class<?> returnType = method.getReturnType();
                Type genericReturnType = method.getGenericReturnType();
                Class<?>[] parameterTypes = method.getParameterTypes();
                Type[] genericParameterTypes = method.getGenericParameterTypes();
                if (PropertyMethod.GET.matches(method)) {
                    String name = PropertyMethod.GET.getName(method);
                    getters.put(name, method);
                    addType(type, name, returnType, genericReturnType);
                } else if (PropertyMethod.IS.matches(method)) {
                    String name = PropertyMethod.IS.getName(method);
                    getters.put(name, method);
                    addType(type, name, returnType, genericReturnType);
                } else if (PropertyMethod.SET.matches(method)) {
                    String name = PropertyMethod.SET.getName(method);
                    setters.put(name, method);
                    addType(type, name, parameterTypes[0], genericParameterTypes[0]);
                } else {
                    methods.add(method);
                }
            }
        }
        List<AnnotatedMethod> typeMethods = new ArrayList<>();
        Map<String, GetPropertyMethod> getPropertyMethods = new HashMap<>();
        for (Map.Entry<String, Method> methodEntry : getters.entrySet()) {
            String name = methodEntry.getKey();
            Method getter = methodEntry.getValue();
            Class<?> propertyType = types.get(name);
            Type genericType = genericTypes.get(name);
            GetPropertyMethod getPropertyMethod = new GetPropertyMethod(getter, name, propertyType, genericType);
            typeMethods.add(getPropertyMethod);
            getPropertyMethods.put(name, getPropertyMethod);
        }
        for (Map.Entry<String, Method> methodEntry : setters.entrySet()) {
            String name = methodEntry.getKey();
            Method setter = methodEntry.getValue();
            GetPropertyMethod getPropertyMethod = getPropertyMethods.get(name);
            Class<?> propertyType = types.get(name);
            Type genericType = genericTypes.get(name);
            SetPropertyMethod setPropertyMethod = new SetPropertyMethod(setter, getPropertyMethod, name, propertyType, genericType);
            typeMethods.add(setPropertyMethod);
        }
        for (Method method : methods) {
            typeMethods.add(new UserMethod(method));
        }
        return typeMethods;
    }
92494
public GroovyMethodDoc[] methods() {
        Collections.sort(methods);
        return methods.toArray(new GroovyMethodDoc[methods.size()]);
    }