Generation of java files from templates

[controller.git] / opendaylight / sal / yang-prototype / code-generator / binding-java-api-generator / src / main / java / org / opendaylight / controller / sal / java / api / generator / InterfaceTemplate.xtend

diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/InterfaceTemplate.xtend b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/InterfaceTemplate.xtend
new file mode 100644 (file)
index 0000000..fb9d606
--- /dev/null
+++ b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/InterfaceTemplate.xtend
@@ -0,0 +1,153 @@
+package org.opendaylight.controller.sal.java.api.generator
+
+import java.util.List
+import java.util.Map
+import org.opendaylight.controller.binding.generator.util.TypeConstants
+import org.opendaylight.controller.sal.binding.model.api.Constant
+import org.opendaylight.controller.sal.binding.model.api.Enumeration
+import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject
+import org.opendaylight.controller.sal.binding.model.api.GeneratedType
+import org.opendaylight.controller.sal.binding.model.api.MethodSignature
+import org.opendaylight.controller.sal.binding.model.api.Type
+import java.util.LinkedHashMap
+
+class InterfaceTemplate {
+    
+    val GeneratedType genType
+    val Map<String, String> imports
+    val List<Constant> consts
+    val List<MethodSignature> methods
+    val List<Enumeration> enums
+    val List<GeneratedType> enclosedGeneratedTypes
+    
+    new(GeneratedType genType) {
+        if (genType == null) {
+            throw new IllegalArgumentException("Generated type reference cannot be NULL!")
+        }
+        
+        this.genType = genType
+        imports = GeneratorUtil.createImports(genType)
+        consts = genType.constantDefinitions
+        methods = genType.methodDefinitions
+        enums = genType.enumerations
+        enclosedGeneratedTypes = genType.enclosedTypes
+    }
+    
+    def generate() {
+        val body = generateBody
+        val pkgAndImports = generatePkgAndImports
+        return pkgAndImports.toString + body.toString
+    }
+    
+    def private generateBody() '''
+        «genType.comment.generateComment»
+        «generateIfcDeclaration» {
+        
+            «generateInnerClasses»
+        
+            «generateEnums»
+        
+            «generateConstants»
+        
+            «generateMethods»
+        
+        }
+        
+    '''
+    
+    def private generateComment(String comment) '''
+        «IF comment != null && !comment.empty»
+            /*
+            «comment»
+            */
+        «ENDIF»
+    '''
+    
+    def private generateIfcDeclaration() '''
+        public interface «genType.name»«
+        IF (!genType.implements.empty)»«
+            " extends "»«
+            FOR type : genType.implements SEPARATOR ", "»«
+                type.resolveName»«
+            ENDFOR»«
+        ENDIF
+    »'''
+    
+    def private generateInnerClasses() '''
+        «IF !enclosedGeneratedTypes.empty»
+            «FOR innerClass : enclosedGeneratedTypes SEPARATOR "\n"»
+                «IF (innerClass instanceof GeneratedTransferObject)»
+                    «val classTemplate = new ClassTemplate(innerClass as GeneratedTransferObject)»
+                    «classTemplate.generateAsInnerClass»
+                «ENDIF»
+            «ENDFOR»
+        «ENDIF»
+    '''
+    
+    def private generateEnums() '''
+        «IF !enums.empty»
+            «FOR e : enums SEPARATOR "\n"»
+                «val enumTemplate = new EnumTemplate(e)»
+                «enumTemplate.generateAsInnerClass»
+            «ENDFOR»
+        «ENDIF»
+    '''
+    
+    def private generateConstants() '''
+        «IF !consts.empty»
+            «FOR c : consts»
+                «IF c.name != TypeConstants.PATTERN_CONSTANT_NAME»
+                    public static final «c.type.resolveName» «c.name» = «c.value»;
+                «ENDIF»
+            «ENDFOR»
+        «ENDIF»
+    '''
+    
+    def private generateMethods() '''
+        «IF !methods.empty»
+            «FOR m : methods SEPARATOR "\n"»
+                «m.comment.generateComment»
+                «m.returnType.resolveName» «m.name»(«m.parameters.generateParameters»);
+            «ENDFOR»
+        «ENDIF»
+    '''
+    
+    def private generateParameters(List<MethodSignature.Parameter> parameters) '''«
+        IF !parameters.empty»«
+            FOR parameter : parameters SEPARATOR ", "»«
+                parameter.type.resolveName» «parameter.name»«
+            ENDFOR»«
+        ENDIF
+    »'''
+    
+    def private generatePkgAndImports() '''
+        package «genType.packageName»;
+        
+        
+        «IF !imports.empty»
+            «FOR entry : resolveImports.entrySet»
+                import «entry.value».«entry.key»;
+            «ENDFOR»
+        «ENDIF»
+        
+    '''
+    
+    def private Map<String, String> resolveImports() {
+        val innerTypeImports = GeneratorUtil.createChildImports(genType)
+        val Map<String, String> resolvedImports = new LinkedHashMap
+        for (Map.Entry<String, String> entry : imports.entrySet() + innerTypeImports.entrySet) {
+            val typeName = entry.getKey();
+            val packageName = entry.getValue();
+            if (packageName != genType.packageName && packageName != genType.fullyQualifiedName) {
+                resolvedImports.put(typeName, packageName);
+            }
+        }
+        return resolvedImports
+    }
+    
+    def private resolveName(Type type) {
+        GeneratorUtil.putTypeIntoImports(genType, type, imports);
+        GeneratorUtil.getExplicitType(genType, type, imports)
+    }
+    
+}   
\ No newline at end of file