Merge "Remove unnecessary declaration of <prerequisites> in features"
[controller.git] / opendaylight / config / yang-jmx-generator-plugin / src / main / java / org / opendaylight / controller / config / yangjmxgenerator / plugin / gofactory / AbsModuleGeneratedObjectFactory.java
1 /*
2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8 package org.opendaylight.controller.config.yangjmxgenerator.plugin.gofactory;
9
10 import static com.google.common.base.Preconditions.checkState;
11 import static java.lang.String.format;
12
13 import com.google.common.base.Function;
14 import com.google.common.base.Joiner;
15 import com.google.common.base.Optional;
16 import com.google.common.collect.Collections2;
17 import com.google.common.collect.Iterables;
18 import com.google.common.collect.Lists;
19 import java.util.Collections;
20 import java.util.HashMap;
21 import java.util.LinkedHashMap;
22 import java.util.List;
23 import java.util.Map;
24 import org.opendaylight.controller.config.api.DependencyResolver;
25 import org.opendaylight.controller.config.api.ModuleIdentifier;
26 import org.opendaylight.controller.config.api.annotations.Description;
27 import org.opendaylight.controller.config.api.runtime.RootRuntimeBeanRegistrator;
28 import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
29 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.AbstractModuleTemplate;
30 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.TemplateFactory;
31 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Annotation;
32 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Field;
33 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.IdentityRefModuleField;
34 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Method;
35 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.MethodDefinition;
36 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.ModuleField;
37 import org.opendaylight.controller.config.yangjmxgenerator.plugin.java.FullyQualifiedName;
38 import org.opendaylight.controller.config.yangjmxgenerator.plugin.java.GeneratedObject;
39 import org.opendaylight.controller.config.yangjmxgenerator.plugin.java.GeneratedObjectBuilder;
40 import org.opendaylight.controller.config.yangjmxgenerator.plugin.java.JavaFileInputBuilder;
41 import org.opendaylight.controller.config.yangjmxgenerator.plugin.java.TypeName;
42 import org.opendaylight.yangtools.yang.common.QName;
43 import org.slf4j.Logger;
44 import org.slf4j.LoggerFactory;
45
46 public class AbsModuleGeneratedObjectFactory {
47
48     private static final Function<String, FullyQualifiedName> FULLY_QUALIFIED_NAME_FUNCTION = new Function<String, FullyQualifiedName>() {
49         @Override
50         public FullyQualifiedName apply(final String input) {
51             return FullyQualifiedName.fromString(input);
52         }
53     };
54
55     public GeneratedObject toGeneratedObject(ModuleMXBeanEntry mbe, Optional<String> copyright) {
56         FullyQualifiedName abstractFQN = new FullyQualifiedName(mbe.getPackageName(), mbe.getAbstractModuleName());
57         Optional<String> classJavaDoc = Optional.fromNullable(mbe.getNullableDescription());
58         AbstractModuleTemplate abstractModuleTemplate = TemplateFactory.abstractModuleTemplateFromMbe(mbe);
59         Optional<String> header = abstractModuleTemplate.getHeaderString();
60
61         List<FullyQualifiedName> implementedInterfaces = Lists.transform(abstractModuleTemplate.getTypeDeclaration().getImplemented(), FULLY_QUALIFIED_NAME_FUNCTION);
62
63         Optional<FullyQualifiedName> extended =
64                 Optional.fromNullable(
65                         Iterables.getFirst(
66                                 Collections2.transform(abstractModuleTemplate.getTypeDeclaration().getExtended(), FULLY_QUALIFIED_NAME_FUNCTION), null));
67
68         Optional<FullyQualifiedName> maybeRegistratorType;
69         if (abstractModuleTemplate.isRuntime()) {
70             maybeRegistratorType = Optional.of(FullyQualifiedName.fromString(abstractModuleTemplate.getRegistratorType()));
71         } else {
72             maybeRegistratorType = Optional.absent();
73         }
74
75         return toGeneratedObject(abstractFQN, copyright, header, classJavaDoc, extended, implementedInterfaces,
76                 abstractModuleTemplate.getModuleFields(), maybeRegistratorType, abstractModuleTemplate.getMethods(),
77                 mbe.getYangModuleQName());
78     }
79
80     public GeneratedObject toGeneratedObject(FullyQualifiedName abstractFQN,
81                                              Optional<String> copyright,
82                                              Optional<String> header,
83                                              Optional<String> classJavaDoc,
84                                              Optional<FullyQualifiedName> extended,
85                                              List<FullyQualifiedName> implementedInterfaces,
86                                              List<ModuleField> moduleFields,
87                                              Optional<FullyQualifiedName> maybeRegistratorType,
88                                              List<? extends Method> methods,
89                                              QName yangModuleQName) {
90         JavaFileInputBuilder b = new JavaFileInputBuilder();
91
92         Annotation moduleQNameAnnotation = Annotation.createModuleQNameANnotation(yangModuleQName);
93         b.addClassAnnotation(moduleQNameAnnotation);
94
95         b.setFqn(abstractFQN);
96         b.setTypeName(TypeName.absClassType);
97
98         b.setCopyright(copyright);
99         b.setHeader(header);
100         b.setClassJavaDoc(classJavaDoc);
101         for(FullyQualifiedName implemented: implementedInterfaces) {
102             b.addImplementsFQN(implemented);
103         }
104         if(extended.isPresent()) {
105             b.addExtendsFQN(extended.get());
106         }
107         if (classJavaDoc.isPresent()) {
108             b.addClassAnnotation(format("@%s(value=\"%s\")", Description.class.getCanonicalName(), classJavaDoc.get()));
109         }
110
111         // add logger:
112         b.addToBody(getLoggerDefinition(abstractFQN));
113
114         b.addToBody("//attributes start");
115         for(ModuleField moduleField: moduleFields) {
116             b.addToBody(moduleField.toString() +"\n");
117         }
118
119         b.addToBody("//attributes end");
120
121
122         b.addToBody(getNewConstructor(abstractFQN));
123         b.addToBody(getCopyFromOldConstructor(abstractFQN));
124
125         b.addToBody(getRuntimeRegistratorCode(maybeRegistratorType));
126         b.addToBody(getValidationMethods(moduleFields));
127
128         b.addToBody(getCachesOfResolvedDependencies(moduleFields));
129         b.addToBody(getCachesOfResolvedIdentityRefs(moduleFields));
130         b.addToBody(getResolveDependencies(moduleFields));
131         b.addToBody(getReuseLogic(moduleFields, abstractFQN));
132         b.addToBody(getEqualsAndHashCode(abstractFQN));
133
134         b.addToBody(getMethods(methods));
135         b.addToBody(getGetLogger());
136
137         return new GeneratedObjectBuilder(b.build()).toGeneratedObject();
138     }
139
140     private static String getMethods(List<? extends Method>  methods) {
141         String result = "\n// getters and setters\n";
142         for(Method method: methods) {
143             result += method.toString()+"\n";
144         }
145         return result;
146     }
147
148     private static String getEqualsAndHashCode(FullyQualifiedName abstractFQN) {
149         return "\n"+
150             "@Override\n"+
151             "public boolean equals(Object o) {\n"+
152                 "if (this == o) return true;\n"+
153                 "if (o == null || getClass() != o.getClass()) return false;\n"+
154                 format("%s that = (%1$s) o;\n", abstractFQN.getTypeName())+
155                 "return identifier.equals(that.identifier);\n"+
156             "}\n"+
157             "\n"+
158             "@Override\n"+
159             "public int hashCode() {\n"+
160                 "return identifier.hashCode();\n"+
161             "}\n";
162     }
163
164     private static String getReuseLogic(List<ModuleField> moduleFields, FullyQualifiedName abstractFQN) {
165         String result = "\n"+
166             format("public boolean canReuseInstance(%s oldModule){\n", abstractFQN.getTypeName())+
167                 "// allow reusing of old instance if no parameters was changed\n"+
168                 "return isSame(oldModule);\n"+
169             "}\n"+
170             "\n"+
171             format("public %s reuseInstance(%1$s oldInstance){\n", AutoCloseable.class.getCanonicalName())+
172                 "// implement if instance reuse should be supported. Override canReuseInstance to change the criteria.\n"+
173                 "return oldInstance;\n"+
174             "}\n";
175         // isSame method that detects changed fields
176         result += "\n"+
177             format("public boolean isSame(%s other) {\n", abstractFQN.getTypeName())+
178                 "if (other == null) {\n"+
179                     "throw new IllegalArgumentException(\"Parameter 'other' is null\");\n"+
180                 "}\n";
181         // loop through fields, do deep equals on each field
182
183         for (ModuleField moduleField : moduleFields) {
184             result += format(
185                 "if (java.util.Objects.deepEquals(%s, other.%1$s) == false) {\n"+
186                     "return false;\n"+
187                 "}\n", moduleField.getName());
188
189             if (moduleField.isListOfDependencies()) {
190                 result += format(
191                         "for (int idx = 0; idx < %1$s.size(); idx++) {\n"+
192                             "if (!dependencyResolver.canReuseDependency(%1$s.get(idx), %1$sJmxAttribute)) {\n"+
193                                 "return false;\n"+
194                             "}\n"+
195                         "}\n" , moduleField.getName());
196             } else if (moduleField.isDependent()) {
197                 result += format(
198                         // If a reference is null (ie optional reference) it makes no sens to call canReuse on it
199                         // In such case we continue in the isSame method because if we have null here, the previous value was null as well
200                         // If the previous value was not null and current is or vice verse, the deepEquals comparison would return false
201                         "if(%1$s!= null) {\n" +
202                             "if (!dependencyResolver.canReuseDependency(%1$s, %1$sJmxAttribute)) { // reference to dependency must be reusable as well\n" +
203                                 "return false;\n" +
204                             "}\n" +
205                         "}\n", moduleField.getName());
206             }
207         }
208
209         result += "\n"+
210                 "return true;\n"+
211             "}\n";
212
213         return result;
214     }
215
216     private static String getResolveDependencies(final List<ModuleField> moduleFields) {
217         // loop through dependent fields, use dependency resolver to instantiate dependencies. Do it in loop in case field represents list of dependencies.
218         Map<ModuleField, String> resolveDependenciesMap = new HashMap<>();
219         for(ModuleField moduleField: moduleFields) {
220             if (moduleField.isDependent()) {
221                 String str;
222                 String osgi = moduleField.getDependency().getSie().getExportedOsgiClassName();
223                 if (moduleField.isList()) {
224                     str = format(
225                             "%sDependency = new java.util.ArrayList<%s>();\n"+
226                                     "for(javax.management.ObjectName dep : %1$s) {\n"+
227                                     "%1$sDependency.add(dependencyResolver.resolveInstance(%2$s.class, dep, %1$sJmxAttribute));\n"+
228                                     "}\n", moduleField.getName(), osgi);
229                 } else {
230                     str = format(
231                             "%1$sDependency = dependencyResolver.resolveInstance(%2$s.class, %1$s, %1$sJmxAttribute);\n",
232                             moduleField.getName(), osgi);
233                 }
234                 resolveDependenciesMap.put(moduleField, str);
235             }
236         }
237
238         String result = "\n"
239                 + "protected final void resolveDependencies() {\n";
240         // wrap each field resolvation statement with if !=null when dependency is not mandatory
241         for (Map.Entry<ModuleField, String> entry : resolveDependenciesMap.entrySet()) {
242             if (entry.getKey().getDependency().isMandatory() == false) {
243                 checkState(entry.getValue().endsWith(";\n"));
244                 result += format("if (%s!=null) {\n%s}\n", entry.getKey().getName(), entry.getValue());
245             } else {
246                 result += entry.getValue();
247             }
248         }
249
250         // add code to inject dependency resolver to fields that support it
251         for(ModuleField moduleField: moduleFields) {
252             if (moduleField.isNeedsDepResolver()) {
253                 result += format("if (%s!=null){\n", moduleField.getName());
254                 if (moduleField.isList()) {
255                     result += format(
256                             "for(%s candidate : %s) {\n"+
257                                     "candidate.injectDependencyResolver(dependencyResolver);\n"+
258                                     "}\n", moduleField.getGenericInnerType(), moduleField.getName());
259                 } else {
260                     result += format("%s.injectDependencyResolver(dependencyResolver);\n", moduleField.getName());
261                 }
262                 result += "}\n";
263             }
264         }
265
266         // identity refs need to be injected with dependencyResolver and base class
267         for (ModuleField moduleField : moduleFields) {
268             if (moduleField.isIdentityRef()) {
269                 result += format("if (%s!=null) {", moduleField.getName());
270                 result += format("set%s(%s.resolveIdentity(dependencyResolver, %s.class));",
271                         moduleField.getAttributeName(), moduleField.getName(),
272                         ((IdentityRefModuleField)moduleField).getIdentityBaseClass());
273                 result += "}\n";
274             }
275         }
276         result += "}\n";
277         return result;
278     }
279
280     private static String getCachesOfResolvedIdentityRefs(List<ModuleField> moduleFields) {
281         StringBuilder result = new StringBuilder();
282         for (ModuleField moduleField : moduleFields) {
283             if (moduleField.isIdentityRef()) {
284                 IdentityRefModuleField field = (IdentityRefModuleField) moduleField;
285                 result.append(format("private %s %s;\n", field.getIdentityClassType(), field.getIdentityClassName()));
286             }
287         }
288         return result.toString();
289     }
290
291     private static String getCachesOfResolvedDependencies(List<ModuleField> moduleFields) {
292         StringBuilder result = new StringBuilder();
293         for (ModuleField moduleField: moduleFields) {
294             if (moduleField.isDependent()) {
295                 String osgi = moduleField.getDependency().getSie().getExportedOsgiClassName();
296                 if (moduleField.isList()) {
297                     result
298                             .append(format("private java.util.List<%s> %sDependency = new java.util.ArrayList<%s>();", osgi, moduleField.getName(), osgi))
299                             .append(format("protected final java.util.List<%s> get%sDependency(){\n", osgi, moduleField.getAttributeName()))
300                             .append(format("return %sDependency;\n", moduleField.getName()))
301                             .append("}\n");
302                 } else {
303                     result.append(format(
304                         "private %s %sDependency;\n"+
305                         "protected final %s get%sDependency(){\n"+
306                             "return %sDependency;\n"+
307                         "}",
308                         osgi, moduleField.getName(), osgi, moduleField.getAttributeName(), moduleField.getName()));
309                 }
310             }
311         }
312         return result.toString();
313     }
314
315     private static String getRuntimeRegistratorCode(Optional<FullyQualifiedName> maybeRegistratorType) {
316         if (maybeRegistratorType.isPresent()) {
317             String registratorType = maybeRegistratorType.get().toString();
318
319             return "\n"+
320                 format("private %s rootRuntimeBeanRegistratorWrapper;\n", registratorType)+
321                 "\n"+
322                 format("public %s getRootRuntimeBeanRegistratorWrapper(){\n", registratorType)+
323                     "return rootRuntimeBeanRegistratorWrapper;\n"+
324                 "}\n"+
325                 "\n"+
326                 "@Override\n"+
327                 format("public void setRuntimeBeanRegistrator(%s rootRuntimeRegistrator){\n", RootRuntimeBeanRegistrator.class.getCanonicalName())+
328                     format("this.rootRuntimeBeanRegistratorWrapper = new %s(rootRuntimeRegistrator);\n", registratorType)+
329                 "}\n";
330         } else {
331             return "";
332         }
333     }
334
335     private static String getValidationMethods(List<ModuleField> moduleFields) {
336         String result = "\n"+
337             "@Override\n"+
338             "public void validate() {\n";
339         // validate each mandatory dependency
340         for(ModuleField moduleField: moduleFields) {
341             if (moduleField.isDependent()) {
342                 if (moduleField.isList()) {
343                     result += "" +
344                             format("for(javax.management.ObjectName dep : %s) {\n", moduleField.getName()) +
345                             format("    dependencyResolver.validateDependency(%s.class, dep, %sJmxAttribute);\n",
346                                     moduleField.getDependency().getSie().getFullyQualifiedName(), moduleField.getName()) +
347                             "}\n";
348                 } else {
349                     if(moduleField.getDependency().isMandatory() == false) {
350                         result += format("if(%s != null) {\n", moduleField.getName());
351                     }
352                     result += format("dependencyResolver.validateDependency(%s.class, %s, %sJmxAttribute);\n",
353                             moduleField.getDependency().getSie().getFullyQualifiedName(), moduleField.getName(), moduleField.getName());
354                     if(moduleField.getDependency().isMandatory() == false) {
355                         result += "}\n";
356                     }
357                 }
358             }
359         }
360         result += "\n"+
361                 "customValidation();\n"+
362             "}\n"+
363             "\n"+
364             "protected void customValidation() {\n"+
365             "}\n";
366         return result;
367     }
368
369     private static String getLoggerDefinition(FullyQualifiedName fqn) {
370         return format("private static final %s LOGGER = %s.getLogger(%s.class);",
371                 Logger.class.getCanonicalName(), LoggerFactory.class.getCanonicalName(), fqn);
372     }
373
374     // assumes that each parameter name corresponds to an field in this class, constructs lines setting this.field = field;
375     private static String getConstructorStart(FullyQualifiedName fqn,
376                                               LinkedHashMap<String, String> parameters, String after) {
377         String paramString = Joiner.on(",").withKeyValueSeparator(" ").join(parameters);
378         return format("public %s(", fqn.getTypeName()) +
379                 paramString +
380                 ") {\n" +
381                 after +
382                 "}\n";
383     }
384
385     private static String getNewConstructor(FullyQualifiedName abstractFQN) {
386         LinkedHashMap<String, String> parameters = new LinkedHashMap<>();
387         parameters.put(ModuleIdentifier.class.getCanonicalName(), "identifier");
388         parameters.put(DependencyResolver.class.getCanonicalName(), "dependencyResolver");
389         String init = "super(identifier, dependencyResolver);\n";
390         return getConstructorStart(abstractFQN, parameters, init);
391     }
392
393     private static String getCopyFromOldConstructor(FullyQualifiedName abstractFQN) {
394         LinkedHashMap<String, String> parameters = new LinkedHashMap<>();
395         parameters.put(ModuleIdentifier.class.getCanonicalName(), "identifier");
396         parameters.put(DependencyResolver.class.getCanonicalName(), "dependencyResolver");
397         parameters.put(abstractFQN.getTypeName(), "oldModule");
398         parameters.put(AutoCloseable.class.getCanonicalName(), "oldInstance");
399         String init = "super(identifier, dependencyResolver, oldModule, oldInstance);\n";
400         return getConstructorStart(abstractFQN, parameters, init);
401     }
402
403     public String getGetLogger() {
404         return new MethodDefinition(Logger.class.getCanonicalName(), "getLogger", Collections.<Field>emptyList(), "return LOGGER;").toString();
405     }
406 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.