JavaIdentifierNormalizer ThreadSafe/Memory leak fix

[mdsal.git] / binding2 / mdsal-binding2-generator-impl / src / main / java / org / opendaylight / mdsal / binding / javav2 / generator / impl / RpcActionGenHelper.java

diff --git a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelper.java b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelper.java
index c9b98f7f1a91768106306c7db7abb39897331a01..d04c5dccd1f41679ea7ce5311a97bcfdb0a37e5d 100644 (file)
--- a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelper.java
+++ b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelper.java
@@ -15,6 +15,7 @@ import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenU
 import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.addImplementedInterfaceFromUses;
 import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.addRawInterfaceDefinition;
 import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.moduleTypeBuilder;
+import static org.opendaylight.mdsal.binding.javav2.generator.impl.GenHelperUtil.processUsesImplements;
 import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.encodeAngleBrackets;
 import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes.ACTION;
 import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes.INPUT;
@@ -36,6 +37,7 @@ import com.google.common.base.Optional;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Set;
+import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
 import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
 import org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes;
 import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedTransferObject;
@@ -99,8 +101,8 @@ final class RpcActionGenHelper {
      * @return generated context
      */
     static Map<Module, ModuleContext> actionMethodsToGenType(final Module module, Map<Module, ModuleContext> genCtx,
-            final SchemaContext schemaContext, final boolean verboseClassComments, Map<String, Map<String,
-            GeneratedTypeBuilder>> genTypeBuilders, TypeProvider typeProvider) {
+            final SchemaContext schemaContext, final boolean verboseClassComments,
+            Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, TypeProvider typeProvider) {
 
         checkModuleAndModuleName(module);
         final Collection<DataSchemaNode> potentials = module.getChildNodes();
@@ -109,7 +111,8 @@ final class RpcActionGenHelper {
                 final Set<ActionDefinition> actions = ((ActionNodeContainer) potential).getActions();
                 for (ActionDefinition action: actions) {
                     genCtx.get(module).addTopLevelNodeType(resolveOperation(potential, action, module,
-                            schemaContext, verboseClassComments, genTypeBuilders, genCtx, typeProvider, true));
+                            schemaContext, verboseClassComments, genTypeBuilders, genCtx, typeProvider, true,
+                            BindingNamespaceType.Data));
                 }
             }
         }
@@ -167,17 +170,20 @@ final class RpcActionGenHelper {
             //routedRPC?
             if (isAction) {
                 genCtx.get(module).addTopLevelNodeType(resolveOperation(parent, rpc, module, schemaContext,
-                        verboseClassComments, genTypeBuilders, genCtx, typeProvider, true));
+                        verboseClassComments, genTypeBuilders, genCtx, typeProvider, true,
+                        BindingNamespaceType.Data));
             } else {
                 //global RPC only
                 genCtx.get(module).addTopLevelNodeType(resolveOperation(parent, rpc, module, schemaContext,
-                        verboseClassComments, genTypeBuilders, genCtx, typeProvider, false));
+                        verboseClassComments, genTypeBuilders, genCtx, typeProvider, false,
+                        BindingNamespaceType.Data));
 
             }
         }
         return genCtx;
     }
 
+    //TODO: This method should be reusable for convertion of action that is in grouping.
     /**
      * Converts RPC, Action or routed RPC into generated type
      * @return generated type
@@ -185,7 +191,7 @@ final class RpcActionGenHelper {
     private static GeneratedTypeBuilder resolveOperation(final DataSchemaNode parent, final OperationDefinition operation,
             final Module module, final SchemaContext schemaContext, final boolean verboseClassComments,
             Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final Map<Module, ModuleContext> genCtx,
-            TypeProvider typeProvider, final boolean isAction) {
+            TypeProvider typeProvider, final boolean isAction, final BindingNamespaceType namespaceType) {
 
         //operation name
         final String operationName = operation.getQName().getLocalName();
@@ -197,19 +203,20 @@ final class RpcActionGenHelper {
             sb.append("Rpc");
         }
         final GeneratedTypeBuilder interfaceBuilder = moduleTypeBuilder(module, sb.toString(),
-                verboseClassComments);
+                verboseClassComments, genCtx.get(module));
 
         final String basePackageName = interfaceBuilder.getPackageName();
 
         interfaceBuilder.setDescription(createDescription(operation, interfaceBuilder.getFullyQualifiedName(),
-                schemaContext, verboseClassComments));
+                schemaContext, verboseClassComments, namespaceType));
         final String operationComment = encodeAngleBrackets(operation.getDescription());
         final MethodSignatureBuilder operationMethod = interfaceBuilder.addMethod("invoke");
 
         //input
         final ContainerSchemaNode input = operation.getInput();
         final GeneratedTypeBuilder inType = resolveOperationNode(interfaceBuilder, module, operation.getInput(),
-                basePackageName, schemaContext, operationName, verboseClassComments, typeProvider, genTypeBuilders, genCtx, true);
+                basePackageName, schemaContext, operationName, verboseClassComments, typeProvider, genTypeBuilders,
+                genCtx, true, namespaceType);
         annotateDeprecatedIfNecessary(operation.getStatus(), inType);
         inType.setParentTypeForBuilder(interfaceBuilder);
         genCtx.get(module).addChildNodeType(input, inType);
@@ -217,7 +224,8 @@ final class RpcActionGenHelper {
         //output
         final ContainerSchemaNode output = operation.getOutput();
         final GeneratedTypeBuilder outType = resolveOperationNode(interfaceBuilder, module, operation.getOutput(),
-                basePackageName, schemaContext, operationName, verboseClassComments, typeProvider, genTypeBuilders, genCtx, false);
+                basePackageName, schemaContext, operationName, verboseClassComments, typeProvider, genTypeBuilders,
+                genCtx, false, namespaceType);
         annotateDeprecatedIfNecessary(operation.getStatus(), outType);
         outType.setParentTypeForBuilder(interfaceBuilder);
         genCtx.get(module).addChildNodeType(output, outType);
@@ -249,7 +257,7 @@ final class RpcActionGenHelper {
                 //Action
                 GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, parentType, parentType,
                         ((ContainerSchemaNode) parent).getChildNodes(), genCtx, schemaContext, verboseClassComments,
-                        genTypeBuilders, typeProvider, BindingNamespaceType.Data);
+                        genTypeBuilders, typeProvider, namespaceType);
                 operationMethod.addParameter(parameterizedTypeFor(INSTANCE_IDENTIFIER, parentType), "ii");
                 interfaceBuilder.addImplementsType(parameterizedTypeFor(ACTION, parentType, inType, outType));
             }
@@ -270,10 +278,10 @@ final class RpcActionGenHelper {
     private static GeneratedTypeBuilder resolveOperationNode(GeneratedTypeBuilder parent, final Module module, final
             ContainerSchemaNode operationNode, final String basePackageName, final SchemaContext schemaContext, final String
             operationName, final boolean verboseClassComments, TypeProvider typeProvider, Map<String, Map<String,
-            GeneratedTypeBuilder>> genTypeBuilders, final Map<Module, ModuleContext> genCtx, final boolean isInput) {
-
+            GeneratedTypeBuilder>> genTypeBuilders, final Map<Module, ModuleContext> genCtx, final boolean isInput,
+            final BindingNamespaceType namespaceType) {
         final GeneratedTypeBuilder nodeType = addRawInterfaceDefinition(basePackageName, operationNode, schemaContext,
-                operationName, "", verboseClassComments, genTypeBuilders);
+                operationName, "", verboseClassComments, genTypeBuilders, namespaceType, genCtx.get(module));
         addImplementedInterfaceFromUses(operationNode, nodeType, genCtx);
         nodeType.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor
                 (BindingTypes.ITEM, parent)));
@@ -285,12 +293,14 @@ final class RpcActionGenHelper {
         nodeType.addImplementsType(parameterizedTypeFor(INSTANTIABLE, nodeType));
         nodeType.addImplementsType(augmentable(nodeType));
         GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, nodeType, nodeType, operationNode.getChildNodes(), genCtx,
-                schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
+                schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
 
         final MethodSignatureBuilder nodeMethod = nodeType.addMethod("implementedInterface");
         nodeMethod.setReturnType(parameterizedTypeFor(CLASS, nodeType));
         nodeMethod.addAnnotation("", "Override");
 
+        processUsesImplements(operationNode, module, schemaContext, genCtx, namespaceType);
+
         return nodeType;
     }
 }