Return the IParameterReact if it exists given the class.

@param paramClass The class
@return           The IParameterReact
434284
public IParameterReact getParameterClass(Class<?> paramClass) {
        for (Iterator<IParameterReact> it = paramsMap2.iterator(); it.hasNext();) {
            IParameterReact ipr = it.next();
            if (ipr.getClass().equals(paramClass)) return ipr;
        }

        return null;
    }
680700
public static Class<?> updateParamClassToTypeIfNeeded(Class<?> paramCls, Type type) {
        if (paramCls != type && type instanceof Class) {
            Class<?> clsType = (Class<?>) type;
            if (paramCls.isAssignableFrom(clsType)
                || clsType != Object.class && !clsType.isInterface() && clsType.isAssignableFrom(paramCls)) {
                paramCls = clsType;
            }
        }
        return paramCls;
    }
944474
public static TypeName parameterizedTypeName(ClassName rawClass, TypeName paramClass) {
		return ParameterizedTypeName.get(rawClass, paramClass);
	}
1013309
@Override
    public <T> T receiveBody(Class<T> paramClass) throws MessageFormatRuntimeException, JMSRuntimeException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "receiveBody", new Object[] { paramClass });

        try {
            // pass timeOut as 0
            return receiveBody(paramClass, 0);
        } finally {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "receiveBody");
        }

    }
816167
def _iparam_classname(classname, arg_name):
        

        if isinstance(classname, CIMClassName):
            classname = classname.copy()
            classname.host = None
            classname.namespace = None
        elif isinstance(classname, six.string_types):
            classname = CIMClassName(classname)
        elif classname is None:
            pass
        else:
            raise TypeError(
                _format("The {0!A} argument of the WBEMConnection operation "
                        "has invalid type {1} (must be None, a string, or a "
                        "CIMClassName)",
                        arg_name, type(classname)))
        return classname
1138139
public <J> RequestHandler5<T, R, U, I, J> param(final Class<J> paramClass) {
    return new RequestHandler5<>(method, path, resolverParam1, resolverParam2, resolverParam3, resolverParam4,
      ParameterResolver.path(4, paramClass),
      errorHandler);
  }
