Returns the {@link MethodRef} for the generated getter method.
338268
private static MethodRef getGetterMethod(FieldDescriptor descriptor) {
    Preconditions.checkArgument(
        !descriptor.isExtension(), "extensions do not have getter methods. %s", descriptor);
    TypeInfo message = messageRuntimeType(descriptor.getContainingType());
    boolean isProto3Enum = isProto3EnumField(descriptor);
    return MethodRef.createInstanceMethod(
            message,
            new Method(
                "get"
                    + getFieldName(descriptor, true)
                    // For proto3 enums we access the Value field
                    + (isProto3Enum ? "Value" : ""),
                isProto3Enum ? Type.INT_TYPE : getRuntimeType(descriptor),
                NO_METHOD_ARGS))
        // All protos are guaranteed to never return null
        .asNonNullable()
        .asCheap();
  }
1267858
public String getRef_id() {
    if (BioVerb_Type.featOkTst && ((BioVerb_Type)jcasType).casFeat_ref_id == null)
      jcasType.jcas.throwFeatMissing("ref_id", "ch.epfl.bbp.uima.types.BioVerb");
    return jcasType.ll_cas.ll_getStringValue(addr, ((BioVerb_Type)jcasType).casFeatCode_ref_id);}
855947
public String getRef() {
        if (refName != null) {
            if (!refName.startsWith("refs/")) {
                return REFS_HEADS + refName;
            }
            return refName;
        }
        return null;
    }
1096677
public Method getMethod(String methodName) {
        return checkNotNull(methods().get(checkNotNull(methodName)), 
        		"The method %s is not exists of object %s", methodName, delegateClass().getName());
    }
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();
    }
828539
public static MethodDescriptor getMethodDescriptor(JavaClass jclass, Method method) {
        return DescriptorFactory.instance().getMethodDescriptor(jclass.getClassName().replace('.', '/'), method.getName(),
                method.getSignature(), method.isStatic());
    }
180821
public static String getMethodDescriptor(final Method m) {
        Class<?>[] parameters = m.getParameterTypes();
		StringBuilder sb = new StringBuilder();
        sb.append('(');
        for (int i = 0; i < parameters.length; ++i) {
            getDescriptor(sb, parameters[i]);
        }
        sb.append(')');
        getDescriptor(sb, m.getReturnType());
        return sb.toString();
    }
403867
public static boolean isGetterMethod(final Method method) {
        
        final String methodName = method.getName();
        if(!methodName.startsWith("get")) {
            return false;
            
        } else if(methodName.length() <= 3) {
            return false;
        }
        
        if(method.getParameterCount() > 0) {
            return false;
        }
        
        if(method.getReturnType().equals(Void.class)) {
            return false;
        }
        
        return true;
        
    }
823117
public boolean referencesMethod(ExecutableElement method)
    {
        TypeElement declaringClass = (TypeElement) method.getEnclosingElement();
        String fullyQualifiedname = declaringClass.getQualifiedName().toString();
        String name = method.getSimpleName().toString();
        assert name.indexOf('.') == -1;
        String descriptor = Descriptor.getDesriptor(method);
        return getRefIndex(Methodref.class, fullyQualifiedname, name, descriptor) != -1;
    }
28341
public static Map<String, Method> getPropGetMethodList(final Class<?> cls) {
        Map<String, Method> getterMethodList = entityDeclaredPropGetMethodPool.get(cls);

        if (getterMethodList == null) {
            loadPropGetSetMethodList(cls);
            getterMethodList = entityDeclaredPropGetMethodPool.get(cls);
        }

        return getterMethodList;
    }
1252062
public MethodBinding getAction() {
        MethodBinding result = null;
        MethodExpression me;

        if (null != (me = getActionExpression())) {
            // if the MethodExpression is an instance of our private
            // wrapper class.
            if (me.getClass().equals(MethodExpressionMethodBindingAdapter.class)) {
                result = ((MethodExpressionMethodBindingAdapter) me).getWrapped();
            } else {
                // otherwise, this is a real MethodExpression.  Wrap it
                // in a MethodBinding.
                result = new MethodBindingMethodExpressionAdapter(me);
            }
        }
        return result;

    }
1329735
private String getMethodName(Method method) {
        StatName statName = method.getAnnotation(StatName.class);
        return statName == null ? method.getName() : statName.value();
    }
