private ComputedValue<FieldConduit<Object>> createComputedFieldConduit(PlasticField field) { final String fieldType = field.getTypeName(); return new ComputedValue<FieldConduit<Object>>() { public FieldConduit<Object> get(InstanceContext context) { Object fieldDefaultValue = classCache.defaultValueForType(fieldType); InternalComponentResources resources = context.get(InternalComponentResources.class); return new UnclaimedFieldConduit(resources, perThreadManager.createValue(), fieldDefaultValue); } }; } }
public boolean provideInjection(PlasticField field, ObjectLocator locator, MutableComponentModel componentModel) { final ResourceProvider provider = configuration.get(field.getTypeName()); if (provider == null) { return false; } field.injectComputed(provider); return true; } }
private Object determineDefaultValueFromFieldType(PlasticField field) { return classCache.defaultValueForType(field.getTypeName()); } }
public boolean accept(PlasticField field) { return field.getTypeName().equals("boolean") && field.getName().equalsIgnoreCase(expectedName); } }).toList();
public boolean provideInjection(PlasticField field, ObjectLocator locator, MutableComponentModel componentModel) { Class fieldType = classCache.forName(field.getTypeName()); Object inject = this.locator.getService(fieldType); assert inject != null; field.inject(inject); // If we make it this far without an exception, then we were successful // and should claim the field. return true; }
@Override public void doBuild(InstructionBuilder builder) { // Load the field builder.loadThis().getField(field); builder.loadArguments(); invokeDelegateAndReturnResult(builder, field.getTypeName()); } });
@Override public void doBuild(InstructionBuilder builder) { // Load the field builder.loadThis().getField(field); builder.loadArguments(); invokeDelegateAndReturnResult(builder, field.getTypeName()); } });
public boolean provideInjection(PlasticField field, ObjectLocator locator, MutableComponentModel componentModel) { if (!field.getTypeName().equals(BLOCK_TYPE_NAME)) { return false; } Id annotation = field.getAnnotation(Id.class); String blockId = getBlockId(field.getName(), annotation); FieldConduit<Object> conduit = createConduit(field, blockId); field.setConduit(conduit); return true; // claim the field }
public boolean provideInjection(PlasticField field, ObjectLocator locator, MutableComponentModel componentModel) { if (!field.hasAnnotation(Named.class)) { return false; } Named annotation = field.getAnnotation(Named.class); Class fieldType = cache.forName(field.getTypeName()); Object service = this.locator.getService(annotation.value(), fieldType); field.inject(service); return true; } }
@Override public InstructionBuilder getField(PlasticField field) { check(); return getField(field.getPlasticClass().getClassName(), field.getName(), field.getTypeName()); }
@Override public InstructionBuilder getField(PlasticField field) { check(); return getField(field.getPlasticClass().getClassName(), field.getName(), field.getTypeName()); }
@Override public void transform(PlasticClass plasticClass) { for (PlasticField f : plasticClass.getFieldsWithAnnotation(TestInject.class)) { if (f.getTypeName().equals(className)) { f.inject(fieldValue); f.claim(this); } } } }
public void transform(PlasticClass plasticClass, TransformationSupport support, MutableComponentModel model) { for (PlasticField field : plasticClass.getFieldsWithAnnotation(InjectService.class)) { InjectService annotation = field.getAnnotation(InjectService.class); field.claim(annotation); Class fieldType = cache.forName(field.getTypeName()); Object service = locator.getService(annotation.value(), fieldType); field.inject(service); } } }
@SuppressWarnings({ "unchecked", "rawtypes" }) public boolean provideInjection(PlasticField field, ObjectLocator locator, MutableComponentModel componentModel) { if (canHandle(field)) { Service service = field.getAnnotation(Service.class); final String serviceId = service == null ? ObjectsForComponentsStore.NO_ID : service.value(); final Class fieldType = classCache.forName(field.getTypeName()); final Object valueInjectedByTapestry = findTapestrysInjectedValue(field, fieldType); field.setConduit(new FieldConduit() { public Object get(Object instance, InstanceContext context) { Object testDouble = objectStore.get(fieldType, serviceId); return testDouble == null ? valueInjectedByTapestry : testDouble; } public void set(Object instance, InstanceContext context, Object newValue) { throw new RuntimeException("Field is read-only"); } }); return true; } return false; }
public void transform(PlasticClass plasticClass, TransformationSupport support, MutableComponentModel model) { for (PlasticField field : plasticClass.getFieldsWithAnnotation(InjectComponent.class)) { InjectComponent annotation = field.getAnnotation(InjectComponent.class); field.claim(annotation); final String type = field.getTypeName(); final String componentId = getComponentId(field, annotation); final String fieldName = field.getName(); ComputedValue<FieldConduit<Object>> provider = new ComputedValue<FieldConduit<Object>>() { public FieldConduit<Object> get(InstanceContext context) { ComponentResources resources = context.get(ComponentResources.class); return new InjectedComponentFieldValueConduit(resources, fieldName, type, componentId); } }; field.setComputedConduit(provider); } }
private void replaceFieldWithMixin(MutableComponentModel model, PlasticField field) { Mixin annotation = field.getAnnotation(Mixin.class); field.claim(annotation); String mixinType = annotation.value(); String[] order = annotation.order(); String fieldType = field.getTypeName(); String mixinClassName = InternalUtils.isBlank(mixinType) ? fieldType : resolver .resolveMixinTypeToClassName(mixinType); model.addMixinClassName(mixinClassName, order); replaceFieldAccessWithMixin(field, mixinClassName); }
private void mapFieldToQueryParameter(PlasticField field, TransformationSupport support) { ActivationRequestParameter annotation = field.getAnnotation(ActivationRequestParameter.class); String parameterName = getParameterName(field, annotation); // Assumption: the field type is not one that's loaded by the component class loader, so it's safe // to convert to a hard type during class transformation. Class fieldType = classCache.forName(field.getTypeName()); ValueEncoder encoder = valueEncoderSource.getValueEncoder(fieldType); FieldHandle handle = field.getHandle(); String fieldName = String.format("%s.%s", field.getPlasticClass().getClassName(), field.getName()); setValueFromInitializeEventHandler(support, fieldName, annotation.required(), handle, parameterName, encoder, urlEncoder); decorateLinks(support, fieldName, handle, parameterName, encoder, urlEncoder); preallocateName(support, parameterName); }
private void addInjectedPage(PlasticField field) { InjectPage annotation = field.getAnnotation(InjectPage.class); field.claim(annotation); String pageName = annotation.value(); String fieldName = field.getName(); String injectedPageName = InternalUtils.isBlank(pageName) ? resolver .resolvePageClassNameToPageName(field.getTypeName()) : pageName; field.setConduit(new InjectedPageConduit(field.getPlasticClass().getClassName(), fieldName, injectedPageName)); } }
private void transformField(PlasticClass transformation, MutableComponentModel model, PlasticField field) { Component annotation = field.getAnnotation(Component.class); field.claim(annotation); String annotationId = annotation.id(); String fieldName = field.getName(); String id = InternalUtils.isNonBlank(annotationId) ? annotationId : InternalUtils.stripMemberName(fieldName); String type = field.getTypeName(); Location location = new StringLocation(String.format("%s.%s", transformation.getClassName(), fieldName), 0); MutableEmbeddedComponentModel embedded = model.addEmbeddedComponent(id, annotation.type(), type, annotation .inheritInformalParameters(), location); addParameters(embedded, annotation.parameters()); updateModelWithPublishedParameters(embedded, annotation); convertAccessToField(field, id); addMixinClasses(field, embedded); addMixinTypes(field, embedded); }
private void convertFieldIntoParameter(PlasticClass plasticClass, MutableComponentModel model, PlasticField field) { Parameter annotation = field.getAnnotation(Parameter.class); String fieldType = field.getTypeName(); String parameterName = getParameterName(field.getName(), annotation.name()); field.claim(annotation); model.addParameter(parameterName, annotation.required(), annotation.allowNull(), annotation.defaultPrefix(), annotation.cache()); MethodHandle defaultMethodHandle = findDefaultMethodHandle(plasticClass, parameterName); ComputedValue<FieldConduit<Object>> computedParameterConduit = createComputedParameterConduit(parameterName, fieldType, annotation, defaultMethodHandle); field.setComputedConduit(computedParameterConduit); }