public void process(Object instance) { configurationRepository.register(new ForMethodOnlyBeansDummyAttribute(instance)); if (instance instanceof ConfigurationTarget) process((ConfigurationTarget) instance, instance); else process(new SimpleNameConfigurationTarget(instance), instance); }
@Override public void afterConfiguration() { for (Configuration configuration : configurations) configuration.afterConfiguration(); }
void configure(Configuration configuration) { for (ConfigurationAttribute attribute : configuration) { updateAttribute(attribute); } }
@Override public void processField(Object target, Field field) { if (field.getType().isPrimitive()) throw new ConfiguredFieldsMustNotBePrimitiveAsDefaultDerivationIsImpossibleException(target, field); configuration.register(new ConfiguredField(parent, target, field, fieldTarget(field), deriveDefaultConfiguration(field))); }
@Override public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException { if (metadata.typeIsConfigured(bean.getClass())) { processor.process(bean); } return true; }
@Override public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException { if (typeIsConfigured(bean.getClass())) { ConfiguredConfiguration configuration = new ConfiguredConfiguration(bean); new Reflector() .forEachField(new ConfiguredFieldProcessor(configuration)) .process(bean); configurationRepository.register(configuration); } return true; }
@Override public void injectMembers(Object instance) { processor.process(instance); }
@Override public void resolve() { log.debug("starting resolution - pass 1"); for (Configuration configuration : configurations) resolveAttributes(configuration); log.debug("starting resolution - pass 2"); for (Configuration configuration : configurations) for (ConfigurationAttribute attribute : configuration) if (attribute.requiresResolution()) { log.debug("resolve second pass {}", attribute); resolver.resolve(attribute); attribute.applyCoercion(coercions); attribute.invertControl(container); } }
@Override public void update() { if (value != null) Fields.set(target, field, value); else if (defaultValue == null) throw new MissingConfigurationException(this, resolution); }
@Override public void register(ConfigurationAttribute attribute) { assert attribute != null; Configuration configuration = getConfiguration(attribute.getTarget()); if (attribute instanceof ForMethodOnlyBeansDummyAttribute) return; // FIXME need a new api method to just register the target without the attribute log.info("registering {} for {} on {}", new Object[] { attribute, attribute.getTarget(), configuration }); configuration.register(attribute); }
public ConfiguredFieldProcessor(ConfigurationRepository configuration, ConfiguredMetadata annotations, ConfigurationTarget parent2) { super(annotations.getConfiguredAnnotations()); this.configuration = configuration; this.defaultSeeds = annotations.getDefaultSeeds(); this.parent = parent2; }
private void resolveAttributes(Configuration configuration) { log.debug("resolve {}", configuration); try { for (ConfigurationAttribute attribute : configuration) { resolveAttribute(attribute); } } catch (ConcurrentModificationException e) { throw new TriedToInvertAnInvertedValue(configuration); } }
@Override public boolean canProcess(Method method) { if (!method.isAnnotationPresent(annotationClass)) return false; if (!Void.TYPE.equals(method.getReturnType())) throw new ReturnTypeMustBeVoidException(annotationClass, method); if (method.getParameterTypes().length > 0) throw new AnnotatedMethodsMustNotHaveParametersException(annotationClass, method); return true; }
@Override public void postConfigure() { for (Configuration configuration : configurations) configuration.postConfigure(); }
@Override public void beforeConfiguration() { for (Configuration configuration : configurations) configuration.beforeConfiguration(); }
@Override public void preConfigure() { for (Configuration configuration : configurations) configuration.preConfigure(); }
void updateAttribute(ConfigurationAttribute field) { field.update(); }
@Override public void beforeConfiguration() { new Reflector() .forEachMethod(new InvokingAnnotatedMethodProcessor(BeforeConfiguration.class)) .process(target); }
@Override public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException { if (metadata.typeIsConfigured(bean.getClass())) { processor.process(bean); } return true; }
@Override public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException { if (annotations.typeIsConfigured(bean.getClass())) { processor.process(bean); } return true; }