public String getBeanName() { return qualifier.getName(); }
private static boolean qualifiersMatch(final InjectableReference injectableReference, final HasInjectableHandle candidate) { return injectableReference.qualifier.isSatisfiedBy(candidate.getQualifier()); }
default Stream<Annotation> stream() { return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator(), 0), false); }
protected void implementConstructor(final ClassStructureBuilder<?> bodyBlockBuilder, final Injectable injectable) { final Statement newObject = generateFactoryHandleStatement(injectable); final ConstructorBlockBuilder<?> con = bodyBlockBuilder.publicConstructor(); con.callSuper(newObject); con.append(loadVariable("handle").invoke("setAssignableTypes", getAssignableTypesArrayStmt(injectable))); final org.jboss.errai.ioc.rebind.ioc.graph.api.Qualifier qualifier = injectable.getQualifier(); if (!qualifier.isDefaultQualifier()) { final AbstractStatementBuilder qualArray = getAnnotationArrayStmt(qualifier); con.append(loadVariable("handle").invoke("setQualifiers", qualArray)); } con.finish(); }
public static AbstractStatementBuilder getAnnotationArrayStmt(final org.jboss.errai.ioc.rebind.ioc.graph.api.Qualifier qualifier) { return newArray(Annotation.class).initialize(qualifier.stream().map(AbstractBodyGenerator::annotationLiteral).toArray()); }
public String generateFor(final MetaClass type, final Qualifier qualifier, final InjectableType injectableType) { final String typeName = qualifiedClassNameToIdentifier(type); final String qualNames = qualifier.getIdentifierSafeString(); String factoryName; if (SHORT_NAMES) { factoryName = injectableType + "_factory__" + shorten(typeName) + "__quals__" + shorten(qualNames); } else { factoryName = injectableType + "_factory_for__" + typeName + "__with_qualifiers__" + qualNames; } final int collisions = allFactoryNames.count(factoryName); allFactoryNames.add(factoryName); if (collisions > 0) { factoryName = factoryName + "_" + String.valueOf(collisions); } return factoryName; }
private Statement generateFactoryHandle(final Injectable injectable, @SuppressWarnings("rawtypes") final BlockBuilder curMethod) { final String handleVarName = "handleFor" + injectable.getFactoryName(); curMethod.append(declareFinalVariable(handleVarName, FactoryHandleImpl.class, ObjectBuilder.newInstanceOf(FactoryHandleImpl.class) .withParameters(loadLiteral(injectable.getInjectedType()), loadLiteral(injectable.getFactoryName()), loadLiteral(injectable.getScope()), loadLiteral(false), loadLiteral(injectable.getBeanName()), loadLiteral(!injectable.isContextual())))); curMethod.append(loadVariable(handleVarName).invoke("setAssignableTypes", getAssignableTypesArrayStmt(injectable))); if (!injectable.getQualifier().isDefaultQualifier()) { curMethod.append(loadVariable(handleVarName).invoke("setQualifiers", getAnnotationArrayStmt(injectable.getQualifier()))); } return loadVariable(handleVarName); }
private static String createCycleMessage(final Set<Injectable> visiting, final Injectable injectable) { final StringBuilder builder = new StringBuilder(); boolean cycleStarted = false; boolean hasProducer = false; for (final Injectable visitingInjectable : visiting) { if (visitingInjectable.equals(injectable)) { cycleStarted = true; } if (cycleStarted) { builder.append("\t"); visitingInjectable.getQualifier().stream() .forEach(anno -> builder.append(anno.toString()).append(' ')); builder.append(visitingInjectable.getInjectedType().getFullyQualifiedName()) .append("\n"); if (visitingInjectable.getInjectableType().equals(InjectableType.Producer)) { hasProducer = true; } } } if (hasProducer) { builder.insert(0, "A cycle was found containing a producer and no other normal scoped types:\n"); } else { builder.insert(0, "A cycle of only pseudo-scoped beans was found:\n"); } return builder.toString(); } }
private Collection<MetaMethod> getMatchingMethods(final MetaClassMember member, final Collection<MetaMethod> disposesMethods) { final Collection<MetaMethod> matching = new ArrayList<>(); final Qualifier memberQual = qualFactory.forSource(member); final MetaClass producedType = getProducedType(member); for (final MetaMethod candidate : disposesMethods) { final MetaParameter disposesParam = candidate.getParametersAnnotatedWith(Disposes.class).iterator().next(); if (producedType.isAssignableTo(disposesParam.getType())) { final Qualifier paramQual = qualFactory.forSink(disposesParam); if (paramQual.isSatisfiedBy(memberQual)) { matching.add(candidate); } } } return matching; }
private Statement createJsTypeProviderFor(final Injectable injectable) { final MetaClass type = injectable.getInjectedType(); final AnonymousClassStructureBuilder jsTypeProvider = newInstanceOf(parameterizedAs(JsTypeProvider.class, typeParametersOf(type))).extend(); jsTypeProvider .publicOverridesMethod("getInstance") .append(Stmt.castTo(type, loadVariable("contextManager").invoke("getInstance", injectable.getFactoryName())) .returnValue()).finish() .publicOverridesMethod("getName") .append(Stmt.loadLiteral(getBeanName(injectable)).returnValue()) .finish() .publicOverridesMethod("getFactoryName") .append(Stmt.loadLiteral(injectable.getFactoryName()).returnValue()) .finish() .publicOverridesMethod("getQualifiers") .append(Stmt.nestedCall(Stmt.newObject(parameterizedAs(JsArray.class, typeParametersOf(String.class)), Stmt.loadLiteral(AnnotationSerializer.serialize(injectable.getQualifier().iterator())))).returnValue()) .finish(); return jsTypeProvider.finish(); }