1374995
private MethodMetaData<? extends Annotation> getMethodMetaData(Method method) {
      MethodMetaData<? extends Annotation> methodMetaData = methodMetaDataCache.get(method);

      if (methodMetaData == null) {
         final String cacheName;
         final Annotation cacheAnnotation;
         final AggregatedParameterMetaData aggregatedParameterMetaData;
         final CacheKeyGenerator cacheKeyGenerator;
         final CacheDefaults cacheDefaultsAnnotation = method.getDeclaringClass().getAnnotation(CacheDefaults.class);

         if (method.isAnnotationPresent(CacheResult.class)) {
            final CacheResult cacheResultAnnotation = method.getAnnotation(CacheResult.class);
            cacheKeyGenerator = getCacheKeyGenerator(beanManager, cacheResultAnnotation.cacheKeyGenerator(), cacheDefaultsAnnotation);
            cacheName = getCacheName(method, cacheResultAnnotation.cacheName(), cacheDefaultsAnnotation, true);
            aggregatedParameterMetaData = getAggregatedParameterMetaData(method, false);
            cacheAnnotation = cacheResultAnnotation;

         } else if (method.isAnnotationPresent(CacheRemove.class)) {
            final CacheRemove cacheRemoveEntryAnnotation = method.getAnnotation(CacheRemove.class);
            cacheKeyGenerator = getCacheKeyGenerator(beanManager, cacheRemoveEntryAnnotation.cacheKeyGenerator(), cacheDefaultsAnnotation);
            cacheName = getCacheName(method, cacheRemoveEntryAnnotation.cacheName(), cacheDefaultsAnnotation, false);
            aggregatedParameterMetaData = getAggregatedParameterMetaData(method, false);
            cacheAnnotation = cacheRemoveEntryAnnotation;

            if (cacheName.isEmpty()) {
               throw log.cacheRemoveEntryMethodWithoutCacheName(method.getName());
            }

         } else if (method.isAnnotationPresent(CacheRemoveAll.class)) {
            final CacheRemoveAll cacheRemoveAllAnnotation = method.getAnnotation(CacheRemoveAll.class);
            cacheKeyGenerator = null;
            cacheName = getCacheName(method, cacheRemoveAllAnnotation.cacheName(), cacheDefaultsAnnotation, false);
            aggregatedParameterMetaData = getAggregatedParameterMetaData(method, false);
            cacheAnnotation = cacheRemoveAllAnnotation;

            if (cacheName.isEmpty()) {
               throw log.cacheRemoveAllMethodWithoutCacheName(method.getName());
            }

         } else if (method.isAnnotationPresent(CachePut.class)) {
            final CachePut cachePutAnnotation = method.getAnnotation(CachePut.class);
            cacheKeyGenerator = getCacheKeyGenerator(beanManager, cachePutAnnotation.cacheKeyGenerator(), cacheDefaultsAnnotation);
            cacheName = getCacheName(method, cachePutAnnotation.cacheName(), cacheDefaultsAnnotation, true);
            aggregatedParameterMetaData = getAggregatedParameterMetaData(method, true);
            cacheAnnotation = cachePutAnnotation;

         } else {
            throw log.methodWithoutCacheAnnotation(method.getName());
         }

         final MethodMetaData<? extends Annotation> newCacheMethodMetaData = new MethodMetaData<Annotation>(
               method,
               aggregatedParameterMetaData,
               asSet(method.getAnnotations()),
               cacheKeyGenerator,
               cacheAnnotation,
               cacheName
         );

         methodMetaData = methodMetaDataCache.putIfAbsent(method, newCacheMethodMetaData);
         if (methodMetaData == null) {
            methodMetaData = newCacheMethodMetaData;
         }
      }

      return methodMetaData;
   }
1089776
private static MethodRef getBuilderMethod(Descriptor descriptor) {
    TypeInfo message = messageRuntimeType(descriptor);
    TypeInfo builder = builderRuntimeType(descriptor);
    return MethodRef.createStaticMethod(
            message, new Method("newBuilder", builder.type(), NO_METHOD_ARGS))
        .asNonNullable();
  }
254881
def GetMethodConfig(self, method):
        """"""
        method_config = self._method_configs.get(method)
        if method_config:
            return method_config
        func = getattr(self, method, None)
        if func is None:
            raise KeyError(method)
        method_config = getattr(func, 'method_config', None)
        if method_config is None:
            raise KeyError(method)
        self._method_configs[method] = config = method_config()
        return config
710873
public static Method getMethod(final Class cls, final String methodName) {
		return getMethod(cls, methodName, false);
	}
269209
public static MethodInstance getMethodInstanceEL(Object objMaybeNull, Class clazz, Collection.Key methodName, Object[] args) {
	checkAccessibility(objMaybeNull, clazz, methodName);
	args = cleanArgs(args);

	Method[] methods = mStorage.getMethods(clazz, methodName, args.length);// getDeclaredMethods(clazz);

	if (methods != null) {
	    Class[] clazzArgs = getClasses(args);
	    // exact comparsion
	    // print.e("exact:"+methodName);
	    outer: for (int i = 0; i < methods.length; i++) {
		if (methods[i] != null) {
		    Class[] parameterTypes = methods[i].getParameterTypes();
		    for (int y = 0; y < parameterTypes.length; y++) {
			if (toReferenceClass(parameterTypes[y]) != clazzArgs[y]) continue outer;
		    }
		    return new MethodInstance(methods[i], args);
		}
	    }
	    // like comparsion
	    // MethodInstance mi=null;
	    // print.e("like:"+methodName);
	    outer: for (int i = 0; i < methods.length; i++) {
		if (methods[i] != null) {
		    Class[] parameterTypes = methods[i].getParameterTypes();
		    for (int y = 0; y < parameterTypes.length; y++) {
			if (!like(clazzArgs[y], toReferenceClass(parameterTypes[y]))) continue outer;
		    }
		    return new MethodInstance(methods[i], args);
		}
	    }

	    // convert comparsion
	    // print.e("convert:"+methodName);
	    MethodInstance mi = null;
	    int _rating = 0;
	    outer: for (int i = 0; i < methods.length; i++) {
		if (methods[i] != null) {
		    RefInteger rating = (methods.length > 1) ? new RefIntegerImpl(0) : null;
		    Class[] parameterTypes = methods[i].getParameterTypes();
		    Object[] newArgs = new Object[args.length];
		    for (int y = 0; y < parameterTypes.length; y++) {
			try {
			    newArgs[y] = convert(args[y], toReferenceClass(parameterTypes[y]), rating);
			}
			catch (PageException e) {
			    continue outer;
			}
		    }
		    if (mi == null || rating.toInt() > _rating) {
			if (rating != null) _rating = rating.toInt();
			mi = new MethodInstance(methods[i], newArgs);
		    }
		    // return new MethodInstance(methods[i],newArgs);
		}
	    }
	    return mi;
	}
	return null;
    }