MentaContainer

Rev

Rev 146 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 146 Rev 148
Line 22... Line 22...
22
 */
22
 */
23
class ClassFactory implements ConfigurableFactory {
23
class ClassFactory implements ConfigurableFactory {
24
       
24
       
25
                private final MentaContainer container;
25
                private final MentaContainer container;
26
       
26
       
27
            private final Class<? extends Object> klass;
-
 
-
 
27
            private final Class<?> klass;
28
           
28
           
29
            private Map<String, Object> props = null;
29
            private Map<String, Object> props = null;
30
           
30
           
31
            private List<Object> initValues = null;
31
            private List<Object> initValues = null;
32
           
32
           
33
            private List<Class<? extends Object>> initTypes = null;
-
 
-
 
33
            private List<Class<?>> initTypes = null;
34
           
34
           
35
            private Constructor<? extends Object> constructor = null;
-
 
-
 
35
            private Constructor<?> constructor = null;
36
           
36
           
37
            private Map<String, Method> cache = null;
37
            private Map<String, Method> cache = null;
38
           
38
           
39
            private boolean useZeroArgumentsConstructor = false;
39
            private boolean useZeroArgumentsConstructor = false;
40
           
40
           
41
            private final Set<ConstructorDependency> constructorDependencies;
41
            private final Set<ConstructorDependency> constructorDependencies;
42
           
42
           
43
            public ClassFactory(MentaContainer container, Class<? extends Object> klass) {
-
 
-
 
43
            public ClassFactory(MentaContainer container, Class<?> klass) {
44
44
45
                this(container, klass, null);
45
                this(container, klass, null);
46
            }
46
            }
47
           
47
           
48
            ClassFactory(MentaContainer container, Class<? extends Object> klass, Set<ConstructorDependency> constructorDependencies) {
-
 
-
 
48
            ClassFactory(MentaContainer container, Class<?> klass, Set<ConstructorDependency> constructorDependencies) {
49
               
49
               
50
                this.container = container;
50
                this.container = container;
51
               
51
               
52
                this.klass = klass;
52
                this.klass = klass;
53
               
53
               
Line 99... Line 99...
99
                String k = InjectionUtils.getKeyName(key);
99
                String k = InjectionUtils.getKeyName(key);
100
               
100
               
101
                return addInitValue(new DependencyKey(k), container.getType(k));
101
                return addInitValue(new DependencyKey(k), container.getType(k));
102
            }
102
            }
103
           
103
           
104
            private ConfigurableFactory addInitValue(Object value, Class<? extends Object> type) {
-
 
-
 
104
            private ConfigurableFactory addInitValue(Object value, Class<?> type) {
105
               
105
               
106
                if (initValues == null) {
106
                if (initValues == null) {
107
                       
107
                       
108
                    initValues = new LinkedList<Object>();
108
                    initValues = new LinkedList<Object>();
109
                   
109
                   
110
                    initTypes = new LinkedList<Class<? extends Object>>();
-
 
-
 
110
                    initTypes = new LinkedList<Class<?>>();
111
                }
111
                }
112
               
112
               
113
                initValues.add(value);
113
                initValues.add(value);
114
               
114
               
115
                initTypes.add(type);
115
                initTypes.add(type);
Line 124... Line 124...
124
            }
124
            }
125
           
125
           
126
            @Override
126
            @Override
127
            public ConfigurableFactory addInitPrimitive(Object value) {
127
            public ConfigurableFactory addInitPrimitive(Object value) {
128
               
128
               
129
                Class<? extends Object> primitive = getPrimitiveFrom(value);
-
 
-
 
129
                Class<?> primitive = getPrimitiveFrom(value);
130
               
130
               
131
                if (primitive == null) throw new IllegalArgumentException("Value is not a primitive: " + value);
131
                if (primitive == null) throw new IllegalArgumentException("Value is not a primitive: " + value);
132
               
132
               
133
                return addInitValue(value, primitive);
133
                return addInitValue(value, primitive);
134
            }
134
            }
135
           
135
           
136
            private List<Class<? extends Object>> convertToPrimitives(List<Class<? extends Object>> list) {
-
 
-
 
136
            private List<Class<?>> convertToPrimitives(List<Class<?>> list) {
137
               
137
               
138
                if (list == null) return null;
138
                if (list == null) return null;
139
               
139
               
140
                Iterator<Class<? extends Object>> iter = list.iterator();
-
 
-
 
140
                Iterator<Class<?>> iter = list.iterator();
141
               
141
               
142
                List<Class<? extends Object>> results = new LinkedList<Class<? extends Object>>();
-
 
-
 
142
                List<Class<?>> results = new LinkedList<Class<?>>();
143
               
143
               
144
                while(iter.hasNext()) {
144
                while(iter.hasNext()) {
145
                       
145
                       
146
                        Class<? extends Object> klass = iter.next();
-
 
-
 
146
                        Class<?> klass = iter.next();
147
                       
147
                       
148
                        Class<? extends Object> primitive = getPrimitiveFrom(klass);
-
 
-
 
148
                        Class<?> primitive = getPrimitiveFrom(klass);
149
                       
149
                       
150
                        if (primitive != null) {
150
                        if (primitive != null) {
151
                               
151
                               
152
                                results.add(primitive);
152
                                results.add(primitive);
153
                               
153
                               
Line 158... Line 158...
158
                }
158
                }
159
               
159
               
160
                return results;
160
                return results;
161
            }
161
            }
162
           
162
           
163
            private Class<? extends Object>[] getClasses(List<Class<? extends Object>> values) {
-
 
-
 
163
            private Class<?>[] getClasses(List<Class<?>> values) {
164
               
164
               
165
                if (values == null) return new Class[0];
165
                if (values == null) return new Class[0];
166
               
166
               
167
                Class<? extends Object>[] types = (Class<? extends Object>[]) new Class[values.size()];
-
 
-
 
167
                Class<?>[] types = (Class<?>[]) new Class[values.size()];
168
               
168
               
169
                return values.toArray(types);
169
                return values.toArray(types);
170
            }
170
            }
171
           
171
           
172
            private Object [] getValues(List<Object> values) throws InstantiationException {
172
            private Object [] getValues(List<Object> values) throws InstantiationException {
Line 223... Line 223...
223
                           
223
                           
224
                        } catch(Exception e) {
224
                        } catch(Exception e) {
225
                               
225
                               
226
                            // try primitive...
226
                            // try primitive...
227
                               
227
                               
228
                            Class<? extends Object> primitive = getPrimitiveFrom(value);
-
 
-
 
228
                            Class<?> primitive = getPrimitiveFrom(value);
229
                           
229
                           
230
                            if (primitive != null) {
230
                            if (primitive != null) {
231
                               
231
                               
232
                                try {
232
                                try {
233
                                       
233
                                       
Line 263... Line 263...
263
                               
263
                               
264
                                throw new RuntimeException("Error trying to set a property with reflection: " + name, e);
264
                                throw new RuntimeException("Error trying to set a property with reflection: " + name, e);
265
                        }
265
                        }
266
                }
266
                }
267
           
267
           
268
            private static Class<? extends Object> getPrimitiveFrom(Object w) {
-
 
-
 
268
            private static Class<?> getPrimitiveFrom(Object w) {
269
                if (w instanceof Boolean) { return Boolean.TYPE; }
269
                if (w instanceof Boolean) { return Boolean.TYPE; }
270
                else if (w instanceof Byte) { return Byte.TYPE; }
270
                else if (w instanceof Byte) { return Byte.TYPE; }
271
                else if (w instanceof Short) { return Short.TYPE; }
271
                else if (w instanceof Short) { return Short.TYPE; }
272
                else if (w instanceof Character) { return Character.TYPE; }
272
                else if (w instanceof Character) { return Character.TYPE; }
273
                else if (w instanceof Integer) { return Integer.TYPE; }
273
                else if (w instanceof Integer) { return Integer.TYPE; }
Line 275... Line 275...
275
                else if (w instanceof Float) { return Float.TYPE; }
275
                else if (w instanceof Float) { return Float.TYPE; }
276
                else if (w instanceof Double) { return Double.TYPE; }
276
                else if (w instanceof Double) { return Double.TYPE; }
277
                return null;
277
                return null;
278
            }
278
            }
279
           
279
           
280
            private static Class<? extends Object> getPrimitiveFrom(Class<? extends Object> klass) {
-
 
-
 
280
            private static Class<?> getPrimitiveFrom(Class<?> klass) {
281
                if (klass.equals(Boolean.class)) { return Boolean.TYPE; }
281
                if (klass.equals(Boolean.class)) { return Boolean.TYPE; }
282
                else if (klass.equals(Byte.class)) { return Byte.TYPE; }
282
                else if (klass.equals(Byte.class)) { return Byte.TYPE; }
283
                else if (klass.equals(Short.class)) { return Short.TYPE; }
283
                else if (klass.equals(Short.class)) { return Short.TYPE; }
284
                else if (klass.equals(Character.class)) { return Character.TYPE; }
284
                else if (klass.equals(Character.class)) { return Character.TYPE; }
285
                else if (klass.equals(Integer.class)) { return Integer.TYPE; }
285
                else if (klass.equals(Integer.class)) { return Integer.TYPE; }
Line 374... Line 374...
374
                }
374
                }
375
               
375
               
376
                return (T) obj;
376
                return (T) obj;
377
            }
377
            }
378
           
378
           
379
            private static boolean betterIsAssignableFrom(Class<? extends Object> klass1, Class<? extends Object> klass2) {
-
 
-
 
379
            private static boolean betterIsAssignableFrom(Class<?> klass1, Class<?> klass2) {
380
               
380
               
381
                // with autoboxing both ways...
381
                // with autoboxing both ways...
382
               
382
               
383
                if (klass1.isAssignableFrom(klass2)) return true;
383
                if (klass1.isAssignableFrom(klass2)) return true;
384
               
384
               
385
                Class<? extends Object> k1 = klass1.isPrimitive() ? klass1 : getPrimitiveFrom(klass1);
-
 
386
                Class<? extends Object> k2 = klass2.isPrimitive() ? klass2 : getPrimitiveFrom(klass2);
-
 
-
 
385
                Class<?> k1 = klass1.isPrimitive() ? klass1 : getPrimitiveFrom(klass1);
-
 
386
                Class<?> k2 = klass2.isPrimitive() ? klass2 : getPrimitiveFrom(klass2);
387
               
387
               
388
                if (k1 == null || k2 == null) return false;
388
                if (k1 == null || k2 == null) return false;
389
               
389
               
390
                return k1.isAssignableFrom(k2);
390
                return k1.isAssignableFrom(k2);
391
            }
391
            }
392
           
392
           
393
            private void checkConstructorDependencies() {
393
            private void checkConstructorDependencies() {
394
               
394
               
395
                Constructor<? extends Object>[] constructors = klass.getConstructors();
-
 
-
 
395
                Constructor<?>[] constructors = klass.getConstructors();
396
               
396
               
397
                for(Constructor<? extends Object> c : constructors) {
-
 
-
 
397
                for(Constructor<?> c : constructors) {
398
                       
398
                       
399
                        LinkedList<Class<? extends Object>> providedInitTypes = null;
-
 
-
 
399
                        LinkedList<Class<?>> providedInitTypes = null;
400
                       
400
                       
401
                        if (initTypes != null) {
401
                        if (initTypes != null) {
402
                               
402
                               
403
                                providedInitTypes = new LinkedList<Class<? extends Object>>(initTypes);
-
 
-
 
403
                                providedInitTypes = new LinkedList<Class<?>>(initTypes);
404
                               
404
                               
405
                        } else {
405
                        } else {
406
                               
406
                               
407
                                providedInitTypes = new LinkedList<Class<? extends Object>>();
-
 
-
 
407
                                providedInitTypes = new LinkedList<Class<?>>();
408
                        }
408
                        }
409
                       
409
                       
410
                        LinkedList<Object> providedInitValues = null;
410
                        LinkedList<Object> providedInitValues = null;
411
                       
411
                       
412
                        if (initValues != null) {
412
                        if (initValues != null) {
Line 416... Line 416...
416
                        } else {
416
                        } else {
417
                               
417
                               
418
                                providedInitValues = new LinkedList<Object>();
418
                                providedInitValues = new LinkedList<Object>();
419
                        }
419
                        }
420
                       
420
                       
421
                        LinkedList<Class<? extends Object>> newInitTypes = new LinkedList<Class<? extends Object>>();
-
 
-
 
421
                        LinkedList<Class<?>> newInitTypes = new LinkedList<Class<?>>();
422
                        LinkedList<Object> newInitValues = new LinkedList<Object>();
422
                        LinkedList<Object> newInitValues = new LinkedList<Object>();
423
                       
423
                       
424
                        Set<ConstructorDependency> constructorDependencies = this.constructorDependencies != null ? this.constructorDependencies : container.getConstructorDependencies();
424
                        Set<ConstructorDependency> constructorDependencies = this.constructorDependencies != null ? this.constructorDependencies : container.getConstructorDependencies();
425
                       
425
                       
426
                        Set<ConstructorDependency> dependencies = new HashSet<ConstructorDependency>(constructorDependencies);
426
                        Set<ConstructorDependency> dependencies = new HashSet<ConstructorDependency>(constructorDependencies);
427
                       
427
                       
428
                        Class<? extends Object>[] constructorParams = c.getParameterTypes();
-
 
-
 
428
                        Class<?>[] constructorParams = c.getParameterTypes();
429
                       
429
                       
430
                        if (constructorParams == null || constructorParams.length == 0) continue; // skip default constructor for now...
430
                        if (constructorParams == null || constructorParams.length == 0) continue; // skip default constructor for now...
431
                       
431
                       
432
                        for(Class<? extends Object> constructorParam : constructorParams) {
-
 
-
 
432
                        for(Class<?> constructorParam : constructorParams) {
433
                               
433
                               
434
                                // first see if it was provided...
434
                                // first see if it was provided...
435
                               
435
                               
436
                                Class<? extends Object> provided = providedInitTypes.isEmpty() ? null : providedInitTypes.get(0);
-
 
-
 
436
                                Class<?> provided = providedInitTypes.isEmpty() ? null : providedInitTypes.get(0);
437
                               
437
                               
438
                                if (provided != null && constructorParam.isAssignableFrom(provided)) {
438
                                if (provided != null && constructorParam.isAssignableFrom(provided)) {
439
                                       
439
                                       
440
                                        newInitTypes.add(providedInitTypes.removeFirst()); // we matched this one, so remove...
440
                                        newInitTypes.add(providedInitTypes.removeFirst()); // we matched this one, so remove...
441
                                       
441
                                       
Line 497... Line 497...
497
               
497
               
498
                private String getKey() { return key; }
498
                private String getKey() { return key; }
499
            }
499
            }
500
           
500
           
501
            @Override
501
            @Override
502
            public Class<? extends Object> getType() {
-
 
-
 
502
            public Class<?> getType() {
503
                return klass;
503
                return klass;
504
            }
504
            }
505
        }
505
        }