binding2/mdsal-binding2-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/javav2/java/api/generator/renderers/InterfaceRenderer.java

   1 /*
   2  * Copyright (c) 2017 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
   9 package org.opendaylight.mdsal.binding.javav2.java.api.generator.renderers;
  10
  11 import com.google.common.base.Preconditions;
  12 import java.util.ArrayList;
  13 import java.util.List;
  14 import org.opendaylight.mdsal.binding.javav2.java.api.generator.txt.enumTemplate;
  15 import org.opendaylight.mdsal.binding.javav2.java.api.generator.txt.interfaceTemplate;
  16 import org.opendaylight.mdsal.binding.javav2.java.api.generator.util.TextTemplateUtil;
  17 import org.opendaylight.mdsal.binding.javav2.model.api.AnnotationType;
  18 import org.opendaylight.mdsal.binding.javav2.model.api.Constant;
  19 import org.opendaylight.mdsal.binding.javav2.model.api.Enumeration;
  20 import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedTransferObject;
  21 import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType;
  22 import org.opendaylight.mdsal.binding.javav2.model.api.MethodSignature;
  23 import org.opendaylight.mdsal.binding.javav2.model.api.Type;
  24
  25 public class InterfaceRenderer extends BaseRenderer {
  26
  27     private static final char NEW_LINE = '\n';
  28
  29     /**
  30      * Creates the instance of this class which is used for generating the interface file source
  31      * code from <code>type</code>.
  32      * @param type generated type
  33      */
  34     public InterfaceRenderer(final GeneratedType type) {
  35         super(type);
  36         Preconditions.checkNotNull(type, "Generated type reference cannot be NULL!");
  37     }
  38
  39     @Override
  40     protected String body() {
  41         // mainAnnotations string with annotations for whole interface
  42         final String mainAnnotations = generateAnnotations(getType().getAnnotations());
  43         // StringBuilder string with the declaration of methods source code in JAVA format
  44         final StringBuilder sb1 = new StringBuilder();
  45         for (MethodSignature method : getType().getMethodDefinitions()) {
  46             if (isAccessor(method)) {
  47                 sb1.append(TextTemplateUtil.asJavadoc(method.getComment()));
  48             } else {
  49                 sb1.append(TextTemplateUtil.getJavaDocForInterface(method));
  50             }
  51             sb1.append(generateAnnotations(method.getAnnotations()))
  52                 .append(importedName(method.getReturnType()))
  53                 .append(' ')
  54                 .append(method.getName())
  55                 .append('(')
  56                 .append(generateParameters(method.getParameters()))
  57                 .append(");")
  58                 .append(NEW_LINE);
  59         }
  60         final String methodList = sb1.toString();
  61
  62         // enums string with rendered enums from template
  63         final StringBuilder sb2 = new StringBuilder();
  64         for (Enumeration enumeration : getType().getEnumerations()) {
  65             final String importedName = importedName(String.class);
  66             final String enumBody = enumTemplate.render(enumeration, importedName).body();
  67             sb2.append(enumBody);
  68         }
  69         final String enums = sb2.toString();
  70
  71         final String generatedImports = generateImports(getType().getImplements());
  72         // generatedConstants list of constants
  73         final List<String> strings = new ArrayList<>(getType().getConstantDefinitions().size());
  74         for (Constant constant : getType().getConstantDefinitions()) {
  75             strings.add(emitConstant(constant));
  76         }
  77
  78         final String generatedConstants = String.join("\n", strings);
  79
  80         final List<String> innerClasses = new ArrayList<>(getType().getEnclosedTypes().size());
  81         for (GeneratedType innerClass : getType().getEnclosedTypes()) {
  82             if (innerClass instanceof GeneratedTransferObject) {
  83                 if (((GeneratedTransferObject) innerClass).isUnionType()) {
  84                     final UnionRenderer unionRenderer = new UnionRenderer((GeneratedTransferObject) innerClass);
  85                     innerClasses.add(unionRenderer.generateAsInnerClass());
  86                     this.putAllToImportMap(unionRenderer.getImportMap());
  87                 } else {
  88                     final ClassRenderer classRenderer = new ClassRenderer((GeneratedTransferObject) innerClass);
  89                     innerClasses.add(classRenderer.generateAsInnerClass());
  90                     this.putAllToImportMap(classRenderer.getImportMap());
  91                 }
  92             }
  93         }
  94         final String generatedInnerClasses = String.join("\n", innerClasses);
  95
  96         return interfaceTemplate.render(getType(), enums, mainAnnotations, methodList, generatedImports,
  97                 generatedConstants, generatedInnerClasses).body();
  98     }
  99
 100     private static boolean isAccessor(final MethodSignature maybeGetter) {
 101         return maybeGetter.getName().startsWith("is") || maybeGetter.getName().startsWith("get");
 102     }
 103
 104     /**
 105      * @param annotationTypeList list of annotations
 106      * @return String of annotations in format:
 107      * "@"annotation
 108      * (parameterName1=ParameterSingleValue1,...)
 109      *
 110      */
 111     private String generateAnnotations(final List<AnnotationType> annotationTypeList) {
 112         final StringBuilder sb1 = new StringBuilder();
 113         for (AnnotationType annotationType : annotationTypeList) {
 114             sb1.append('@').append(importedName(annotationType));
 115             if (!annotationType.getParameters().isEmpty()) {
 116                 sb1.append('(');
 117             }
 118             final List<String> parameterList = new ArrayList<>(annotationType.getParameters().size());
 119             for (AnnotationType.Parameter parameter : annotationType.getParameters()) {
 120                 final StringBuilder sb2 = new StringBuilder();
 121                 sb2.append(parameter.getName())
 122                    .append('=')
 123                    .append(parameter.getSingleValue());
 124                 parameterList.add(sb2.toString());
 125             }
 126             sb1.append(String.join(",", parameterList));
 127             if (!annotationType.getParameters().isEmpty()) {
 128                 sb1.append(')');
 129             }
 130             sb1.append(NEW_LINE);
 131         }
 132         return sb1.toString();
 133     }
 134
 135     /**
 136      * @param parameters list of parameters
 137      * @return list of parameters separated with ","
 138      */
 139     private String generateImports(final List<Type> parameters) {
 140         final List<String> strings = new ArrayList<>(parameters.size());
 141         for (Type parameter : parameters) {
 142             strings.add(importedName(parameter));
 143         }
 144
 145         return String.join(", ", strings);
 146     }
 147 }