source: java/main/src/main/java/com/framsticks/params/Registry.java @ 193

Last change on this file since 193 was 193, checked in by Maciej Komosinski, 10 years ago

Set svn:eol-style native for all textual files

  • Property svn:eol-style set to native
File size: 6.5 KB
Line 
1package com.framsticks.params;
2
3import org.apache.logging.log4j.Logger;
4import org.apache.logging.log4j.LogManager;
5
6import com.framsticks.params.annotations.FramsClassAnnotation;
7import com.framsticks.params.annotations.ParamAnnotation;
8import com.framsticks.util.DoubleMap;
9import com.framsticks.util.FramsticksException;
10import com.framsticks.util.lang.Casting;
11import com.framsticks.util.lang.Strings;
12
13import java.util.IdentityHashMap;
14import java.util.Map;
15import java.util.Set;
16
17import javax.annotation.Nonnull;
18
19/**
20 * Author: Piotr Śniegowski
21 */
22@FramsClassAnnotation
23public class Registry implements AccessProvider {
24        private static final Logger log = LogManager.getLogger(Registry.class.getName());
25
26        protected final DoubleMap<String, Class<?>> javaClasses = new DoubleMap<>();
27        protected final DoubleMap<String, FramsClass> framsClasses = new DoubleMap<>();
28        protected final Map<Class<?>, FramsClass> javaToFramsAssociation = new IdentityHashMap<>();
29
30        /**
31         *
32         */
33        public Registry() {
34                // registerAndBuild(Registry.class);
35                // registerAndBuild(FramsClass.class);
36                // registerAndBuild(Param.class);
37        }
38
39        public void registerReflectedClass(String name, String id, Class<?> javaClass) {
40                javaClasses.put(id, name, javaClass);
41        }
42
43        public void associate(Class<?> javaClass, FramsClass framsClass) {
44                javaToFramsAssociation.put(javaClass, framsClass);
45        }
46
47        public Registry registerAndBuild(Class<?> javaClass) {
48                if (javaToFramsAssociation.containsKey(javaClass)) {
49                        return this;
50                }
51                register(javaClass);
52                associate(javaClass, putFramsClass(FramsClass.build().forClass(javaClass)));
53                for (Class<?> r : ParamCandidate.getAllCandidates(javaClass).getDependentClasses()) {
54                        registerAndBuild(r);
55                }
56
57                for (String i : ParamCandidate.getAllCandidates(javaClass).getDependentClassesFromInfo()) {
58                        putFramsClass(FramsClassBuilder.readFromStream(getClass().getResourceAsStream("/info/" + i + ".info")));
59                }
60                return this;
61        }
62
63        public FramsClass registerReflectedIfNeeded(Class<?> javaClass) {
64                if (!javaToFramsAssociation.containsKey(javaClass)) {
65                        registerAndBuild(javaClass);
66                }
67                return javaToFramsAssociation.get(javaClass);
68        }
69
70        public Registry register(Class<?> javaClass) {
71                FramsClassAnnotation a = javaClass.getAnnotation(FramsClassAnnotation.class);
72                if (a == null) {
73                        throw new FramsticksException().msg("class is not annotated").arg("class", javaClass);
74                }
75
76                registerReflectedClass(FramsClassBuilder.getName(a, javaClass), FramsClassBuilder.getId(a, javaClass), javaClass);
77                return this;
78        }
79
80        public @Nonnull ReflectionAccess createAccess(Class<?> javaClass) throws ConstructionException {
81                try {
82                        if (!javaClasses.containsValue(javaClass)) {
83                                registerAndBuild(javaClass);
84                        }
85
86                        if (!javaClasses.containsValue(javaClass)) {
87                                throw new FramsticksException().msg("java class is not registered");
88                        }
89                        if (!javaToFramsAssociation.containsKey(javaClass)) {
90                                throw new FramsticksException().msg("java class is not associated with any frams class");
91                        }
92                        return new ReflectionAccess(javaClass, javaToFramsAssociation.get(javaClass));
93                }
94                catch (FramsticksException e) {
95                        throw new FramsticksException().msg("failed to create access for java class").arg("class", javaClass).cause(e);
96                }
97        }
98
99        public @Nonnull Access createAccess(String name, FramsClass framsClass) throws ConstructionException {
100                // assert framsClasses.containsValue(framsClass);
101                if (javaClasses.containsKey(name)) {
102                        return new ReflectionAccess(javaClasses.get(name), framsClass);
103                }
104                return new PropertiesAccess(framsClass);
105        }
106
107        public FramsClass putFramsClass(FramsClass framsClass) {
108                log.debug("caching info for {}", framsClass);
109                framsClasses.put(framsClass.getId(), framsClass.getName(), framsClass);
110                return framsClass;
111        }
112
113        public FramsClass getFramsClass(@Nonnull CompositeParam param) {
114                return framsClasses.get(param.getContainedTypeName());
115        }
116
117        public FramsClass getFramsClass(@Nonnull String identifier) {
118                return framsClasses.get(identifier);
119        }
120
121        public static @Nonnull Access wrapAccessWithListIfNeeded(@Nonnull CompositeParam param, @Nonnull Access access) {
122                return param.prepareAccess(access);
123        }
124
125        public @Nonnull Access prepareAccess(CompositeParam param, boolean force) throws ConstructionException {
126                return wrapAccessWithListIfNeeded(param, createAccess(param.getContainedTypeName(), force));
127        }
128
129        public @Nonnull Access createAccess(@Nonnull Object object) throws ConstructionException {
130                if (object instanceof MapBasedObject) {
131                        return createAccess(((MapBasedObject) object).getFramsTypeName());
132                }
133                return createAccess(object.getClass());
134        }
135
136        public @Nonnull Access createAccess(@Nonnull String name, boolean force) throws ConstructionException {
137                try {
138                        Strings.assureNotEmpty(name);
139                        FramsClass framsClass = getFramsClass(name);
140                        if (framsClass == null) {
141                                if (!force) {
142                                        throw new ConstructionException().msg("framsclass is missing");
143                                }
144                                return new FreeAccess(name);
145                        }
146
147                        return createAccess(name, framsClass);
148                }
149                catch (FramsticksException e) {
150                        throw new FramsticksException().msg("failed to create access for name").arg("name", name).cause(e);
151                }
152        }
153
154        public @Nonnull Access createAccess(@Nonnull String name) throws ConstructionException {
155                return createAccess(name, false);
156        }
157
158        public FramsClass getFramsClassForJavaClass(Class<?> javaClass) {
159                return javaToFramsAssociation.get(javaClass);
160        }
161
162        public Set<Class<?>> getReflectedClasses() {
163                return javaClasses.getValues();
164        }
165
166        public Set<FramsClass> getFramsClasses() {
167                return framsClasses.getValues();
168        }
169
170        @ParamAnnotation
171        public Map<String, FramsClass> getFramsClassesById() {
172                return framsClasses.getValuesById();
173        }
174
175        public void takeAllFrom(Registry source) {
176                for (Class<?> javaClass : source.getReflectedClasses()) {
177                        register(javaClass);
178                }
179                for (FramsClass framsClass : source.getFramsClasses()) {
180                        putFramsClass(framsClass);
181                }
182
183        }
184
185        @Override
186        public Access getAccess(String name) {
187                return createAccess(name);
188        }
189
190        public Access bindAccessFor(Object object) {
191                return createAccess(object).select(object);
192        }
193
194        public Registry register(ParamsPackage paramsPackage) {
195                paramsPackage.register(this);
196                return this;
197        }
198
199        public Registry registerAndBuild(ParamsPackage paramsPackage) {
200                paramsPackage.setBuild(true);
201                paramsPackage.register(this);
202                return this;
203        }
204
205        public Access bindAccessFor(Access parent, String paramName) {
206                CompositeParam childParam = Casting.throwCast(CompositeParam.class, parent.getParam(paramName));
207                return prepareAccess(childParam, true).select(parent.get(childParam, Object.class));
208        }
209
210
211}
Note: See TracBrowser for help on using the repository browser.