1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package jp.liq.container.vocabulary;
17
18 import jp.liq.container.component.ComponentMethodComponent;
19 import jp.liq.container.component.ConstructorComponent;
20 import jp.liq.container.component.InjectableComponentList;
21 import jp.liq.container.component.MappingComponent;
22 import jp.liq.container.component.ObjectComponent;
23 import jp.liq.container.component.ObjectMethodComponent;
24 import jp.liq.container.reflect.ClassMethodFinder;
25 import jp.liq.container.reflect.ConstructorWrapper;
26 import jp.liq.container.reflect.MethodWrapper;
27 import jp.liq.container.reflect.ObjectMethod;
28 import jp.liq.container.reflect.ObjectMethodFinder;
29 import jp.liq.container.vocabulary.VocabularyException.Reason;
30
31
32
33
34
35
36 public class Components {
37 private final Methods methods = new Methods();
38
39
40
41
42 public <T> MappingComponent<T> mapping(Class<T> type, Class<?> subtype) {
43
44 if(!type.isAssignableFrom(subtype)) {
45 throw new VocabularyException(Reason.INVALID_MAPPING,
46 type, subtype);
47 }
48 return new MappingComponent<T>(type, subtype);
49 }
50
51
52
53
54 public <T> ObjectComponent<T> instance(Class<T> type ,T obj) {
55 return new ObjectComponent<T>(type, obj);
56 }
57
58
59
60
61
62
63
64 public InjectableComponentList factory(Object obj) {
65 return from(methods.of(obj).withAnnotation(Factory.class));
66 }
67
68 public InjectableComponentList factory(Class<?> type) {
69 return from(methods.of(type).withAnnotation(Factory.class));
70 }
71
72
73
74
75
76
77
78 public <T> ConstructorComponent<T> from(ConstructorWrapper<T> ctor) {
79 Class<T> declaringClass = ctor.getConstructor().getDeclaringClass();
80 boolean recycled = declaringClass.isAnnotationPresent(Recycle.class);
81 return new ConstructorComponent<T>(ctor, declaringClass, recycled);
82 }
83
84
85
86
87
88
89
90 public <T> InjectableComponentList from(ObjectMethodFinder finder) {
91 InjectableComponentList rv = new InjectableComponentList();
92 for(ObjectMethod m : finder) {
93 rv.add(createObjectMethodComponent(m.getMethod().getReturnType(), m));
94 }
95 return rv;
96 }
97
98
99
100
101
102
103
104 public InjectableComponentList from(ClassMethodFinder<?> finder) {
105 InjectableComponentList rv =
106 new InjectableComponentList();
107 for(MethodWrapper m : finder) {
108 rv.add(createComponentMethodComponent(m.getMethod().getReturnType(), m,
109 finder.getOwnerClass()));
110 }
111 return rv;
112 }
113
114 private <T> ObjectMethodComponent<T> createObjectMethodComponent(Class<T> returnType,
115 ObjectMethod m) {
116 return new ObjectMethodComponent<T>(returnType, m);
117 }
118
119 private <T> ComponentMethodComponent<T> createComponentMethodComponent(Class<T> rtype,
120 MethodWrapper m, Class<?> ctype) {
121 return new ComponentMethodComponent<T>(rtype, m, ctype);
122 }
123 }