KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > commons > jxpath > ri > model > dynabeans > DynaBeanPropertyPointer


1 /*
2  * Copyright 1999-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.jxpath.ri.model.dynabeans;
17
18 import java.util.Arrays JavaDoc;
19
20 import org.apache.commons.beanutils.DynaBean;
21 import org.apache.commons.beanutils.DynaClass;
22 import org.apache.commons.beanutils.DynaProperty;
23 import org.apache.commons.jxpath.JXPathException;
24 import org.apache.commons.jxpath.ri.model.NodePointer;
25 import org.apache.commons.jxpath.ri.model.beans.PropertyPointer;
26 import org.apache.commons.jxpath.util.TypeUtils;
27 import org.apache.commons.jxpath.util.ValueUtils;
28
29 /**
30  * Pointer pointing to a property of a DynaBean.
31  *
32  * @author Dmitri Plotnikov
33  * @version $Revision: 1.12 $ $Date: 2004/04/04 22:06:35 $
34  */
35 public class DynaBeanPropertyPointer extends PropertyPointer {
36     private DynaBean dynaBean;
37     private String JavaDoc name;
38     private String JavaDoc[] names;
39
40     public DynaBeanPropertyPointer(NodePointer parent, DynaBean dynaBean) {
41         super(parent);
42         this.dynaBean = dynaBean;
43     }
44
45     public Object JavaDoc getBaseValue() {
46         return dynaBean.get(getPropertyName());
47     }
48
49     /**
50      * This type of node is auxiliary.
51      */
52     public boolean isContainer() {
53         return true;
54     }
55
56     /**
57      * Number of the DP object's properties.
58      */
59     public int getPropertyCount() {
60         return getPropertyNames().length;
61     }
62
63     /**
64      * Names of all properties, sorted alphabetically
65      *
66      * @todo do something about the sorting
67      */
68     public String JavaDoc[] getPropertyNames() {
69         if (names == null) {
70             DynaClass dynaClass = dynaBean.getDynaClass();
71             DynaProperty properties[] = dynaClass.getDynaProperties();
72             int count = properties.length;
73             boolean hasClass = dynaClass.getDynaProperty("class") != null;
74             if (hasClass) {
75                 count--; // Exclude "class" from properties
76 }
77             names = new String JavaDoc[count];
78             for (int i = 0, j = 0; i < properties.length; i++) {
79                 String JavaDoc name = properties[i].getName();
80                 if (!hasClass || !name.equals("class")) {
81                     names[j++] = name;
82                 }
83             }
84             Arrays.sort(names);
85         }
86         return names;
87     }
88
89     /**
90      * Returns the name of the currently selected property or "*"
91      * if none has been selected.
92      */
93     public String JavaDoc getPropertyName() {
94         if (name == null) {
95             String JavaDoc names[] = getPropertyNames();
96             if (propertyIndex >= 0 && propertyIndex < names.length) {
97                 name = names[propertyIndex];
98             }
99             else {
100                 name = "*";
101             }
102         }
103         return name;
104     }
105
106     /**
107      * Select a property by name.
108      */
109     public void setPropertyName(String JavaDoc propertyName) {
110         setPropertyIndex(UNSPECIFIED_PROPERTY);
111         this.name = propertyName;
112     }
113
114     /**
115      * Index of the currently selected property in the list of all
116      * properties sorted alphabetically.
117      */
118     public int getPropertyIndex() {
119         if (propertyIndex == UNSPECIFIED_PROPERTY) {
120             String JavaDoc names[] = getPropertyNames();
121             for (int i = 0; i < names.length; i++) {
122                 if (names[i].equals(name)) {
123                     propertyIndex = i;
124                     name = null;
125                     break;
126                 }
127             }
128         }
129         return super.getPropertyIndex();
130     }
131
132     /**
133      * Index a property by its index in the list of all
134      * properties sorted alphabetically.
135      */
136     public void setPropertyIndex(int index) {
137         if (propertyIndex != index) {
138             super.setPropertyIndex(index);
139             name = null;
140         }
141     }
142
143     /**
144      * If index == WHOLE_COLLECTION, the value of the property, otherwise
145      * the value of the index'th element of the collection represented by the
146      * property. If the property is not a collection, index should be zero
147      * and the value will be the property itself.
148      */
149     public Object JavaDoc getImmediateNode() {
150         String JavaDoc name = getPropertyName();
151         if (name.equals("*")) {
152             return null;
153         }
154
155         Object JavaDoc value;
156         if (index == WHOLE_COLLECTION) {
157             value = ValueUtils.getValue(dynaBean.get(name));
158         }
159         else if (isIndexedProperty()) {
160             // DynaClass at this point is not based on whether
161 // the property is indeed indexed, but rather on
162 // whether it is an array or List. Therefore
163 // the indexed set may fail.
164 try {
165                 value = ValueUtils.getValue(dynaBean.get(name, index));
166             }
167             catch (ArrayIndexOutOfBoundsException JavaDoc ex) {
168                 value = null;
169             }
170             catch (IllegalArgumentException JavaDoc ex) {
171                 value = dynaBean.get(name);
172                 value = ValueUtils.getValue(value, index);
173             }
174         }
175         else {
176             value = dynaBean.get(name);
177             if (ValueUtils.isCollection(value)) {
178                 value = ValueUtils.getValue(value, index);
179             }
180             else if (index != 0) {
181                 value = null;
182             }
183         }
184         return value;
185     }
186
187     /**
188      * Returns true if the bean has the currently selected property
189      */
190     protected boolean isActualProperty() {
191         DynaClass dynaClass = dynaBean.getDynaClass();
192         return dynaClass.getDynaProperty(getPropertyName()) != null;
193     }
194
195     protected boolean isIndexedProperty() {
196         DynaClass dynaClass = dynaBean.getDynaClass();
197         DynaProperty property = dynaClass.getDynaProperty(name);
198         return property.isIndexed();
199     }
200
201     /**
202      * If index == WHOLE_COLLECTION, change the value of the property, otherwise
203      * change the value of the index'th element of the collection
204      * represented by the property.
205      */
206     public void setValue(Object JavaDoc value) {
207         setValue(index, value);
208     }
209
210     public void remove() {
211         if (index == WHOLE_COLLECTION) {
212             dynaBean.set(getPropertyName(), null);
213         }
214         else if (isIndexedProperty()) {
215             dynaBean.set(getPropertyName(), index, null);
216         }
217         else if (isCollection()) {
218             Object JavaDoc collection = ValueUtils.remove(getBaseValue(), index);
219             dynaBean.set(getPropertyName(), collection);
220         }
221         else if (index == 0) {
222             dynaBean.set(getPropertyName(), null);
223         }
224     }
225
226     private void setValue(int index, Object JavaDoc value) {
227         if (index == WHOLE_COLLECTION) {
228             dynaBean.set(getPropertyName(), convert(value, false));
229         }
230         else if (isIndexedProperty()) {
231             dynaBean.set(getPropertyName(), index, convert(value, true));
232         }
233         else {
234             Object JavaDoc baseValue = dynaBean.get(getPropertyName());
235             ValueUtils.setValue(baseValue, index, value);
236         }
237    }
238
239
240     private Object JavaDoc convert(Object JavaDoc value, boolean element) {
241         DynaClass dynaClass = (DynaClass) dynaBean.getDynaClass();
242         DynaProperty property = dynaClass.getDynaProperty(getPropertyName());
243         Class JavaDoc type = property.getType();
244         if (element) {
245             if (type.isArray()) {
246                 type = type.getComponentType();
247             }
248             else {
249                 return value; // No need to convert
250 }
251         }
252
253         try {
254             return TypeUtils.convert(value, type);
255         }
256         catch (Exception JavaDoc ex) {
257             throw new JXPathException(
258                 "Cannot convert value of class "
259                     + (value == null ? "null" : value.getClass().getName())
260                     + " to type "
261                     + type,
262                 ex);
263         }
264     }
265 }
Popular Tags