binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/AbstractJavaGeneratedType.java

   1 /*
   2  * Copyright (c) 2018 Pantheon Technologies, s.r.o. 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.mdsal.binding.java.api.generator;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.collect.ImmutableMap;
  13 import com.google.common.collect.ImmutableMap.Builder;
  14 import com.google.common.collect.ImmutableSet;
  15 import com.google.common.collect.Iterables;
  16 import java.util.HashMap;
  17 import java.util.HashSet;
  18 import java.util.Map;
  19 import java.util.Set;
  20 import javax.annotation.concurrent.NotThreadSafe;
  21 import org.eclipse.jdt.annotation.NonNullByDefault;
  22 import org.eclipse.jdt.annotation.Nullable;
  23 import org.opendaylight.mdsal.binding.model.api.Enumeration;
  24 import org.opendaylight.mdsal.binding.model.api.Enumeration.Pair;
  25 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
  26 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
  27 import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
  28 import org.opendaylight.mdsal.binding.model.api.Type;
  29 import org.opendaylight.mdsal.binding.model.api.WildcardType;
  30
  31 /**
  32  * Abstract class representing a generated type, either top-level or nested. It takes care of tracking references
  33  * to other Java types and resolving them as best as possible.
  34  *
  35  * @author Robert Varga
  36  */
  37 @NonNullByDefault
  38 @NotThreadSafe
  39 abstract class AbstractJavaGeneratedType {
  40     private final Map<JavaTypeName, @Nullable String> nameCache = new HashMap<>();
  41     private final ImmutableMap<String, NestedJavaGeneratedType> enclosedTypes;
  42     private final ImmutableSet<String> conflictingNames;
  43
  44     private final JavaTypeName name;
  45
  46     AbstractJavaGeneratedType(final GeneratedType genType) {
  47         name = genType.getIdentifier();
  48         final Builder<String, NestedJavaGeneratedType> b = ImmutableMap.builder();
  49         for (GeneratedType type : Iterables.concat(genType.getEnclosedTypes(), genType.getEnumerations())) {
  50             b.put(type.getIdentifier().simpleName(), new NestedJavaGeneratedType(this, type));
  51         }
  52         enclosedTypes = b.build();
  53
  54         final Set<String> cb = new HashSet<>();
  55         if (genType instanceof Enumeration) {
  56             ((Enumeration) genType).getValues().stream().map(Pair::getMappedName).forEach(cb::add);
  57         }
  58         // TODO: perhaps we can do something smarter to actually access the types
  59         collectAccessibleTypes(cb, genType);
  60
  61         conflictingNames = ImmutableSet.copyOf(cb);
  62     }
  63
  64     private void collectAccessibleTypes(final Set<String> set, final GeneratedType type) {
  65         for (Type impl : type.getImplements()) {
  66             if (impl instanceof GeneratedType) {
  67                 final GeneratedType genType = (GeneratedType) impl;
  68                 for (GeneratedType inner : Iterables.concat(genType.getEnclosedTypes(), genType.getEnumerations())) {
  69                     set.add(inner.getIdentifier().simpleName());
  70                 }
  71                 collectAccessibleTypes(set, genType);
  72             }
  73         }
  74     }
  75
  76     final JavaTypeName getName() {
  77         return name;
  78     }
  79
  80     final String getSimpleName() {
  81         return name.simpleName();
  82     }
  83
  84     final String getReferenceString(final Type type, final String... annotations) {
  85         final String ref = getReferenceString(type.getIdentifier());
  86         if (!(type instanceof ParameterizedType)) {
  87             return annotations.length == 0 ? ref : annotate(ref, annotations).toString();
  88         }
  89
  90         final StringBuilder sb = annotate(ref, annotations).append('<');
  91         final Type[] types = ((ParameterizedType) type).getActualTypeArguments();
  92         if (types.length == 0) {
  93             return sb.append("?>").toString();
  94         }
  95
  96         for (int i = 0; i < types.length; i++) {
  97             final Type t = types[i];
  98             if (t instanceof WildcardType) {
  99                 sb.append("? extends ");
 100             }
 101             sb.append(getReferenceString(t));
 102             if (i != types.length - 1) {
 103                 sb.append(", ");
 104             }
 105         }
 106
 107         return sb.append('>').toString();
 108     }
 109
 110     final String getReferenceString(final JavaTypeName type) {
 111         if (type.packageName().isEmpty()) {
 112             // This is a packageless primitive type, refer to it directly
 113             return type.simpleName();
 114         }
 115
 116         // Self-reference, return simple name
 117         if (name.equals(type)) {
 118             return name.simpleName();
 119         }
 120
 121         // Fast path: we have already resolved how to refer to this type
 122         final String existing = nameCache.get(type);
 123         if (existing != null) {
 124             return existing;
 125         }
 126
 127         // Fork based on whether the class is in this compilation unit, package or neither
 128         final String result;
 129         if (name.topLevelClass().equals(type.topLevelClass())) {
 130             result = localTypeName(type);
 131         } else if (name.packageName().equals(type.packageName())) {
 132             result = packageTypeName(type);
 133         } else {
 134             result = foreignTypeName(type);
 135         }
 136
 137         nameCache.put(type, result);
 138         return result;
 139     }
 140
 141     final NestedJavaGeneratedType getEnclosedType(final JavaTypeName type) {
 142         return requireNonNull(enclosedTypes.get(type.simpleName()));
 143     }
 144
 145     final boolean checkAndImportType(final JavaTypeName type) {
 146         // We can import the type only if it does not conflict with us or our immediately-enclosed types
 147         final String simpleName = type.simpleName();
 148         return !simpleName.equals(getSimpleName()) && !enclosedTypes.containsKey(simpleName)
 149                 && !conflictingNames.contains(simpleName) && importCheckedType(type);
 150     }
 151
 152     abstract boolean importCheckedType(JavaTypeName type);
 153
 154     abstract String localTypeName(JavaTypeName type);
 155
 156     private String foreignTypeName(final JavaTypeName type) {
 157         return checkAndImportType(type) ? type.simpleName() : type.toString();
 158     }
 159
 160     private String packageTypeName(final JavaTypeName type) {
 161         // Try to anchor the top-level type and use a local reference
 162         return checkAndImportType(type.topLevelClass()) ? type.localName() : type.toString();
 163     }
 164
 165     private static StringBuilder annotate(final String ref, final String... annotations) {
 166         final StringBuilder sb = new StringBuilder();
 167         if (annotations.length == 0) {
 168             return sb.append(ref);
 169         }
 170
 171         final int dot = ref.lastIndexOf('.');
 172         if (dot != -1) {
 173             sb.append(ref, 0, dot + 1);
 174         }
 175         for (String annotation : annotations) {
 176             sb.append('@').append(annotation).append(' ');
 177         }
 178
 179         return sb.append(ref, dot + 1, ref.length());
 180     }
 181 }