Groovy example source code file (VetoableASTTransformation.java)
The Groovy VetoableASTTransformation.java source code/*
* Copyright 2008-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package groovy.beans;
import org.codehaus.groovy.ast.*;
import org.codehaus.groovy.ast.expr.*;
import org.codehaus.groovy.ast.stmt.BlockStatement;
import org.codehaus.groovy.ast.stmt.ExpressionStatement;
import org.codehaus.groovy.ast.stmt.ReturnStatement;
import org.codehaus.groovy.ast.stmt.Statement;
import org.codehaus.groovy.control.CompilePhase;
import org.codehaus.groovy.control.SourceUnit;
import org.codehaus.groovy.control.messages.SimpleMessage;
import org.codehaus.groovy.control.messages.SyntaxErrorMessage;
import org.codehaus.groovy.runtime.MetaClassHelper;
import org.codehaus.groovy.syntax.SyntaxException;
import org.codehaus.groovy.syntax.Token;
import org.codehaus.groovy.syntax.Types;
import org.codehaus.groovy.transform.GroovyASTTransformation;
import org.objectweb.asm.Opcodes;
import java.beans.PropertyVetoException;
import java.beans.VetoableChangeListener;
import java.beans.VetoableChangeSupport;
/**
* Handles generation of code for the {@code @Vetoable} annotation, and {@code @Bindable}
* if also present.
* <p/>
* Generally, it adds (if needed) a VetoableChangeSupport field and
* the needed add/removeVetoableChangeListener methods to support the
* listeners.
* <p/>
* It also generates the setter and wires the setter through the
* VetoableChangeSupport.
* <p/>
* If a {@link Bindable} annotation is detected it also adds support similar
* to what {@link BindableASTTransformation} would do.
*
* @author Danno Ferrin (shemnon)
* @author Chris Reeves
*/
@GroovyASTTransformation(phase = CompilePhase.CANONICALIZATION)
public class VetoableASTTransformation extends BindableASTTransformation {
protected static ClassNode constrainedClassNode = ClassHelper.make(Vetoable.class);
protected ClassNode vcsClassNode = ClassHelper.make(VetoableChangeSupport.class);
/**
* Convenience method to see if an annotated node is {@code @Vetoable}.
*
* @param node the node to check
* @return true if the node is constrained
*/
public static boolean hasVetoableAnnotation(AnnotatedNode node) {
for (AnnotationNode annotation : node.getAnnotations()) {
if (constrainedClassNode.equals(annotation.getClassNode())) {
return true;
}
}
return false;
}
/**
* 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, node, (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()),
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()),
source));
} else {
createListenerSetter(source, node, 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()),
source));
}
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);
}
}
}
/**
* Wrap an existing setter.
*/
private void wrapSetterMethod(ClassNode classNode, boolean bindable, String propertyName) {
String getterName = "get" + MetaClassHelper.capitalize(propertyName);
MethodNode setter = classNode.getSetterMethod("set" + MetaClassHelper.capitalize(propertyName));
if (setter != null) {
// Get the existing code block
Statement code = setter.getCode();
VariableExpression oldValue = new VariableExpression("$oldValue");
VariableExpression newValue = new VariableExpression("$newValue");
VariableExpression proposedValue = new VariableExpression(setter.getParameters()[0].getName());
BlockStatement block = new BlockStatement();
// create a local variable to hold the old value from the getter
block.addStatement(new ExpressionStatement(
new DeclarationExpression(oldValue,
Token.newSymbol(Types.EQUALS, 0, 0),
new MethodCallExpression(VariableExpression.THIS_EXPRESSION, getterName, ArgumentListExpression.EMPTY_ARGUMENTS))));
// add the fireVetoableChange method call
block.addStatement(new ExpressionStatement(new MethodCallExpression(
VariableExpression.THIS_EXPRESSION,
"fireVetoableChange",
new ArgumentListExpression(
new Expression[]{
new ConstantExpression(propertyName),
oldValue,
proposedValue}))));
// call the existing block, which will presumably set the value properly
block.addStatement(code);
if (bindable) {
// get the new value to emit in the event
block.addStatement(new ExpressionStatement(
new DeclarationExpression(newValue,
Token.newSymbol(Types.EQUALS, 0, 0),
new MethodCallExpression(VariableExpression.THIS_EXPRESSION, getterName, ArgumentListExpression.EMPTY_ARGUMENTS))));
// add the firePropertyChange method call
block.addStatement(new ExpressionStatement(new MethodCallExpression(
VariableExpression.THIS_EXPRESSION,
"firePropertyChange",
new ArgumentListExpression(
new Expression[]{
new ConstantExpression(propertyName),
oldValue,
newValue}))));
}
// replace the existing code block with our new one
setter.setCode(block);
}
}
private void createListenerSetter(SourceUnit source, AnnotationNode node, 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 = new FieldExpression(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>(
Other Groovy examples (source code examples)Here is a short list of links related to this Groovy VetoableASTTransformation.java source code file: |
The search page
Other Groovy source code examples at this package level
Click here to learn more about this project
