|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Expression | |
---|---|
groovy.beans | |
org.codehaus.groovy.antlr | Parser related classes. |
org.codehaus.groovy.ast | Groovy AST nodes for the syntax of the language |
org.codehaus.groovy.ast.expr | AST nodes for Groovy expressions |
org.codehaus.groovy.ast.stmt | AST nodes for Groovy statements |
org.codehaus.groovy.classgen | Generates Java classes for Groovy classes using ASM. |
org.codehaus.groovy.control | Compiler control classes. |
org.codehaus.groovy.tools.javac | Classes related to the joint compiler. |
org.codehaus.groovy.transform |
Uses of Expression in groovy.beans |
---|
Methods in groovy.beans with parameters of type Expression | |
---|---|
protected Statement |
BindableASTTransformation.createBindableStatement(PropertyNode propertyNode,
Expression fieldExpression)
Creates a statement body similar to: this.firePropertyChange("field", field, field = value) |
protected Statement |
VetoableASTTransformation.createConstrainedStatement(PropertyNode propertyNode,
Expression fieldExpression)
Creates a statement body silimar to: this.fireVetoableChange("field", field, field = value) |
protected Statement |
VetoableASTTransformation.createSetStatement(Expression fieldExpression)
Creates a statement body similar to: field = value
Used when the field is not also @Bindable |
Uses of Expression in org.codehaus.groovy.antlr |
---|
Methods in org.codehaus.groovy.antlr that return Expression | |
---|---|
protected Expression |
AntlrParserPlugin.arguments(antlr.collections.AST elist)
|
protected Expression |
AntlrParserPlugin.asExpression(antlr.collections.AST node)
|
protected Expression |
AntlrParserPlugin.binaryExpression(int type,
antlr.collections.AST node)
|
protected Expression |
AntlrParserPlugin.blockExpression(antlr.collections.AST node)
|
protected Expression |
AntlrParserPlugin.castExpression(antlr.collections.AST castNode)
|
protected Expression |
AntlrParserPlugin.constructorCallExpression(antlr.collections.AST node)
|
protected Expression |
AntlrParserPlugin.declarationExpression(antlr.collections.AST variableDef)
|
protected Expression |
AntlrParserPlugin.dotExpression(antlr.collections.AST node)
|
protected Expression |
AntlrParserPlugin.dynamicMemberExpression(antlr.collections.AST dynamicMemberNode)
|
protected Expression |
AntlrParserPlugin.expression(antlr.collections.AST node)
|
protected Expression |
AntlrParserPlugin.expression(antlr.collections.AST node,
boolean convertToConstant)
|
protected Expression |
AntlrParserPlugin.expressionList(antlr.collections.AST node)
|
protected Expression |
AntlrParserPlugin.expressionSwitch(antlr.collections.AST node)
|
protected Expression |
AntlrParserPlugin.gstring(antlr.collections.AST gstringNode)
|
protected Expression |
AntlrParserPlugin.indexExpression(antlr.collections.AST indexNode)
|
protected Expression |
AntlrParserPlugin.instanceofExpression(antlr.collections.AST node)
|
protected Expression |
AntlrParserPlugin.listExpression(antlr.collections.AST listNode)
|
protected Expression |
AntlrParserPlugin.literalExpression(antlr.collections.AST node,
java.lang.Object value)
|
protected Expression |
AntlrParserPlugin.mapExpression(antlr.collections.AST mapNode)
Typically only used for map constructors I think? |
protected Expression |
AntlrParserPlugin.methodCallExpression(antlr.collections.AST methodCallNode)
|
protected Expression |
AntlrParserPlugin.methodPointerExpression(antlr.collections.AST node)
|
protected Expression |
AntlrParserPlugin.postfixExpression(antlr.collections.AST node,
int token)
|
protected Expression |
AntlrParserPlugin.prefixExpression(antlr.collections.AST node,
int token)
|
protected Expression |
AntlrParserPlugin.rangeExpression(antlr.collections.AST rangeNode,
boolean inclusive)
|
protected Expression |
AntlrParserPlugin.specialConstructorCallExpression(antlr.collections.AST methodCallNode,
ClassNode special)
|
protected Expression |
AntlrParserPlugin.spreadExpression(antlr.collections.AST node)
|
protected Expression |
AntlrParserPlugin.spreadMapExpression(antlr.collections.AST node)
|
protected Expression |
AntlrParserPlugin.ternaryExpression(antlr.collections.AST ternaryNode)
|
protected Expression |
AntlrParserPlugin.unaryMinusExpression(antlr.collections.AST unaryMinusExpr)
|
protected Expression |
AntlrParserPlugin.unaryPlusExpression(antlr.collections.AST unaryPlusExpr)
|
protected Expression |
AntlrParserPlugin.variableExpression(antlr.collections.AST node)
|
Methods in org.codehaus.groovy.antlr with parameters of type Expression | |
---|---|
static void |
EnumHelper.addEnumConstant(ClassNode enumClass,
java.lang.String name,
Expression init)
|
Uses of Expression in org.codehaus.groovy.ast |
---|
Fields in org.codehaus.groovy.ast declared as Expression | |
---|---|
private Expression |
Parameter.defaultValue
|
private Expression |
FieldNode.initialValueExpression
|
Methods in org.codehaus.groovy.ast that return Expression | |
---|---|
Expression |
PropertyNode.getInitialExpression()
|
Expression |
FieldNode.getInitialExpression()
|
Expression |
Parameter.getInitialExpression()
|
Expression |
DynamicVariable.getInitialExpression()
|
Expression |
Variable.getInitialExpression()
expression used to initialize the variable or null of there is no initialization. |
Expression |
FieldNode.getInitialValueExpression()
|
Expression |
AnnotationNode.getMember(java.lang.String name)
|
Expression |
ClassCodeExpressionTransformer.transform(Expression exp)
|
Methods in org.codehaus.groovy.ast with parameters of type Expression | |
---|---|
FieldNode |
ClassNode.addField(java.lang.String name,
int modifiers,
ClassNode type,
Expression initialValue)
|
void |
AnnotationNode.addMember(java.lang.String name,
Expression value)
|
PropertyNode |
ClassNode.addProperty(java.lang.String name,
int modifiers,
ClassNode type,
Expression initialValueExpression,
Statement getterBlock,
Statement setterBlock)
|
boolean |
ClassNode.hasPossibleMethod(java.lang.String name,
Expression arguments)
Returns true if the given method has a possibly matching instance method with the given name and arguments. |
boolean |
ClassNode.hasPossibleStaticMethod(java.lang.String name,
Expression arguments)
Returns true if the given method has a possibly matching static method with the given name and arguments. |
void |
Parameter.setInitialExpression(Expression init)
|
void |
FieldNode.setInitialValueExpression(Expression initialValueExpression)
|
void |
AnnotationNode.setMember(java.lang.String name,
Expression value)
|
Expression |
ClassCodeExpressionTransformer.transform(Expression exp)
|
MethodNode |
ClassNode.tryFindPossibleMethod(java.lang.String name,
Expression arguments)
|
Constructors in org.codehaus.groovy.ast with parameters of type Expression | |
---|---|
FieldNode(java.lang.String name,
int modifiers,
ClassNode type,
ClassNode owner,
Expression initialValueExpression)
|
|
Parameter(ClassNode type,
java.lang.String name,
Expression defaultValue)
|
|
PropertyNode(java.lang.String name,
int modifiers,
ClassNode type,
ClassNode owner,
Expression initialValueExpression,
Statement getterBlock,
Statement setterBlock)
|
Uses of Expression in org.codehaus.groovy.ast.expr |
---|
Subclasses of Expression in org.codehaus.groovy.ast.expr | |
---|---|
class |
AnnotationConstantExpression
Represents an annotation "constant" that may appear in annotation attributes (mainly used as a marker). |
class |
ArgumentListExpression
Represents one or more arguments being passed into a method |
class |
ArrayExpression
Represents an array object construction either using a fixed size or an initializer expression |
class |
AttributeExpression
Represents an attribute access (accessing the field of a class) such as the expression "foo.@bar". |
class |
BinaryExpression
Represents two expressions and an operation |
class |
BitwiseNegationExpression
|
class |
BooleanExpression
Represents a boolean expression |
class |
CastExpression
Represents a type cast expression |
class |
ClassExpression
Represents access to a Java/Groovy class in an expression, such as when invoking a static method or accessing a static type |
class |
ClosureExpression
Represents a closure creation expression such as { statement; } or { i : statement; } or { i, x, String y: statement } |
class |
ClosureListExpression
This class rerpresents a list of expressions used to create closures. |
class |
ConstantExpression
Represents a constant expression such as null, true, false |
class |
ConstructorCallExpression
A constructor call |
class |
DeclarationExpression
Represents a local variable name declaration, an expression like "def foo" or with type "String foo". |
class |
ElvisOperatorExpression
Represents a short ternary expression x ?: y, which is equal to |
class |
EmptyExpression
This class is a place holder for an empty expression. |
class |
FieldExpression
Represents a field access such as the expression "this.foo". |
class |
GStringExpression
Represents a String expression which contains embedded values inside it such as "hello there ${user} how are you" which is expanded lazily |
class |
ListExpression
Represents a list expression [1, 2, 3] which creates a mutable List |
class |
MapEntryExpression
Represents an entry inside a map expression such as 1 : 2. |
class |
MapExpression
Represents a map expression [1 : 2, "a" : "b", x : y] which creates a mutable Map |
class |
MethodCallExpression
A method call on an object or class |
class |
MethodPointerExpression
Represents a method pointer on an object such as foo.&bar which means find the method pointer on foo for the method called "bar" which is equivalent to
foo.metaClass.getMethodPointer(foo, "bar") |
class |
NamedArgumentListExpression
Represents one or more arguments being passed into a method by name |
class |
NotExpression
|
class |
PostfixExpression
Represents a postfix expression like foo++ or bar++ |
class |
PrefixExpression
Represents a prefix expression like ++foo or --bar |
class |
PropertyExpression
Represents a property access such as the expression "foo.bar". |
class |
RangeExpression
Represents a range expression such as for iterating. |
class |
RegexExpression
Represents a regular expression of the form ~ |
class |
SpreadExpression
Represents a spread expression *x in the list expression [1, *x, 2]. |
class |
SpreadMapExpression
Represents a spread map expression *:m in the map expression [1, *:m, 2, "c":100] or in the method invoke expression func(1, *:m, 2, "c":100). |
class |
StaticMethodCallExpression
A static method call on a class |
class |
TernaryExpression
Represents a ternary expression (booleanExpression) ? expression : expression |
class |
TupleExpression
Represents a tuple expression {1, 2, 3} which creates an immutable List |
class |
UnaryMinusExpression
|
class |
UnaryPlusExpression
|
class |
VariableExpression
Represents a local variable name, the simplest form of expression. |
Fields in org.codehaus.groovy.ast.expr declared as Expression | |
---|---|
private Expression |
ConstructorCallExpression.arguments
|
private Expression |
MethodCallExpression.arguments
|
private Expression |
StaticMethodCallExpression.arguments
|
private Expression |
UnaryPlusExpression.expression
|
private Expression |
SpreadMapExpression.expression
|
private Expression |
BooleanExpression.expression
|
private Expression |
UnaryMinusExpression.expression
|
private Expression |
BitwiseNegationExpression.expression
|
private Expression |
MethodPointerExpression.expression
|
private Expression |
CastExpression.expression
|
private Expression |
SpreadExpression.expression
|
private Expression |
PostfixExpression.expression
|
private Expression |
PrefixExpression.expression
|
private Expression |
TernaryExpression.falseExpression
|
private Expression |
RangeExpression.from
|
private Expression |
MapEntryExpression.keyExpression
|
private Expression |
BinaryExpression.leftExpression
|
private Expression |
MethodCallExpression.method
|
private Expression |
MethodPointerExpression.methodName
|
static Expression |
MethodCallExpression.NO_ARGUMENTS
|
private Expression |
MethodCallExpression.objectExpression
|
private Expression |
PropertyExpression.objectExpression
|
private Expression |
PropertyExpression.property
|
private Expression |
BinaryExpression.rightExpression
|
private Expression |
RegexExpression.string
|
private Expression |
RangeExpression.to
|
private Expression |
TernaryExpression.trueExpression
|
private Expression |
MapEntryExpression.valueExpression
|
Methods in org.codehaus.groovy.ast.expr with parameters of type Expression | |
---|---|
void |
ListExpression.addExpression(Expression expression)
|
void |
ArrayExpression.addExpression(Expression expression)
|
TupleExpression |
TupleExpression.addExpression(Expression expression)
|
void |
MapExpression.addMapEntryExpression(Expression keyExpression,
Expression valueExpression)
|
void |
GStringExpression.addValue(Expression value)
|
static CastExpression |
CastExpression.asExpression(ClassNode type,
Expression expression)
|
private void |
DeclarationExpression.check(Expression left,
Expression right)
|
private static BooleanExpression |
ElvisOperatorExpression.getBool(Expression base)
|
static BinaryExpression |
BinaryExpression.newAssignmentExpression(Variable variable,
Expression rhs)
Creates an assignment expression in which the specified expression is written into the specified variable name. |
static BinaryExpression |
BinaryExpression.newInitializationExpression(java.lang.String variable,
ClassNode type,
Expression rhs)
Creates variable initialization expression in which the specified expression is written into the specified variable name. |
void |
MethodCallExpression.setArguments(Expression arguments)
|
void |
PostfixExpression.setExpression(Expression expression)
|
void |
PrefixExpression.setExpression(Expression expression)
|
void |
BinaryExpression.setLeftExpression(Expression leftExpression)
|
void |
DeclarationExpression.setLeftExpression(Expression leftExpression)
|
void |
MethodCallExpression.setMethod(Expression method)
|
void |
MethodCallExpression.setObjectExpression(Expression objectExpression)
|
void |
PropertyExpression.setObjectExpression(Expression exp)
|
void |
BinaryExpression.setRightExpression(Expression rightExpression)
|
void |
DeclarationExpression.setRightExpression(Expression rightExpression)
|
Expression |
ExpressionTransformer.transform(Expression expression)
Transforms the given expression into another expression |
Uses of Expression in org.codehaus.groovy.ast.stmt |
---|
Fields in org.codehaus.groovy.ast.stmt declared as Expression | |
---|---|
private Expression |
ForStatement.collectionExpression
|
private Expression |
SwitchStatement.expression
|
private Expression |
ThrowStatement.expression
|
private Expression |
ReturnStatement.expression
|
private Expression |
CaseStatement.expression
|
private Expression |
SynchronizedStatement.expression
|
private Expression |
ExpressionStatement.expression
|
private Expression |
AssertStatement.messageExpression
|
Methods in org.codehaus.groovy.ast.stmt that return Expression | |
---|---|
Expression |
ForStatement.getCollectionExpression()
|
Expression |
SwitchStatement.getExpression()
|
Expression |
ThrowStatement.getExpression()
|
Expression |
ReturnStatement.getExpression()
|
Expression |
CaseStatement.getExpression()
|
Expression |
SynchronizedStatement.getExpression()
|
Expression |
ExpressionStatement.getExpression()
|
Expression |
AssertStatement.getMessageExpression()
|
Methods in org.codehaus.groovy.ast.stmt with parameters of type Expression | |
---|---|
void |
ForStatement.setCollectionExpression(Expression collectionExpression)
|
void |
SwitchStatement.setExpression(Expression e)
|
void |
ThrowStatement.setExpression(Expression expression)
|
void |
ReturnStatement.setExpression(Expression expression)
|
void |
CaseStatement.setExpression(Expression e)
|
void |
SynchronizedStatement.setExpression(Expression expression)
|
void |
ExpressionStatement.setExpression(Expression expression)
|
void |
AssertStatement.setMessageExpression(Expression messageExpression)
|
Constructors in org.codehaus.groovy.ast.stmt with parameters of type Expression | |
---|---|
AssertStatement(BooleanExpression booleanExpression,
Expression messageExpression)
|
|
CaseStatement(Expression expression,
Statement code)
|
|
ExpressionStatement(Expression expression)
|
|
ForStatement(Parameter variable,
Expression collectionExpression,
Statement loopBlock)
|
|
ReturnStatement(Expression expression)
|
|
SwitchStatement(Expression expression)
|
|
SwitchStatement(Expression expression,
java.util.List caseStatements,
Statement defaultStatement)
|
|
SwitchStatement(Expression expression,
Statement defaultStatement)
|
|
SynchronizedStatement(Expression expression,
Statement code)
|
|
ThrowStatement(Expression expression)
|
Uses of Expression in org.codehaus.groovy.classgen |
---|
Subclasses of Expression in org.codehaus.groovy.classgen | |
---|---|
class |
BytecodeExpression
Represents some custom bytecode generation by the compiler |
Fields in org.codehaus.groovy.classgen declared as Expression | |
---|---|
private static Expression |
VariableScopeVisitor.CALL
|
Methods in org.codehaus.groovy.classgen that return Expression | |
---|---|
protected Expression |
AsmClassGenerator.createReturnLHSExpression(Expression expression)
For assignment expressions, return a safe expression for the LHS we can use to return the value |
protected Expression |
AsmClassGenerator.createReusableExpression(Expression expression)
|
Expression |
BytecodeExpression.transformExpression(ExpressionTransformer transformer)
|
Methods in org.codehaus.groovy.classgen with parameters of type Expression | |
---|---|
private void |
AsmClassGenerator.addVariableNames(Expression expression,
java.util.List list)
|
protected static int |
AsmClassGenerator.argumentSize(Expression arguments)
|
protected boolean |
AsmClassGenerator.argumentsUseStack(Expression arguments)
|
private void |
AsmClassGenerator.assignmentCastAndVisit(ClassNode type,
Expression rightExpression)
|
void |
AnnotationVisitor.checkcircularReference(ClassNode searchClass,
ClassNode attrType,
Expression startExp)
|
private void |
ClassCompletionVerifier.checkForInvalidDeclaration(Expression exp)
|
private void |
VariableScopeVisitor.checkVariableContextAccess(Variable v,
Expression expr)
|
private Variable |
VariableScopeVisitor.checkVariableNameForDeclaration(java.lang.String name,
Expression expression)
|
protected static boolean |
AsmClassGenerator.containsSpreadExpression(Expression arguments)
|
protected Expression |
AsmClassGenerator.createReturnLHSExpression(Expression expression)
For assignment expressions, return a safe expression for the LHS we can use to return the value |
protected Expression |
AsmClassGenerator.createReusableExpression(Expression expression)
|
protected void |
AsmClassGenerator.doConvertAndCast(ClassNode type,
Expression expression,
boolean ignoreAutoboxing,
boolean forceCast,
boolean coerce)
Casts to the given type unless it can be determined that the cast is unnecessary |
protected boolean |
AsmClassGenerator.emptyArguments(Expression arguments)
|
protected void |
AsmClassGenerator.evaluateExpression(Expression expression)
|
protected void |
AsmClassGenerator.evaluatePostfixMethod(java.lang.String method,
Expression expression)
|
protected void |
AsmClassGenerator.evaluatePrefixMethod(java.lang.String method,
Expression expression)
|
private void |
AsmClassGenerator.execMethodAndStoreForSubscriptOperator(java.lang.String method,
Expression expression)
|
private ConstantExpression |
AnnotationVisitor.getConstantExpression(Expression exp)
|
protected ClassNode |
AsmClassGenerator.getExpressionType(Expression expression)
|
protected ClassNode |
AsmClassGenerator.getLHSType(Expression leftExpression)
Deduces the type name required for some casting |
private java.lang.String |
AsmClassGenerator.getMethodName(Expression message)
|
private void |
AsmClassGenerator.improveExprType(Expression expr)
|
private void |
AsmClassGenerator.invokeClosure(Expression arguments,
java.lang.String methodName)
|
protected boolean |
AsmClassGenerator.isComparisonExpression(Expression expression)
|
protected boolean |
AsmClassGenerator.isGroovyObject(Expression objectExpression)
|
protected boolean |
AsmClassGenerator.isPopRequired(Expression expression)
|
private static boolean |
AsmClassGenerator.isSuperExpression(Expression expression)
|
private static boolean |
AsmClassGenerator.isThisExpression(Expression expression)
|
private static boolean |
AsmClassGenerator.isThisOrSuper(Expression expression)
|
private void |
AsmClassGenerator.load(Expression exp)
|
private void |
AsmClassGenerator.loadDynamicName(Expression name)
|
private void |
AsmClassGenerator.loadWrapper(Expression argument)
|
private void |
AsmClassGenerator.makeBinopCallSite(Expression receiver,
java.lang.String message,
Expression arguments)
|
private void |
AsmClassGenerator.makeCall(ClassExpression sender,
Expression receiver,
Expression message,
Expression arguments,
MethodCallerMultiAdapter adapter,
boolean safe,
boolean spreadSafe,
boolean implicitThis)
|
private void |
AsmClassGenerator.makeCall(Expression receiver,
Expression message,
Expression arguments,
MethodCallerMultiAdapter adapter,
boolean safe,
boolean spreadSafe,
boolean implicitThis)
|
private void |
AsmClassGenerator.makeCallSite(Expression receiver,
java.lang.String message,
Expression arguments,
boolean safe,
boolean implicitThis,
boolean callCurrent,
boolean callStatic)
|
private void |
AsmClassGenerator.makeGetPropertySite(Expression receiver,
java.lang.String methodName,
boolean safe,
boolean implicitThis)
|
private void |
AsmClassGenerator.makeGroovyObjectGetPropertySite(Expression receiver,
java.lang.String methodName,
boolean safe,
boolean implicitThis)
|
protected void |
AsmClassGenerator.visitAndAutoboxBoolean(Expression expression)
|
(package private) void |
AsmClassGenerator.visitAnnotationDefaultExpression(org.objectweb.asm.AnnotationVisitor av,
ClassNode type,
Expression exp)
|
protected void |
AnnotationVisitor.visitExpression(java.lang.String attrName,
Expression attrExp,
ClassNode attrType)
|
Uses of Expression in org.codehaus.groovy.control |
---|
Fields in org.codehaus.groovy.control declared as Expression | |
---|---|
private Expression |
StaticImportVisitor.foundArgs
|
private Expression |
StaticImportVisitor.foundConstant
|
Methods in org.codehaus.groovy.control with parameters of type Expression | |
---|---|
private Expression |
StaticImportVisitor.findStaticMethod(ClassNode staticImportType,
java.lang.String methodName,
Expression args)
|
private Expression |
StaticImportVisitor.findStaticMethodImportFromModule(Expression method,
Expression args)
|
Expression |
OptimizerVisitor.transform(Expression exp)
|
Expression |
ResolveVisitor.transform(Expression exp)
|
Expression |
StaticImportVisitor.transform(Expression exp)
|
Uses of Expression in org.codehaus.groovy.tools.javac |
---|
Methods in org.codehaus.groovy.tools.javac with parameters of type Expression | |
---|---|
private ClassNode |
JavaStubGenerator.getConstructorArgumentType(Expression arg,
ConstructorNode node)
|
Uses of Expression in org.codehaus.groovy.transform |
---|
Methods in org.codehaus.groovy.transform that return Expression | |
---|---|
private Expression |
ImmutableASTTransformation.assignExpr(Expression fieldExpr,
Expression value)
|
private Expression |
ImmutableASTTransformation.checkUnresolved(ClassNode cNode,
FieldNode fNode,
Expression value)
|
private Expression |
ImmutableASTTransformation.cloneArrayOrCloneableExpr(Expression fieldExpr)
|
private Expression |
ImmutableASTTransformation.cloneCollectionExpr(Expression fieldExpr)
|
private Expression |
ImmutableASTTransformation.cloneDateExpr(Expression origDate)
|
private Expression |
ImmutableASTTransformation.findArg(java.lang.String fName)
|
private Expression |
LazyASTTransformation.getInitExpr(FieldNode fieldNode)
|
Expression |
NewifyASTTransformation.transform(Expression expr)
|
private Expression |
NewifyASTTransformation.transformMethodCall(MethodCallExpression mce,
Expression args)
|
Methods in org.codehaus.groovy.transform with parameters of type Expression | |
---|---|
private ExpressionStatement |
ImmutableASTTransformation.append(Expression result,
Expression expr)
|
private Expression |
ImmutableASTTransformation.assignExpr(Expression fieldExpr,
Expression value)
|
private Statement |
ImmutableASTTransformation.assignStatement(Expression fieldExpr,
Expression value)
|
private Statement |
ImmutableASTTransformation.calculateHashStatements(Expression hash,
java.util.List<PropertyNode> list)
|
private Expression |
ImmutableASTTransformation.checkUnresolved(ClassNode cNode,
FieldNode fNode,
Expression value)
|
private Expression |
ImmutableASTTransformation.cloneArrayOrCloneableExpr(Expression fieldExpr)
|
private Expression |
ImmutableASTTransformation.cloneCollectionExpr(Expression fieldExpr)
|
private Expression |
ImmutableASTTransformation.cloneDateExpr(Expression origDate)
|
private void |
LazyASTTransformation.create(FieldNode fieldNode,
Expression initExpr)
|
private void |
LazyASTTransformation.createSoft(FieldNode fieldNode,
Expression initExpr)
|
private void |
LazyASTTransformation.createSoftGetter(FieldNode fieldNode,
Expression initExpr,
ClassNode type)
|
private boolean |
NewifyASTTransformation.determineAutoFlag(Expression autoExpr)
|
private ListExpression |
NewifyASTTransformation.determineClassesToNewify(Expression expr)
|
private BooleanExpression |
ImmutableASTTransformation.equalsNullExpr(Expression argExpr)
|
private BooleanExpression |
ImmutableASTTransformation.identicalExpr(Expression self,
Expression other)
|
private BooleanExpression |
ImmutableASTTransformation.isOneExpr(Expression expr)
|
private BooleanExpression |
ImmutableASTTransformation.isTrueExpr(Expression argExpr)
|
private BooleanExpression |
ImmutableASTTransformation.isZeroExpr(Expression expr)
|
private BooleanExpression |
ImmutableASTTransformation.notEqualsExpr(PropertyNode pNode,
Expression other)
|
private IfStatement |
ImmutableASTTransformation.returnFalseIfNull(Expression other)
|
private Statement |
ImmutableASTTransformation.returnFalseIfPropertyNotEqual(PropertyNode pNode,
Expression other)
|
private Statement |
ImmutableASTTransformation.returnFalseIfWrongType(ClassNode cNode,
Expression other)
|
private IfStatement |
ImmutableASTTransformation.returnTrueIfIdentical(Expression self,
Expression other)
|
private Statement |
ImmutableASTTransformation.safeExpression(Expression fieldExpr,
Expression expression)
|
private Statement |
ImmutableASTTransformation.toStringPropertyName(Expression result,
java.lang.String fName)
|
Expression |
NewifyASTTransformation.transform(Expression expr)
|
private Expression |
NewifyASTTransformation.transformMethodCall(MethodCallExpression mce,
Expression args)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |