public static boolean canHandle(PlasticField field) { return field.getAnnotation(Inject.class) != null && field.getAnnotation(Symbol.class) == null && field.getAnnotation(Value.class) == null; }
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) { return field.getAnnotation(annotationClass); } }, this.locator, false);
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) { return field.getAnnotation(annotationClass); } };
@Override public boolean provideInjection(PlasticField field, ObjectLocator locator, MutableComponentModel componentModel) { if (field.getAnnotation(Service.class) != null) { return false; } else { return super.provideInjection(field, locator, componentModel); } }
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; } };
public int compare(PlasticField o1, PlasticField o2) { boolean principal1 = o1.getAnnotation(Parameter.class).principal(); boolean principal2 = o2.getAnnotation(Parameter.class).principal(); if (principal1 == principal2) { return o1.getName().compareTo(o2.getName()); } return principal1 ? -1 : 1; } };
private void transformField(PlasticField field) { InjectContainer annotation = field.getAnnotation(InjectContainer.class); field.claim(annotation); ComputedValue<FieldConduit<Object>> provider = createFieldValueConduitProvider(field); field.setComputedConduit(provider); }
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) { 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 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); } }
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 convertFieldToSessionAccess(PlasticField field) { SessionAttribute annotation = field.getAnnotation(SessionAttribute.class); field.claim(annotation); String key = determineSessionKey(field, annotation.value()); field.setConduit(new SessionKeyConduit(key)); }
private void addMixinTypes(PlasticField field, MutableEmbeddedComponentModel model) { Mixins annotation = field.getAnnotation(Mixins.class); if (annotation == null) return; for (String typeName : annotation.value()) { Orderable<String> typeAndOrder = TapestryInternalUtils.mixinTypeAndOrder(typeName); String mixinClassName = resolver.resolveMixinTypeToClassName(typeAndOrder.getTarget()); model.addMixin(mixinClassName, typeAndOrder.getConstraints()); } }
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); } } }
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); }