Refine search
@Override public ContextualStatementBuilder call(final Statement instance, final HasAnnotations annotated, final BuildMetaClass factory, final Statement... params) { final MetaField field = (MetaField) annotated; if (field.isPublic()) { if (field.isStatic()) { return loadStatic(field.getDeclaringClass(), field.getName()); } else { return nestedCall(instance).loadField(field); } } else { final Object[] accessorParams = (field.isStatic() ? new Object[0] : new Object[] { instance }); return invokeStatic(notNull(factory), getPrivateFieldAccessorName(field), accessorParams); } } },
private Set<Class<?>> extractValidatableBeans(final Set<MetaClass> beans, final GeneratorContext context) { final Set<Class<?>> allBeans = new HashSet<Class<?>>(); for (final MetaClass bean : beans) { allBeans.add(bean.asClass()); } for (final MetaField field : ClassScanner.getFieldsAnnotatedWith(Valid.class, null, context)) { allBeans.add(field.getDeclaringClass().asClass()); allBeans.add(field.getType().asClass()); } for (final MetaMethod method : ClassScanner.getMethodsAnnotatedWith(Valid.class, null, context)) { allBeans.add(method.getDeclaringClass().asClass()); allBeans.add(method.getReturnType().asClass()); } return allBeans; }
@Override public final List<MetaField> getFieldsAnnotatedWith(final Class<? extends Annotation> annotation) { final List<MetaField> fields = new ArrayList<>(); MetaClass scanTarget = this; while (scanTarget != null) { for (final MetaField m : scanTarget.getDeclaredFields()) { if (m.isAnnotationPresent(annotation)) { fields.add(m); } } scanTarget = scanTarget.getSuperClass(); } return Collections.unmodifiableList(fields); }
public static boolean equals(final MetaField a, final MetaField b) { return a.getName().equals(b.getName()) && !a.getType().equals(b.getType()) && !a.getDeclaringClass().equals(b.getDeclaringClass()); }
public static String fieldAccess(final MetaField field) { if (field.isStatic()) { return "@" + field.getDeclaringClass().getFullyQualifiedName().replace('$', '.') + "::" + field.getName(); } else { return "instance.@" + field.getDeclaringClass().getFullyQualifiedName().replace('$', '.') + "::" + field.getName(); } }
/** * Returns a string that uniquely identifies this field for purposes of * comparison with other implementations of {@link MetaField}. The returned * string includes the declaring class name, the field name, and the field's * type. * * @return */ public String hashString() { if (_hashString != null) return _hashString; return _hashString = MetaField.class.getName() + ":" + getDeclaringClass().getFullyQualifiedName() + "." + getName() + "::" + getType().getFullyQualifiedName(); }
final MetaClass arrayType = toMap.asArrayOf(1); classStructureBuilder.privateField("EMPTY_ARRAY", arrayType).initializesWith(Stmt.newArray(toMap, 0)).finish(); .append(Stmt.loadClassMember("EMPTY_ARRAY").returnValue()) .finish(); Parameter.of(EJValue.class, "a0"), Parameter.of(MarshallingSession.class, "a1")); builder.append(Stmt.loadVariable("this").invoke("lazyInit")); if (toMap.isEnum()) { final MetaClass type = mapping.getType().asBoxed(); if (field.isPublic()) { BlockBuilder<CaseBlockBuilder> caseBlock = switchBlock.case_(memberMapping.getKey()); caseBlock.append(loadVariable("entity").loadField(field.getName()).assignValue(val)) field.getDeclaringClass(), "set" + field.getName(), field.getType()); if (setterMeth != null && !setterMeth.isPrivate()) { else if (field.getType().getCanonicalName().equals("long")) { throw new RuntimeException("cannot support private field marshalling of long type" + " (not supported by JSNI) for field: " + field.getDeclaringClass().getFullyQualifiedName() + "#" + field.getName());
for (final MetaField field : c.getDeclaredFields()) { if (field.isTransient() || field.isStatic()) { continue; final Field fld = field.asField(); fld.setAccessible(true); if (writeKeys.contains(field.getName()) && readKeys.contains(field.getName())) { continue; final MetaClass type = field.getType().getErased(); final MetaClass compType = type.isArray() ? type.getOuterComponentType().asBoxed() : type.asBoxed(); if (!(compType.isAbstract() || compType.isInterface() || compType.isEnum()) && !definitionsFactory.isExposedClass(compType)) { throw new InvalidMappingException("portable entity " + toMap.getFullyQualifiedName() + " contains a field (" + field.getName() + ") that is not known to the marshaller framework: " + compType.getFullyQualifiedName()); if (writeKeys.contains(field.getName()) && !readKeys.contains(field.getName())) { final MetaMethod getterMethod = MarshallingGenUtil.findGetterMethod(toMap, field.getName()); definition.addMemberMapping(new ReadMapping(field.getName(), field.getType(), getterMethod.getName())); continue; private MetaClass type = (field.getType().isArray() ? field.getType() : field.getType()); private final MetaClass targetType = type.getErased().asBoxed();
private static BuildMetaClass cloneToBuildMetaClass(final MetaClass clazz, final MetaParameterizedType parameterizedType, final boolean reifyRecursively) { final BuildMetaClass buildMetaClass = new BuildMetaClass(null, clazz.getFullyQualifiedName()); buildMetaClass.setAbstract(clazz.isAbstract()); buildMetaClass.setFinal(clazz.isFinal()); buildMetaClass.setStatic(clazz.isStatic()); buildMetaClass.setInterface(clazz.isInterface()); for (final MetaField field : clazz.getDeclaredFields()) { final BuildMetaField bmf = new ShadowBuildMetaField(buildMetaClass, EmptyStatement.INSTANCE, GenUtil.scopeOf(field), field.getType(), field.getName(), field); bmf.setFinal(field.isFinal()); bmf.setStatic(field.isStatic()); bmf.setVolatile(field.isVolatile()); bmf.setTransient(field.isTransient()); for (final MetaMethod method : clazz.getDeclaredMethods()) { MetaClass returnType = method.getReturnType(); if (method.getGenericReturnType() instanceof MetaTypeVariable) { final MetaTypeVariable typeVariable = (MetaTypeVariable) method.getGenericReturnType(); final MetaClass tVarVal = getTypeVariableValue(typeVariable, buildMetaClass); if (tVarVal != null) {
method.append(Stmt.declareFinalVariable("pageState", Map.class, new HashMap<String, Object>())); for (MetaField field : pageClass.getFieldsAnnotatedWith(PageState.class)) { PageState psAnno = field.getAnnotation(PageState.class); String fieldName = field.getName(); String queryParamName = psAnno.value(); if (queryParamName == null || queryParamName.trim().isEmpty()) { MetaClass erasedFieldType = field.getType().getErased(); if (erasedFieldType.isAssignableTo(Collection.class)) { MetaClass elementType = MarshallingGenUtil.getConcreteCollectionElementType(field.getType()); if (elementType == null) { throw new UnsupportedOperationException( method.append(Stmt.declareVariable(fieldName, Stmt.newObject(HashSet.class)));
final String fieldName = metaField.getName(); final String defaultName = metaField.getDeclaringClass().getFullyQualifiedName() + "." + fieldName; if (!metaField.getType().isAssignableFrom(String.class)) { throw new GenerationException("Translation key fields must be of type java.lang.String: " + defaultName); final Class<?> asClass = metaField.getDeclaringClass().asClass(); final Field field = asClass.getField(fieldName); final Object fieldVal = field.get(null); final TranslationKey annotation = metaField.getAnnotation(TranslationKey.class); final String defaultValue = annotation.defaultValue(); if (defaultValue != null) { ctor.append(Stmt.loadVariable("this").invoke("registerTranslation", name, value, null)); ctor.append(Stmt.declareVariable(messageBundleResourceInterface).named(msgBundleVarName) .initializeWith(Stmt.invokeStatic(GWT.class, "create", messageBundleResourceInterface)));
@Override public void createReadableField(final MetaClass type, final ClassStructureBuilder<?> classBuilder, final MetaField field, final Modifier[] modifiers) { final String cachedField = initCachedField(classBuilder, field); final String getterName = getReflectionFieldGetterName(field); final MethodCommentBuilder<? extends ClassStructureBuilder<?>> methodBuilder = classBuilder.privateMethod(field.getType().getErased(), PrivateAccessUtil.getPrivateFieldAccessorName(field)); if (!field.isStatic()) { methodBuilder.parameters( DefParameters.fromParameters( Parameter.of(field.getDeclaringClass().getErased(), "instance") ) ); } methodBuilder.modifiers(modifiers) .body() ._(Stmt.try_() ._(Stmt.nestedCall(Cast.to(field.getType().getErased(), Stmt.loadVariable(cachedField) .invoke(getterName, field.isStatic() ? null : Refs.get("instance")))).returnValue()) .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish(); }
@Test public void testFieldWithStringTypeParam() throws Exception { final MetaClass metaClass = getMetaClass(ClassWithGenericCollections.class); final MetaField field = metaClass.getDeclaredField("hasStringParam"); assertNotNull(field); assertEquals("Collection", field.getType().getName()); assertEquals("java.util.Collection", field.getType().getFullyQualifiedName()); assertEquals("<java.lang.String>", field.getType().getParameterizedType().toString()); assertEquals("java.util.Collection<java.lang.String>", field.getType().getFullyQualifiedNameWithTypeParms()); assertEquals("java.util.Collection", field.getType().getErased().getFullyQualifiedNameWithTypeParms()); assertEquals( Arrays.asList(getMetaClass(String.class)), Arrays.asList(field.getType().getParameterizedType().getTypeParameters())); }
public Statement valueAccessorFor(final MetaClassMember member, ClassStructureBuilder<?> classStructureBuilder) { if (member instanceof MetaField) { final MetaField field = (MetaField) member; if (!field.isPublic()) { final MetaMethod getterMethod = GenUtil.findCaseInsensitiveMatch(field.getType(), field.getDeclaringClass(), "get" + field.getName()); return loadVariable("a0").invoke(getterMethod); return Stmt.invokeStatic(classStructureBuilder.getClassDefinition(), PrivateAccessUtil .getPrivateFieldAccessorName(field), loadVariable("a0")); return loadVariable("a0").loadField(field.getName()); if (!method.isPublic()) { if (!context.isExposed(method, classStructureBuilder.getClassDefinition().getName())) { PrivateAccessUtil.addPrivateAccessStubs(gwtTarget ? "jsni" : "reflection", classStructureBuilder, method);
private List<Statement> fieldCreateInstanceStatements(final MetaField producingMember, final Injectable producerInjectable, final Injectable producedInjectable, final ClassStructureBuilder<?> bodyBlockBuilder) { final List<Statement> stmts = new ArrayList<>(); controller.ensureMemberExposed(producingMember); if (!producingMember.isStatic()) { final Statement producerInstanceValue = loadVariable("contextManager").invoke("getInstance", producerInjectable.getFactoryName()); stmts.add(declareVariable(PRODUCER_INSTANCE, producerInjectable.getInjectedType(), producerInstanceValue)); stmts.add(loadVariable(PRODUCER_INSTANCE).assignValue(Stmt.castTo(producerInjectable.getInjectedType(), invokeStatic(Factory.class, "maybeUnwrapProxy", loadVariable(PRODUCER_INSTANCE))))); } final Statement invocation = controller.exposedFieldStmt(loadVariable(PRODUCER_INSTANCE), producingMember); stmts.add(declareFinalVariable("instance", producedInjectable.getInjectedType(), invocation)); if (!producingMember.isStatic()) { stmts.add(setProducerInstanceReference()); if (producerInjectable.getWiringElementTypes().contains(WiringElementType.DependentBean)) { stmts.add(loadVariable("this").invoke("registerDependentScopedReference", loadVariable("instance"), loadVariable(PRODUCER_INSTANCE))); } } stmts.add(loadVariable("instance").returnValue()); return stmts; }
if (extendsBlock == null && (type.isAbstract() || type.isInterface() || type.isPrimitive())) throw new InvalidTypeException("Cannot instantiate type:" + type, blame); Arrays.stream(type.getDeclaredFields()) .forEach(field -> context1.addVariable(Variable.create(field.getName(), field.getType()))); buf.append(" {\n").append(extendsBlock.generate(context1)).append("\n}\n");
final MetaClass[] typeArgsClasses = getTypeArguments(field.getType()); final Annotation[] qualifiers = getQualifiers(field).toArray(new Annotation[0]); injectedValue = castTo(depInjectable.getInjectedType(), loadVariable("contextManager").invoke("getContextualInstance", loadLiteral(depInjectable.getFactoryName()), typeArgsClasses, qualifiers)); } else { injectedValue = castTo(depInjectable.getInjectedType(), final String fieldDepVarName = field.getDeclaringClassName().replace('.', '_').replace('$', '_') + "_" + field.getName(); createInstanceStatements.add(declareFinalVariable(fieldDepVarName, depInjectable.getInjectedType(), injectedValue)); if (!field.isPublic()) { controller.addExposedField(field); final String privateFieldInjectorName = getPrivateFieldAccessorName(field);
private void validateExistingRolesPresent(final Collection<MetaClass> pages, final Multimap<Class<?>, MetaClass> pageRoles) { for (final MetaClass page : pages) { for (final MetaField field : getAllFields(page)) { if (field.getType().getErased().equals(MetaClassFactory.get(TransitionToRole.class))) { final MetaType uniquePageRole = field.getType().getParameterizedType().getTypeParameters()[0]; try { getPageWithRole(uniquePageRole, pageRoles); } catch (IllegalStateException e) { // give a more descriptive error message. throw new GenerationException("No @Page with the UniquePageRole " + uniquePageRole.getName() + " exists to satisfy TransitionToRole<" + uniquePageRole.getName() + "> in " + page.getFullyQualifiedName() + "." + "\nThere must be exactly 1 @Page with this role.", e); } } } } }
dataModelType = (MetaClass) mp.getType().getParameterizedType().getTypeParameters()[0]; dataBinderRef = getAccessStatementForAutoBoundDataBinder(decorable, controller); final MetaField field = (MetaField) allAnnotated.iterator().next(); assertTypeIsDataBinder(field.getType()); dataModelType = (MetaClass) field.getType().getParameterizedType().getTypeParameters()[0]; dataBinderRef = DecorableType.FIELD.getAccessStatement(field, decorable.getFactoryMetaClass()); if (!field.isPublic()) { controller.addExposedField(field); for (final MetaField field : enclosingType.getFields()) { if (field.isAnnotationPresent(AutoBound.class)) { assertTypeIsDataBinder(field.getType()); dataModelType = (MetaClass) field.getType().getParameterizedType().getTypeParameters()[0]; dataBinderRef = invokeStatic(decorable.getInjectionContext().getProcessingContext().getBootstrapClass(), PrivateAccessUtil.getPrivateFieldAccessorName(field), Variable.get("instance"));
private void validateAssignableTypes(final HasAnnotations annotated, final Class<?>[] beanTypes, final List<String> problems) { MetaClass actualRawType; if (annotated instanceof MetaClass) { actualRawType = ((MetaClass) annotated).getErased(); } else if (annotated instanceof MetaField) { actualRawType = ((MetaField) annotated).getType().getErased(); } else if (annotated instanceof MetaMethod) { actualRawType = ((MetaMethod) annotated).getReturnType().getErased(); } else { throw new IllegalArgumentException("Unrecognized element kind annotated with @Typed: " + annotated); } final Set<String> assignableTypeNames = actualRawType .getAllSuperTypesAndInterfaces() .stream() .map(type -> type.getFullyQualifiedName()) .collect(Collectors.toSet()); final Optional<String> unassignableTypes = Arrays .stream(beanTypes) .map(Class::getName) .filter(name -> !assignableTypeNames.contains(name)) .reduce((s1, s2) -> s1 + "\n" + s2); unassignableTypes.ifPresent(typeNameString -> problems.add( String.format("The @Typed declaration on [%s] contained the following types not assignable to [%s]:\n%s", annotated, actualRawType, typeNameString))); }