X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding%2Fmdsal-binding-java-api-generator%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fbinding%2Fjava%2Fapi%2Fgenerator%2FYangModuleInfoTemplate.xtend;h=e27d7cdec40739144a2e14a38e251c9d6c01f110;hb=1144f464d67c5371b30463be5e4e144edaddd05b;hp=b4db903b0e973caa1ac2d0c58c6a003ba951fa7e;hpb=be42d49bf915cf4e8921fae0945c48687ee9680e;p=mdsal.git

diff --git a/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/YangModuleInfoTemplate.xtend b/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/YangModuleInfoTemplate.xtend
index b4db903b0e..e27d7cdec4 100644
--- a/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/YangModuleInfoTemplate.xtend
+++ b/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/YangModuleInfoTemplate.xtend
@@ -7,41 +7,66 @@
  */
 package org.opendaylight.mdsal.binding.java.api.generator
 
-import static org.opendaylight.yangtools.yang.binding.BindingMapping.MODEL_BINDING_PROVIDER_CLASS_NAME
-import static org.opendaylight.yangtools.yang.binding.BindingMapping.MODULE_INFO_CLASS_NAME
-import static extension org.opendaylight.yangtools.yang.binding.BindingMapping.getClassName
-import static extension org.opendaylight.yangtools.yang.binding.BindingMapping.getRootPackageName
+import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.getClassName
+import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.getRootPackageName
+import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.MODEL_BINDING_PROVIDER_CLASS_NAME
+import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.MODULE_INFO_CLASS_NAME
+import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.MODULE_INFO_QNAMEOF_METHOD_NAME
 
 import com.google.common.base.Preconditions
 import com.google.common.collect.ImmutableSet
-import java.util.Collections
+import java.util.Comparator
 import java.util.HashSet
-import java.util.LinkedHashMap
-import java.util.Map
 import java.util.Optional
 import java.util.Set
 import java.util.TreeMap
 import java.util.function.Function
 import org.eclipse.xtend.lib.annotations.Accessors
-import org.opendaylight.mdsal.binding.model.api.ParameterizedType
-import org.opendaylight.mdsal.binding.model.api.Type
-import org.opendaylight.mdsal.binding.model.api.WildcardType
-import org.opendaylight.mdsal.binding.model.util.Types
-import org.opendaylight.yangtools.yang.binding.ResourceYangModuleInfo
-import org.opendaylight.yangtools.yang.binding.YangModelBindingProvider
+import org.gaul.modernizer_maven_annotations.SuppressModernizer
 import org.opendaylight.yangtools.yang.binding.YangModuleInfo
-import org.opendaylight.yangtools.yang.common.QName
 import org.opendaylight.yangtools.yang.common.Revision
 import org.opendaylight.yangtools.yang.model.api.Module
 import org.opendaylight.yangtools.yang.model.api.SchemaContext
 
