X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fsal%2Fyang-prototype%2Fcode-generator%2Fbinding-generator-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fbinding%2Fgenerator%2Fimpl%2FBindingGeneratorImpl.java;h=b89dbb44ac786756b60d866c02459097bbe615b4;hp=a903ef15811daeb7197c4ef7a80ca612c30520e4;hb=8f13b5e59fc066808cc73879f8defcb9cf3dc82a;hpb=fb99d767417ba5a92c24412aa15ddb56f1f292a3 diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/generator/impl/BindingGeneratorImpl.java b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/generator/impl/BindingGeneratorImpl.java index a903ef1581..b89dbb44ac 100644 --- a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/generator/impl/BindingGeneratorImpl.java +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/generator/impl/BindingGeneratorImpl.java @@ -9,28 +9,31 @@ package org.opendaylight.controller.sal.binding.generator.impl; import org.opendaylight.controller.binding.generator.util.ReferencedTypeImpl; import org.opendaylight.controller.binding.generator.util.Types; +import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl; import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTypeBuilderImpl; import org.opendaylight.controller.sal.binding.generator.api.BindingGenerator; import org.opendaylight.controller.sal.binding.generator.spi.TypeProvider; -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.Type; +import org.opendaylight.controller.sal.binding.model.api.*; import org.opendaylight.controller.sal.binding.model.api.type.builder.*; import org.opendaylight.controller.sal.binding.yang.types.TypeProviderImpl; +import org.opendaylight.controller.yang.binding.Notification; import org.opendaylight.controller.yang.common.QName; +import org.opendaylight.controller.yang.common.RpcResult; import org.opendaylight.controller.yang.model.api.*; import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition; import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition.EnumPair; import org.opendaylight.controller.yang.model.util.DataNodeIterator; import org.opendaylight.controller.yang.model.util.ExtendedType; +import org.opendaylight.controller.yang.model.util.SchemaContextUtil; import java.util.*; +import java.util.concurrent.Future; import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.*; import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findDataSchemaNode; import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findParentModule; -public class BindingGeneratorImpl implements BindingGenerator { +public final class BindingGeneratorImpl implements BindingGenerator { private Map> genTypeBuilders; private TypeProvider typeProvider; @@ -43,94 +46,206 @@ public class BindingGeneratorImpl implements BindingGenerator { @Override public List generateTypes(final SchemaContext context) { if (context == null) { - throw new IllegalArgumentException("Schema Context reference cannot be NULL"); + throw new IllegalArgumentException("Schema Context reference " + + "cannot be NULL!"); } if (context.getModules() == null) { - throw new IllegalStateException("Schema Context does not contain defined modules!"); + throw new IllegalStateException("Schema Context does not contain " + + "defined modules!"); } - final List genTypes = new ArrayList<>(); + final List generatedTypes = new ArrayList<>(); schemaContext = context; typeProvider = new TypeProviderImpl(context); final Set modules = context.getModules(); genTypeBuilders = new HashMap<>(); for (final Module module : modules) { - final DataNodeIterator moduleIterator = new DataNodeIterator( - module); - - final List sortedAugmentations = provideSortedAugmentations(module); - final List schemaContainers = moduleIterator - .allContainers(); - final List schemaLists = moduleIterator - .allLists(); - - final String basePackageName = moduleNamespaceToPackageName(module); - if ((schemaContainers != null) - && !schemaContainers.isEmpty()) { - for (final ContainerSchemaNode container : schemaContainers) { - genTypes.add(containerToGenType(basePackageName, - container)); - } - } - if ((schemaLists != null) && !schemaLists.isEmpty()) { - for (final ListSchemaNode list : schemaLists) { - genTypes.addAll(listToGenType(basePackageName, list)); - } + generatedTypes.add(moduleToDataType(module)); + generatedTypes.addAll(allTypeDefinitionsToGenTypes(module)); + generatedTypes.addAll(allContainersToGenTypes(module)); + generatedTypes.addAll(allListsToGenTypes(module)); + generatedTypes.addAll(allAugmentsToGenTypes(module)); + generatedTypes.addAll(allRPCMethodsToGenType(module)); + generatedTypes.addAll(allNotificationsToGenType(module)); + generatedTypes.addAll(allIdentitiesToGenTypes(module, context)); + generatedTypes.addAll(allGroupingsToGenTypes(module)); + } + return generatedTypes; + } + + @Override + public List generateTypes(final SchemaContext context, + final Set modules) { + if (context == null) { + throw new IllegalArgumentException("Schema Context reference " + + "cannot be NULL!"); + } + if (context.getModules() == null) { + throw new IllegalStateException("Schema Context does not contain " + + "defined modules!"); + } + if (modules == null) { + throw new IllegalArgumentException("Sef of Modules cannot be " + + "NULL!"); + } + + final List filteredGenTypes = new ArrayList<>(); + schemaContext = context; + typeProvider = new TypeProviderImpl(context); + final Set contextModules = context.getModules(); + genTypeBuilders = new HashMap<>(); + for (final Module contextModule : contextModules) { + final List generatedTypes = new ArrayList<>(); + + generatedTypes.add(moduleToDataType(contextModule)); + generatedTypes.addAll(allTypeDefinitionsToGenTypes(contextModule)); + generatedTypes.addAll(allContainersToGenTypes(contextModule)); + generatedTypes.addAll(allListsToGenTypes(contextModule)); + generatedTypes.addAll(allAugmentsToGenTypes(contextModule)); + generatedTypes.addAll(allRPCMethodsToGenType(contextModule)); + generatedTypes.addAll(allNotificationsToGenType(contextModule)); + generatedTypes.addAll(allIdentitiesToGenTypes(contextModule, + context)); + generatedTypes.addAll(allGroupingsToGenTypes(contextModule)); + + if (modules.contains(contextModule)) { + filteredGenTypes.addAll(generatedTypes); } + } + return filteredGenTypes; + } - if ((sortedAugmentations != null) - && !sortedAugmentations.isEmpty()) { - for (final AugmentationSchema augment : sortedAugmentations) { - genTypes.addAll(augmentationToGenTypes(basePackageName, augment)); + private List allTypeDefinitionsToGenTypes(final Module module) { + if (module == null) { + throw new IllegalArgumentException( + "Module reference cannot be NULL!"); + } + if (module.getName() == null) { + throw new IllegalArgumentException("Module name cannot be NULL!"); + } + if (module.getTypeDefinitions() == null) { + throw new IllegalArgumentException("Type Definitions for module " + + module.getName() + " cannot be NULL!"); + } + + final Set> typeDefinitions = module + .getTypeDefinitions(); + final List generatedTypes = new ArrayList<>(); + for (final TypeDefinition typedef : typeDefinitions) { + if (typedef != null) { + final Type type = ((TypeProviderImpl) typeProvider) + .generatedTypeForExtendedDefinitionType(typedef); + if ((type != null) && !generatedTypes.contains(type)) { + generatedTypes.add(type); } } + } + return generatedTypes; + } + + private List allContainersToGenTypes(final Module module) { + if (module == null) { + throw new IllegalArgumentException( + "Module reference cannot be NULL!"); + } - final GeneratedType genDataType = moduleToDataType(basePackageName, module); - final List genRpcType = rpcMethodsToGenType(basePackageName, module); - final List genNotifyType = notifycationsToGenType(basePackageName, module); + if (module.getName() == null) { + throw new IllegalArgumentException("Module name cannot be NULL!"); + } - if (genDataType != null) { - genTypes.add(genDataType); - } - if (genRpcType != null) { - genTypes.addAll(genRpcType); - } - if (genNotifyType != null) { - genTypes.addAll(genNotifyType); + if (module.getChildNodes() == null) { + throw new IllegalArgumentException("Reference to Set of Child " + + "Nodes in module " + module.getName() + " cannot be " + + "NULL!"); + } + + final List generatedTypes = new ArrayList<>(); + final DataNodeIterator it = new DataNodeIterator(module); + final List schemaContainers = it.allContainers(); + final String basePackageName = moduleNamespaceToPackageName(module); + for (final ContainerSchemaNode container : schemaContainers) { + generatedTypes.add(containerToGenType(basePackageName, container)); + } + return generatedTypes; + } + + private List allListsToGenTypes(final Module module) { + if (module == null) { + throw new IllegalArgumentException( + "Module reference cannot be NULL!"); + } + + if (module.getName() == null) { + throw new IllegalArgumentException("Module name cannot be NULL!"); + } + + if (module.getChildNodes() == null) { + throw new IllegalArgumentException("Reference to Set of Child " + + "Nodes in module " + module.getName() + " cannot be " + + "NULL!"); + } + + final List generatedTypes = new ArrayList<>(); + final DataNodeIterator it = new DataNodeIterator(module); + final List schemaLists = it.allLists(); + final String basePackageName = moduleNamespaceToPackageName(module); + if (schemaLists != null) { + for (final ListSchemaNode list : schemaLists) { + generatedTypes.addAll(listToGenType(basePackageName, list)); } } - genTypes.addAll(((TypeProviderImpl) typeProvider) - .getGeneratedTypeDefs()); + return generatedTypes; + } + + private List allAugmentsToGenTypes(final Module module) { + if (module == null) { + throw new IllegalArgumentException( + "Module reference cannot be NULL!"); + } - return genTypes; + if (module.getName() == null) { + throw new IllegalArgumentException("Module name cannot be NULL!"); + } + + if (module.getChildNodes() == null) { + throw new IllegalArgumentException("Reference to Set of " + + "Augmentation Definitions in module " + module.getName() + + " cannot be NULL!"); + } + + final List generatedTypes = new ArrayList<>(); + final String basePackageName = moduleNamespaceToPackageName(module); + final List augmentations = resolveAugmentations(module); + for (final AugmentationSchema augment : augmentations) { + generatedTypes.addAll(augmentationToGenTypes(basePackageName, + augment)); + } + return generatedTypes; } - private List provideSortedAugmentations(final Module module) { + private List resolveAugmentations(final Module module) { if (module == null) { - throw new IllegalArgumentException("Module reference cannot be NULL!"); + throw new IllegalArgumentException( + "Module reference cannot be NULL!"); } if (module.getAugmentations() == null) { throw new IllegalStateException("Augmentations Set cannot be NULL!"); } - final Set augmentations = module - .getAugmentations(); + final Set augmentations = module.getAugmentations(); final List sortedAugmentations = new ArrayList<>( augmentations); Collections.sort(sortedAugmentations, new Comparator() { @Override - public int compare( - AugmentationSchema augSchema1, + public int compare(AugmentationSchema augSchema1, AugmentationSchema augSchema2) { - if (augSchema1.getTargetPath().getPath() - .size() > augSchema2 + if (augSchema1.getTargetPath().getPath().size() > augSchema2 .getTargetPath().getPath().size()) { return 1; - } else if (augSchema1.getTargetPath() - .getPath().size() < augSchema2 + } else if (augSchema1.getTargetPath().getPath().size() < augSchema2 .getTargetPath().getPath().size()) { return -1; } @@ -142,32 +257,229 @@ public class BindingGeneratorImpl implements BindingGenerator { return sortedAugmentations; } - private GeneratedType moduleToDataType(final String basePackageName, final Module module) { + private GeneratedType moduleToDataType(final Module module) { if (module == null) { - throw new IllegalArgumentException("Module reference cannot be NULL!"); + throw new IllegalArgumentException( + "Module reference cannot be NULL!"); } final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder( module, "Data"); + final String basePackageName = moduleNamespaceToPackageName(module); if (moduleDataTypeBuilder != null) { final Set dataNodes = module.getChildNodes(); - resolveDataSchemaNodes(basePackageName, moduleDataTypeBuilder, dataNodes); + resolveDataSchemaNodes(basePackageName, moduleDataTypeBuilder, + dataNodes); } return moduleDataTypeBuilder.toInstance(); } - private boolean isDerivedFromEnumerationType( - final TypeDefinition typeDefinition) { - if (typeDefinition != null) { - if (typeDefinition.getBaseType() instanceof EnumTypeDefinition) { - return true; - } else if (typeDefinition.getBaseType() instanceof ExtendedType) { - return isDerivedFromEnumerationType(typeDefinition - .getBaseType()); + private List allRPCMethodsToGenType(final Module module) { + if (module == null) { + throw new IllegalArgumentException( + "Module reference cannot be NULL!"); + } + + if (module.getName() == null) { + throw new IllegalArgumentException("Module name cannot be NULL!"); + } + + if (module.getChildNodes() == null) { + throw new IllegalArgumentException("Reference to Set of " + + "RPC Method Definitions in module " + module.getName() + + " cannot be NULL!"); + } + + final String basePackageName = moduleNamespaceToPackageName(module); + final Set rpcDefinitions = module.getRpcs(); + final List genRPCTypes = new ArrayList<>(); + final GeneratedTypeBuilder interfaceBuilder = moduleTypeBuilder(module, + "Service"); + final Type future = Types.typeForClass(Future.class); + for (final RpcDefinition rpc : rpcDefinitions) { + if (rpc != null) { + + String rpcName = parseToClassName(rpc.getQName() + .getLocalName()); + MethodSignatureBuilder method = interfaceBuilder + .addMethod(rpcName); + + final List rpcInOut = new ArrayList<>(); + + ContainerSchemaNode input = rpc.getInput(); + ContainerSchemaNode output = rpc.getOutput(); + + if (input != null) { + rpcInOut.add(new DataNodeIterator(input)); + GeneratedTypeBuilder inType = addRawInterfaceDefinition( + basePackageName, input, rpcName); + resolveDataSchemaNodes(basePackageName, inType, input.getChildNodes()); + Type inTypeInstance = inType.toInstance(); + genRPCTypes.add(inTypeInstance); + method.addParameter(inTypeInstance, "input"); + } + + Type outTypeInstance = Types.typeForClass(Void.class); + if (output != null) { + rpcInOut.add(new DataNodeIterator(output)); + + GeneratedTypeBuilder outType = addRawInterfaceDefinition( + basePackageName, output, rpcName); + resolveDataSchemaNodes(basePackageName, outType, output.getChildNodes()); + outTypeInstance = outType.toInstance(); + genRPCTypes.add(outTypeInstance); + + } + + final Type rpcRes = Types.parameterizedTypeFor( + Types.typeForClass(RpcResult.class), outTypeInstance); + method.addReturnType(Types.parameterizedTypeFor(future, rpcRes)); + for (DataNodeIterator it : rpcInOut) { + List nContainers = it.allContainers(); + if ((nContainers != null) && !nContainers.isEmpty()) { + for (final ContainerSchemaNode container : nContainers) { + genRPCTypes.add(containerToGenType(basePackageName, + container)); + } + } + List nLists = it.allLists(); + if ((nLists != null) && !nLists.isEmpty()) { + for (final ListSchemaNode list : nLists) { + genRPCTypes.addAll(listToGenType(basePackageName, + list)); + } + } + } } } - return false; + genRPCTypes.add(interfaceBuilder.toInstance()); + return genRPCTypes; + } + + private List allNotificationsToGenType(final Module module) { + if (module == null) { + throw new IllegalArgumentException( + "Module reference cannot be NULL!"); + } + + if (module.getName() == null) { + throw new IllegalArgumentException("Module name cannot be NULL!"); + } + + if (module.getChildNodes() == null) { + throw new IllegalArgumentException("Reference to Set of " + + "Notification Definitions in module " + module.getName() + + " cannot be NULL!"); + } + + final String basePackageName = moduleNamespaceToPackageName(module); + final List genNotifyTypes = new ArrayList<>(); + final Set notifications = module + .getNotifications(); + + for (final NotificationDefinition notification : notifications) { + if (notification != null) { + DataNodeIterator it = new DataNodeIterator(notification); + + // Containers + for (ContainerSchemaNode node : it.allContainers()) { + genNotifyTypes + .add(containerToGenType(basePackageName, node)); + } + // Lists + for (ListSchemaNode node : it.allLists()) { + genNotifyTypes.addAll(listToGenType(basePackageName, node)); + } + final GeneratedTypeBuilder notificationTypeBuilder = addRawInterfaceDefinition( + basePackageName, notification); + notificationTypeBuilder.addImplementsType(Types + .typeForClass(Notification.class)); + // Notification object + resolveDataSchemaNodes(basePackageName, + notificationTypeBuilder, notification.getChildNodes()); + genNotifyTypes.add(notificationTypeBuilder.toInstance()); + } + } + return genNotifyTypes; + } + + private List allIdentitiesToGenTypes(final Module module, + final SchemaContext context) { + List genTypes = new ArrayList(); + + final Set schemaIdentities = module.getIdentities(); + + final String basePackageName = moduleNamespaceToPackageName(module); + + if (schemaIdentities != null && !schemaIdentities.isEmpty()) { + for (final IdentitySchemaNode identity : schemaIdentities) { + genTypes.add(identityToGenType(basePackageName, identity, + context)); + } + } + return genTypes; + } + + private GeneratedType identityToGenType(final String basePackageName, + IdentitySchemaNode identity, SchemaContext context) { + if (identity == null) { + return null; + } + + final String packageName = packageNameForGeneratedType(basePackageName, + identity.getPath()); + + final String genTypeName = parseToClassName(identity.getQName() + .getLocalName()); + final GeneratedTOBuilderImpl newType = new GeneratedTOBuilderImpl( + packageName, genTypeName); + + IdentitySchemaNode baseIdentity = identity.getBaseIdentity(); + if (baseIdentity != null) { + Module baseIdentityParentModule = SchemaContextUtil.findParentModule( + context, baseIdentity); + + final String returnTypePkgName = moduleNamespaceToPackageName(baseIdentityParentModule); + final String returnTypeName = parseToClassName(baseIdentity + .getQName().getLocalName()); + + GeneratedTransferObject gto = new GeneratedTOBuilderImpl( + returnTypePkgName, returnTypeName).toInstance(); + newType.addExtendsType(gto); + } else { + newType.addExtendsType(Types.getBaseIdentityTO()); + } + + return newType.toIdentityInstance(); + } + + private List allGroupingsToGenTypes(Module module) { + final List genTypes = new ArrayList(); + final String basePackageName = moduleNamespaceToPackageName(module); + Set groupings = module.getGroupings(); + if (groupings != null && !groupings.isEmpty()) { + for (final GroupingDefinition grouping : groupings) { + genTypes.add(groupingToGenType(basePackageName, grouping)); + } + } + return genTypes; + } + + private GeneratedType groupingToGenType(final String basePackageName, + GroupingDefinition grouping) { + if (grouping == null) { + return null; + } + + final String packageName = packageNameForGeneratedType(basePackageName, + grouping.getPath()); + final Set schemaNodes = grouping.getChildNodes(); + final GeneratedTypeBuilder typeBuilder = addRawInterfaceDefinition( + packageName, grouping); + + resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes); + return typeBuilder.toInstance(); } private EnumTypeDefinition enumTypeDefFromExtendedType( @@ -182,7 +494,7 @@ public class BindingGeneratorImpl implements BindingGenerator { return null; } - private EnumBuilder resolveEnumFromTypeDefinition( + private EnumBuilder resolveInnerEnumFromTypeDefinition( final EnumTypeDefinition enumTypeDef, final String enumName, final GeneratedTypeBuilder typeBuilder) { if ((enumTypeDef != null) && (typeBuilder != null) @@ -218,89 +530,20 @@ public class BindingGeneratorImpl implements BindingGenerator { } private GeneratedTypeBuilder moduleTypeBuilder(final Module module, - final String postfix) { + final String postfix) { if (module == null) { - throw new IllegalArgumentException("Module reference cannot be NULL!"); + throw new IllegalArgumentException( + "Module reference cannot be NULL!"); } String packageName = moduleNamespaceToPackageName(module); - final String moduleName = parseToClassName(module.getName()) - + postfix; + final String moduleName = parseToClassName(module.getName()) + postfix; return new GeneratedTypeBuilderImpl(packageName, moduleName); } - private List rpcMethodsToGenType(final String basePackageName, final Module module) { - if (module == null) { - throw new IllegalArgumentException("Module reference cannot be NULL!"); - } - - final Set rpcDefinitions = module.getRpcs(); - final List rpcTypes = new ArrayList<>(); - - if ((rpcDefinitions != null) && !rpcDefinitions.isEmpty()) { - for (final RpcDefinition rpc : rpcDefinitions) { - if (rpc != null) { - final List rpcInOut = new ArrayList<>(); - rpcInOut.add(new DataNodeIterator(rpc.getInput())); - rpcInOut.add(new DataNodeIterator(rpc.getOutput())); - - for (DataNodeIterator it : rpcInOut) { - List nContainers = it.allContainers(); - if ((nContainers != null) && !nContainers.isEmpty()) { - for (final ContainerSchemaNode container : nContainers) { - rpcTypes.add(containerToGenType(basePackageName, container)); - } - } - } - } - } - } - return rpcTypes; - } - - private List notifycationsToGenType(final String basePackageName, final Module module) { - if (module == null) { - throw new IllegalArgumentException("Module reference cannot be NULL!"); - } - final List notificationTypes = new ArrayList<>(); - final Set notifications = module - .getNotifications(); - - if ((notifications != null) && !notifications.isEmpty()) { - for (final NotificationDefinition notification : notifications) { - if (notification != null) { - final List notifyChildren = new ArrayList<>(); - - for (DataSchemaNode childNode : notification.getChildNodes()) { - if (childNode instanceof DataNodeContainer) { - notifyChildren.add(new DataNodeIterator((DataNodeContainer) childNode)); - } - } - - for (DataNodeIterator it : notifyChildren) { - List nContainers = it.allContainers(); - List nLists = it.allLists(); - if ((nContainers != null) && !nContainers.isEmpty()) { - for (final ContainerSchemaNode container : nContainers) { - notificationTypes.add(containerToGenType(basePackageName, container)); - } - } - if ((nLists != null) && !nLists.isEmpty()) { - for (final ListSchemaNode list : nLists) { - - notificationTypes.addAll(listToGenType(basePackageName, list)); - } - } - } - } - } - } - return notificationTypes; - } - private List augmentationToGenTypes(final String augmentPackageName, - final AugmentationSchema augSchema) { + final AugmentationSchema augSchema) { if (augmentPackageName == null) { throw new IllegalArgumentException("Package Name cannot be NULL!"); } @@ -318,23 +561,23 @@ public class BindingGeneratorImpl implements BindingGenerator { // EVERY augmented interface will extends Augmentation interface // and DataObject interface!!! final SchemaPath targetPath = augSchema.getTargetPath(); - final DataSchemaNode targetSchemaNode = findDataSchemaNode(schemaContext, - targetPath); - if ((targetSchemaNode != null) && - (targetSchemaNode.getQName() != null) && - (targetSchemaNode.getQName().getLocalName() != null)) { + final DataSchemaNode targetSchemaNode = findDataSchemaNode( + schemaContext, targetPath); + if ((targetSchemaNode != null) && (targetSchemaNode.getQName() != null) + && (targetSchemaNode.getQName().getLocalName() != null)) { final Module targetModule = findParentModule(schemaContext, targetSchemaNode); final String targetBasePackage = moduleNamespaceToPackageName(targetModule); - final String targetPackageName = packageNameForGeneratedType(targetBasePackage, - targetSchemaNode.getPath()); + final String targetPackageName = packageNameForGeneratedType( + targetBasePackage, targetSchemaNode.getPath()); - final String targetSchemaNodeName = targetSchemaNode.getQName().getLocalName(); - final Set augChildNodes = augSchema - .getChildNodes(); + final String targetSchemaNodeName = targetSchemaNode.getQName() + .getLocalName(); + final Set augChildNodes = augSchema.getChildNodes(); final GeneratedTypeBuilder augTypeBuilder = addRawAugmentGenTypeDefinition( - augmentPackageName, targetPackageName, targetSchemaNodeName, augSchema); + augmentPackageName, targetPackageName, + targetSchemaNodeName, augSchema); if (augTypeBuilder != null) { genTypes.add(augTypeBuilder.toInstance()); } @@ -357,10 +600,11 @@ public class BindingGeneratorImpl implements BindingGenerator { genTypeBuilders.put(augmentPackageName, augmentBuilders); } - final String augTypeName = augGenTypeName(augmentBuilders, targetTypeName); - final Type targetTypeRef = new ReferencedTypeImpl(targetPackageName, targetTypeName); - final Set augChildNodes = augSchema - .getChildNodes(); + final String augTypeName = augGenTypeName(augmentBuilders, + targetTypeName); + final Type targetTypeRef = new ReferencedTypeImpl(targetPackageName, + targetTypeName); + final Set augChildNodes = augSchema.getChildNodes(); final GeneratedTypeBuilder augTypeBuilder = new GeneratedTypeBuilderImpl( augmentPackageName, augTypeName); @@ -369,13 +613,15 @@ public class BindingGeneratorImpl implements BindingGenerator { augTypeBuilder.addImplementsType(Types .augmentationTypeFor(targetTypeRef)); - augSchemaNodeToMethods(augmentPackageName, augTypeBuilder, augChildNodes); + augSchemaNodeToMethods(augmentPackageName, augTypeBuilder, + augChildNodes); augmentBuilders.put(augTypeName, augTypeBuilder); return augTypeBuilder; } - private List augmentationBodyToGenTypes(final String augBasePackageName, - final Set augChildNodes) { + private List augmentationBodyToGenTypes( + final String augBasePackageName, + final Set augChildNodes) { final List genTypes = new ArrayList<>(); final List augSchemaIts = new ArrayList<>(); for (final DataSchemaNode childNode : augChildNodes) { @@ -399,13 +645,12 @@ public class BindingGeneratorImpl implements BindingGenerator { if ((augContainers != null) && !augContainers.isEmpty()) { for (final ContainerSchemaNode container : augContainers) { - genTypes.add(containerToGenType(augBasePackageName, container)); + genTypes.add(containerToGenType(augBasePackageName, + container)); } } if ((augLists != null) && !augLists.isEmpty()) { for (final ListSchemaNode list : augLists) { -// final String listPackageName = packageNameForAugmentedType( -// augBasePackageName, list.getPath()); genTypes.addAll(listToGenType(augBasePackageName, list)); } } @@ -427,13 +672,13 @@ public class BindingGeneratorImpl implements BindingGenerator { } private GeneratedType containerToGenType(final String basePackageName, - ContainerSchemaNode containerNode) { + ContainerSchemaNode containerNode) { if (containerNode == null) { return null; } - final String packageName = packageNameForGeneratedType( - basePackageName, containerNode.getPath()); + final String packageName = packageNameForGeneratedType(basePackageName, + containerNode.getPath()); final Set schemaNodes = containerNode.getChildNodes(); final GeneratedTypeBuilder typeBuilder = addRawInterfaceDefinition( packageName, containerNode); @@ -452,7 +697,8 @@ public class BindingGeneratorImpl implements BindingGenerator { if (schemaNode.isAugmenting()) { continue; } - addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder); + addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, + typeBuilder); } } return typeBuilder; @@ -466,15 +712,15 @@ public class BindingGeneratorImpl implements BindingGenerator { if ((schemaNodes != null) && (typeBuilder != null)) { for (final DataSchemaNode schemaNode : schemaNodes) { if (schemaNode.isAugmenting()) { - addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder); + addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, + typeBuilder); } } } return typeBuilder; } - private void addSchemaNodeToBuilderAsMethod( - final String basePackageName, + private void addSchemaNodeToBuilderAsMethod(final String basePackageName, final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder) { if (schemaNode != null && typeBuilder != null) { @@ -507,31 +753,27 @@ public class BindingGeneratorImpl implements BindingGenerator { final TypeDefinition typeDef = leaf.getType(); Type returnType = null; - if (!(typeDef instanceof EnumTypeDefinition) - && !isDerivedFromEnumerationType(typeDef)) { + if (!(typeDef instanceof EnumTypeDefinition)) { returnType = typeProvider .javaTypeForSchemaDefinitionType(typeDef); } else { - if (isImported(leaf.getPath(), typeDef.getPath())) { - // TODO: resolving of imported enums as references to - // GeneratedTypeData interface - } else { - final EnumTypeDefinition enumTypeDef = enumTypeDefFromExtendedType(typeDef); - final EnumBuilder enumBuilder = resolveEnumFromTypeDefinition( - enumTypeDef, leafName, typeBuilder); - - if (enumBuilder != null) { - returnType = new ReferencedTypeImpl( - enumBuilder.getPackageName(), - enumBuilder.getName()); - } + final EnumTypeDefinition enumTypeDef = enumTypeDefFromExtendedType(typeDef); + final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition( + enumTypeDef, leafName, typeBuilder); + + if (enumBuilder != null) { + returnType = new ReferencedTypeImpl( + enumBuilder.getPackageName(), + enumBuilder.getName()); } + ((TypeProviderImpl) typeProvider).putReferencedType( + leaf.getPath(), returnType); } - if (returnType != null) { constructGetter(typeBuilder, leafName, leafDesc, returnType); if (!leaf.isConfiguration()) { - constructSetter(typeBuilder, leafName, leafDesc, returnType); + constructSetter(typeBuilder, leafName, leafDesc, + returnType); } return true; } @@ -540,26 +782,6 @@ public class BindingGeneratorImpl implements BindingGenerator { return false; } - private boolean isImported(final SchemaPath leafPath, - final SchemaPath typeDefPath) { - if ((leafPath != null) && (leafPath.getPath() != null) - && (typeDefPath != null) && (typeDefPath.getPath() != null)) { - - final QName leafPathQName = leafPath.getPath().get(0); - final QName typePathQName = typeDefPath.getPath().get(0); - - if ((leafPathQName != null) - && (leafPathQName.getNamespace() != null) - && (typePathQName != null) - && (typePathQName.getNamespace() != null)) { - - return !leafPathQName.getNamespace().equals( - typePathQName.getNamespace()); - } - } - return false; - } - private boolean resolveLeafSchemaNodeAsProperty( final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf, boolean isReadOnly) { @@ -622,8 +844,8 @@ public class BindingGeneratorImpl implements BindingGenerator { } private boolean resolveContainerSchemaNode(final String basePackageName, - final GeneratedTypeBuilder typeBuilder, - final ContainerSchemaNode containerNode) { + final GeneratedTypeBuilder typeBuilder, + final ContainerSchemaNode containerNode) { if ((containerNode != null) && (typeBuilder != null)) { final String nodeName = containerNode.getQName().getLocalName(); @@ -642,8 +864,8 @@ public class BindingGeneratorImpl implements BindingGenerator { } private boolean resolveListSchemaNode(final String basePackageName, - final GeneratedTypeBuilder typeBuilder, - final ListSchemaNode schemaNode) { + final GeneratedTypeBuilder typeBuilder, + final ListSchemaNode schemaNode) { if ((schemaNode != null) && (typeBuilder != null)) { final String listName = schemaNode.getQName().getLocalName(); @@ -665,7 +887,13 @@ public class BindingGeneratorImpl implements BindingGenerator { } private GeneratedTypeBuilder addRawInterfaceDefinition( - final String packageName, final DataSchemaNode schemaNode) { + final String packageName, final SchemaNode schemaNode) { + return addRawInterfaceDefinition(packageName, schemaNode, ""); + } + + private GeneratedTypeBuilder addRawInterfaceDefinition( + final String packageName, final SchemaNode schemaNode, + final String prefix) { if (schemaNode == null) { return null; } @@ -673,7 +901,8 @@ public class BindingGeneratorImpl implements BindingGenerator { final String schemaNodeName = schemaNode.getQName().getLocalName(); if ((packageName != null) && (schemaNodeName != null)) { - final String genTypeName = parseToClassName(schemaNodeName); + final String genTypeName = prefix + parseToClassName(schemaNodeName) + ; final GeneratedTypeBuilder newType = new GeneratedTypeBuilderImpl( packageName, genTypeName); @@ -738,9 +967,8 @@ public class BindingGeneratorImpl implements BindingGenerator { return setMethod; } - private List listToGenType(final String basePackageName, - final ListSchemaNode list) { + final ListSchemaNode list) { if (basePackageName == null) { throw new IllegalArgumentException( "Package Name for Generated Type cannot be NULL!"); @@ -750,8 +978,8 @@ public class BindingGeneratorImpl implements BindingGenerator { "List Schema Node cannot be NULL!"); } - final String packageName = packageNameForGeneratedType( - basePackageName, list.getPath()); + final String packageName = packageNameForGeneratedType(basePackageName, + list.getPath()); final GeneratedTypeBuilder typeBuilder = resolveListTypeBuilder( packageName, list); final List listKeys = listKeys(list); @@ -764,34 +992,16 @@ public class BindingGeneratorImpl implements BindingGenerator { if (schemaNode.isAugmenting()) { continue; } - addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder, - genTOBuilder, listKeys); - } - -// if (list.isAugmenting()) { -// for (final DataSchemaNode schemaNode : schemaNodes) { -// if (schemaNode.isAugmenting()) { -// addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder, -// genTOBuilder, listKeys); -// } -// } -// } else { -// for (final DataSchemaNode schemaNode : schemaNodes) { -// if (schemaNode.isAugmenting()) { -// continue; -// } -// addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder, -// genTOBuilder, listKeys); -// } -// } + addSchemaNodeToListBuilders(basePackageName, schemaNode, + typeBuilder, genTOBuilder, listKeys); + } return typeBuildersToGenTypes(typeBuilder, genTOBuilder); } private void addSchemaNodeToListBuilders(final String basePackageName, - final DataSchemaNode schemaNode, - final GeneratedTypeBuilder typeBuilder, - final GeneratedTOBuilder genTOBuilder, - final List listKeys) { + final DataSchemaNode schemaNode, + final GeneratedTypeBuilder typeBuilder, + final GeneratedTOBuilder genTOBuilder, final List listKeys) { if (schemaNode == null) { throw new IllegalArgumentException( "Data Schema Node cannot be NULL!"); @@ -816,9 +1026,9 @@ public class BindingGeneratorImpl implements BindingGenerator { resolveContainerSchemaNode(basePackageName, typeBuilder, (ContainerSchemaNode) schemaNode); } else if (schemaNode instanceof ListSchemaNode) { - resolveListSchemaNode(basePackageName, typeBuilder, (ListSchemaNode) schemaNode); + resolveListSchemaNode(basePackageName, typeBuilder, + (ListSchemaNode) schemaNode); } - } private List typeBuildersToGenTypes( @@ -845,13 +1055,13 @@ public class BindingGeneratorImpl implements BindingGenerator { * @return */ private GeneratedTOBuilder resolveListKey(final String packageName, - final ListSchemaNode list) { + final ListSchemaNode list) { final String listName = list.getQName().getLocalName() + "Key"; return schemaNodeToTransferObjectBuilder(packageName, list, listName); } private boolean isPartOfListKey(final LeafSchemaNode leaf, - final List keys) { + final List keys) { if ((leaf != null) && (keys != null) && (leaf.getQName() != null)) { final String leafName = leaf.getQName().getLocalName(); if (keys.contains(leafName)) { @@ -889,7 +1099,8 @@ public class BindingGeneratorImpl implements BindingGenerator { final String genTypeName = parseToClassName(schemaNodeName); GeneratedTypeBuilder typeBuilder = null; - final Map builders = genTypeBuilders.get(packageName); + final Map builders = genTypeBuilders + .get(packageName); if (builders != null) { typeBuilder = builders.get(genTypeName); } @@ -906,7 +1117,6 @@ public class BindingGeneratorImpl implements BindingGenerator { if (listKeys.size() > 0) { genTOBuilder = resolveListKey(packageName, list); } - return genTOBuilder; } }