Repository navigation
Expand file tree
/
Copy pathExpression.java
More file actions
145 lines (135 loc) · 4.54 KB
/
Copy pathExpression.java
File metadata and controls
145 lines (135 loc) · 4.54 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
/*
* Copyright 2000-2007 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package java.beans;
/**
* An <code>Expression</code> object represents a primitive expression
* in which a single method is applied to a target and a set of
* arguments to return a result - as in <code>"a.getFoo()"</code>.
* <p>
* In addition to the properties of the super class, the
* <code>Expression</code> object provides a <em>value</em> which
* is the object returned when this expression is evaluated.
* The return value is typically not provided by the caller and
* is instead computed by dynamically finding the method and invoking
* it when the first call to <code>getValue</code> is made.
*
* @see #getValue
* @see #setValue
*
* @since 1.4
*
* @author Philip Milne
*/
public class Expression extends Statement {
private static Object unbound = new Object();
private Object value = unbound;
/**
* Creates a new <code>Statement</code> object with a <code>target</code>,
* <code>methodName</code> and <code>arguments</code> as per the parameters.
*
* @param target The target of this expression.
* @param methodName The methodName of this expression.
* @param arguments The arguments of this expression. If <code>null</code> then an empty array will be used.
*
* @see #getValue
*/
@ConstructorProperties({"target", "methodName", "arguments"})
public Expression(Object target, String methodName, Object[] arguments) {
super(target, methodName, arguments);
}
/**
* Creates a new <code>Expression</code> object for a method
* that returns a result. The result will never be calculated
* however, since this constructor uses the <code>value</code>
* parameter to set the value property by calling the
* <code>setValue</code> method.
*
* @param value The value of this expression.
* @param target The target of this expression.
* @param methodName The methodName of this expression.
* @param arguments The arguments of this expression. If <code>null</code> then an empty array will be used.
*
* @see #setValue
*/
public Expression(Object value, Object target, String methodName, Object[] arguments) {
this(target, methodName, arguments);
setValue(value);
}
/**
* If the value property of this instance is not already set,
* this method dynamically finds the method with the specified
* methodName on this target with these arguments and calls it.
* The result of the method invocation is first copied
* into the value property of this expression and then returned
* as the result of <code>getValue</code>. If the value property
* was already set, either by a call to <code>setValue</code>
* or a previous call to <code>getValue</code> then the value
* property is returned without either looking up or calling the method.
* <p>
* The value property of an <code>Expression</code> is set to
* a unique private (non-<code>null</code>) value by default and
* this value is used as an internal indication that the method
* has not yet been called. A return value of <code>null</code>
* replaces this default value in the same way that any other value
* would, ensuring that expressions are never evaluated more than once.
* <p>
* See the <code>excecute</code> method for details on how
* methods are chosen using the dynamic types of the target
* and arguments.
*
* @see Statement#execute
* @see #setValue
*
* @return The result of applying this method to these arguments.
*/
public Object getValue() throws Exception {
if (value == unbound) {
setValue(invoke());
}
return value;
}
/**
* Sets the value of this expression to <code>value</code>.
* This value will be returned by the getValue method
* without calling the method associated with this
* expression.
*
* @param value The value of this expression.
*
* @see #getValue
*/
public void setValue(Object value) {
this.value = value;
}
/*pp*/ String instanceName(Object instance) {
return instance == unbound ? "<unbound>" : super.instanceName(instance);
}
/**
* Prints the value of this expression using a Java-style syntax.
*/
public String toString() {
return instanceName(value) + "=" + super.toString();
}
}