+/**
+ * Template for {@link YangModuleInfo} implementation for a particular module. Aside from fulfilling that contract,
+ * this class provides a static {@code createQName(String)} method, which is used by co-generated code to initialize
+ * QNAME constants.
+ */
+@SuppressModernizer
 class YangModuleInfoTemplate {
+    static val Comparator<Optional<Revision>> REVISION_COMPARATOR =
+        [ Optional<Revision> first, Optional<Revision> second | Revision.compare(first, second) ]
+
+    // These are always imported. Note we need to import even java.lang members, as there can be conflicting definitions
+    // in our package
+    static val CORE_IMPORT_STR = '''
+        import com.google.common.collect.ImmutableSet;
+        import java.lang.Override;
+        import java.lang.String;
+        import org.eclipse.jdt.annotation.NonNull;
+        import org.opendaylight.yangtools.yang.binding.ResourceYangModuleInfo;
+        import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+        import org.opendaylight.yangtools.yang.common.QName;
+    '''
+    static val EXT_IMPORT_STR = '''
+        import com.google.common.collect.ImmutableSet;
+        import java.lang.Override;
+        import java.lang.String;
+        import java.util.HashSet;
+        import java.util.Set;
+        import org.eclipse.jdt.annotation.NonNull;
+        import org.opendaylight.yangtools.yang.binding.ResourceYangModuleInfo;
+        import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+        import org.opendaylight.yangtools.yang.common.QName;
+    '''
 
     val Module module
     val SchemaContext ctx
-    val Map<String, String> importMap = new LinkedHashMap()
     val Function<Module, Optional<String>> moduleFilePathResolver
 
+    var importedTypes = CORE_IMPORT_STR
+
     @Accessors
     val String packageName
 
@@ -58,49 +83,65 @@ class YangModuleInfoTemplate {
     }
 
     def String generate() {
-        val body = '''
-            public final class «MODULE_INFO_CLASS_NAME» extends «ResourceYangModuleInfo.importedName» {
-
-                private static final «YangModuleInfo.importedName» INSTANCE = new «MODULE_INFO_CLASS_NAME»();
+        val Set<Module> submodules = new HashSet
+        collectSubmodules(submodules, module)
 
+        val body = '''
+            public final class «MODULE_INFO_CLASS_NAME» extends ResourceYangModuleInfo {
                 «val rev = module.revision»
-                private final «QName.importedName» name = QName.create("«module.namespace.toString»", «IF rev.present»"«rev.get.toString»", «ENDIF»"«module.name»").intern();
-                private final «Set.importedName»<«YangModuleInfo.importedName»> importedModules;
+                private static final @NonNull QName NAME = QName.create("«module.namespace.toString»", «IF rev.present»"«rev.get.toString»", «ENDIF»"«module.name»").intern();
+                private static final @NonNull YangModuleInfo INSTANCE = new «MODULE_INFO_CLASS_NAME»();
+
+                private final @NonNull ImmutableSet<YangModuleInfo> importedModules;
 
-                public static «YangModuleInfo.importedName» getInstance() {
+                public static @NonNull YangModuleInfo getInstance() {
                     return INSTANCE;
                 }
 
-                «classBody(module, MODULE_INFO_CLASS_NAME)»
+                public static @NonNull QName «MODULE_INFO_QNAMEOF_METHOD_NAME»(final String localName) {
+                    return QName.create(NAME, localName).intern();
+                }
+
+                «classBody(module, MODULE_INFO_CLASS_NAME, submodules)»
             }
         '''
         return '''
             package «packageName»;
 
-            «imports»
+            «importedTypes»
 
             «body»
         '''.toString
     }
 
-    def String generateModelProvider() {
-        '''
-            package «packageName»;
+    def String generateModelProvider() '''
+        package «packageName»;
 
-            public final class «MODEL_BINDING_PROVIDER_CLASS_NAME» implements «YangModelBindingProvider.name» {
-                @Override
-                public «YangModuleInfo.name» getModuleInfo() {
-                    return «MODULE_INFO_CLASS_NAME».getInstance();
-                }
+        import java.lang.Override;
+        import org.opendaylight.yangtools.yang.binding.YangModelBindingProvider;
+        import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+
+        public final class «MODEL_BINDING_PROVIDER_CLASS_NAME» implements YangModelBindingProvider {
+            @Override
+            public YangModuleInfo getModuleInfo() {
+                return «MODULE_INFO_CLASS_NAME».getInstance();
             }
-        '''
+        }
+    '''
 
+    private static def void collectSubmodules(Set<Module> dest, Module module) {
+        for (Module submodule : module.submodules) {
+            if (dest.add(submodule)) {
+                collectSubmodules(dest, submodule)
+            }
+        }
     }
 
-    private def CharSequence classBody(Module m, String className) '''
+    private def CharSequence classBody(Module m, String className, Set<Module> submodules) '''
         private «className»() {
-            «IF !m.imports.empty || !m.submodules.empty»
-                «Set.importedName»<«YangModuleInfo.importedName»> set = new «HashSet.importedName»<>();
+            «IF !m.imports.empty || !submodules.empty»
+                «extendImports»
+                Set<YangModuleInfo> set = new HashSet<>();
             «ENDIF»
             «IF !m.imports.empty»
                 «FOR imp : m.imports»
@@ -108,7 +149,7 @@ class YangModuleInfoTemplate {
                     «val rev = imp.revision»
                     «IF !rev.present»
                         «val Set<Module> modules = ctx.modules»
-                        «val TreeMap<Optional<Revision>, Module> sorted = new TreeMap()»
+                        «val TreeMap<Optional<Revision>, Module> sorted = new TreeMap(REVISION_COMPARATOR)»
                         «FOR module : modules»
                             «IF module.name.equals(name)»
                                 «sorted.put(module.revision, module)»
@@ -120,159 +161,60 @@ class YangModuleInfoTemplate {
                     «ENDIF»
                 «ENDFOR»
             «ENDIF»
-            «IF !m.submodules.empty»
-                «FOR submodule : m.submodules»
-                    set.add(«submodule.name.className»Info.getInstance());
-                «ENDFOR»
-            «ENDIF»
-            «IF m.imports.empty && m.submodules.empty»
-                importedModules = «Collections.importedName».emptySet();
+            «FOR submodule : submodules»
+                set.add(«submodule.name.className»Info.getInstance());
+            «ENDFOR»
+            «IF m.imports.empty && submodules.empty»
+                importedModules = ImmutableSet.of();
             «ELSE»
-                importedModules = «ImmutableSet.importedName».copyOf(set);
+                importedModules = ImmutableSet.copyOf(set);
             «ENDIF»
         }
 
         @Override
-        public «QName.importedName» getName() {
-            return name;
+        public QName getName() {
+            return NAME;
         }
 
         @Override
-        protected «String.importedName» resourceName() {
+        protected String resourceName() {
             return "«sourcePath(m)»";
         }
 
         @Override
-        public «Set.importedName»<«YangModuleInfo.importedName»> getImportedModules() {
+        public ImmutableSet<YangModuleInfo> getImportedModules() {
             return importedModules;
         }
-
-        «generateSubInfo(m)»
-
+        «generateSubInfo(submodules)»
     '''
 
+    private def void extendImports() {
+        importedTypes = EXT_IMPORT_STR
+    }
+
     private def sourcePath(Module module) {
         val opt = moduleFilePathResolver.apply(module)
         Preconditions.checkState(opt.isPresent, "Module %s does not have a file path", module)
         return opt.get
     }
 
-    private def imports() '''
-        «IF !importMap.empty»
-            «FOR entry : importMap.entrySet»
-                «IF entry.value != module.QNameModule.rootPackageName»
-                    import «entry.value».«entry.key»;
-                «ENDIF»
-            «ENDFOR»
-        «ENDIF»
-    '''
-
-    final protected def importedName(Class<?> cls) {
-        val Type intype = Types.typeForClass(cls)
-        putTypeIntoImports(intype)
-        intype.explicitType
-    }
-
-    final def void putTypeIntoImports(Type type) {
-        val String typeName = type.name
-        val String typePackageName = type.packageName
-        if (typePackageName.startsWith("java.lang") || typePackageName.empty) {
-            return
-        }
-        if (!importMap.containsKey(typeName)) {
-            importMap.put(typeName, typePackageName)
-        }
-        if (type instanceof ParameterizedType) {
-            val Type[] params = type.actualTypeArguments
-            if (params !== null) {
-                for (Type param : params) {
-                    putTypeIntoImports(param)
-                }
-            }
-        }
-    }
-
-    final def String getExplicitType(Type type) {
-        val String typePackageName = type.packageName
-        val String typeName = type.name
-        val String importedPackageName = importMap.get(typeName)
-        var StringBuilder builder
-        if (typePackageName.equals(importedPackageName)) {
-            builder = new StringBuilder(typeName)
-            if (builder.toString().equals("Void")) {
-                return "void"
-            }
-            addActualTypeParameters(builder, type)
-        } else {
-            if (type.equals(Types.voidType())) {
-                return "void"
-            }
-            builder = new StringBuilder()
-            if (!typePackageName.empty) {
-                builder.append(typePackageName).append(Constants.DOT).append(typeName)
-            } else {
-                builder.append(typeName)
-            }
-            addActualTypeParameters(builder, type)
-        }
-        return builder.toString()
-    }
-
-    final def StringBuilder addActualTypeParameters(StringBuilder builder, Type type) {
-        if (type instanceof ParameterizedType) {
-            val Type[] pTypes = type.actualTypeArguments
-            builder.append('<').append(getParameters(pTypes)).append('>')
-        }
-        return builder
-    }
-
-    final def String getParameters(Type[] pTypes) {
-        if (pTypes === null || pTypes.length == 0) {
-            return "?"
-        }
-        val StringBuilder builder = new StringBuilder()
-
-        var int i = 0
-        for (pType : pTypes) {
-            val Type t = pTypes.get(i)
-
-            var String separator = ","
-            if (i == (pTypes.length - 1)) {
-                separator = ""
-            }
-
-            var String wildcardParam = ""
-            if (t.equals(Types.voidType())) {
-                builder.append("java.lang.Void").append(separator)
-            } else {
-
-                if (t instanceof WildcardType) {
-                    wildcardParam = "? extends "
-                }
-
-                builder.append(wildcardParam).append(t.explicitType).append(separator)
-                i = i + 1
-            }
-        }
-        return builder.toString()
-    }
-
-    private def generateSubInfo(Module module) '''
-        «FOR submodule : module.submodules»
+    private def generateSubInfo(Set<Module> submodules) '''
+        «FOR submodule : submodules»
             «val className = submodule.name.className»
-            private static final class «className»Info extends «ResourceYangModuleInfo.importedName» {
-
-                private static final «YangModuleInfo.importedName» INSTANCE = new «className»Info();
 
+            private static final class «className»Info extends ResourceYangModuleInfo {
                 «val rev = submodule.revision»
-                private final «QName.importedName» name = QName.create("«submodule.namespace.toString»", «IF rev.present»"«rev.get.toString»", «ENDIF» "«submodule.name»").intern();
-                private final «Set.importedName»<YangModuleInfo> importedModules;
+                private final @NonNull QName NAME = QName.create("«submodule.namespace.toString»", «
+                IF rev.present»"«rev.get.toString»", «ENDIF»"«submodule.name»").intern();
+                private static final @NonNull YangModuleInfo INSTANCE = new «className»Info();
+
+                private final @NonNull ImmutableSet<YangModuleInfo> importedModules;
 
-                public static «YangModuleInfo.importedName» getInstance() {
+                public static @NonNull YangModuleInfo getInstance() {
                     return INSTANCE;
                 }
 
-                «classBody(submodule, className + "Info")»
+                «classBody(submodule, className + "Info", ImmutableSet.of)»
             }
         «ENDFOR»
     '''