Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Licensed to the Apache Software Foundation (ASF) under one or more
3
   * contributor license agreements.  See the NOTICE file distributed with
4
   * this work for additional information regarding copyright ownership.
5
   * The ASF licenses this file to You under the Apache License, Version 2.0
6
   * (the "License"); you may not use this file except in compliance with
7
   * the License.  You may obtain a copy of the License at
8
   *
9
   *     http://www.apache.org/licenses/LICENSE-2.0
10
  *
11
  * Unless required by applicable law or agreed to in writing, software
12
  * distributed under the License is distributed on an "AS IS" BASIS,
13
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
  * See the License for the specific language governing permissions and
15
  * limitations under the License.
16
  */
17
 /* Generated By:JJTree: Do not edit this line. AstIdentifier.java */
18
 
19
 package org.apache.el.parser;
20
 
21
 import  javax.el.ELException;
22
 import  javax.el.MethodExpression;
23
 import  javax.el.MethodInfo;
24
 import  javax.el.MethodNotFoundException;
25
 import  javax.el.PropertyNotFoundException;
26
 import  javax.el.ValueExpression;
27
 import  javax.el.VariableMapper;
28
 

Author(s):
Jacob Hookom [jacob@hookom.net]
Version:
$Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author: remy.maucherat@jboss.com $
35
 
36
 public final class AstIdentifier extends SimpleNode {
37
     public AstIdentifier(int id) {
38
         super(id);
39
     }
40
 
41
     public Class getType(EvaluationContext ctx) throws ELException {
42
         VariableMapper varMapper = ctx.getVariableMapper();
43
         if (varMapper != null) {
44
             ValueExpression expr = varMapper.resolveVariable(this.);
45
             if (expr != null) {
46
                 return expr.getType(ctx.getELContext());
47
             }
48
         }
49
         ctx.setPropertyResolved(false);
50
         Class result = ctx.getELResolver().getType(ctx, null, this.);
51
         if (ctx.isPropertyResolved()) {
52
             return result;
53
         } else {
54
             throw new PropertyNotFoundException("Could not resolve property '" + this. + "'");
55
         }
56
     }
57
 
58
     public Object getValue(EvaluationContext ctx) throws ELException {
59
         VariableMapper varMapper = ctx.getVariableMapper();
60
         if (varMapper != null) {
61
             ValueExpression expr = varMapper.resolveVariable(this.);
62
             if (expr != null) {
63
                 return expr.getValue(ctx.getELContext());
64
             }
65
         }
66
         ctx.setPropertyResolved(false);
67
         Object result = ctx.getELResolver().getValue(ctx, null, this.);
68
         if (ctx.isPropertyResolved()) {
69
             return result;
70
         } else {
71
             throw new PropertyNotFoundException("Could not resolve property '" + this. + "'");
72
         }
73
     }
74
 
75
     public boolean isReadOnly(EvaluationContext ctx) throws ELException {
76
         VariableMapper varMapper = ctx.getVariableMapper();
77
         if (varMapper != null) {
78
             ValueExpression expr = varMapper.resolveVariable(this.);
79
             if (expr != null) {
80
                 return expr.isReadOnly(ctx.getELContext());
81
             }
82
         }
83
         ctx.setPropertyResolved(false);
84
         boolean result = ctx.getELResolver().isReadOnly(ctx, null, this.);
85
         if (ctx.isPropertyResolved()) {
86
             return result;
87
         } else {
88
             throw new PropertyNotFoundException("Could not resolve property '" + this. + "'");
89
         }
90
     }
91
 
92
     public void setValue(EvaluationContext ctx, Object value)
93
             throws ELException {
94
         VariableMapper varMapper = ctx.getVariableMapper();
95
         if (varMapper != null) {
96
             ValueExpression expr = varMapper.resolveVariable(this.);
97
             if (expr != null) {
98
                 expr.setValue(ctx.getELContext(), value);
99
                 return;
100
            }
101
        }
102
        ctx.setPropertyResolved(false);
103
        ctx.getELResolver().setValue(ctx, null, this., value);
104
        if (!ctx.isPropertyResolved()) {
105
            throw new PropertyNotFoundException("Could not resolve property '" + this. + "'");
106
        }
107
    }
109
    private final Object invokeTarget(EvaluationContext ctx, Object target,
110
            Object[] paramValues) throws ELException {
111
        if (target instanceof MethodExpression) {
112
            MethodExpression me = (MethodExpression) target;
113
            return me.invoke(ctx.getELContext(), paramValues);
114
        } else if (target == null) {
115
            throw new MethodNotFoundException("Identity '" + this.
116
                    + "' was null and was unable to invoke");
117
        } else {
118
            throw new ELException(
119
                    "Identity '"
120
                            + this.
121
                            + "' does not reference a MethodExpression instance, returned type: "
122
                            + target.getClass().getName());
123
        }
124
    }
126
    public Object invoke(EvaluationContext ctx, Class[] paramTypes,
127
            Object[] paramValues) throws ELException {
128
        return this.getMethodExpression(ctx).invoke(ctx.getELContext(), paramValues);
129
    }
130
    
132
    public MethodInfo getMethodInfo(EvaluationContext ctx, Class[] paramTypes)
133
            throws ELException {
134
        return this.getMethodExpression(ctx).getMethodInfo(ctx.getELContext());
135
    }
137
    private final MethodExpression getMethodExpression(EvaluationContext ctx)
138
            throws ELException {
139
        Object obj = null;
141
        // case A: ValueExpression exists, getValue which must
142
        // be a MethodExpression
143
        VariableMapper varMapper = ctx.getVariableMapper();
144
        ValueExpression ve = null;
145
        if (varMapper != null) {
146
            ve = varMapper.resolveVariable(this.);
147
            if (ve != null) {
148
                obj = ve.getValue(ctx);
149
            }
150
        }
152
        // case B: evaluate the identity against the ELResolver, again, must be
153
        // a MethodExpression to be able to invoke
154
        if (ve == null) {
155
            ctx.setPropertyResolved(false);
156
            obj = ctx.getELResolver().getValue(ctx, null, this.);
157
        }
159
        // finally provide helpful hints
160
        if (obj instanceof MethodExpression) {
161
            return (MethodExpression) obj;
162
        } else if (obj == null) {
163
            throw new MethodNotFoundException("Identity '" + this.
164
                    + "' was null and was unable to invoke");
165
        } else {
166
            throw new ELException(
167
                    "Identity '"
168
                            + this.
169
                            + "' does not reference a MethodExpression instance, returned type: "
170
                            + obj.getClass().getName());
171
        }
172
    }
New to GrepCode? Check out our FAQ X