protected DeclaredTypeFactory createDeclaredTypeFactory() { return new DeclaredTypeFactory(uriHelper); }
public JvmDeclaredType apply(Class<?> key) { if (log.isDebugEnabled()) log.debug("Hit:" + key.getCanonicalName()); return delegate.createType(key); } });
protected JvmEnumerationType createEnumerationType(Class<?> clazz) { JvmEnumerationType result = TypesFactory.eINSTANCE.createJvmEnumerationType(); result.internalSetIdentifier(clazz.getName()); result.setSimpleName(clazz.getSimpleName()); if (clazz.getDeclaringClass() == null && clazz.getPackage() != null) result.setPackageName(clazz.getPackage().getName()); setVisibility(clazz, result); setTypeModifiers(clazz, result); createNestedTypes(clazz, result); createMethods(clazz, result); createFields(clazz, result); createConstructors(clazz, result); setSuperTypes(clazz, result); createAnnotationValues(clazz, result); return result; }
protected JvmAnnotationType createAnnotationType(Class<?> clazz) { JvmAnnotationType result = TypesFactory.eINSTANCE.createJvmAnnotationType(); result.internalSetIdentifier(clazz.getName()); result.setSimpleName(clazz.getSimpleName()); if (clazz.getDeclaringClass() == null && clazz.getPackage() != null) result.setPackageName(clazz.getPackage().getName()); setVisibility(clazz, result); setTypeModifiers(clazz, result); createNestedTypes(clazz, result); createMethods(clazz, result); setSuperTypes(clazz, result); createAnnotationValues(clazz, result); return result; }
throw new IllegalStateException("Cannot create type for anonymous or synthetic classes"); if (clazz.isAnnotation()) return createAnnotationType(clazz); if (clazz.isEnum()) return createEnumerationType(clazz); setTypeModifiers(clazz, result); setVisibility(clazz, result); result.internalSetIdentifier(clazz.getName()); result.setSimpleName(clazz.getSimpleName()); createNestedTypes(clazz, result); createMethods(clazz, result); createConstructors(clazz, result); createFields(clazz, result); setSuperTypes(clazz, result); try { TypeVariable<?>[] typeParameters = clazz.getTypeParameters(); InternalEList<JvmTypeParameter> jvmTypeParameters = (InternalEList<JvmTypeParameter>)result.getTypeParameters(); for (TypeVariable<?> variable : typeParameters) { jvmTypeParameters.addUnique(createTypeParameter(variable, result)); logSignatureFormatError(clazz); } catch (MalformedParameterizedTypeException error) { logSignatureFormatError(clazz); createAnnotationValues(clazz, result);
genericParameterTypes = method.getGenericParameterTypes(); } catch (GenericSignatureFormatError error) { logSignatureFormatError(method.getDeclaringClass()); genericParameterTypes = method.getParameterTypes(); } catch (MalformedParameterizedTypeException error) { logSignatureFormatError(method.getDeclaringClass()); genericParameterTypes = method.getParameterTypes(); enhanceGenericDeclaration(result, method); enhanceExecutable(result, method, method.getName(), genericParameterTypes, method.getParameterAnnotations(), 0); result.setVarArgs(method.isVarArgs()); int modifiers = method.getModifiers(); returnType = method.getGenericReturnType(); } catch (GenericSignatureFormatError error) { logSignatureFormatError(method.getDeclaringClass()); returnType = method.getReturnType(); } catch (MalformedParameterizedTypeException error) { logSignatureFormatError(method.getDeclaringClass()); returnType = method.getReturnType(); result.setReturnType(createTypeReference(returnType)); Type[] exceptionTypes; try { exceptionTypes = method.getGenericExceptionTypes(); } catch (GenericSignatureFormatError error) { logSignatureFormatError(method.getDeclaringClass()); exceptionTypes = method.getExceptionTypes(); } catch (MalformedParameterizedTypeException error) {
protected JvmAnnotationValue createAnnotationValue(Object value, Class<?> type) { EStructuralFeature.Setting result = createAnnotationValue(type); @SuppressWarnings("unchecked") InternalEList<Object> values = (InternalEList<Object>)result; if (type.isPrimitive() || String.class == type) { values.addUnique(value); } else if (type == Class.class) { Class<?> referencedClass = (Class<?>) value; JvmTypeReference reference = createTypeReference(referencedClass); values.addUnique(reference); } else if (type.isAnnotation()) { Annotation nestedAnnotation = (Annotation) value; values.addUnique(createAnnotationReference(nestedAnnotation)); } else if (type.isEnum()) { Enum<?> e = (Enum<?>) value; JvmEnumerationLiteral proxy = createEnumLiteralProxy(e); values.addUnique(proxy); } return (JvmAnnotationValue)result.getEObject(); }
protected JvmFormalParameter createFormalParameter(Type parameterType, String paramName, JvmMember container, GenericDeclaration member, Annotation[] annotations) { JvmFormalParameter result = TypesFactory.eINSTANCE.createJvmFormalParameter(); result.setName(paramName); if (isLocal(parameterType, member)) { result.setParameterType(createLocalTypeReference(parameterType, (JvmTypeParameterDeclarator) container, member)); } else { result.setParameterType(createTypeReference(parameterType)); } if (annotations.length != 0) { InternalEList<JvmAnnotationReference> annotationsReferences = (InternalEList<JvmAnnotationReference>)result.getAnnotations(); for (Annotation annotation : annotations) { annotationsReferences.addUnique(createAnnotationReference(annotation)); } } return result; }
protected JvmAnnotationReference createAnnotationReference(Annotation annotation) { JvmAnnotationReference annotationReference = TypesFactory.eINSTANCE.createJvmAnnotationReference(); Class<? extends Annotation> type = annotation.annotationType(); annotationReference.setAnnotation(createAnnotationProxy(type)); Method[] declaredMethods = type.getDeclaredMethods(); if (declaredMethods.length > 0) { InternalEList<JvmAnnotationValue> values = (InternalEList<JvmAnnotationValue>)annotationReference.getValues(); for (Method method : declaredMethods) { try { Object value = method.invoke(annotation, EMPTY_ARRAY); Class<?> returnType = method.getReturnType(); if (returnType.isArray()) { JvmAnnotationValue annotationValue = createArrayAnnotationValue(value, returnType); values.addUnique(annotationValue); annotationValue.setOperation(createMethodProxy(method)); } else { JvmAnnotationValue annotationValue = createAnnotationValue(value, returnType); values.addUnique(annotationValue); annotationValue.setOperation(createMethodProxy(method)); } } catch (Exception e) { log.error(e.getMessage(), e); } } } return annotationReference; }
protected JvmField createField(Field field) { JvmField result; if (!field.isEnumConstant()) result = TypesFactory.eINSTANCE.createJvmField(); else result = TypesFactory.eINSTANCE.createJvmEnumerationLiteral(); String fieldName = field.getName(); result.internalSetIdentifier(field.getDeclaringClass().getName() + "." + fieldName); result.setSimpleName(fieldName); int modifiers = field.getModifiers(); result.setFinal(Modifier.isFinal(modifiers)); result.setStatic(Modifier.isStatic(modifiers)); result.setTransient(Modifier.isTransient(modifiers)); result.setVolatile(Modifier.isVolatile(modifiers)); setVisibility(result, modifiers); Type fieldType = null; try { fieldType = field.getGenericType(); } catch (GenericSignatureFormatError error) { logSignatureFormatError(field.getDeclaringClass()); fieldType = field.getType(); } catch (MalformedParameterizedTypeException error) { logSignatureFormatError(field.getDeclaringClass()); fieldType = field.getType(); } result.setType(createTypeReference(fieldType)); createAnnotationValues(field, result); return result; }
protected void createNestedTypes(Class<?> clazz, JvmDeclaredType result) { try { Class<?>[] declaredClasses = clazz.getDeclaredClasses(); if (declaredClasses.length != 0) { InternalEList<JvmMember> members = (InternalEList<JvmMember>)result.getMembers(); for (Class<?> declaredClass : declaredClasses) { if (!declaredClass.isAnonymousClass() && !declaredClass.isSynthetic()) { members.addUnique(createType(declaredClass)); } } } } catch(NoClassDefFoundError e) { logNoClassDefFoundError(e, clazz, "nested types"); } }
protected JvmTypeReference createTypeReference(Type type) { if (type instanceof GenericArrayType) { GenericArrayType arrayType = (GenericArrayType) type; Type componentType = arrayType.getGenericComponentType(); return createArrayTypeReference(componentType); } else if (type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; JvmParameterizedTypeReference result = TypesFactory.eINSTANCE.createJvmParameterizedTypeReference(); result.setType(createProxy(parameterizedType.getRawType())); Type[] actualTypeArguments = parameterizedType.getActualTypeArguments(); if (actualTypeArguments.length != 0) { InternalEList<JvmTypeReference> arguments = (InternalEList<JvmTypeReference>)result.getArguments(); for (Type actualTypeArgument : actualTypeArguments) { JvmTypeReference argument = createTypeArgument(actualTypeArgument); arguments.addUnique(argument); } } return result; } else if (type instanceof Class<?> && ((Class<?>) type).isArray()) { Class<?> arrayType = (Class<?>) type; Type componentType = arrayType.getComponentType(); return createArrayTypeReference(componentType); } else { JvmParameterizedTypeReference result = TypesFactory.eINSTANCE.createJvmParameterizedTypeReference(); result.setType(createProxy(type)); return result; } }
protected void createConstructors(Class<?> clazz, JvmDeclaredType result) { try { Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors(); if (declaredConstructors.length != 0) { InternalEList<JvmMember> members = (InternalEList<JvmMember>)result.getMembers(); for (Constructor<?> constructor : declaredConstructors) { if (!constructor.isSynthetic()) { members.addUnique(createConstructor(constructor)); } } } } catch (NoClassDefFoundError e) { logNoClassDefFoundError(e, clazz, "constructors"); } }
private void setDefaultValue(JvmOperation operation, Method method) { Object defaultValue = method.getDefaultValue(); if (defaultValue != null) { Class<?> returnType = method.getReturnType(); if (returnType.isArray()) { JvmAnnotationValue annotationValue = createArrayAnnotationValue(defaultValue, returnType); operation.setDefaultValue(annotationValue); annotationValue.setOperation(operation); } else { JvmAnnotationValue annotationValue = createAnnotationValue(defaultValue, returnType); operation.setDefaultValue(annotationValue); annotationValue.setOperation(operation); } } }
protected void createAnnotationValues(final AnnotatedElement annotated, final JvmAnnotationTarget result) { Annotation[] declaredAnnotations = annotated.getDeclaredAnnotations(); if (declaredAnnotations.length != 0) { InternalEList<JvmAnnotationReference> annotations = (InternalEList<JvmAnnotationReference>)result.getAnnotations(); for (Annotation annotation : declaredAnnotations) { annotations.addUnique(createAnnotationReference(annotation)); } } }
genericParameterTypes = constructor.getGenericParameterTypes(); } catch (GenericSignatureFormatError error) { logSignatureFormatError(declaringClass); genericParameterTypes = constructor.getParameterTypes(); } catch (MalformedParameterizedTypeException error) { logSignatureFormatError(declaringClass); genericParameterTypes = constructor.getParameterTypes(); enhanceGenericDeclaration(result, constructor); enhanceExecutable(result, constructor, declaringClass.getSimpleName(), genericParameterTypes, constructor.getParameterAnnotations(), offset); result.setVarArgs(constructor.isVarArgs()); exceptionTypes = constructor.getGenericExceptionTypes(); } catch (GenericSignatureFormatError error) { logSignatureFormatError(declaringClass); exceptionTypes = constructor.getExceptionTypes(); } catch (MalformedParameterizedTypeException error) { logSignatureFormatError(declaringClass); exceptionTypes = constructor.getExceptionTypes(); InternalEList<JvmTypeReference> exceptions = (InternalEList<JvmTypeReference>)result.getExceptions(); for (Type exceptionType : exceptionTypes) { exceptions.addUnique(createTypeReference(exceptionType)); createAnnotationValues(constructor, result); return result;
throw new IllegalArgumentException("type is not an array type: " + type.getCanonicalName()); Class<?> componentType = type.getComponentType(); EStructuralFeature.Setting result = createAnnotationValue(componentType); int length = Array.getLength(value); if (length > 0) { for (int i = 0; i < length; i++) { Class<?> referencedClass = (Class<?>) Array.get(value, i); values.addUnique(createTypeReference(referencedClass)); values.addUnique(createAnnotationReference(nestedAnnotation)); values.addUnique(createEnumLiteralProxy(e));
private JvmDeclaredType load(BinaryClass key) { if (log.isDebugEnabled()) log.debug("Hit:" + key.getName()); return delegate.createType(key); }
protected ITypeFactory<BinaryClass, JvmDeclaredType> createDeclaredTypeFactory(ClassFileBytesAccess readerAccess, ClassLoader classLoader) { return new DeclaredTypeFactory(readerAccess, classLoader); }
@Override public JvmDeclaredType createType(Class<?> clazz) { try { JvmDeclaredType cachedResult = typeCache.get(clazz); // the cached result contains proxies and is not // contained in a resource set. clone it since the // client of #createClass will usually put the result // into a resource and perform proxy resolution afterwards // in the context of a single resource set. return EcoreUtil2.cloneWithProxies(cachedResult); } catch (Exception e) { if (log.isDebugEnabled()) { log.debug(e.getMessage(), e); } return delegate.createType(clazz); } }