View Javadoc

1   /*
2    * Copyright 2000-2002,2004 The Apache Software Foundation.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.apache.commons.jexl.util;
17  
18  import java.lang.reflect.InvocationTargetException;
19  
20  import org.apache.commons.jexl.util.introspection.Introspector;
21  import org.apache.commons.logging.Log;
22  
23  /***
24   * Returned the value of object property when executed.
25   * @since 1.0
26   */
27  public class PropertyExecutor extends AbstractExecutor {
28  
29      /*** index of the first character of the property. */
30      private static final int PROPERTY_START_INDEX = 3;
31      /*** The JEXL introspector used. */
32      protected Introspector introspector = null;
33  
34      /*** The method used. */
35      protected String methodUsed = null;
36  
37      /***
38       * Constructor.
39       *
40       * @param r The log for this property executor instance.
41       * @param ispctr The JEXL introspector.
42       * @param clazz The class being examined.
43       * @param property The property being addressed.
44       */
45      public PropertyExecutor(Log r, Introspector ispctr,
46              Class clazz, String property) {
47          rlog = r;
48          introspector = ispctr;
49  
50          discover(clazz, property);
51      }
52  
53      /***
54       * Locate the getter method for this property.
55       *
56       * @param clazz The class being analyzed.
57       * @param property Name of the property.
58       */
59      protected void discover(Class clazz, String property) {
60          /*
61           *  this is gross and linear, but it keeps it straightforward.
62           */
63  
64          try {
65              char c;
66              StringBuffer sb;
67  
68              Object[] params = {};
69  
70              /*
71               *  start with get<property>
72               *  this leaves the property name 
73               *  as is...
74               */
75              sb = new StringBuffer("get");
76              sb.append(property);
77  
78              methodUsed = sb.toString();
79  
80              method = introspector.getMethod(clazz, methodUsed, params);
81               
82              if (method != null) {
83                  return;
84              }
85          
86              /*
87               *  now the convenience, flip the 1st character
88               */
89           
90              sb = new StringBuffer("get");
91              sb.append(property);
92  
93              c = sb.charAt(PROPERTY_START_INDEX);
94  
95              if (Character.isLowerCase(c)) {
96                  sb.setCharAt(PROPERTY_START_INDEX, Character.toUpperCase(c));
97              } else {
98                  sb.setCharAt(PROPERTY_START_INDEX, Character.toLowerCase(c));
99              }
100 
101             methodUsed = sb.toString();
102             method = introspector.getMethod(clazz, methodUsed, params);
103 
104             if (method != null) {
105                 return;
106             }
107             
108         } catch (Exception e) {
109             rlog.error("PROGRAMMER ERROR : PropertyExector() : " + e);
110         }
111     }
112 
113 
114     /***
115      * {@inheritDoc}
116      */
117     public Object execute(Object o)
118     throws IllegalAccessException,  InvocationTargetException {
119         if (method == null) {
120             return null;
121         }
122 
123         return method.invoke(o, null);
124     }
125 }
126