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 return query().ofConfigurationSourceType(sourceType).findMultiple();
84 }
85
86 @Override
87 public DefinitionQuery query() {
88 return new AggregatingQuery();
89 }
90
91 @Override
92 public DefinitionQuery query(DefinitionQuery base) {
93 return new AggregatingQuery(base);
94 }
95
96 private class AggregatingQuery extends DefinitionQuery {
97
98 AggregatingQuery() {
99 super();
100 }
101
102 AggregatingQuery(DefinitionQuery base) {
103 super(base);
104 }
105
106 @Override
107 public Collection<DefinitionProvider<?>> findMultiple() {
108 final Collection<Registry> allRegistries = all();
109
110 final Collection<Collection<? extends DefinitionProvider<?>>> allRes = Collections2.transform(allRegistries,
111 new RegistryCollectionFunction(this));
112
113 return Lists.newLinkedList(Iterables.concat(allRes));
114 }
115
116
117 private class RegistryCollectionFunction implements Function<Registry, Collection<? extends DefinitionProvider<?>>> {
118 private final AggregatingQuery query;
119
120 public RegistryCollectionFunction(AggregatingQuery query) {
121 this.query = query;
122 }
123
124 @Override
125 public Collection<? extends DefinitionProvider<?>> apply(final Registry registry) {
126 return DefinitionQuery.build(registry, query).findMultiple();
127 }
128 }
129
130 }
131
132 private static class RegistryByType implements Predicate<Registry> {
133 private final DefinitionType type;
134
135 public RegistryByType(DefinitionType type) {
136 this.type = type;
137 }
138
139 @Override
140 public boolean apply(Registry registry) {
141 return registry.type().equals(type);
142 }
143 }
144
145 }