public void write(Object owner, String propertyName, Object value) { DefaultPropertyWriter.INSTANCE.write(owner, propertyName, value); } }
public Object read(Object owner, String propertyName) { return DefaultPropertyReader.INSTANCE.read(owner, propertyName); }
public Object getSourceValue() { return propertyAccessor().read(bean, propertyName); }
private void createListenerSetter(SourceUnit source, boolean bindable, ClassNode declaringClass, PropertyNode propertyNode) { if (bindable && needsPropertyChangeSupport(declaringClass, source)) { addPropertyChangeSupport(declaringClass); } if (needsVetoableChangeSupport(declaringClass, source)) { addVetoableChangeSupport(declaringClass); } String setterName = "set" + MetaClassHelper.capitalize(propertyNode.getName()); if (declaringClass.getMethods(setterName).isEmpty()) { Expression fieldExpression = fieldX(propertyNode.getField()); BlockStatement setterBlock = new BlockStatement(); setterBlock.addStatement(createConstrainedStatement(propertyNode, fieldExpression)); if (bindable) { setterBlock.addStatement(createBindableStatement(propertyNode, fieldExpression)); } else { setterBlock.addStatement(createSetStatement(fieldExpression)); } // create method void <setter>(<type> fieldName) createSetterMethod(declaringClass, propertyNode, setterName, setterBlock); } else { wrapSetterMethod(declaringClass, bindable, propertyNode.getName()); } }
private void addListenerToClass(SourceUnit source, ClassNode classNode) { if (needsPropertyChangeSupport(classNode, source)) { addPropertyChangeSupport(classNode); } for (PropertyNode propertyNode : classNode.getProperties()) { FieldNode field = propertyNode.getField(); // look to see if per-field handlers will catch this one... if (hasBindableAnnotation(field) || ((field.getModifiers() & Opcodes.ACC_FINAL) != 0) || field.isStatic() || VetoableASTTransformation.hasVetoableAnnotation(field)) { // explicitly labeled properties are already handled, // don't transform final properties // don't transform static properties // VetoableASTTransformation will handle both @Bindable and @Vetoable continue; } createListenerSetter(classNode, propertyNode); } }
private void addListenerToClass(SourceUnit source, ClassNode classNode) { boolean bindable = BindableASTTransformation.hasBindableAnnotation(classNode); for (PropertyNode propertyNode : classNode.getProperties()) { if (!hasVetoableAnnotation(propertyNode.getField()) && !propertyNode.getField().isFinal() && !propertyNode.getField().isStatic()) { createListenerSetter(source, bindable || BindableASTTransformation.hasBindableAnnotation(propertyNode.getField()), classNode, propertyNode); } } }
private void createListenerSetter(ClassNode classNode, PropertyNode propertyNode) { String setterName = "set" + MetaClassHelper.capitalize(propertyNode.getName()); if (classNode.getMethods(setterName).isEmpty()) { Statement setterBlock = createBindableStatement(propertyNode, fieldX(propertyNode.getField())); // create method void <setter>(<type> fieldName) createSetterMethod(classNode, propertyNode, setterName, setterBlock); } else { wrapSetterMethod(classNode, propertyNode.getName()); } }
AnnotatedNode parent = (AnnotatedNode) nodes[1]; if (VetoableASTTransformation.hasVetoableAnnotation(parent)) { if (VetoableASTTransformation.hasVetoableAnnotation(parent.getDeclaringClass())) { addListenerToProperty(source, node, declaringClass, (FieldNode) parent); } else if (parent instanceof ClassNode) { addListenerToClass(source, (ClassNode) parent);
private void addListenerToProperty(SourceUnit source, AnnotationNode node, ClassNode declaringClass, FieldNode field) { String fieldName = field.getName(); for (PropertyNode propertyNode : declaringClass.getProperties()) { if (propertyNode.getName().equals(fieldName)) { if (field.isStatic()) { //noinspection ThrowableInstanceNeverThrown source.getErrorCollector().addErrorAndContinue(new SyntaxErrorMessage( new SyntaxException("@groovy.beans.Bindable cannot annotate a static property.", node.getLineNumber(), node.getColumnNumber(), node.getLastLineNumber(), node.getLastColumnNumber()), source)); } else { if (needsPropertyChangeSupport(declaringClass, source)) { addPropertyChangeSupport(declaringClass); } createListenerSetter(declaringClass, propertyNode); } return; } } //noinspection ThrowableInstanceNeverThrown source.getErrorCollector().addErrorAndContinue(new SyntaxErrorMessage( new SyntaxException("@groovy.beans.Bindable must be on a property, not a field. Try removing the private, protected, or public modifier.", node.getLineNumber(), node.getColumnNumber(), node.getLastLineNumber(), node.getLastColumnNumber()), source)); }
/** * Handles the bulk of the processing, mostly delegating to other methods. * * @param nodes the AST nodes * @param source the source unit for the nodes */ public void visit(ASTNode[] nodes, SourceUnit source) { if (!(nodes[0] instanceof AnnotationNode) || !(nodes[1] instanceof AnnotatedNode)) { throw new RuntimeException("Internal error: wrong types: $node.class / $parent.class"); } AnnotationNode node = (AnnotationNode) nodes[0]; if (nodes[1] instanceof ClassNode) { addListenerToClass(source, (ClassNode) nodes[1]); } else { if ((((FieldNode)nodes[1]).getModifiers() & Opcodes.ACC_FINAL) != 0) { source.getErrorCollector().addErrorAndContinue(new SyntaxErrorMessage( new SyntaxException("@groovy.beans.Vetoable cannot annotate a final property.", node.getLineNumber(), node.getColumnNumber(), node.getLastLineNumber(), node.getLastColumnNumber()), source)); } addListenerToProperty(source, node, (AnnotatedNode) nodes[1]); } }
private void addListenerToProperty(SourceUnit source, AnnotationNode node, AnnotatedNode parent) { ClassNode declaringClass = parent.getDeclaringClass(); FieldNode field = ((FieldNode) parent); String fieldName = field.getName(); for (PropertyNode propertyNode : declaringClass.getProperties()) { boolean bindable = BindableASTTransformation.hasBindableAnnotation(parent) || BindableASTTransformation.hasBindableAnnotation(parent.getDeclaringClass()); if (propertyNode.getName().equals(fieldName)) { if (field.isStatic()) { //noinspection ThrowableInstanceNeverThrown source.getErrorCollector().addErrorAndContinue(new SyntaxErrorMessage( new SyntaxException("@groovy.beans.Vetoable cannot annotate a static property.", node.getLineNumber(), node.getColumnNumber(), node.getLastLineNumber(), node.getLastColumnNumber()), source)); } else { createListenerSetter(source, bindable, declaringClass, propertyNode); } return; } } //noinspection ThrowableInstanceNeverThrown source.getErrorCollector().addErrorAndContinue(new SyntaxErrorMessage( new SyntaxException("@groovy.beans.Vetoable must be on a property, not a field. Try removing the private, protected, or public modifier.", node.getLineNumber(), node.getColumnNumber(), node.getLastLineNumber(), node.getLastColumnNumber()), source)); }
if (hasVetoableAnnotation(consideredClass)) return false; for (FieldNode field : consideredClass.getFields()) { if (hasVetoableAnnotation(field)) return false;
if (hasBindableAnnotation(consideredClass)) return false; for (FieldNode field : consideredClass.getFields()) { if (hasBindableAnnotation(field)) return false;
private void setBeanProperty(Object newValue) { try { propertyAccessor().write(bean, propertyName, newValue); } catch (InvokerInvocationException iie) { if (!(iie.getCause() instanceof PropertyVetoException)) { throw iie; } // ignore veto exceptions, just let the binding fail like a validation does } }
private void addListenerToClass(SourceUnit source, AnnotationNode node, ClassNode classNode) { boolean bindable = BindableASTTransformation.hasBindableAnnotation(classNode); for (PropertyNode propertyNode : (Collection<PropertyNode>) classNode.getProperties()) { if (!hasVetoableAnnotation(propertyNode.getField()) && !((propertyNode.getField().getModifiers() & Opcodes.ACC_FINAL) != 0) && !propertyNode.getField().isStatic()) { createListenerSetter(source, node, bindable || BindableASTTransformation.hasBindableAnnotation(propertyNode.getField()), classNode, propertyNode); } } }
public Object getSourceValue() { return propertyAccessor().read(bean, propertyName); }
public void write(Object owner, String propertyName, Object value) { DefaultPropertyWriter.INSTANCE.write(owner, propertyName, value); } }
public Object read(Object owner, String propertyName) { return DefaultPropertyReader.INSTANCE.read(owner, propertyName); }
private void addListenerToClass(SourceUnit source, AnnotationNode node, ClassNode classNode) { boolean bindable = BindableASTTransformation.hasBindableAnnotation(classNode); for (PropertyNode propertyNode : (Collection<PropertyNode>) classNode.getProperties()) { if (!hasVetoableAnnotation(propertyNode.getField()) && !((propertyNode.getField().getModifiers() & Opcodes.ACC_FINAL) != 0) && !propertyNode.getField().isStatic()) { createListenerSetter(source, node, bindable || BindableASTTransformation.hasBindableAnnotation(propertyNode.getField()), classNode, propertyNode); } } }
private void addListenerToClass(SourceUnit source, AnnotationNode node, ClassNode classNode) { boolean bindable = BindableASTTransformation.hasBindableAnnotation(classNode); for (PropertyNode propertyNode : classNode.getProperties()) { if (!hasVetoableAnnotation(propertyNode.getField()) && !((propertyNode.getField().getModifiers() & Opcodes.ACC_FINAL) != 0) && !propertyNode.getField().isStatic()) { createListenerSetter(source, node, bindable || BindableASTTransformation.hasBindableAnnotation(propertyNode.getField()), classNode, propertyNode); } } }