binding2/mdsal-binding2-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/javav2/java/api/generator/renderers/YangModuleInfoTemplateRenderer.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 static org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer.normalizeFullPackageName;
  12 import static org.opendaylight.mdsal.binding.javav2.util.BindingMapping.MODEL_BINDING_PROVIDER_CLASS_NAME;
  13 import static org.opendaylight.mdsal.binding.javav2.util.BindingMapping.getRootPackageName;
  14
  15 import com.google.common.base.Optional;
  16 import com.google.common.base.Preconditions;
  17 import com.google.common.collect.ImmutableSet;
  18 import java.io.IOException;
  19 import java.io.InputStream;
  20 import java.util.Collections;
  21 import java.util.Date;
  22 import java.util.HashMap;
  23 import java.util.HashSet;
  24 import java.util.Map;
  25 import java.util.Set;
  26 import java.util.TreeMap;
  27 import java.util.function.Function;
  28 import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
  29 import org.opendaylight.mdsal.binding.javav2.java.api.generator.txt.modelProviderTemplate;
  30 import org.opendaylight.mdsal.binding.javav2.java.api.generator.txt.yangModuleInfoTemplate;
  31 import org.opendaylight.mdsal.binding.javav2.model.api.ParameterizedType;
  32 import org.opendaylight.mdsal.binding.javav2.model.api.Type;
  33 import org.opendaylight.mdsal.binding.javav2.model.api.WildcardType;
  34 import org.opendaylight.mdsal.binding.javav2.spec.runtime.YangModelBindingProvider;
  35 import org.opendaylight.mdsal.binding.javav2.spec.runtime.YangModuleInfo;
  36 import org.opendaylight.yangtools.concepts.SemVer;
  37 import org.opendaylight.yangtools.yang.model.api.Module;
  38 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  39 import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
  40
  41 public class YangModuleInfoTemplateRenderer {
  42
  43     private final Module module;
  44     private final SchemaContext ctx;
  45     private final Map<String, String> importMap = new HashMap<>();
  46     private final String packageName;
  47     private final String modelBindingProviderName;
  48     private final Function<Module, java.util.Optional<String>> moduleFilePathResolver;
  49
  50     public YangModuleInfoTemplateRenderer(final Module module, final SchemaContext ctx, final Function<Module,
  51             java.util.Optional<String>> moduleFilePathResolver) {
  52
  53         Preconditions.checkArgument(module != null, "Module must not be null.");
  54         this.module = module;
  55         this.ctx = ctx;
  56         this.packageName = normalizeFullPackageName(getRootPackageName(module));
  57         this.moduleFilePathResolver = moduleFilePathResolver;
  58
  59         final StringBuilder sb = new StringBuilder();
  60         sb.append(packageName)
  61             .append('.')
  62             .append(MODEL_BINDING_PROVIDER_CLASS_NAME);
  63         this.modelBindingProviderName = sb.toString();
  64     }
  65
  66     protected String body() {
  67         /**
  68          * list of all imported names for template
  69          */
  70         final Map<String, String> importedNames = new HashMap<>();
  71
  72         importedNames.put("string", importedName(String.class));
  73         importedNames.put("stringBuilder", importedName(StringBuilder.class));
  74         importedNames.put("set", importedName(Set.class));
  75         importedNames.put("hashSet", importedName(HashSet.class));
  76         importedNames.put("collections", importedName(Collections.class));
  77         importedNames.put("immutableSet", importedName(ImmutableSet.class));
  78         importedNames.put("inputStream", importedName(InputStream.class));
  79         importedNames.put("iOException", importedName(IOException.class));
  80         importedNames.put("yangModuleInfo", importedName(YangModuleInfo.class));
  81         importedNames.put("optional", importedName(Optional.class));
  82         importedNames.put("semVer", importedName(SemVer.class));
  83         importedNames.put("schemaSourceRepresentation", importedName(SchemaSourceRepresentation.class));
  84
  85         return yangModuleInfoTemplate.render(module, ctx, importedNames, moduleFilePathResolver).body();
  86     }
  87
  88     /**
  89      * Builds template
  90      * @return generated final template
  91      */
  92     public String generateTemplate() {
  93         final StringBuilder sb = new StringBuilder();
  94         /* body must be filled before imports method call */
  95         final String templateBody = body();
  96         sb.append("package ")
  97             .append(packageName)
  98             .append(";\n\n")
  99             .append(imports())
 100             .append(templateBody);
 101         return sb.toString();
 102     }
 103
 104     public String generateModelProvider() {
 105         return modelProviderTemplate.render(packageName, YangModelBindingProvider.class.getName(), YangModuleInfo.class
 106         .getName()).body();
 107     }
 108
 109     /**
 110      * Walks through map of imports
 111      * @return string of imports for template
 112      */
 113     private String imports() {
 114         final StringBuilder sb = new StringBuilder();
 115         for (Map.Entry<String, String> entry : importMap.entrySet()) {
 116             if (!getRootPackageName(module).equals(entry.getValue())) {
 117                 sb.append("import ")
 118                     .append(entry.getValue())
 119                     .append('.')
 120                     .append(entry.getKey())
 121                     .append(";\n");
 122             }
 123         }
 124         return sb.toString();
 125     }
 126
 127     private String importedName(final Class<?> cls) {
 128         final Type inType = Types.typeForClass(cls);
 129         putTypeIntoImports(inType);
 130         return getExplicitType(inType);
 131     }
 132
 133     private void putTypeIntoImports(final Type type) {
 134         final String typeName = type.getName();
 135         final String typePackageName = type.getPackageName();
 136         if (typePackageName.startsWith("java.lang") || typePackageName.isEmpty()) {
 137             return;
 138         }
 139         if (!importMap.containsKey(typeName)) {
 140             importMap.put(typeName, typePackageName);
 141         }
 142         if (type instanceof ParameterizedType) {
 143             final Type[] params = ((ParameterizedType) type).getActualTypeArguments();
 144             if (params != null) {
 145                 for (Type param : params) {
 146                     putTypeIntoImports(param);
 147                 }
 148             }
 149         }
 150     }
 151
 152     private String getExplicitType(final Type type) {
 153         final String typePackageName = type.getPackageName();
 154         final String typeName = type.getName();
 155         final String importedPackageName = importMap.get(typeName);
 156         final StringBuilder sb;
 157         if (typePackageName.equals(importedPackageName)) {
 158             sb = new StringBuilder(type.getName());
 159             if (sb.toString().equals("Void")) {
 160                 return "void";
 161             }
 162             addActualTypeParameters(sb, type);
 163         } else {
 164             if (type.equals(Types.voidType())) {
 165                 return "void";
 166             }
 167             sb = new StringBuilder();
 168             if (!typePackageName.isEmpty()) {
 169                 sb.append(typePackageName)
 170                     .append('.')
 171                     .append(type.getName());
 172             } else {
 173                 sb.append(type.getName());
 174             }
 175             addActualTypeParameters(sb, type);
 176         }
 177         return sb.toString();
 178     }
 179
 180     private StringBuilder addActualTypeParameters(final StringBuilder sb, final Type type) {
 181         if (type instanceof ParameterizedType) {
 182             final Type[] pTypes = ((ParameterizedType) type).getActualTypeArguments();
 183             sb.append('<');
 184             sb.append(getParameters(pTypes));
 185             sb.append('>');
 186         }
 187         return sb;
 188     }
 189
 190     private String getParameters(final Type[] pTypes) {
 191         if (pTypes == null || pTypes.length == 0) {
 192             return "?";
 193         }
 194         final StringBuilder sb = new StringBuilder();
 195         int i = 0;
 196         for (Type pType : pTypes) {
 197             final Type type = pTypes[i];
 198             String separator = ",";
 199             if (i == (pTypes.length - 1)) {
 200                 separator = "";
 201             }
 202             String wildcardParam = "";
 203             if (type.equals(Types.voidType())) {
 204                 sb.append("java.lang.Void" + separator);
 205             } else {
 206                 if (type instanceof WildcardType) {
 207                     wildcardParam = "? extends ";
 208                 }
 209                 sb.append(wildcardParam + getExplicitType(type) + separator);
 210                 i = i + 1;
 211             }
 212         }
 213         return sb.toString();
 214     }
 215
 216     public static Module getSortedQName(final Set<Module> modules, final String name) {
 217         final TreeMap<Date, Module> sorted = new TreeMap<>();
 218         for (Module module : modules) {
 219             if (name.equals(module.getName())) {
 220                 sorted.put(module.getRevision(), module);
 221             }
 222         }
 223         return sorted.lastEntry().getValue();
 224     }
 225
 226     public String getModelBindingProviderName() {
 227         return modelBindingProviderName;
 228     }
 229 }