1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 package info.magnolia.objectfactory.configuration;
35
36 import static java.util.stream.Collectors.toMap;
37
38 import java.util.ArrayList;
39 import java.util.HashMap;
40 import java.util.List;
41 import java.util.Map;
42
43 import com.google.inject.Key;
44 import com.google.inject.Provider;
45
46
47
48
49
50 public class ComponentProviderConfiguration implements Cloneable {
51
52 private Map<Key, Class> typeMapping = new HashMap<>();
53 private Map<Key, ComponentConfiguration> components = new HashMap<>();
54 private List<ComponentConfigurer> configurers = new ArrayList<>();
55
56 public void addComponent(ComponentConfiguration componentConfiguration) {
57 this.components.put(componentConfiguration.getKey(), componentConfiguration);
58 }
59
60 public void addTypeMapping(Key<?> from, Class<?> to) {
61 this.typeMapping.put(from, to);
62 }
63
64 public void addTypeMapping(Class<?> from, Class<?> to) {
65 this.typeMapping.put(Key.get(from), to);
66 }
67
68 public Map<Key, Class> getAnnotatedTypeMappings() {
69 return this.typeMapping;
70 }
71
72
73
74
75 @Deprecated
76 @SuppressWarnings("unchecked")
77 public Map<Class<?>, Class<?>> getTypeMapping() {
78 return typeMapping
79 .entrySet()
80 .stream()
81 .collect(toMap(entry -> entry.getKey().getTypeLiteral().getRawType(), Map.Entry::getValue));
82 }
83
84 public Map<Key, ComponentConfiguration> getAnnotatedComponents() {
85 return components;
86 }
87
88
89
90
91 @Deprecated
92 @SuppressWarnings("unchecked")
93 public Map<Class, ComponentConfiguration> getComponents() {
94 return components
95 .entrySet()
96 .stream()
97 .collect(toMap(entry -> entry.getKey().getTypeLiteral().getRawType(), Map.Entry::getValue));
98 }
99
100 public List<ComponentConfigurer> getConfigurers() {
101 return configurers;
102 }
103
104 public boolean addConfigurer(ComponentConfigurer configurer) {
105 return configurers.add(configurer);
106 }
107
108 public <T> void registerImplementation(Class<T> type, Class<? extends T> implementation) {
109 addComponent(ImplementationConfiguration.valueOf(type, implementation));
110 }
111
112 public <T> void registerImplementation(Class<T> type) {
113 registerImplementation(type, type);
114 }
115
116 public <T> void registerInstance(Class<T> type, Object instance) {
117 addComponent(InstanceConfiguration.valueOf(type, instance));
118 }
119
120 public <T> void registerProvider(Class<T> type, Class<? extends Provider<T>> providerClass) {
121 addComponent(ProviderConfiguration.of(type, providerClass));
122 }
123
124 public void combine(ComponentProviderConfiguration components) {
125 this.typeMapping.putAll(components.typeMapping);
126 this.components.putAll(components.clone().components);
127 this.configurers.addAll(components.configurers);
128 }
129
130 @Override
131 public ComponentProviderConfiguration clone() {
132 try {
133 ComponentProviderConfiguration clone = (ComponentProviderConfiguration) super.clone();
134 clone.components = new HashMap<>();
135 for (Map.Entry<Key, ComponentConfiguration> entry : components.entrySet()) {
136 clone.components.put(entry.getKey(), entry.getValue().clone());
137 }
138 clone.typeMapping = new HashMap<>(typeMapping);
139 clone.configurers = new ArrayList<>(configurers);
140 return clone;
141 } catch (CloneNotSupportedException e) {
142
143 throw new RuntimeException(e);
144 }
145 }
146 }