Returns the functional types accepted by {@code methodName} on {@code type}.
182694
public static List<FunctionalType> functionalTypesAcceptedByMethod(
      DeclaredType type,
      String methodName,
      Elements elements,
      Types types) {
    TypeElement typeElement = asElement(type);
    return methodsOn(typeElement, elements, errorType -> { })
        .stream()
        .filter(method -> method.getSimpleName().contentEquals(methodName)
            && method.getParameters().size() == 1)
        .flatMap(method -> {
          ExecutableType methodType = (ExecutableType) types.asMemberOf(type, method);
          TypeMirror parameter = getOnlyElement(methodType.getParameterTypes());
          return maybeFunctionalType(parameter, elements, types)
              .map(Stream::of).orElse(Stream.of());
        })
        .collect(toList());
  }
1280829
private static <T> List<Method> getMethods(Class<T> type, String... names) {

		Assert.notNull(type, "Missing class to search for methods!");
		Assert.notNullOrEmpty(names, "Missing method names to search for!");

		Map<String, Method> candidates = new HashMap<>();
		for (Method method : type.getMethods()) {

			if (Modifier.isStatic(method.getModifiers()) &&
			    method.getReturnType().equals(type) &&
			    method.getParameterTypes().length == 1 &&
			    method.getParameterTypes()[0].isAssignableFrom(String.class)) {

				candidates.put(method.getName(), method);
			}
		}

		List<Method> output = new ArrayList<>();

		// go in order desired
		for (String name : names) {
			if (candidates.containsKey(name)) {
				output.add(candidates.get(name));
			}
		}

		return output;
	}
965591
function types () {
        var pub = {};

        var i;
        var keys = Object.keys(revalidator.validate.types);
        var length = keys.length;

        for (i = 0; i < length; i++) {
            pub[keys[i]] = getValidationFunctionForTypesByKey(keys[i]);
        }

        return pub;
    }
339042
@SuppressWarnings( "unchecked" )
    protected MethodMetadata getMethodTypeMemberMetadataFrom( MethodDeclaration methodDeclaration ) {
        MethodMetadata methodTypeMemberMetadata = MethodMetadata.methodMemberType(JavaMetadataUtil.getName(methodDeclaration.getName()));
        processReturnTypeOfMethodDeclaration(methodDeclaration, methodTypeMemberMetadata);
        processModifiersOfMethodDeclaration(methodDeclaration, methodTypeMemberMetadata);
        processParametersOfMethodDeclaration(methodDeclaration, methodTypeMemberMetadata);
        List<SingleVariableDeclaration> params = methodDeclaration.parameters();
        for (SingleVariableDeclaration singleVariableDeclaration : params) {
            singleVariableDeclaration.getName();
        }
        return methodTypeMemberMetadata;
    }
226354
List<String> getArgumentsType(ExecutableElement methodElement) {
		ExecutableType methodType = (ExecutableType) methodElement.asType();
		List<String> res = new ArrayList<>();
		for (TypeMirror argumentType : methodType.getParameterTypes()) {
			res.add(argumentType.toString());
		}
		return res;
	}
391698
protected List<TypeName> getExtractedTypes(TypeName permutationType, TypeName paramType) {
    return match(permutationType)
        .when(typeOf(ParameterizedTypeName.class)).get(
            t -> {
              if (isDecomposableBuilder(t.rawType)) {
                return t.typeArguments.subList(1, t.typeArguments.size());
              } else if (t.rawType.equals(MATCH_ANY)) {
                return ImmutableList.of(paramType);
              } else {
                return Collections.<TypeName>emptyList();
              }
            })
        .when(typeOf(TypeVariableName.class)).get(t -> ImmutableList.of())
        .when(typeOf(ClassName.class)).get(t -> ImmutableList.of(paramType))
        .orElse(t -> ImmutableList.of(t))
        .getMatch();
  }
536607
public List<MethodType<BeanType<T>>> getAllMethod()
   {
      List<MethodType<BeanType<T>>> list = new ArrayList<MethodType<BeanType<T>>>();
      List<Node> nodeList = childNode.get("method");
      for(Node node: nodeList)
      {
         MethodType<BeanType<T>>  type = new MethodTypeImpl<BeanType<T>>(this, "method", childNode, node);
         list.add(type);
      }
      return list;
   }
54028
function getAlternateTypes(method) {
          var types = [];

          function process(arr) {
            if (arr) {
              arr.forEach(function(obj) {
                if (obj.type) {
                  var split = obj.type.split('|');
                  if (split.length > 1) {
                    types = types.concat(split);
                  }
                }
              });
            }
          }

          process(method.params);
          process(method.options);

          return types;
        }
