1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.apache.commons.beanutils;
17
18 import java.util.List;
19 import java.util.ArrayList;
20 import java.util.Map;
21 import java.util.HashMap;
22 import java.util.Date;
23 import java.lang.reflect.Array;
24 import java.math.BigDecimal;
25 import java.math.BigInteger;
26 import java.io.Serializable;
27 import org.apache.commons.logging.Log;
28 import org.apache.commons.logging.LogFactory;
29
30 /**
31 * <p>DynaBean which automatically adds properties to the <code>DynaClass</code>
32 * and provides <i>Lazy List</i> and <i>Lazy Map</i> features.</p>
33 *
34 * <p>DynaBeans deal with three types of properties - <i>simple</i>, <i>indexed</i> and <i>mapped</i> and
35 * have the following <code>get()</code> and <code>set()</code> methods for
36 * each of these types:</p>
37 * <ul>
38 * <li><i>Simple</i> property methods - <code>get(name)</code> and <code>set(name, value)</code></li>
39 * <li><i>Indexed</i> property methods - <code>get(name, index)</code> and <code>set(name, index, value)</code></li>
40 * <li><i>Mapped</i> property methods - <code>get(name, key)</code> and <code>set(name, key, value)</code></li>
41 * </ul>
42 *
43 * <p><b><u>Getting Property Values</u></b></p>
44 * <p>Calling any of the <code>get()</code> methods, for a property which
45 * doesn't exist, returns <code>null</code> in this implementation.</p>
46 *
47 * <p><b><u>Setting Simple Properties</u></b></p>
48 * <p>The <code>LazyDynaBean</code> will automatically add a property to the <code>DynaClass</code>
49 * if it doesn't exist when the <code>set(name, value)</code> method is called.</p>
50 *
51 * <code>DynaBean myBean = new LazyDynaBean();</code></br>
52 * <code>myBean.set("myProperty", "myValue");</code></br>
53 *
54 * <p><b><u>Setting Indexed Properties</u></b></p>
55 * <p>If the property <b>doesn't</b> exist, the <code>LazyDynaBean</code> will automatically add
56 * a property with an <code>ArrayList</code> type to the <code>DynaClass</code> when
57 * the <code>set(name, index, value)</code> method is called.
58 * It will also instantiate a new <code>ArrayList</code> and automatically <i>grow</i>
59 * the <code>List</code> so that it is big enough to accomodate the index being set.
60 * <code>ArrayList</code> is the default indexed property that LazyDynaBean uses but
61 * this can be easily changed by overriding the <code>newIndexedProperty(name)</code>
62 * method.</p>
63 *
64 * <code>DynaBean myBean = new LazyDynaBean();</code></br>
65 * <code>myBean.set("myIndexedProperty", 0, "myValue1");</code></br>
66 * <code>myBean.set("myIndexedProperty", 1, "myValue2");</code></br>
67 *
68 * <p>If the indexed property <b>does</b> exist in the <code>DynaClass</code> but is set to
69 * <code>null</code> in the <code>LazyDynaBean</code>, then it will instantiate a
70 * new <code>List</code> or <code>Array</code> as specified by the property's type
71 * in the <code>DynaClass</code> and automatically <i>grow</i> the <code>List</code>
72 * or <code>Array</code> so that it is big enough to accomodate the index being set.</p>
73 *
74 * <code>DynaBean myBean = new LazyDynaBean();</code></br>
75 * <code>MutableDynaClass myClass = (MutableDynaClass)myBean.getDynaClass();</code></br>
76 * <code>myClass.add("myIndexedProperty", int[].class);</code></br>
77 * <code>myBean.set("myIndexedProperty", 0, new Integer(10));</code></br>
78 * <code>myBean.set("myIndexedProperty", 1, new Integer(20));</code></br>
79 *
80 * <p><b><u>Setting Mapped Properties</u></b></p>
81 * <p>If the property <b>doesn't</b> exist, the <code>LazyDynaBean</code> will automatically add
82 * a property with a <code>HashMap</code> type to the <code>DynaClass</code> and
83 * instantiate a new <code>HashMap</code> in the DynaBean when the
84 * <code>set(name, key, value)</code> method is called. <code>HashMap</code> is the default
85 * mapped property that LazyDynaBean uses but this can be easily changed by overriding
86 * the <code>newMappedProperty(name)</code> method.</p>
87 *
88 * <code>DynaBean myBean = new LazyDynaBean();</code></br>
89 * <code>myBean.set("myMappedProperty", "myKey", "myValue");</code></br>
90 *
91 * <p>If the mapped property <b>does</b> exist in the <code>DynaClass</code> but is set to
92 * <code>null</code> in the <code>LazyDynaBean</code>, then it will instantiate a
93 * new <code>Map</code> as specified by the property's type in the <code>DynaClass</code>.</p>
94 *
95 * <code>DynaBean myBean = new LazyDynaBean();</code></br>
96 * <code>MutableDynaClass myClass = (MutableDynaClass)myBean.getDynaClass();</code></br>
97 * <code>myClass.add("myMappedProperty", TreeMap.class);</code></br>
98 * <code>myBean.set("myMappedProperty", "myKey", "myValue");</code></br>
99 *
100 * <p><b><u><i>Restricted</i> DynaClass</u></b></p>
101 * <p><code>MutableDynaClass</code> have a facility to <i>restrict</i> the <code>DynaClass</code>
102 * so that its properties cannot be modified. If the <code>MutableDynaClass</code> is
103 * restricted then calling any of the <code>set()</code> methods for a property which
104 * doesn't exist will result in a <code>IllegalArgumentException</code> being thrown.</p>
105 *
106 * @see LazyDynaClass
107 * @author Niall Pemberton
108 */
109 public class LazyDynaBean implements DynaBean, Serializable {
110
111
112 /**
113 * Commons Logging
114 */
115 private static Log logger = LogFactory.getLog(LazyDynaBean.class);
116
117 protected static final BigInteger BigInteger_ZERO = new BigInteger("0");
118 protected static final BigDecimal BigDecimal_ZERO = new BigDecimal("0");
119 protected static final Character Character_SPACE = new Character(' ');
120 protected static final Byte Byte_ZERO = new Byte((byte)0);
121 protected static final Short Short_ZERO = new Short((short)0);
122 protected static final Integer Integer_ZERO = new Integer(0);
123 protected static final Long Long_ZERO = new Long((long)0);
124 protected static final Float Float_ZERO = new Float((byte)0);
125 protected static final Double Double_ZERO = new Double((byte)0);
126
127 /**
128 * The <code>MutableDynaClass</code> "base class" that this DynaBean
129 * is associated with.
130 */
131 protected Map values;
132
133 /**
134 * The <code>MutableDynaClass</code> "base class" that this DynaBean
135 * is associated with.
136 */
137 protected MutableDynaClass dynaClass;
138
139
140
141
142 /**
143 * Construct a new <code>LazyDynaBean</code> with a <code>LazyDynaClass</code> instance.
144 */
145 public LazyDynaBean() {
146 this(new LazyDynaClass());
147 }
148
149 /**
150 * Construct a new <code>LazyDynaBean</code> with a <code>LazyDynaClass</code> instance.
151 *
152 * @param name Name of this DynaBean class
153 */
154 public LazyDynaBean(String name) {
155 this(new LazyDynaClass(name));
156 }
157
158 /**
159 * Construct a new <code>DynaBean</code> associated with the specified
160 * <code>DynaClass</code> instance - if its not a <code>MutableDynaClass</code>
161 * then a new <code>LazyDynaClass</code> is created and the properties copied.
162 *
163 * @param dynaClass The DynaClass we are associated with
164 */
165 public LazyDynaBean(DynaClass dynaClass) {
166
167 values = newMap();
168
169 if (dynaClass instanceof MutableDynaClass) {
170 this.dynaClass = (MutableDynaClass)dynaClass;
171 } else {
172 this.dynaClass = new LazyDynaClass(dynaClass.getName(), dynaClass.getDynaProperties());
173 }
174
175 }
176
177
178
179
180 /**
181 * Return the Map backing this <code>DynaBean</code>
182 */
183 public Map getMap() {
184 return values;
185 }
186
187 /**
188 * <p>Return the size of an indexed or mapped property.</p>
189 *
190 * @param name Name of the property
191 * @exception IllegalArgumentException if no property name is specified
192 */
193 public int size(String name) {
194
195 if (name == null) {
196 throw new IllegalArgumentException("No property name specified");
197 }
198
199 Object value = values.get(name);
200 if (value == null) {
201 return 0;
202 }
203
204 if (value instanceof Map) {
205 return ((Map)value).size();
206 }
207
208 if (value instanceof List) {
209 return ((List)value).size();
210 }
211
212 if ((value.getClass().isArray())) {
213 return Array.getLength(value);
214 }
215
216 return 0;
217
218 }
219
220
221
222 /**
223 * Does the specified mapped property contain a value for the specified
224 * key value?
225 *
226 * @param name Name of the property to check
227 * @param key Name of the key to check
228 *
229 * @exception IllegalArgumentException if no property name is specified
230 */
231 public boolean contains(String name, String key) {
232
233 if (name == null) {
234 throw new IllegalArgumentException("No property name specified");
235 }
236
237 Object value = values.get(name);
238 if (value == null) {
239 return false;
240 }
241
242 if (value instanceof Map) {
243 return (((Map) value).containsKey(key));
244 }
245
246 return false;
247
248 }
249
250 /**
251 * <p>Return the value of a simple property with the specified name.</p>
252 *
253 * <p><strong>N.B.</strong> Returns <code>null</code> if there is no property
254 * of the specified name.</p>
255 *
256 * @param name Name of the property whose value is to be retrieved.
257 * @exception IllegalArgumentException if no property name is specified
258 */
259 public Object get(String name) {
260
261 if (name == null) {
262 throw new IllegalArgumentException("No property name specified");
263 }
264
265
266 Object value = values.get(name);
267 if (value != null) {
268 return value;
269 }
270
271
272 if (!isDynaProperty(name)) {
273 return null;
274 }
275
276
277 value = createProperty(name, dynaClass.getDynaProperty(name).getType());
278
279 if (value != null) {
280 set(name, value);
281 }
282
283 return value;
284
285 }
286
287 /**
288 * <p>Return the value of an indexed property with the specified name.</p>
289 *
290 * <p><strong>N.B.</strong> Returns <code>null</code> if there is no 'indexed'
291 * property of the specified name.</p>
292 *
293 * @param name Name of the property whose value is to be retrieved
294 * @param index Index of the value to be retrieved
295 *
296 * @exception IllegalArgumentException if the specified property
297 * exists, but is not indexed
298 * @exception IndexOutOfBoundsException if the specified index
299 * is outside the range of the underlying property
300 */
301 public Object get(String name, int index) {
302
303
304 if (!isDynaProperty(name)) {
305 set(name, defaultIndexedProperty(name));
306 }
307
308
309 Object indexedProperty = get(name);
310
311
312 if (!dynaClass.getDynaProperty(name).isIndexed()) {
313 throw new IllegalArgumentException
314 ("Non-indexed property for '" + name + "[" + index + "]' "
315 + dynaClass.getDynaProperty(name).getName());
316 }
317
318
319 indexedProperty = growIndexedProperty(name, indexedProperty, index);
320
321
322 if (indexedProperty.getClass().isArray()) {
323 return Array.get(indexedProperty, index);
324 } else if (indexedProperty instanceof List) {
325 return ((List)indexedProperty).get(index);
326 } else {
327 throw new IllegalArgumentException
328 ("Non-indexed property for '" + name + "[" + index + "]' "
329 + indexedProperty.getClass().getName());
330 }
331
332 }
333
334 /**
335 * <p>Return the value of a mapped property with the specified name.</p>
336 *
337 * <p><strong>N.B.</strong> Returns <code>null</code> if there is no 'mapped'
338 * property of the specified name.</p>
339 *
340 * @param name Name of the property whose value is to be retrieved
341 * @param key Key of the value to be retrieved
342 *
343 * @exception IllegalArgumentException if the specified property
344 * exists, but is not mapped
345 */
346 public Object get(String name, String key) {
347
348
349 if (!isDynaProperty(name)) {
350 set(name, defaultMappedProperty(name));
351 }
352
353
354 Object mappedProperty = get(name);
355
356
357 if (!dynaClass.getDynaProperty(name).isMapped()) {
358 throw new IllegalArgumentException
359 ("Non-mapped property for '" + name + "(" + key + ")' "
360 + dynaClass.getDynaProperty(name).getType().getName());
361 }
362
363
364 if (mappedProperty instanceof Map) {
365 return (((Map) mappedProperty).get(key));
366 } else {
367 throw new IllegalArgumentException
368 ("Non-mapped property for '" + name + "(" + key + ")'"
369 + mappedProperty.getClass().getName());
370 }
371
372 }
373
374
375 /**
376 * Return the <code>DynaClass</code> instance that describes the set of
377 * properties available for this DynaBean.
378 */
379 public DynaClass getDynaClass() {
380 return (DynaClass)dynaClass;
381 }
382
383 /**
384 * Remove any existing value for the specified key on the
385 * specified mapped property.
386 *
387 * @param name Name of the property for which a value is to
388 * be removed
389 * @param key Key of the value to be removed
390 *
391 * @exception IllegalArgumentException if there is no property
392 * of the specified name
393 */
394 public void remove(String name, String key) {
395
396 if (name == null) {
397 throw new IllegalArgumentException("No property name specified");
398 }
399
400 Object value = values.get(name);
401 if (value == null) {
402 return;
403 }
404
405 if (value instanceof Map) {
406 ((Map) value).remove(key);
407 } else {
408 throw new IllegalArgumentException
409 ("Non-mapped property for '" + name + "(" + key + ")'"
410 + value.getClass().getName());
411 }
412
413 }
414
415 /**
416 * Set the value of a simple property with the specified name.
417 *
418 * @param name Name of the property whose value is to be set
419 * @param value Value to which this property is to be set
420 *
421 * @exception IllegalArgumentException if this is not an existing property
422 * name for our DynaClass and the MutableDynaClass is restricted
423 * @exception ConversionException if the specified value cannot be
424 * converted to the type required for this property
425 * @exception NullPointerException if an attempt is made to set a
426 * primitive property to null
427 */
428 public void set(String name, Object value) {
429
430
431 if (!isDynaProperty(name)) {
432
433 if (dynaClass.isRestricted()) {
434 throw new IllegalArgumentException
435 ("Invalid property name '" + name + "' (DynaClass is restricted)");
436 }
437 if (value == null) {
438 dynaClass.add(name);
439 } else {
440 dynaClass.add(name, value.getClass());
441 }
442
443 }
444
445 DynaProperty descriptor = dynaClass.getDynaProperty(name);
446
447 if (value == null) {
448 if (descriptor.getType().isPrimitive()) {
449 throw new NullPointerException
450 ("Primitive value for '" + name + "'");
451 }
452 } else if (!isAssignable(descriptor.getType(), value.getClass())) {
453 throw new ConversionException
454 ("Cannot assign value of type '" +
455 value.getClass().getName() +
456 "' to property '" + name + "' of type '" +
457 descriptor.getType().getName() + "'");
458 }
459
460
461 values.put(name, value);
462
463 }
464
465 /**
466 * Set the value of an indexed property with the specified name.
467 *
468 * @param name Name of the property whose value is to be set
469 * @param index Index of the property to be set
470 * @param value Value to which this property is to be set
471 *
472 * @exception ConversionException if the specified value cannot be
473 * converted to the type required for this property
474 * @exception IllegalArgumentException if there is no property
475 * of the specified name
476 * @exception IllegalArgumentException if the specified property
477 * exists, but is not indexed
478 * @exception IndexOutOfBoundsException if the specified index
479 * is outside the range of the underlying property
480 */
481 public void set(String name, int index, Object value) {
482
483
484 if (!isDynaProperty(name)) {
485 set(name, defaultIndexedProperty(name));
486 }
487
488
489 Object indexedProperty = get(name);
490
491
492 if (!dynaClass.getDynaProperty(name).isIndexed()) {
493 throw new IllegalArgumentException
494 ("Non-indexed property for '" + name + "[" + index + "]'"
495 + dynaClass.getDynaProperty(name).getType().getName());
496 }
497
498
499 indexedProperty = growIndexedProperty(name, indexedProperty, index);
500
501
502 if (indexedProperty.getClass().isArray()) {
503 Array.set(indexedProperty, index, value);
504 } else if (indexedProperty instanceof List) {
505 ((List)indexedProperty).set(index, value);
506 } else {
507 throw new IllegalArgumentException
508 ("Non-indexed property for '" + name + "[" + index + "]' "
509 + indexedProperty.getClass().getName());
510 }
511
512 }
513
514 /**
515 * Set the value of a mapped property with the specified name.
516 *
517 * @param name Name of the property whose value is to be set
518 * @param key Key of the property to be set
519 * @param value Value to which this property is to be set
520 *
521 * @exception ConversionException if the specified value cannot be
522 * converted to the type required for this property
523 * @exception IllegalArgumentException if there is no property
524 * of the specified name
525 * @exception IllegalArgumentException if the specified property
526 * exists, but is not mapped
527 */
528 public void set(String name, String key, Object value) {
529
530
531 if (!isDynaProperty(name)) {
532 set(name, defaultMappedProperty(name));
533 }
534
535
536 Object mappedProperty = get(name);
537
538
539 if (!dynaClass.getDynaProperty(name).isMapped()) {
540 throw new IllegalArgumentException
541 ("Non-mapped property for '" + name + "(" + key + ")'"
542 + dynaClass.getDynaProperty(name).getType().getName());
543 }
544
545
546 ((Map)mappedProperty).put(key, value);
547
548 }
549
550
551
552 protected Object growIndexedProperty(String name, Object indexedProperty, int index) {
553
554
555 if (indexedProperty instanceof List) {
556
557 List list = (List)indexedProperty;
558 while (index >= list.size()) {
559 list.add(null);
560 }
561
562 }
563
564
565 if ((indexedProperty.getClass().isArray())) {
566
567 int length = Array.getLength(indexedProperty);
568 if (index >= length) {
569 Class componentType = indexedProperty.getClass().getComponentType();
570 Object newArray = Array.newInstance(componentType, (index + 1));
571 System.arraycopy(indexedProperty, 0, newArray, 0, length);
572 indexedProperty = newArray;
573 set(name, indexedProperty);
574 int newLength = Array.getLength(indexedProperty);
575 for (int i = length; i < newLength; i++) {
576 Array.set(indexedProperty, i, createProperty(name+"["+i+"]", componentType));
577 }
578 }
579 }
580
581 return indexedProperty;
582
583 }
584
585 /**
586 * Create a new Instance of a Property
587 */
588 protected Object createProperty(String name, Class type) {
589
590
591 if (type.isArray() || List.class.isAssignableFrom(type)) {
592 return createIndexedProperty(name, type);
593 }
594
595 if (Map.class.isAssignableFrom(type)) {
596 return createMappedProperty(name, type);
597 }
598
599 if (DynaBean.class.isAssignableFrom(type)) {
600 return createDynaBeanProperty(name, type);
601 }
602
603 if (type.isPrimitive()) {
604 return createPrimitiveProperty(name, type);
605 }
606
607 if (Number.class.isAssignableFrom(type)) {
608 return createNumberProperty(name, type);
609 }
610
611 return createOtherProperty(name, type);
612
613 }
614
615 /**
616 * Create a new Instance of an 'Indexed' Property
617 */
618 protected Object createIndexedProperty(String name, Class type) {
619
620
621 Object indexedProperty = null;
622
623 if (type == null) {
624
625 indexedProperty = defaultIndexedProperty(name);
626
627 } else if (type.isArray()) {
628
629 indexedProperty = Array.newInstance(type.getComponentType(), 0);
630
631 } else if (List.class.isAssignableFrom(type)) {
632 if (type.isInterface()) {
633 indexedProperty = defaultIndexedProperty(name);
634 } else {
635 try {
636 indexedProperty = type.newInstance();
637 }
638 catch (Exception ex) {
639 throw new IllegalArgumentException
640 ("Error instantiating indexed property of type '" +
641 type.getName() + "' for '" + name + "' " + ex);
642 }
643 }
644 } else {
645
646 throw new IllegalArgumentException
647 ("Non-indexed property of type '" + type.getName() + "' for '" + name + "'");
648 }
649
650 return indexedProperty;
651
652 }
653
654 /**
655 * Create a new Instance of a 'Mapped' Property
656 */
657 protected Object createMappedProperty(String name, Class type) {
658
659
660 Object mappedProperty = null;
661
662 if (type == null) {
663
664 mappedProperty = defaultMappedProperty(name);
665
666 } else if (type.isInterface()) {
667
668 mappedProperty = defaultMappedProperty(name);
669
670 } else if (Map.class.isAssignableFrom(type)) {
671 try {
672 mappedProperty = type.newInstance();
673 }
674 catch (Exception ex) {
675 throw new IllegalArgumentException
676 ("Error instantiating mapped property of type '" + type.getName() + "' for '" + name + "' " + ex);
677 }
678 } else {
679
680 throw new IllegalArgumentException
681 ("Non-mapped property of type '" + type.getName() + "' for '" + name + "'");
682 }
683
684 return mappedProperty;
685
686 }
687
688 /**
689 * Create a new Instance of a 'Mapped' Property
690 */
691 protected Object createDynaBeanProperty(String name, Class type) {
692 try {
693 return type.newInstance();
694 }
695 catch (Exception ex) {
696 if (logger.isWarnEnabled()) {
697 logger.warn("Error instantiating DynaBean property of type '" + type.getName() + "' for '" + name + "' " + ex);
698 }
699 return null;
700 }
701 }
702
703 /**
704 * Create a new Instance of a 'Primitive' Property
705 */
706 protected Object createPrimitiveProperty(String name, Class type) {
707
708 if (type == Boolean.TYPE) {
709 return Boolean.FALSE;
710 } else if (type == Integer.TYPE) {
711 return Integer_ZERO;
712 } else if (type == Long.TYPE) {
713 return Long_ZERO;
714 } else if (type == Double.TYPE) {
715 return Double_ZERO;
716 } else if (type == Float.TYPE) {
717 return Float_ZERO;
718 } else if (type == Byte.TYPE) {
719 return Byte_ZERO;
720 } else if (type == Short.TYPE) {
721 return Short_ZERO;
722 } else if (type == Character.TYPE) {
723 return Character_SPACE;
724 } else {
725 return null;
726 }
727
728 }
729
730 /**
731 * Create a new Instance of a 'Primitive' Property
732 */
733 protected Object createNumberProperty(String name, Class type) {
734
735 return null;
736
737 }
738
739 /**
740 * Create a new Instance of a 'Mapped' Property
741 */
742 protected Object createOtherProperty(String name, Class type) {
743
744 if (type == String.class || type == Boolean.class ||
745 type == Character.class || Date.class.isAssignableFrom(type)) {
746 return null;
747 }
748
749 try {
750 return type.newInstance();
751 }
752 catch (Exception ex) {
753 if (logger.isWarnEnabled()) {
754 logger.warn("Error instantiating property of type '" + type.getName() + "' for '" + name + "' " + ex);
755 }
756 return null;
757 }
758 }
759
760 /**
761 * <p>Creates a new <code>ArrayList</code> for an 'indexed' property
762 * which doesn't exist.</p>
763 *
764 * <p>This method shouls be overriden if an alternative <code>List</code>
765 * or <code>Array</code> implementation is required for 'indexed' properties.</p>
766 *
767 * @param name Name of the 'indexed property.
768 */
769 protected Object defaultIndexedProperty(String name) {
770 return new ArrayList();
771 }
772
773 /**
774 * <p>Creates a new <code>HashMap</code> for a 'mapped' property
775 * which doesn't exist.</p>
776 *
777 * <p>This method can be overriden if an alternative <code>Map</code>
778 * implementation is required for 'mapped' properties.</p>
779 *
780 * @param name Name of the 'mapped property.
781 */
782 protected Map defaultMappedProperty(String name) {
783 return new HashMap();
784 }
785
786 /**
787 * Indicates if there is a property with the specified name.
788 */
789 protected boolean isDynaProperty(String name) {
790
791 if (name == null) {
792 throw new IllegalArgumentException("No property name specified");
793 }
794
795
796 if (dynaClass instanceof LazyDynaClass) {
797 return ((LazyDynaClass)dynaClass).isDynaProperty(name);
798 }
799
800
801 return dynaClass.getDynaProperty(name) == null ? false : true;
802
803 }
804
805 /**
806 * Is an object of the source class assignable to the destination class?
807 *
808 * @param dest Destination class
809 * @param source Source class
810 */
811 protected boolean isAssignable(Class dest, Class source) {
812
813 if (dest.isAssignableFrom(source) ||
814 ((dest == Boolean.TYPE) && (source == Boolean.class)) ||
815 ((dest == Byte.TYPE) && (source == Byte.class)) ||
816 ((dest == Character.TYPE) && (source == Character.class)) ||
817 ((dest == Double.TYPE) && (source == Double.class)) ||
818 ((dest == Float.TYPE) && (source == Float.class)) ||
819 ((dest == Integer.TYPE) && (source == Integer.class)) ||
820 ((dest == Long.TYPE) && (source == Long.class)) ||
821 ((dest == Short.TYPE) && (source == Short.class))) {
822 return (true);
823 } else {
824 return (false);
825 }
826
827 }
828
829 /**
830 * <p>Creates a new instance of the <code>Map</code>.</p>
831 */
832 protected Map newMap() {
833 return new HashMap();
834 }
835
836 }