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    }