Resolve Bug:445 Remove freemarker from config code generator.
[controller.git] / opendaylight / config / yang-jmx-generator-plugin / src / main / java / org / opendaylight / controller / config / yangjmxgenerator / plugin / ftl / TemplateFactory.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.ftl;
9
10 import com.google.common.base.Preconditions;
11 import com.google.common.collect.Lists;
12 import com.google.common.collect.Maps;
13 import org.opendaylight.controller.config.api.DependencyResolver;
14 import org.opendaylight.controller.config.api.IdentityAttributeRef;
15 import org.opendaylight.controller.config.api.RuntimeBeanRegistratorAwareModule;
16 import org.opendaylight.controller.config.api.annotations.AbstractServiceInterface;
17 import org.opendaylight.controller.config.api.runtime.RuntimeBean;
18 import org.opendaylight.controller.config.spi.Module;
19 import org.opendaylight.controller.config.yangjmxgenerator.AbstractEntry;
20 import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
21 import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry;
22 import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry.Rpc;
23 import org.opendaylight.controller.config.yangjmxgenerator.ServiceInterfaceEntry;
24 import org.opendaylight.controller.config.yangjmxgenerator.attribute.AbstractDependencyAttribute;
25 import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
26 import org.opendaylight.controller.config.yangjmxgenerator.attribute.Dependency;
27 import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
28 import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListAttribute;
29 import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListDependenciesAttribute;
30 import org.opendaylight.controller.config.yangjmxgenerator.attribute.TOAttribute;
31 import org.opendaylight.controller.config.yangjmxgenerator.attribute.TypedAttribute;
32 import org.opendaylight.controller.config.yangjmxgenerator.attribute.VoidAttribute;
33 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Annotation;
34 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Annotation.Parameter;
35 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Constructor;
36 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Field;
37 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Header;
38 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.IdentityRefModuleField;
39 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.MethodDeclaration;
40 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.MethodDefinition;
41 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.ModuleField;
42 import org.opendaylight.controller.config.yangjmxgenerator.plugin.util.FullyQualifiedNameHelper;
43 import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil;
44 import org.opendaylight.yangtools.sal.binding.model.api.ParameterizedType;
45 import org.opendaylight.yangtools.sal.binding.model.api.Type;
46
47 import javax.management.openmbean.SimpleType;
48 import java.util.ArrayList;
49 import java.util.Arrays;
50 import java.util.Collections;
51 import java.util.HashMap;
52 import java.util.List;
53 import java.util.Map;
54 import java.util.Map.Entry;
55
56 public class TemplateFactory {
57
58     /**
59      * Get map of file name as key, FtlFile instance representing runtime mx
60      * bean as value that should be persisted from this instance.
61      */
62     public static Map<String, FtlTemplate> getTOAndMXInterfaceFtlFiles(
63             RuntimeBeanEntry entry) {
64         Map<String, FtlTemplate> result = new HashMap<>();
65         { // create GeneralInterfaceFtlFile for runtime MXBean. Attributes will
66           // be transformed to getter methods
67             String mxBeanTypeName = entry.getJavaNameOfRuntimeMXBean();
68             List<String> extendedInterfaces = Arrays.asList(RuntimeBean.class
69                     .getCanonicalName());
70             List<MethodDeclaration> methods = new ArrayList<>();
71
72             // convert attributes to getters
73             for (AttributeIfc attributeIfc : entry.getAttributes()) {
74                 String returnType;
75                 returnType = getReturnType(attributeIfc);
76                 String getterName = "get"
77                         + attributeIfc.getUpperCaseCammelCase();
78                 MethodDeclaration getter = new MethodDeclaration(returnType,
79                         getterName, Collections.<Field> emptyList());
80                 methods.add(getter);
81             }
82
83             // add rpc methods
84             for (Rpc rpc : entry.getRpcs()) {
85                 // convert JavaAttribute parameters into fields
86                 List<Field> fields = new ArrayList<>();
87                 for (JavaAttribute ja : rpc.getParameters()) {
88                     Field field = new Field(Collections.<String> emptyList(),
89                             ja.getType().getFullyQualifiedName(),
90                             ja.getLowerCaseCammelCase(), ja.getNullableDefaultWrappedForCode());
91                     fields.add(field);
92                 }
93                 MethodDeclaration operation = new MethodDeclaration(
94                         getReturnType(rpc.getReturnType()), rpc.getName(), fields);
95                 methods.add(operation);
96             }
97
98             // FIXME header
99             GeneralInterfaceTemplate runtimeMxBeanIfc = new GeneralInterfaceTemplate(
100                     null, entry.getPackageName(), mxBeanTypeName,
101                     extendedInterfaces, methods);
102
103             result.put(runtimeMxBeanIfc.getTypeDeclaration().getName()
104                     + ".java", runtimeMxBeanIfc);
105         }
106
107         result.putAll(TemplateFactory.tOsFromRbe(entry));
108
109         return result;
110     }
111
112     // FIXME: put into Type.toString
113     static String serializeType(Type type, boolean addWildcards) {
114         if (type instanceof ParameterizedType){
115             ParameterizedType parameterizedType = (ParameterizedType) type;
116             StringBuffer sb = new StringBuffer();
117             sb.append(parameterizedType.getRawType().getFullyQualifiedName());
118             sb.append(addWildcards ? "<? extends " : "<");
119             boolean first = true;
120             for(Type parameter: parameterizedType.getActualTypeArguments()) {
121                 if (first) {
122                     first = false;
123                 } else {
124                     sb.append(",");
125                 }
126                 sb.append(serializeType(parameter));
127             }
128             sb.append(">");
129             return sb.toString();
130         } else {
131             return type.getFullyQualifiedName();
132         }
133     }
134
135     static String serializeType(Type type) {
136         return serializeType(type, false);
137     }
138
139     private static String getReturnType(AttributeIfc attributeIfc) {
140         String returnType;
141         if (attributeIfc instanceof TypedAttribute) {
142             Type type = ((TypedAttribute) attributeIfc).getType();
143             returnType = serializeType(type);
144         } else if (attributeIfc == VoidAttribute.getInstance()) {
145             return "void";
146         } else {
147             throw new UnsupportedOperationException(
148                     "Attribute not supported: "
149                             + attributeIfc.getClass());
150         }
151         return returnType;
152     }
153
154     public static GeneralInterfaceTemplate serviceInterfaceFromSie(
155             ServiceInterfaceEntry sie) {
156
157         List<String> extendedInterfaces = Lists
158                 .newArrayList(AbstractServiceInterface.class.getCanonicalName());
159         if (sie.getBase().isPresent()) {
160             extendedInterfaces.add(sie.getBase().get().getFullyQualifiedName());
161         }
162
163         // FIXME header
164         GeneralInterfaceTemplate sieTemplate = new GeneralInterfaceTemplate(
165                 getHeaderFromEntry(sie), sie.getPackageName(),
166                 sie.getTypeName(), extendedInterfaces,
167                 Lists.<MethodDeclaration> newArrayList());
168         sieTemplate.setJavadoc(sie.getNullableDescription());
169
170         if (sie.getNullableDescription() != null)
171             sieTemplate.getAnnotations().add(
172                     Annotation.createDescriptionAnnotation(sie
173                             .getNullableDescription()));
174         sieTemplate.getAnnotations().addAll(Annotation.createSieAnnotations(sie));
175
176         return sieTemplate;
177     }
178
179     public static AbstractFactoryTemplate abstractFactoryTemplateFromMbe(
180             ModuleMXBeanEntry mbe) {
181         AbstractFactoryAttributesProcessor attrProcessor = new AbstractFactoryAttributesProcessor();
182         attrProcessor.processAttributes(mbe.getAttributes(),
183                 mbe.getPackageName());
184
185
186
187         return new AbstractFactoryTemplate(getHeaderFromEntry(mbe),
188                 mbe.getPackageName(), mbe.getAbstractFactoryName(),
189                 attrProcessor.getFields()
190         );
191     }
192
193     public static AbstractModuleTemplate abstractModuleTemplateFromMbe(
194             ModuleMXBeanEntry mbe) {
195         AbstractModuleAttributesProcessor attrProcessor = new AbstractModuleAttributesProcessor(mbe.getAttributes());
196
197         List<ModuleField> moduleFields = attrProcessor.getModuleFields();
198         List<String> implementedIfcs = Lists.newArrayList(
199                 Module.class.getCanonicalName(),
200                 mbe.getFullyQualifiedName(mbe.getMXBeanInterfaceName()));
201
202         for (String implementedService : mbe.getProvidedServices().keySet()) {
203             implementedIfcs.add(implementedService);
204         }
205
206         boolean generateRuntime = false;
207         String registratorFullyQualifiedName = null;
208         if (mbe.getRuntimeBeans() != null
209                 && mbe.getRuntimeBeans().isEmpty() == false) {
210             generateRuntime = true;
211             RuntimeBeanEntry rootEntry = RuntimeRegistratorFtlTemplate
212                     .findRoot(mbe.getRuntimeBeans());
213             registratorFullyQualifiedName = rootEntry
214                     .getPackageName()
215                     .concat(".")
216                     .concat(RuntimeRegistratorFtlTemplate.getJavaNameOfRuntimeRegistrator(rootEntry));
217             implementedIfcs.add(RuntimeBeanRegistratorAwareModule.class
218                     .getCanonicalName());
219         }
220
221         AbstractModuleTemplate abstractModuleTemplate = new AbstractModuleTemplate(
222                 getHeaderFromEntry(mbe), mbe.getPackageName(),
223                 mbe.getAbstractModuleName(), implementedIfcs, moduleFields,
224                 attrProcessor.getMethods(), generateRuntime,
225                 registratorFullyQualifiedName);
226
227         if (mbe.getNullableDescription() != null)
228             abstractModuleTemplate.getAnnotations().add(
229                     Annotation.createDescriptionAnnotation(mbe
230                             .getNullableDescription()));
231         return abstractModuleTemplate;
232     }
233
234     public static StubFactoryTemplate stubFactoryTemplateFromMbe(
235             ModuleMXBeanEntry mbe) {
236         return new StubFactoryTemplate(getHeaderFromEntry(mbe),
237                 mbe.getPackageName(), mbe.getStubFactoryName(),
238                 mbe.getFullyQualifiedName(mbe.getAbstractFactoryName())
239         );
240     }
241
242     public static GeneralInterfaceTemplate mXBeanInterfaceTemplateFromMbe(
243             ModuleMXBeanEntry mbe) {
244         MXBeanInterfaceAttributesProcessor attrProcessor = new MXBeanInterfaceAttributesProcessor();
245         attrProcessor.processAttributes(mbe.getAttributes());
246         GeneralInterfaceTemplate ifcTemplate = new GeneralInterfaceTemplate(
247                 getHeaderFromEntry(mbe), mbe.getPackageName(),
248                 mbe.getMXBeanInterfaceName(), Lists.<String> newArrayList(),
249                 attrProcessor.getMethods());
250         ifcTemplate.setJavadoc(mbe.getNullableDescription());
251         return ifcTemplate;
252     }
253
254     public static Map<String, GeneralClassTemplate> tOsFromMbe(
255             ModuleMXBeanEntry mbe) {
256         Map<String, GeneralClassTemplate> retVal = Maps.newHashMap();
257         TOAttributesProcessor processor = new TOAttributesProcessor();
258         processor.processAttributes(mbe.getAttributes());
259         for (org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.TemplateFactory.TOAttributesProcessor.TOInternal to : processor
260                 .getTOs()) {
261             List<Constructor> constructors = Lists.newArrayList();
262             constructors.add(new Constructor(to.getName(), "super();"));
263
264             Header header = getHeaderFromEntry(mbe);
265             retVal.put(
266                     to.getType(),
267                     new GeneralClassTemplate(header, mbe.getPackageName(), to
268                             .getName(), Collections.<String> emptyList(),
269                             Collections.<String> emptyList(), to.getFields(),
270                             to.getMethods(), false, false, constructors));
271         }
272         return retVal;
273     }
274
275     public static Map<String, GeneralClassTemplate> tOsFromRbe(
276             RuntimeBeanEntry rbe) {
277         Map<String, GeneralClassTemplate> retVal = Maps.newHashMap();
278         TOAttributesProcessor processor = new TOAttributesProcessor();
279         Map<String, AttributeIfc> yangPropertiesToTypesMap = Maps.newHashMap(rbe.getYangPropertiesToTypesMap());
280
281         // Add TOs from output parameters
282         for (Rpc rpc : rbe.getRpcs()) {
283             AttributeIfc returnType = rpc.getReturnType();
284
285             if (returnType == VoidAttribute.getInstance())
286                 continue;
287             if (returnType instanceof JavaAttribute)
288                 continue;
289             if (returnType instanceof ListAttribute && returnType.getOpenType() instanceof SimpleType)
290                 continue;
291
292             Preconditions.checkState(yangPropertiesToTypesMap.containsKey(returnType.getAttributeYangName()) == false,
293                     "Duplicate TO %s for %s", returnType.getAttributeYangName(), rbe);
294             yangPropertiesToTypesMap.put(returnType.getAttributeYangName(), returnType);
295         }
296
297         processor.processAttributes(yangPropertiesToTypesMap);
298         for (org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.TemplateFactory.TOAttributesProcessor.TOInternal to : processor
299                 .getTOs()) {
300             List<Constructor> constructors = Lists.newArrayList();
301             constructors.add(new Constructor(to.getName(), "super();"));
302
303             // TODO header
304             retVal.put(
305                     to.getType(),
306                     new GeneralClassTemplate(null, rbe.getPackageName(), to
307                             .getName(), Collections.<String> emptyList(),
308                             Collections.<String> emptyList(), to.getFields(),
309                             to.getMethods(), false, false, constructors));
310         }
311         return retVal;
312     }
313
314     private static Header getHeaderFromEntry(AbstractEntry mbe) {
315         return new Header(mbe.getYangModuleName(), mbe.getYangModuleLocalname());
316     }
317
318     // TODO refactor attribute processors
319
320     private static class TOAttributesProcessor {
321
322         private final List<TOInternal> tos = Lists.newArrayList();
323
324         void processAttributes(Map<String, AttributeIfc> attributes) {
325             for (Entry<String, AttributeIfc> attrEntry : attributes.entrySet()) {
326                 AttributeIfc attributeIfc = attrEntry.getValue();
327                 if (attributeIfc instanceof TOAttribute) {
328                     createTOInternal((TOAttribute) attributeIfc);
329                 }
330                 if (attributeIfc instanceof ListAttribute) {
331                     AttributeIfc innerAttr = ((ListAttribute) attributeIfc)
332                             .getInnerAttribute();
333                     if (innerAttr instanceof TOAttribute) {
334                         createTOInternal((TOAttribute) innerAttr);
335                     }
336                 }
337             }
338         }
339
340         private void createTOInternal(TOAttribute toAttribute) {
341
342             Map<String, AttributeIfc> attrs = toAttribute.getCapitalizedPropertiesToTypesMap();
343             // recursive processing of TO's attributes
344             processAttributes(attrs);
345
346             tos.add(new TOInternal(toAttribute.getType(), attrs));
347         }
348
349         List<TOInternal> getTOs() {
350             return tos;
351         }
352
353         private static class TOInternal {
354             private final String fullyQualifiedName, name;
355             private List<Field> fields;
356             private List<MethodDefinition> methods;
357
358             public TOInternal(Type type, Map<String, AttributeIfc> attrs) {
359                 this(type.getFullyQualifiedName(), type.getName(), attrs, type.getPackageName());
360             }
361
362             public TOInternal(String fullyQualifiedName, String name,
363                     Map<String, AttributeIfc> attrs, String packageName) {
364                 this.fullyQualifiedName = fullyQualifiedName;
365                 this.name = name;
366                 processAttrs(attrs, packageName);
367             }
368
369             private final static String dependencyResolverVarName = "dependencyResolver";
370             private final static String dependencyResolverInjectMethodName = "injectDependencyResolver";
371
372             private void processAttrs(Map<String, AttributeIfc> attrs, String packageName) {
373                 fields = Lists.newArrayList();
374                 methods = Lists.newArrayList();
375
376                 // FIXME conflict if "dependencyResolver" field from yang
377                 Field depRes = new Field(DependencyResolver.class.getName(), dependencyResolverVarName);
378                 fields.add(depRes);
379                 methods.add(new MethodDefinition("void", dependencyResolverInjectMethodName, Lists.newArrayList(depRes),
380                         "this." + dependencyResolverVarName + " = " + dependencyResolverVarName + ";"));
381
382                 for (Entry<String, AttributeIfc> attrEntry : attrs.entrySet()) {
383                     String innerName = attrEntry.getKey();
384                     String varName = BindingGeneratorUtil
385                             .parseToValidParamName(attrEntry.getKey());
386
387                     String fullyQualifiedName, nullableDefault = null;
388                     if (attrEntry.getValue() instanceof TypedAttribute) {
389                         Type type = ((TypedAttribute) attrEntry.getValue()).getType();
390                         if(attrEntry.getValue() instanceof JavaAttribute) {
391                             nullableDefault = ((JavaAttribute)attrEntry.getValue()).getNullableDefaultWrappedForCode();
392                             if(((JavaAttribute)attrEntry.getValue()).isIdentityRef()) {
393
394                                 String fieldType = serializeType(type, true);
395                                 String innerType = getInnerTypeFromIdentity(type);
396                                 methods.add(new MethodDefinition(fieldType, "resolve" + attrEntry.getKey(), Collections.<Field>emptyList(),
397                                         "return " + varName + ".resolveIdentity(" + dependencyResolverVarName + "," +  innerType + ".class);"));
398                                 type = identityRefType;
399                             }
400                         }
401                         fullyQualifiedName = serializeType(type);
402                     } else {
403                         fullyQualifiedName = FullyQualifiedNameHelper
404                                 .getFullyQualifiedName(packageName, attrEntry.getValue().getUpperCaseCammelCase());
405                     }
406                     fields.add(new Field(fullyQualifiedName, varName, nullableDefault, needsDepResolver(attrEntry.getValue())));
407
408                     String getterName = "get" + innerName;
409                     MethodDefinition getter = new MethodDefinition(
410                             fullyQualifiedName, getterName,
411                             Collections.<Field> emptyList(), "return "
412                                     + varName + ";");
413
414                     String setterName = "set" + innerName;
415                     MethodDefinition setter = new MethodDefinition("void",
416                             setterName, Lists.newArrayList(new Field(
417                                     fullyQualifiedName, varName)), "this."
418                                     + varName + " = " + varName + ";");
419                     methods.add(getter);
420                     methods.add(setter);
421                 }
422
423             }
424
425             String getType() {
426                 return fullyQualifiedName;
427             }
428
429             String getName() {
430                 return name;
431             }
432
433             List<Field> getFields() {
434                 return fields;
435             }
436
437             List<MethodDefinition> getMethods() {
438                 return methods;
439             }
440         }
441     }
442
443
444     private static class MXBeanInterfaceAttributesProcessor {
445         private final List<MethodDeclaration> methods = Lists.newArrayList();
446
447         void processAttributes(Map<String, AttributeIfc> attributes) {
448             for (Entry<String, AttributeIfc> attrEntry : attributes.entrySet()) {
449                 String returnType;
450                 AttributeIfc attributeIfc = attrEntry.getValue();
451
452                 boolean isIdentityRef = false;
453                 if (attributeIfc instanceof TypedAttribute) {
454                     TypedAttribute typedAttribute = (TypedAttribute) attributeIfc;
455                     returnType = serializeType(typedAttribute.getType());
456
457                     if (attributeIfc instanceof JavaAttribute && ((JavaAttribute)attrEntry.getValue()).isIdentityRef()) {
458                         returnType = serializeType(identityRefType);
459                     }
460
461                 } else {
462                     throw new UnsupportedOperationException(
463                             "Attribute not supported: "
464                                     + attributeIfc.getClass());
465                 }
466
467                 String getterName = "get"
468                         + attributeIfc.getUpperCaseCammelCase();
469                 MethodDeclaration getter = new MethodDeclaration(returnType,
470                         getterName, Collections.<Field> emptyList());
471
472                 String varName = BindingGeneratorUtil
473                         .parseToValidParamName(attrEntry.getKey());
474                 String setterName = "set"
475                         + attributeIfc.getUpperCaseCammelCase();
476                 MethodDeclaration setter = new MethodDeclaration("void",
477                         setterName, Lists.newArrayList(new Field(returnType,
478                                 varName)));
479
480                 methods.add(getter);
481                 methods.add(setter);
482
483                 if (attributeIfc.getNullableDescription() != null) {
484                     setter.setJavadoc(attrEntry.getValue()
485                             .getNullableDescription());
486                 }
487             }
488         }
489
490         List<MethodDeclaration> getMethods() {
491             return methods;
492         }
493     }
494
495     private static final Type identityRefType = new Type() {
496         public final Class<IdentityAttributeRef> IDENTITY_ATTRIBUTE_REF_CLASS = IdentityAttributeRef.class;
497
498         @Override
499         public String getPackageName() {
500             return IDENTITY_ATTRIBUTE_REF_CLASS.getPackage().getName();
501         }
502
503         @Override
504         public String getName() {
505             return IDENTITY_ATTRIBUTE_REF_CLASS.getSimpleName();
506         }
507
508         @Override
509         public String getFullyQualifiedName() {
510             return IDENTITY_ATTRIBUTE_REF_CLASS.getName();
511         }
512     };
513
514     private static class AbstractFactoryAttributesProcessor {
515
516         private final List<Field> fields = Lists.newArrayList();
517
518         void processAttributes(Map<String, AttributeIfc> attributes,
519                 String packageName) {
520             for (Entry<String, AttributeIfc> attrEntry : attributes.entrySet()) {
521                 String type;
522                 String nullableDefaultWrapped = null;
523                 AttributeIfc attributeIfc = attrEntry.getValue();
524
525                 if (attributeIfc instanceof TypedAttribute) {
526                     TypedAttribute typedAttribute = (TypedAttribute) attributeIfc;
527                     type = serializeType(typedAttribute.getType());
528                 } else {
529                     throw new UnsupportedOperationException(
530                             "Attribute not supported: "
531                                     + attributeIfc.getClass());
532                 }
533
534                 fields.add(new Field(type, attributeIfc
535                         .getUpperCaseCammelCase(), nullableDefaultWrapped));
536             }
537         }
538
539         List<Field> getFields() {
540             return fields;
541         }
542     }
543
544     private static class AbstractModuleAttributesProcessor {
545         private static class Holder {
546             private final List<ModuleField> moduleFields;
547             private final List<MethodDefinition> methods;
548
549             private Holder(List<ModuleField> moduleFields, List<MethodDefinition> methods) {
550                 this.moduleFields = Collections.unmodifiableList(moduleFields);
551                 this.methods = Collections.unmodifiableList(methods);
552             }
553         }
554
555         private final Holder holder;
556
557
558         private AbstractModuleAttributesProcessor(Map<String, AttributeIfc> attributes) {
559             this.holder = processAttributes(attributes);
560         }
561
562         private static Holder processAttributes(Map<String, AttributeIfc> attributes) {
563             List<ModuleField> moduleFields = new ArrayList<>();
564             List<MethodDefinition> methods = new ArrayList<>();
565             for (Entry<String, AttributeIfc> attrEntry : attributes.entrySet()) {
566                 String type, nullableDefaultWrapped = null;
567                 AttributeIfc attributeIfc = attrEntry.getValue();
568                 boolean isIdentity = false;
569                 boolean needsDepResolver = needsDepResolver(attrEntry.getValue());
570
571                 if (attributeIfc instanceof TypedAttribute) {
572                     TypedAttribute typedAttribute = (TypedAttribute) attributeIfc;
573                     type = serializeType(typedAttribute.getType());
574                     if (attributeIfc instanceof JavaAttribute) {
575                         nullableDefaultWrapped = ((JavaAttribute) attributeIfc).getNullableDefaultWrappedForCode();
576                         if(((JavaAttribute)attrEntry.getValue()).isIdentityRef()) {
577                             isIdentity = true;
578                             type = serializeType(typedAttribute.getType(), true);
579                         }
580                     }
581                 } else {
582                     throw new UnsupportedOperationException(
583                             "Attribute not supported: "
584                                     + attributeIfc.getClass());
585                 }
586
587                 boolean isDependency = false;
588                 boolean isListOfDependencies = false;
589                 Dependency dependency = null;
590                 Annotation overrideAnnotation = new Annotation("Override",
591                         Collections.<Parameter> emptyList());
592                 List<Annotation> annotations = Lists
593                         .newArrayList(overrideAnnotation);
594
595                 if (attributeIfc instanceof AbstractDependencyAttribute) {
596                     isDependency = true;
597                     dependency = ((AbstractDependencyAttribute) attributeIfc)
598                             .getDependency();
599                     annotations.add(Annotation
600                             .createRequireIfcAnnotation(dependency.getSie()));
601                     if (attributeIfc instanceof ListDependenciesAttribute) {
602                         isListOfDependencies = true;
603                     }
604                 }
605
606                 String varName = BindingGeneratorUtil
607                         .parseToValidParamName(attrEntry.getKey());
608                 {
609                 ModuleField field;
610
611                 if (isIdentity) {
612                     String identityBaseClass = getInnerTypeFromIdentity(((TypedAttribute) attributeIfc).getType());
613                     IdentityRefModuleField identityField = new IdentityRefModuleField(type, varName,
614                             attributeIfc.getUpperCaseCammelCase(), identityBaseClass);
615
616                     String getterName = "get"
617                             + attributeIfc.getUpperCaseCammelCase() + "Identity";
618                     MethodDefinition additionalGetter = new MethodDefinition(type, getterName, Collections.<Field> emptyList(),
619                             Collections.<Annotation> emptyList(), "return " + identityField.getIdentityClassName()
620                                     + ";");
621                     methods.add(additionalGetter);
622
623                     String setterName = "set"
624                             + attributeIfc.getUpperCaseCammelCase();
625
626                     String setterBody = "this." + identityField.getIdentityClassName() + " = " + identityField.getIdentityClassName() + ";";
627                     MethodDefinition additionalSetter = new MethodDefinition("void",
628                             setterName,
629                             Lists.newArrayList(new Field(type, identityField.getIdentityClassName())),
630                             Collections.<Annotation> emptyList(), setterBody);
631                     additionalSetter.setJavadoc(attributeIfc.getNullableDescription());
632
633                     methods.add(additionalSetter);
634
635                     type = serializeType(identityRefType);
636                     field = identityField;
637                 } else {
638                     field = new ModuleField(type, varName, attributeIfc.getUpperCaseCammelCase(),
639                             nullableDefaultWrapped, isDependency, dependency, isListOfDependencies, needsDepResolver);
640                 }
641                 moduleFields.add(field);
642                 }
643                 String getterName = "get"
644                         + attributeIfc.getUpperCaseCammelCase();
645                 MethodDefinition getter = new MethodDefinition(type,
646                         getterName, Collections.<Field> emptyList(),
647                         Lists.newArrayList(overrideAnnotation), "return "
648                         + varName + ";");
649
650                 methods.add(getter);
651
652                 String setterName = "set"
653                         + attributeIfc.getUpperCaseCammelCase();
654
655                 if (attributeIfc.getNullableDescription() != null) {
656                     annotations.add(Annotation
657                             .createDescriptionAnnotation(attributeIfc.getNullableDescription()));
658                 }
659
660                 String setterBody = "this." + varName + " = " + varName + ";";
661                 if (isListOfDependencies) {
662                     String nullCheck = String.format("if (%s == null) throw new IllegalArgumentException(\"Null not supported\");%n",
663                             varName);
664                     setterBody = nullCheck + setterBody;
665                 }
666                 MethodDefinition setter = new MethodDefinition("void",
667                         setterName,
668                         Lists.newArrayList(new Field(type, varName)),
669                         annotations, setterBody);
670                 setter.setJavadoc(attributeIfc.getNullableDescription());
671
672                 methods.add(setter);
673             }
674             return new Holder(moduleFields, methods);
675         }
676
677         List<ModuleField> getModuleFields() {
678             return holder.moduleFields;
679         }
680
681         List<MethodDefinition> getMethods() {
682             return holder.methods;
683         }
684
685     }
686
687
688     private static boolean needsDepResolver(AttributeIfc value) {
689         if(value instanceof TOAttribute)
690             return true;
691         if(value instanceof ListAttribute) {
692             AttributeIfc innerAttribute = ((ListAttribute) value).getInnerAttribute();
693             return needsDepResolver(innerAttribute);
694         }
695
696         return false;
697     }
698
699     private static String getInnerTypeFromIdentity(Type type) {
700         Preconditions.checkArgument(type instanceof ParameterizedType);
701         Type[] args = ((ParameterizedType) type).getActualTypeArguments();
702         Preconditions.checkArgument(args.length ==1);
703         return serializeType(args[0]);
704     }
705 }

©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.