private void generateReferenceInjectionMapping(AbstractReference definition, WebComponentType type, Map<String, Map<String, InjectionSite>> mappings) { Map<String, InjectionSite> mapping = mappings.get(definition.getName()); if (mapping == null) { mapping = new HashMap<String, InjectionSite>(); mappings.put(definition.getName(), mapping); } for (Map.Entry<String, Map<InjectionSite, Injectable>> entry : type.getInjectionSites().entrySet()) { for (Map.Entry<InjectionSite, Injectable> siteMap : entry.getValue().entrySet()) { if (siteMap.getValue().getName().equals(definition.getName())) { mapping.put(entry.getKey(), siteMap.getKey()); } } } ServiceContract contract = definition.getServiceContract(); String interfaceClass = contract.getQualifiedInterfaceName(); // inject the reference into the session context WebContextInjectionSite site = new WebContextInjectionSite(interfaceClass, SESSION_CONTEXT); mapping.put(SESSION_CONTEXT_SITE, site); // also inject the reference into the servlet context WebContextInjectionSite servletContextsite = new WebContextInjectionSite(interfaceClass, SERVLET_CONTEXT); mapping.put(SERVLET_CONTEXT_SITE, servletContextsite); }
public PhysicalSourceDefinition generateSource(LogicalReference reference, EffectivePolicy policy) throws GenerationException { URI uri = reference.getUri(); ServiceContract serviceContract = reference.getDefinition().getServiceContract(); String interfaceName = getInterfaceName(serviceContract); JavaSourceDefinition wireDefinition = new JavaSourceDefinition(); wireDefinition.setUri(uri); wireDefinition.setInjectable(new Injectable(InjectableType.REFERENCE, uri.getFragment())); wireDefinition.setInterfaceName(interfaceName); // assume for now that any wire from a JUnit component can be optimized wireDefinition.setOptimizable(true); if (reference.getDefinition().isKeyed()) { wireDefinition.setKeyed(true); DataType<?> type = reference.getDefinition().getKeyDataType(); String className = type.getPhysical().getName(); wireDefinition.setKeyClassName(className); } return wireDefinition; }
if (referenceDefinition.getAutowire() == Autowire.INHERITED) { reference.setAutowire(autowire); } else { autowire = referenceDefinition.getAutowire();
public PhysicalSourceDefinition generateSource(LogicalReference reference, EffectivePolicy policy) throws GenerationException { ServiceContract contract = reference.getLeafReference().getServiceContract(); if (!(contract instanceof JavaServiceContract)) { // Spring reference contracts are always defined by Java interfaces throw new GenerationException("Unexpected interface type for " + reference.getUri() + ": " + contract.getClass().getName()); } String interfaze = contract.getQualifiedInterfaceName(); URI uri = reference.getParent().getUri(); String referenceName = reference.getDefinition().getName(); return new SpringSourceDefinition(referenceName, interfaze, uri); }
public URI createCallbackUri(LogicalReference source) { LogicalComponent<?> component = source.getParent(); String name = source.getDefinition().getServiceContract().getCallbackContract().getInterfaceName(); return URI.create(component.getUri() + "#" + name); }
|| (componentReference.getAutowire() == Autowire.INHERITED && component.getAutowire() == Autowire.ON)) { AbstractReference referenceDefinition = logicalReference.getDefinition(); ServiceContract requiredContract = referenceDefinition.getServiceContract(); boolean resolved = resolveByType(component.getParent(), logicalReference, requiredContract); if (!resolved) { if (!targeted && logicalReference.getDefinition().isRequired() && !logicalReference.isConcreteBound()) { String referenceUri = logicalReference.getUri().toString(); ReferenceNotFound error = new ReferenceNotFound("Unable to resolve reference " + referenceUri, logicalReference);
/** * Returns true if the reference is not keyed, true if the reference is keyed and the target specifies a key, false if the reference is keyed and * the target does not specify a key. * * @param logicalReference the logical reference * @param target the target * @return true if the reference is not keyed, true if the reference is keyed and the target specifies a key, false if the reference is keyed and * the target does not specify a key */ private boolean validKey(LogicalReference logicalReference, LogicalComponent<?> target) { return !logicalReference.getDefinition().isKeyed() || target.getDefinition().getKey() != null || target.getDefinition().getComponentType().getKey() != null; } }
private boolean isBoundReinjection(LogicalReference logicalReference, boolean incremental) { Multiplicity multiplicity = logicalReference.getDefinition().getMultiplicity(); if (incremental && multiplicity == Multiplicity.ZERO_N || multiplicity == Multiplicity.ONE_N) { for (LogicalBinding<?> binding : logicalReference.getBindings()) { if (binding.getState() == LogicalState.NEW || binding.getState() == LogicalState.MARKED) { return true; } } } return false; }
for (BindingDefinition binding : definition.getBindings()) { if (binding instanceof SCABinding) { SCABinding scaBinding = (SCABinding) binding;
private void createReferences(ComponentDefinition<?> definition, LogicalComponent<?> component, ComponentType componentType) { for (AbstractReference reference : componentType.getReferences().values()) { String name = reference.getName(); URI referenceUri = component.getUri().resolve('#' + name); LogicalReference logicalReference = new LogicalReference(referenceUri, reference, component); // reference is configured in the component definition ComponentReference componentReference = definition.getReferences().get(name); if (componentReference != null) { logicalReference.addIntents(componentReference.getIntents()); for (BindingDefinition binding : componentReference.getBindings()) { LogicalBinding<BindingDefinition> logicalBinding = new LogicalBinding<BindingDefinition>(binding, logicalReference); logicalReference.addBinding(logicalBinding); } for (BindingDefinition binding : componentReference.getCallbackBindings()) { LogicalBinding<BindingDefinition> logicalBinding = new LogicalBinding<BindingDefinition>(binding, logicalReference); logicalReference.addCallbackBinding(logicalBinding); } } component.addReference(logicalReference); } }
/** * Merges the POJO component type into the web component type. * * @param webType the web component type to merge into * @param componentType the component type to merge * @param context the introspection context */ private void mergeComponentTypes(WebComponentType webType, InjectingComponentType componentType, IntrospectionContext context) { for (Map.Entry<String, ReferenceDefinition> entry : componentType.getReferences().entrySet()) { String name = entry.getKey(); AbstractReference reference = webType.getReferences().get(name); if (reference != null) { ServiceContract source = reference.getServiceContract(); ServiceContract target = entry.getValue().getServiceContract(); MatchResult result = matcher.isAssignableFrom(source, target, false); if (!result.isAssignable()) { // TODO display areas where it was not matching IncompatibleReferenceDefinitions failure = new IncompatibleReferenceDefinitions(name); context.addError(failure); } } else { webType.add(entry.getValue()); } } // apply all injection sites for (Map.Entry<InjectionSite, Injectable> entry : componentType.getInjectionSites().entrySet()) { webType.addMapping(componentType.getImplClass(), entry.getKey(), entry.getValue()); } }
/** * Validates a target key is present for keyed references. * * @param reference the reference * @param service the service * @param context the logical context */ private void validateKeyedReference(LogicalReference reference, LogicalService service, InstantiationContext context) { if (!reference.getDefinition().isKeyed()) { return; } LogicalComponent<?> parent = service.getParent(); if (parent.getDefinition().getKey() == null && parent.getDefinition().getComponentType().getKey() == null) { KeyNotFound error = new KeyNotFound(reference); context.addError(error); } }
private void resolveReferences(LogicalComponent<?> component, InstantiationContext context) { for (LogicalReference reference : component.getReferences()) { Multiplicity multiplicityValue = reference.getDefinition().getMultiplicity(); boolean refMultiplicity = multiplicityValue.equals(Multiplicity.ZERO_N) || multiplicityValue.equals(Multiplicity.ONE_N); if (refMultiplicity || !reference.isResolved()) { // Only resolve references that have not been resolved or ones that are multiplicities since the latter may be reinjected. // Explicitly set the reference to unresolved, since if it was a multiplicity it may have been previously resolved. reference.setResolved(false); resolve(reference, context); } } }
if (callbackContract != null) { URI callbackUri = generateCallbackUri(source, callbackContract, referenceDefinition.getName()); targetDefinition.setCallbackUri(callbackUri);
private boolean isWireReinjection(LogicalReference logicalReference, boolean incremental) { Multiplicity multiplicity = logicalReference.getDefinition().getMultiplicity(); if (incremental && multiplicity == Multiplicity.ZERO_N || multiplicity == Multiplicity.ONE_N) { for (LogicalWire wire : logicalReference.getWires()) { LogicalComponent<?> targetComponent = wire.getTarget().getLeafComponent(); // check the source and target sides since a target may have been added or removed if (wire.getState() == LogicalState.NEW || wire.getState() == LogicalState.MARKED || targetComponent.getState() == LogicalState.NEW || targetComponent.getState() == LogicalState.MARKED) { return true; } } } return false; }
if (callbackContract != null) { URI callbackUri = generateCallbackUri(source, callbackContract, referenceDefinition.getName()); targetDefinition.setCallbackUri(callbackUri);
Multiplicity multiplicity = reference.getDefinition().getMultiplicity(); switch (multiplicity) { case ONE_N:
URI callbackUri = generateCallbackUri(component, callbackContract, referenceDefinition.getName()); targetDefinition.setCallbackUri(callbackUri);
private void resolveReferences(LogicalComponent<?> component, InstantiationContext context) { LogicalCompositeComponent parent = component.getParent(); for (LogicalReference reference : component.getReferences()) { boolean scaTarget = isScaTarget(reference); if (scaTarget || reference.isConcreteBound()) { // reference is targeted using binding.sca or is explicitly bound so it should not be autowired continue; } Multiplicity multiplicityValue = reference.getDefinition().getMultiplicity(); boolean refMultiplicity = multiplicityValue.equals(Multiplicity.ZERO_N) || multiplicityValue.equals(Multiplicity.ONE_N); if (refMultiplicity || !reference.isResolved()) { // Only resolve references that have not been resolved or ones that are multiplicities since the latter may be reinjected. // Explicitly set the reference to unresolved, since if it was a multiplicity it may have been previously resolved. reference.setResolved(false); resolve(reference, parent, context); } } }
Multiplicity refMultiplicity = logicalReference.getDefinition().getMultiplicity(); boolean multiplicity = Multiplicity.ZERO_N.equals(refMultiplicity) || Multiplicity.ONE_N.equals(refMultiplicity); for (LogicalComponent<?> child : composite.getComponents()) {