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.config.registry;
35
36 import info.magnolia.config.source.ConfigurationSourceType;
37
38 import java.util.Collection;
39 import java.util.Set;
40
41 import javax.inject.Inject;
42
43 import com.google.common.base.Function;
44 import com.google.common.base.Predicate;
45 import com.google.common.collect.Collections2;
46 import com.google.common.collect.Iterables;
47 import com.google.common.collect.Lists;
48
49
50
51
52 public class RegistryFacadeImpl implements RegistryFacade {
53 private final Collection<Registry> registries;
54
55 @Inject
56 public RegistryFacadeImpl(Set<Registry> registries) {
57 this.registries = registries;
58
59 }
60
61 @Override
62 public Registry registryFor(final DefinitionType type) {
63 return Iterables.find(registries, new RegistryByType(type));
64 }
65
66 @Override
67 public Collection<Registry> all() {
68 return registries;
69 }
70
71 @Override
72 public Collection<DefinitionProvider> byModule(String moduleName) {
73 return query().from(moduleName).findMultiple();
74 }
75
76 @Override
77 public Collection<DefinitionProvider> byType(DefinitionType type) {
78 return query().ofType(type).findMultiple();
79 }
80
81 @Override
82 public Collection<DefinitionProvider> bySource(ConfigurationSourceType sourceType) {
83 throw new IllegalStateException("not implemented yet");
84 }
85
86 @Override
87 public DefinitionQuery query() {
88 return new AggregatingQuery();
89 }
90
91 private class AggregatingQuery extends DefinitionQuery {
92 @Override
93 public Collection<DefinitionProvider<?>> findMultiple() {
94 final Collection<Registry> allRegistries = all();
95
96 final Collection<Collection<? extends DefinitionProvider<?>>> allRes = Collections2.transform(allRegistries,
97 new RegistryCollectionFunction(this));
98
99 return Lists.newLinkedList(Iterables.concat(allRes));
100 }
101
102
103 private class RegistryCollectionFunction implements Function<Registry, Collection<? extends DefinitionProvider<?>>> {
104 private final AggregatingQuery query;
105
106 public RegistryCollectionFunction(AggregatingQuery query) {
107 this.query = query;
108 }
109
110 @Override
111 public Collection<? extends DefinitionProvider<?>> apply(final Registry registry) {
112 return ((DefinitionQuery<?>) copyFor(query, registry)).findMultiple();
113 }
114 }
115
116 }
117
118
119
120 private static DefinitionQuery<?> copyFor(AggregatingQuery src, Registry<?> registry) {
121 return registry.query()
122 .from(src.getModule())
123 .at(src.getLocationPattern())
124 .ofType(src.getType())
125 .named(src.getName());
126 }
127
128
129 private static class RegistryByType implements Predicate<Registry> {
130 private final DefinitionType type;
131
132 public RegistryByType(DefinitionType type) {
133 this.type = type;
134 }
135
136 @Override
137 public boolean apply(Registry registry) {
138 return registry.type().equals(type);
139 }
140 }
141
142 }