/** * Claims each field with the {@link org.apache.tapestry5.annotations.Retain} , claiming it using the * annotation class (not the annotation instance, to avoid * instantiating the annotation) as the tag. */ public void transform(PlasticClass plasticClass, TransformationSupport support, MutableComponentModel model) { for (PlasticField field : plasticClass.getFieldsWithAnnotation(Retain.class)) { field.claim(Retain.class); } } }
public void run() { try { boolean success = injectionProvider.provideInjection(field, locator, model); if (success) { field.claim("@Inject"); } } catch (RuntimeException ex) { throw new RuntimeException(String.format("Error obtaining injected value for field %s.%s: %s", plasticClass.getClassName(), fieldName, ExceptionUtils.toMessage(ex)), ex); } } });
private void transformField(PlasticField field) { InjectContainer annotation = field.getAnnotation(InjectContainer.class); field.claim(annotation); ComputedValue<FieldConduit<Object>> provider = createFieldValueConduitProvider(field); field.setComputedConduit(provider); }
public void transform(PlasticClass plasticClass, TransformationSupport support, MutableComponentModel model) { for (PlasticField field : plasticClass.getFieldsWithAnnotation(SessionState.class)) { SessionState annotation = field.getAnnotation(SessionState.class); transform(plasticClass, field, annotation.create()); field.claim(annotation); } }
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)); }
@Override public void transform(PlasticClass plasticClass) { for (PlasticField f : plasticClass.getFieldsWithAnnotation(TestInject.class)) { if (f.getTypeName().equals(className)) { f.inject(fieldValue); f.claim(this); } } } }
@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); } }); } } }
@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); } }); } } }
private void makeFieldPersistent(PlasticField field, MutableComponentModel model) { Persist annotation = field.getAnnotation(Persist.class); field.claim(annotation); final String logicalFieldName = model.setFieldPersistenceStrategy(field.getName(), annotation.value()); final Object defaultValue = determineDefaultValueFromFieldType(field); ComputedValue<FieldConduit<Object>> computed = new ComputedValue<FieldConduit<Object>>() { public FieldConduit<Object> get(InstanceContext context) { InternalComponentResources resources = context.get(InternalComponentResources.class); return new PersistentFieldConduit(resources, logicalFieldName, defaultValue); } }; field.setComputedConduit(computed); }
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); } } }
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 transform(final String componentClassName, PlasticField field) { Environmental annotation = field.getAnnotation(Environmental.class); field.claim(annotation); final String fieldName = field.getName(); final Class fieldType = classCache.forName(field.getTypeName()); final boolean required = annotation.value(); ComputedValue<FieldConduit<Object>> provider = new ComputedValue<FieldConduit<Object>>() { public FieldConduit<Object> get(InstanceContext context) { return new EnvironmentalConduit(componentClassName, fieldName, fieldType, required); } public void set(Object instance, InstanceContext context, Object newValue) { throw new RuntimeException( String.format("Field %s of component %s is read only.", fieldName, componentClassName)); } }; 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 convertFieldIntoContainerBoundParameter(PlasticField field) { BindParameter annotation = field.getAnnotation(BindParameter.class); field.claim(annotation); final String[] possibleNames = annotation.value(); final String fieldTypeName = field.getTypeName(); final String fieldName = field.getName(); ComputedValue<FieldConduit<Object>> computedConduit = new ComputedValue<FieldConduit<Object>>() { public FieldConduit<Object> get(InstanceContext context) { ComponentResources resources = context.get(ComponentResources.class); try { return createConduit(resources, fieldTypeName, fieldName, possibleNames); } catch (Exception ex) { throw new TapestryException(String.format( "Failure binding parameter field '%s' of mixin %s (type %s): %s", fieldName, resources .getCompleteId(), resources.getComponentModel().getComponentClassName(), ExceptionUtils.toMessage(ex)), ex); } } }; field.setComputedConduit(computedConduit); }
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); }
existsField.claim(this);