671504
public final void mCLASS() throws RecognitionException {
		try {
			int _type = CLASS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// hql.g:16:7: ( 'class' )
			// hql.g:16:9: 'class'
			{
			match("class"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
1363490
@Override
    public <Y> SingularAttribute<X, Y> getDeclaredId(Class<Y> paramClass)
    {
        if (idAttribute != null)
        {
            if (idAttribute.getJavaType().equals(paramClass) && !isIdClass)
            {
                return (SingularAttribute<X, Y>) idAttribute;
            }
        }

        onError();
        return null;
    }
515317
private static Constructor<?> getConstructor(final Class<?> genericClass, final Class<?>[] constructorParameterTypes) {
        Constructor<?> constructor = null;
        try {
            constructor = genericClass.getConstructor(constructorParameterTypes);
        } catch (final NoSuchMethodException e) {
            // Return the first constructor as a workaround
            constructor = genericClass.getConstructors()[0];
        } catch (final SecurityException e) {
            LOGGER.log(NO_CONSTRUCTOR, e);
            throw e; // Pop up the exception to let it managed by the caller method
        }
        return constructor;
    }
353499
@SuppressWarnings("unchecked")
    private Class<? extends T> generateProxyClass() throws IOException {
        if (ViewProxy.class.isAssignableFrom(mBaseClass)) {
            return mBaseClass;
        }

        Class<? extends T> proxyClass = (Class) sGeneratedProxyClasses.get(mBaseClass);
        if (proxyClass != null &&
                (proxyClass.getClassLoader() == mParentClassLoader ||
                 proxyClass.getClassLoader().getParent() == mParentClassLoader)) {
            // Cache hit; return immediately.
            return proxyClass;
        }

        proxyClass = (Class<? extends T>) findProxyViewClass(mContext, mBaseClass.getName());
        if (proxyClass != null) {
            // This app ships with the build-time proxy.
            sGeneratedProxyClasses.put(mBaseClass, proxyClass);
            return proxyClass;
        }

        try {
            Class.forName("com.google.dexmaker.DexMaker");
            return DexProxyBuilder.generateProxyClass(mContext, mBaseClass);
        } catch (ClassNotFoundException e) {
            return null;
        }
    }
1032333
public static<E, T extends ParamValidator<E>> T getValidator(Class<T> clazz, Param<Boolean> param) {

        // get if such validator was already initialized
        List<ParamValidator> validators = validatorsMap.get(clazz);
        if (validators == null) {
            addValidators(validatorsMap, clazz, null, null);
        }

        // start searching from index 2 - from this index and on, the list preserves <ParamValidatorWrapper> specific instances
        for (int i=2; i<validators.size(); i++) {
            ParamValidator validator = validators.get(i);

            if (validator.getClass() == ParamValidatorWrapper.class &&
                ((ParamValidatorWrapper)validator).ifParam == param) {

                return (T)validator;
            }

        }

        T validator = (T)new ParamValidatorWrapper<E>(clazz, param);
        validators.add(validator);

        return validator;
    }
303394
protected Object convertParameter(final Object iParameter) {
		if (iParameter != null)
			// FILTER PARAMETERS
			if (iParameter instanceof Map<?, ?>) {
				Map<String, Object> map = (Map<String, Object>) iParameter;

				for (Entry<String, Object> e : map.entrySet()) {
					map.put(e.getKey(), convertParameter(e.getValue()));
				}

			} else if (iParameter != null && !OType.isSimpleType(iParameter)) {
				final ORID rid = getIdentity(iParameter);
				if (rid != null && rid.isValid())
					// REPLACE OBJECT INSTANCE WITH ITS RECORD ID
					return rid;
			}

		return iParameter;
	}
1015975
private static Class<?> getTypedClass(java.lang.reflect.Type type)
    {
        if (type instanceof Class)
        {
            return ((Class) type);
        }
        else if (type instanceof ParameterizedType)
        {
            java.lang.reflect.Type rawParamterizedType = ((ParameterizedType) type).getRawType();
            return getTypedClass(rawParamterizedType);
        }
        else if (type instanceof TypeVariable)
        {
            java.lang.reflect.Type upperBound = ((TypeVariable) type).getBounds()[0];
            return getTypedClass(upperBound);
        }

        throw new IllegalArgumentException("Error while finding generic class for :" + type);
    }
1252370
public static Object getParameterValueFromString(String parameterClass, String value) throws Exception {
	   return getParameterValueFromString(parameterClass, value, null);
   }
619951
@Override
  public final String getFor(final Class<?> pClass, final String pThingName) {
    if (pClass == CuOrSe.class) {
      if ("entitySave".equals(pThingName)) {
        return PrCuOrSeSv.class.getSimpleName();
      } else if ("entityEdit".equals(pThingName)
        || "entityPrint".equals(pThingName)) {
        return PrcEntityRetrieve.class.getSimpleName();
      }
      return null;
    } else if ("entityEdit".equals(pThingName)
      || "entityConfirmDelete".equals(pThingName)) {
      return getForRetrieveForEditDelete(pClass, pThingName);
    } else if ("entityCopy".equals(pThingName)) {
      return getForCopy(pClass);
    } else if ("entityPrint".equals(pThingName)) {
      return getForPrint(pClass);
    } else if ("entityFSave".equals(pThingName)) {
      return getForFSave(pClass);
    } else if ("entityEFSave".equals(pThingName)) {
      return getForEFSave(pClass);
    } else if ("entitySave".equals(pThingName)) {
      return getForSave(pClass);
    } else if ("entityFfolDelete".equals(pThingName)) {
      return getForFfolDelete(pClass);
    } else if ("entityFfolSave".equals(pThingName)) {
      return getForFfolSave(pClass);
    } else if ("entityFolDelete".equals(pThingName)) {
      return getForFolDelete(pClass);
    } else if ("entityFolSave".equals(pThingName)) {
      return getForFolSave(pClass);
    } else if ("entityFDelete".equals(pThingName)) {
      return getForFDelete(pClass);
    } else if ("entityEFDelete".equals(pThingName)) {
      return getForEFDelete(pClass);
    } else if ("entityDelete".equals(pThingName)) {
      return getForDelete(pClass);
    } else if ("entityCreate".equals(pThingName)) {
      return getForCreate(pClass);
    }
    return null;
  }
1130105
public static Class<?> getPrimitiveClass(final Class<?> clazz) {

    if (clazz == null) {
      return null;
    }
    int index = ArrayUtils.indexOf(WRAPPER_CLASSES, clazz);
    if (index != ArrayUtils.INDEX_OF_NOT_FOUND) {
      return PRIMITIVE_CLASSES[index];
    }
    return clazz;
  }
181433
public static Class<?> resolvePrimitiveIfNecessary(Class<?> clazz) {
		Assert.notNull(clazz, "Class must not be null");
		return (clazz.isPrimitive() && clazz != void.class? primitiveTypeToWrapperMap.get(clazz) : clazz);
	}