1248882
public static Type[] getParameterTypes(Type generic) {
		Type[] types = null;
		if(isGeneric(generic)) {
			types = ((ParameterizedType)generic).getActualTypeArguments();
		}
		return types;
	}
420739
@Override
    public Set<String> getSupportedAnnotationTypes() {
        Class<? extends Annotation>[] supportedAnnotations = getClass().getAnnotation(SupportedAnnotations.class).value();

        return FluentIterable
                .from(Arrays.asList(supportedAnnotations))
                .transform(new ClassToNameTransform())
                .toSet();
    }
797485
public static <T> Method[] getAllMethodsExcept(Class<T> type, String methodNameToExclude, Class<?>[] argumentTypes) {
        Method[] methods = getAllMethods(type);
        List<Method> methodList = new ArrayList<Method>();
        outer:
        for (Method method : methods) {
            if (method.getName().equals(methodNameToExclude)) {
                if (argumentTypes != null && argumentTypes.length > 0) {
                    final Class<?>[] args = method.getParameterTypes();
                    if (args != null && args.length == argumentTypes.length) {
                        for (int i = 0; i < args.length; i++) {
                            if (args[i].isAssignableFrom(getOriginalUnmockedType(argumentTypes[i]))) {
                                /*
                                         * Method was not found thus it should not be
                                         * mocked. Continue to investigate the next
                                         * method.
                                         */
                                continue outer;
                            }
                        }
                    }
                } else {
                    continue;
                }
            }
            methodList.add(method);
        }
        return methodList.toArray(new Method[0]);
    }
89346
private IMethodInfo getSingleMethodWithName( String methodName, IType typeToResolveAgainst, ITypeInfo typeInfo )
  {
    MethodList methods;
    if( typeInfo instanceof IRelativeTypeInfo )
    {
      methods = ((IRelativeTypeInfo)typeInfo).getMethods( typeToResolveAgainst );
    }
    else
    {
      methods = typeInfo.getMethods();
    }

    IMethodInfo match = null;
    for( IMethodInfo possibleMatch : methods )
    {
      if( possibleMatch.getDisplayName().equals( methodName ) )
      {
        if( match != null )
        {
          return null; // more than one, bail
        }
        else
        {
          match = possibleMatch;
        }
      }
    }
    return match;
  }
604512
def get_types(func):
    
    return _get_types(func, util.is_classmethod(func), util.is_method(func))
931012
public static List<Method> methodsOf(Class<?> type) {
        if (type == null) {
            throw new IllegalArgumentException("Method argument type must not be null");
        }
        List<Method> methods = new LinkedList<>();
        Queue<Class<?>> classes = new LinkedList<>();
        classes.add(type);
        while (!classes.isEmpty()) {
            Class<?> c = classes.poll();
            methods.addAll(asList(c.getDeclaredMethods()));
            if (c.getSuperclass() != null) {
                classes.add(c.getSuperclass());
            }
            addAll(classes, c.getInterfaces());
        }
        return methods;
    }
325082
public static List<Class> getMethodGenericParameterTypes(Method method, int index) {
    	List<Class> results = new ArrayList<Class>();
    	Type[] genericParameterTypes = method.getGenericParameterTypes();
    	if (index >= genericParameterTypes.length ||index < 0) {
			throw new IllegalArgumentException("index "+ (index<0 ? " must > 0 " : " over total arguments"));
		}
    	Type genericParameterType = genericParameterTypes[index];
    	if(genericParameterType instanceof ParameterizedType){
    	     ParameterizedType aType = (ParameterizedType) genericParameterType;
    	     Type[] parameterArgTypes = aType.getActualTypeArguments();
    	     for(Type parameterArgType : parameterArgTypes){
    	         Class parameterArgClass = (Class) parameterArgType;
    	         results.add(parameterArgClass);
    	     }
    	     return results;
    	}
    	return results;
    }
1093313
public static Function<Object,List<String>> listOfString(final String methodName, final Object... optionalParameters) {
        return methodForListOfString(methodName, optionalParameters);
    }
467583
public String[] getVarTypes()
    {
    TreeSet<String> typeSet = new TreeSet<String>();
    for( Iterator<IVarDef> vars = getVarDefs(); vars.hasNext(); )
      {
      typeSet.add( vars.next().getType());
      }

    String[] types = new String[ typeSet.size()];
    typeSet.toArray( types);
    return types;
    }