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

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