001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018
019 package org.apache.commons.beanutils;
020
021
022 import java.io.Serializable;
023 import java.lang.reflect.Array;
024 import java.util.HashMap;
025 import java.util.List;
026 import java.util.Map;
027
028
029 /**
030 * <p>Minimal implementation of the <code>DynaBean</code> interface. Can be
031 * used as a convenience base class for more sophisticated implementations.</p>
032 *
033 * <p><strong>IMPLEMENTATION NOTE</strong> - Instances of this class that are
034 * accessed from multiple threads simultaneously need to be synchronized.</p>
035 *
036 * <p><strong>IMPLEMENTATION NOTE</strong> - Instances of this class can be
037 * successfully serialized and deserialized <strong>ONLY</strong> if all
038 * property values are <code>Serializable</code>.</p>
039 *
040 * @author Craig McClanahan
041 * @version $Revision: 926529 $ $Date: 2010-03-23 11:44:24 +0000 (Tue, 23 Mar 2010) $
042 */
043
044 public class BasicDynaBean implements DynaBean, Serializable {
045
046
047 // ---------------------------------------------------------- Constructors
048
049
050 /**
051 * Construct a new <code>DynaBean</code> associated with the specified
052 * <code>DynaClass</code> instance.
053 *
054 * @param dynaClass The DynaClass we are associated with
055 */
056 public BasicDynaBean(DynaClass dynaClass) {
057
058 super();
059 this.dynaClass = dynaClass;
060
061 }
062
063
064 // ---------------------------------------------------- Instance Variables
065
066
067 /**
068 * The <code>DynaClass</code> "base class" that this DynaBean
069 * is associated with.
070 */
071 protected DynaClass dynaClass = null;
072
073
074 /**
075 * The set of property values for this DynaBean, keyed by property name.
076 */
077 protected HashMap values = new HashMap();
078
079 /** Map decorator for this DynaBean */
080 private transient Map mapDecorator;
081
082 /**
083 * Return a Map representation of this DynaBean.
084 * </p>
085 * This, for example, could be used in JSTL in the following way to access
086 * a DynaBean's <code>fooProperty</code>:
087 * <ul><li><code>${myDynaBean.<b>map</b>.fooProperty}</code></li></ul>
088 *
089 * @return a Map representation of this DynaBean
090 * @since 1.8.0
091 */
092 public Map getMap() {
093
094 // cache the Map
095 if (mapDecorator == null) {
096 mapDecorator = new DynaBeanMapDecorator(this);
097 }
098 return mapDecorator;
099
100 }
101
102 // ------------------------------------------------------ DynaBean Methods
103
104
105 /**
106 * Does the specified mapped property contain a value for the specified
107 * key value?
108 *
109 * @param name Name of the property to check
110 * @param key Name of the key to check
111 * @return <code>true<code> if the mapped property contains a value for
112 * the specified key, otherwise <code>false</code>
113 *
114 * @exception IllegalArgumentException if there is no property
115 * of the specified name
116 */
117 public boolean contains(String name, String key) {
118
119 Object value = values.get(name);
120 if (value == null) {
121 throw new NullPointerException
122 ("No mapped value for '" + name + "(" + key + ")'");
123 } else if (value instanceof Map) {
124 return (((Map) value).containsKey(key));
125 } else {
126 throw new IllegalArgumentException
127 ("Non-mapped property for '" + name + "(" + key + ")'");
128 }
129
130 }
131
132
133 /**
134 * Return the value of a simple property with the specified name.
135 *
136 * @param name Name of the property whose value is to be retrieved
137 * @return The property's value
138 *
139 * @exception IllegalArgumentException if there is no property
140 * of the specified name
141 */
142 public Object get(String name) {
143
144 // Return any non-null value for the specified property
145 Object value = values.get(name);
146 if (value != null) {
147 return (value);
148 }
149
150 // Return a null value for a non-primitive property
151 Class type = getDynaProperty(name).getType();
152 if (!type.isPrimitive()) {
153 return (value);
154 }
155
156 // Manufacture default values for primitive properties
157 if (type == Boolean.TYPE) {
158 return (Boolean.FALSE);
159 } else if (type == Byte.TYPE) {
160 return (new Byte((byte) 0));
161 } else if (type == Character.TYPE) {
162 return (new Character((char) 0));
163 } else if (type == Double.TYPE) {
164 return (new Double(0.0));
165 } else if (type == Float.TYPE) {
166 return (new Float((float) 0.0));
167 } else if (type == Integer.TYPE) {
168 return (new Integer(0));
169 } else if (type == Long.TYPE) {
170 return (new Long(0));
171 } else if (type == Short.TYPE) {
172 return (new Short((short) 0));
173 } else {
174 return (null);
175 }
176
177 }
178
179
180 /**
181 * Return the value of an indexed property with the specified name.
182 *
183 * @param name Name of the property whose value is to be retrieved
184 * @param index Index of the value to be retrieved
185 * @return The indexed property's value
186 *
187 * @exception IllegalArgumentException if there is no property
188 * of the specified name
189 * @exception IllegalArgumentException if the specified property
190 * exists, but is not indexed
191 * @exception IndexOutOfBoundsException if the specified index
192 * is outside the range of the underlying property
193 * @exception NullPointerException if no array or List has been
194 * initialized for this property
195 */
196 public Object get(String name, int index) {
197
198 Object value = values.get(name);
199 if (value == null) {
200 throw new NullPointerException
201 ("No indexed value for '" + name + "[" + index + "]'");
202 } else if (value.getClass().isArray()) {
203 return (Array.get(value, index));
204 } else if (value instanceof List) {
205 return ((List) value).get(index);
206 } else {
207 throw new IllegalArgumentException
208 ("Non-indexed property for '" + name + "[" + index + "]'");
209 }
210
211 }
212
213
214 /**
215 * Return the value of a mapped property with the specified name,
216 * or <code>null</code> if there is no value for the specified key.
217 *
218 * @param name Name of the property whose value is to be retrieved
219 * @param key Key of the value to be retrieved
220 * @return The mapped property's value
221 *
222 * @exception IllegalArgumentException if there is no property
223 * of the specified name
224 * @exception IllegalArgumentException if the specified property
225 * exists, but is not mapped
226 */
227 public Object get(String name, String key) {
228
229 Object value = values.get(name);
230 if (value == null) {
231 throw new NullPointerException
232 ("No mapped value for '" + name + "(" + key + ")'");
233 } else if (value instanceof Map) {
234 return (((Map) value).get(key));
235 } else {
236 throw new IllegalArgumentException
237 ("Non-mapped property for '" + name + "(" + key + ")'");
238 }
239
240 }
241
242
243 /**
244 * Return the <code>DynaClass</code> instance that describes the set of
245 * properties available for this DynaBean.
246 *
247 * @return The associated DynaClass
248 */
249 public DynaClass getDynaClass() {
250
251 return (this.dynaClass);
252
253 }
254
255
256 /**
257 * Remove any existing value for the specified key on the
258 * specified mapped property.
259 *
260 * @param name Name of the property for which a value is to
261 * be removed
262 * @param key Key of the value to be removed
263 *
264 * @exception IllegalArgumentException if there is no property
265 * of the specified name
266 */
267 public void remove(String name, String key) {
268
269 Object value = values.get(name);
270 if (value == null) {
271 throw new NullPointerException
272 ("No mapped value for '" + name + "(" + key + ")'");
273 } else if (value instanceof Map) {
274 ((Map) value).remove(key);
275 } else {
276 throw new IllegalArgumentException
277 ("Non-mapped property for '" + name + "(" + key + ")'");
278 }
279
280 }
281
282
283 /**
284 * Set the value of a simple property with the specified name.
285 *
286 * @param name Name of the property whose value is to be set
287 * @param value Value to which this property is to be set
288 *
289 * @exception ConversionException if the specified value cannot be
290 * converted to the type required for this property
291 * @exception IllegalArgumentException if there is no property
292 * of the specified name
293 * @exception NullPointerException if an attempt is made to set a
294 * primitive property to null
295 */
296 public void set(String name, Object value) {
297
298 DynaProperty descriptor = getDynaProperty(name);
299 if (value == null) {
300 if (descriptor.getType().isPrimitive()) {
301 throw new NullPointerException
302 ("Primitive value for '" + name + "'");
303 }
304 } else if (!isAssignable(descriptor.getType(), value.getClass())) {
305 throw new ConversionException
306 ("Cannot assign value of type '" +
307 value.getClass().getName() +
308 "' to property '" + name + "' of type '" +
309 descriptor.getType().getName() + "'");
310 }
311 values.put(name, value);
312
313 }
314
315
316 /**
317 * Set the value of an indexed property with the specified name.
318 *
319 * @param name Name of the property whose value is to be set
320 * @param index Index of the property to be set
321 * @param value Value to which this property is to be set
322 *
323 * @exception ConversionException if the specified value cannot be
324 * converted to the type required for this property
325 * @exception IllegalArgumentException if there is no property
326 * of the specified name
327 * @exception IllegalArgumentException if the specified property
328 * exists, but is not indexed
329 * @exception IndexOutOfBoundsException if the specified index
330 * is outside the range of the underlying property
331 */
332 public void set(String name, int index, Object value) {
333
334 Object prop = values.get(name);
335 if (prop == null) {
336 throw new NullPointerException
337 ("No indexed value for '" + name + "[" + index + "]'");
338 } else if (prop.getClass().isArray()) {
339 Array.set(prop, index, value);
340 } else if (prop instanceof List) {
341 try {
342 ((List) prop).set(index, value);
343 } catch (ClassCastException e) {
344 throw new ConversionException(e.getMessage());
345 }
346 } else {
347 throw new IllegalArgumentException
348 ("Non-indexed property for '" + name + "[" + index + "]'");
349 }
350
351 }
352
353
354 /**
355 * Set the value of a mapped property with the specified name.
356 *
357 * @param name Name of the property whose value is to be set
358 * @param key Key of the property to be set
359 * @param value Value to which this property is to be set
360 *
361 * @exception ConversionException if the specified value cannot be
362 * converted to the type required for this property
363 * @exception IllegalArgumentException if there is no property
364 * of the specified name
365 * @exception IllegalArgumentException if the specified property
366 * exists, but is not mapped
367 */
368 public void set(String name, String key, Object value) {
369
370 Object prop = values.get(name);
371 if (prop == null) {
372 throw new NullPointerException
373 ("No mapped value for '" + name + "(" + key + ")'");
374 } else if (prop instanceof Map) {
375 ((Map) prop).put(key, value);
376 } else {
377 throw new IllegalArgumentException
378 ("Non-mapped property for '" + name + "(" + key + ")'");
379 }
380
381 }
382
383
384 // ------------------------------------------------------ Protected Methods
385
386
387 /**
388 * Return the property descriptor for the specified property name.
389 *
390 * @param name Name of the property for which to retrieve the descriptor
391 * @return The property descriptor
392 *
393 * @exception IllegalArgumentException if this is not a valid property
394 * name for our DynaClass
395 */
396 protected DynaProperty getDynaProperty(String name) {
397
398 DynaProperty descriptor = getDynaClass().getDynaProperty(name);
399 if (descriptor == null) {
400 throw new IllegalArgumentException
401 ("Invalid property name '" + name + "'");
402 }
403 return (descriptor);
404
405 }
406
407
408 /**
409 * Is an object of the source class assignable to the destination class?
410 *
411 * @param dest Destination class
412 * @param source Source class
413 * @return <code>true</code> if the source class is assignable to the
414 * destination class, otherwise <code>false</code>
415 */
416 protected boolean isAssignable(Class dest, Class source) {
417
418 if (dest.isAssignableFrom(source) ||
419 ((dest == Boolean.TYPE) && (source == Boolean.class)) ||
420 ((dest == Byte.TYPE) && (source == Byte.class)) ||
421 ((dest == Character.TYPE) && (source == Character.class)) ||
422 ((dest == Double.TYPE) && (source == Double.class)) ||
423 ((dest == Float.TYPE) && (source == Float.class)) ||
424 ((dest == Integer.TYPE) && (source == Integer.class)) ||
425 ((dest == Long.TYPE) && (source == Long.class)) ||
426 ((dest == Short.TYPE) && (source == Short.class))) {
427 return (true);
428 } else {
429 return (false);
430 }
431
432 }
433
434
435 }