@Override protected final boolean isConstructorParameterValid(Injectable fp) { // This method is declared as final, since parseConstructors(), which // calls it, is invoked from the constructor return !(fp.getParamType() == Injectable.ParamType.ENTITY); }
protected <T> Collection<T> elementAsTypeCollection(T object, Comparator<T> comparator) { return asTypeCollection(Collections.nCopies(1, object), comparator); }
public ConsumesMethod(Method method, MediaType mediaType) { super(method, mediaType); for (Injectable fp : getFormalParameters()) { if (fp.getParamType() == ParamType.ENTITY) { if (type != null) { // we allow to have only one entity parameter String methodName = method.getDeclaringClass().getName() + "." + method.getName(); //$NON-NLS-1$ if (logger.isErrorEnabled()) { logger .error(Messages .getMessage("assetLocatorMethodMoreThanOneEntityParam", methodName)); //$NON-NLS-1$ } throw new WebApplicationException(); } type = fp.getGenericType(); typeClass = fp.getType(); } } } }
ParamType pt = paramMetadata.getParamType(); Annotation[] annotations = paramMetadata.getAnnotations(); switch (pt) { case HEADER: Class<?> memberType = paramMetadata.getType(); if (memberType.equals(int.class) || memberType.equals(Integer.class)) { p.setType(new QName(XML_SCHEMA_NS, "int"));
Param param = null; boolean isUnique = true; switch (p.getParamType()) { case QUERY: hasValidParams = true; hasValidParams = true; Annotation[] anns = p.getAnnotations(); if (anns != null && anns.length > 0) { for (Annotation a : anns) {
public static void injectFields(final Object object, ClassMetadata metadata, RuntimeContext runtimeContext) throws IOException, PrivilegedActionException { logger.trace("entry {} {} {}", new Object[]{object, metadata, runtimeContext}); List<Injectable> injectableFields = metadata.getInjectableFields(); logger.trace("injectableFields are {}", injectableFields); for (Injectable injectableData : injectableFields) { Object value = injectableData.getValue(runtimeContext); Member member = injectableData.getMember(); logger.trace("Processing value {} and member {}", value, member); if (member instanceof Field) { injectField(object, value, (Field)member); } else if (member instanceof Method) { invokeMethod(object, value, (Method)member); } else { // should never get here throw new WebApplicationException(); } } logger.trace("exit"); }
/** * Instantiates a list of formal parameters into an Object array * * @param runtimeContext * @param formalParameters * @return * @throws IOException */ public Object[] instantiate(List<Injectable> formalParameters, RuntimeContext runtimeContext) throws IOException { Object[] result = new Object[formalParameters.size()]; for (int pos = 0; pos < result.length; pos++) { Injectable fp = formalParameters.get(pos); result[pos] = fp.getValue(runtimeContext); } return result; }
private void mergeFormalParameterMetadata(MethodMetadata metadata, Method method) { logger.trace("mergeFormalParameterMetadata({})", new Object[] {metadata, method}); Type[] parameterTypes = method.getGenericParameterTypes(); List<Injectable> currentParameters = new ArrayList<Injectable>(metadata.getFormalParameters()); metadata.getFormalParameters().clear(); int i = 0; for (Injectable injectable : currentParameters) { Injectable fp = InjectableFactory.getInstance().create(parameterTypes[i], injectable.getAnnotations(), method, getMetadata().isEncoded() || metadata .isEncoded(), metadata.getDefaultValue()); metadata.getFormalParameters().add(fp); ++i; } logger.trace("mergeFormalParameterMetadata exit"); }
@Override protected final boolean isConstructorParameterValid(Injectable fp) { // This method is declared as final, since parseConstructors(), which // calls it, is invoked from the constructor return fp.getParamType() == Injectable.ParamType.CONTEXT; }
@Override protected final boolean isConstructorParameterValid(Injectable fp) { logger.trace("isConstructorParameterValid({}) entry", fp); // This method is declared as final, since parseConstructors(), which // calls it, is invoked from the constructor boolean ret = !(fp.getParamType() == Injectable.ParamType.ENTITY); if (logger.isTraceEnabled()) { logger.trace("isConstructorParameterValid() exit returning {}", ret); } return ret; }
@Override protected final Injectable parseAccessibleObject(AccessibleObject field, Type fieldType) { logger.trace("parseAccessibleObject({}, {})", field, fieldType); Injectable injectable = InjectableFactory.getInstance().create(fieldType, field.getAnnotations(), (Member)field, getMetadata().isEncoded(), null); logger.trace("Injectable is {}", injectable); if (injectable.getParamType() == Injectable.ParamType.ENTITY) { // EntityParam should be ignored for fields (see JSR-311 3.2) logger.trace("parseAccessibleObject() returning null"); return null; } logger.trace("parseAccessibleObject() returning {}", injectable); return injectable; }
private void buildQueryParams(MethodMetadata methodMetadata, QueryParameters xmlQueryVariables) { List<Injectable> formalParameters = methodMetadata.getFormalParameters(); for (Injectable var : formalParameters) { if (var.getParamType() == Injectable.ParamType.QUERY) { Parameter param = resourcesObjectFactory.createParameter(); param.setValue(((BoundInjectable)var).getName()); xmlQueryVariables.getParameter().add(param); } } }
private void buildMatrixParams(MethodMetadata methodMetadata, MatrixParameters params) { List<Injectable> formalParameters = methodMetadata.getFormalParameters(); for (Injectable var : formalParameters) { if (var.getParamType() == Injectable.ParamType.MATRIX) { Parameter param = resourcesObjectFactory.createParameter(); param.setValue(((BoundInjectable)var).getName()); params.getParameter().add(param); } } }
private void parseMethodParameters(Method method, MethodMetadata methodMetadata) { logger.trace("parseMethodParameters({}, {}), entry", method, methodMetadata); Annotation[][] parameterAnnotations = method.getParameterAnnotations(); Type[] paramTypes = getParamTypesFilterByXmlElementAnnotation(method); boolean entityParamExists = false; for (int pos = 0, limit = paramTypes.length; pos < limit; pos++) { Injectable fp = InjectableFactory.getInstance().create(paramTypes[pos], parameterAnnotations[pos], method, getMetadata().isEncoded() || methodMetadata .isEncoded(), methodMetadata.getDefaultValue()); if (fp.getParamType() == Injectable.ParamType.ENTITY) { if (entityParamExists) { // we are allowed to have only one entity parameter String methodName = method.getDeclaringClass().getName() + "." + method.getName(); //$NON-NLS-1$ throw new IllegalStateException(Messages .getMessage("resourceMethodMoreThanOneEntityParam", methodName)); //$NON-NLS-1$ } entityParamExists = true; } methodMetadata.getFormalParameters().add(fp); logger.trace("Adding formal parameter {}", fp); } logger.trace("parseMethodParameters(), exit"); }
if (metadata != null && metadata.getParamType() != ParamType.ENTITY) { throw new IllegalArgumentException("Parameter data is not for an entity."); if (injectables != null) { for (Injectable i : injectables) { if (ParamType.FORM.equals(i.getParamType())) { params.add(buildParam(i));
String.format("%s.%s", declaringClass.getName(), method.getName()); //$NON-NLS-1$ for (Injectable id : methodMetadata.getFormalParameters()) { if (id.getParamType() == Injectable.ParamType.ENTITY) { if (logger.isWarnEnabled()) { logger.warn(Messages
boolean isEntityParamFound = false; for (Injectable p : params) { if (ParamType.ENTITY.equals(p.getParamType())) { isEntityParamFound = true;
@Override protected final Injectable parseAccessibleObject(AccessibleObject field, Type fieldType) { Injectable injectable = InjectableFactory.getInstance().create(fieldType, field.getAnnotations(), (Member)field, getMetadata().isEncoded(), null); if (injectable.getParamType() == Injectable.ParamType.ENTITY) { // EntityParam should be ignored for fields (see JSR-311 3.2) return null; } return injectable; }
Param param = null; boolean isUnique = true; switch (p.getParamType()) { case QUERY: boolean isUnique = true; switch (p.getParamType()) { case QUERY: resourceParams.add(buildParam(p)); boolean isUnique = true; switch (p.getParamType()) { case QUERY: boolean isUnique = true; switch (p.getParamType()) { case QUERY: param = buildParam(p);