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); } }
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); } } }
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)); } }
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 void transformField(PlasticField field) { InjectContainer annotation = field.getAnnotation(InjectContainer.class); field.claim(annotation); ComputedValue<FieldConduit<Object>> provider = createFieldValueConduitProvider(field); field.setComputedConduit(provider); }
public boolean accept(PlasticField field) { return field.getTypeName().equals("boolean") && field.getName().equalsIgnoreCase(expectedName); } }).toList();
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 }
@Override public void transform(PlasticClass plasticClass, TransformationSupport support, MutableComponentModel model) { for (final PlasticField field : plasticClass .getFieldsWithAnnotation(PersistenceContext.class)) { final PersistenceContext annotation = field.getAnnotation(PersistenceContext.class); field.claim(annotation); field.setConduit(new ReadOnlyComponentFieldConduit(plasticClass.getClassName(), field.getName()) { @Override public Object get(Object instance, InstanceContext context) { return JpaInternalUtils.getEntityManager(entityManagerManager, annotation); } }); } } }
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; } }
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); }
@SuppressWarnings("unchecked") private void transform(PlasticClass transformation, PlasticField field, final boolean create) final Class fieldClass = componentClassCache.forName(field.getTypeName()); field.setConduit(new FieldConduit() final String expectedName = field.getName() + "Exists"; existsField.claim(this); final String fieldName = existsField.getName(); existsField.setConduit(new ReadOnlyComponentFieldConduit(className, fieldName)
/** * Defer creation of the delegate field unless actually needed. */ private PlasticField getDelegateField() { if (delegateField == null) delegateField = plasticClass.introduceField(PropertyConduitDelegate.class, "delegate").inject( sharedDelegate); return delegateField; } }
@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 int compare(PlasticField field1, PlasticField field2) { int index1 = field1.getAnnotation(PageActivationContext.class).index(); int index2 = field2.getAnnotation(PageActivationContext.class).index(); int compare = index1 < index2 ? -1 : (index1 > index2 ? 1 : 0); if (compare == 0) { compare = field1.getName().compareTo(field2.getName()); } return compare; } };
@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; }
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 convertFieldToSessionAccess(PlasticField field) { SessionAttribute annotation = field.getAnnotation(SessionAttribute.class); field.claim(annotation); String key = determineSessionKey(field, annotation.value()); field.setConduit(new SessionKeyConduit(key)); }
private PropertyAccessType toType(PlasticField field) { Property annotation = field.getAnnotation(Property.class); boolean read = annotation.read(); boolean write = annotation.write(); if (read && write) return PropertyAccessType.READ_WRITE; if (read) return PropertyAccessType.READ_ONLY; if (write) return PropertyAccessType.WRITE_ONLY; throw new IllegalArgumentException(String.format( "@Property annotation on %s.%s should have either read() or write() enabled.", field.getPlasticClass() .getClassName(), field.getName())); } }
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; }