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=3c0d9ed35a4d0b53e4634a30ea669e0c84661a70;hb=8f13b5e59fc066808cc73879f8defcb9cf3dc82a;hpb=7ec533b6d0c7dd15146839b2c6e07647d66f82dc 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 3c0d9ed35a..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 @@ -7,187 +7,479 @@ */ package org.opendaylight.controller.sal.binding.generator.impl; -import java.net.URI; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Calendar; -import java.util.GregorianCalendar; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil; +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.type.builder.EnumBuilder; -import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedPropertyBuilder; -import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTOBuilder; -import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTypeBuilder; -import org.opendaylight.controller.sal.binding.model.api.type.builder.MethodSignatureBuilder; +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.model.api.ContainerSchemaNode; -import org.opendaylight.controller.yang.model.api.DataSchemaNode; -import org.opendaylight.controller.yang.model.api.LeafListSchemaNode; -import org.opendaylight.controller.yang.model.api.LeafSchemaNode; -import org.opendaylight.controller.yang.model.api.ListSchemaNode; -import org.opendaylight.controller.yang.model.api.Module; -import org.opendaylight.controller.yang.model.api.NotificationDefinition; -import org.opendaylight.controller.yang.model.api.RpcDefinition; -import org.opendaylight.controller.yang.model.api.SchemaContext; -import org.opendaylight.controller.yang.model.api.SchemaPath; -import org.opendaylight.controller.yang.model.api.TypeDefinition; +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; -public class BindingGeneratorImpl implements BindingGenerator { +import java.util.*; +import java.util.concurrent.Future; - private static final String[] SET_VALUES = new String[] { "abstract", - "assert", "boolean", "break", "byte", "case", "catch", "char", - "class", "const", "continue", "default", "double", "do", "else", - "enum", "extends", "false", "final", "finally", "float", "for", - "goto", "if", "implements", "import", "instanceof", "int", - "interface", "long", "native", "new", "null", "package", "private", - "protected", "public", "return", "short", "static", "strictfp", - "super", "switch", "synchronized", "this", "throw", "throws", - "transient", "true", "try", "void", "volatile", "while" }; +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 static final Set JAVA_RESERVED_WORDS = new HashSet( - Arrays.asList(SET_VALUES)); +public final class BindingGeneratorImpl implements BindingGenerator { - private static Calendar calendar = new GregorianCalendar(); private Map> genTypeBuilders; private TypeProvider typeProvider; - private String basePackageName; + private SchemaContext schemaContext; public BindingGeneratorImpl() { super(); } - private static String validatePackage(final String packageName) { - if (packageName != null) { - final String[] packNameParts = packageName.split("\\."); - if (packNameParts != null) { - final StringBuilder builder = new StringBuilder(); - for (int i = 0; i < packNameParts.length; ++i) { - if (JAVA_RESERVED_WORDS.contains(packNameParts[i])) { - packNameParts[i] = "_" + packNameParts[i]; - } - if (i > 0) { - builder.append("."); - } - builder.append(packNameParts[i]); + @Override + public List generateTypes(final SchemaContext context) { + 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!"); + } + + final List generatedTypes = new ArrayList<>(); + schemaContext = context; + typeProvider = new TypeProviderImpl(context); + final Set modules = context.getModules(); + genTypeBuilders = new HashMap<>(); + for (final Module module : modules) { + 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; + } + + 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 builder.toString(); } } - return packageName; + return generatedTypes; } - @Override - public List generateTypes(final SchemaContext context) { - final List genTypes = new ArrayList(); + private List allContainersToGenTypes(final Module module) { + if (module == null) { + throw new IllegalArgumentException( + "Module reference cannot be NULL!"); + } - if (context != null) { - typeProvider = new TypeProviderImpl(context); - final Set modules = context.getModules(); - - if (modules != null) { - for (final Module module : modules) { - final DataNodeIterator moduleIterator = new DataNodeIterator( - module); - - genTypeBuilders = new HashMap>(); - final List schemaContainers = moduleIterator - .allContainers(); - final List schemaLists = moduleIterator - .allLists(); - - basePackageName = BindingGeneratorUtil - .moduleNamespaceToPackageName( - module.getNamespace(), - module.getYangVersion()); - - if (schemaContainers.size() > 0) { - for (final ContainerSchemaNode container : schemaContainers) { - genTypes.add(containerToGenType(container)); - } - } - if (schemaLists.size() > 0) { - for (final ListSchemaNode list : schemaLists) { - genTypes.addAll(listToGenType(list)); + 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 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)); + } + } + return generatedTypes; + } + + private List allAugmentsToGenTypes(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 " + + "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 resolveAugmentations(final Module module) { + if (module == 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 List sortedAugmentations = new ArrayList<>( + augmentations); + Collections.sort(sortedAugmentations, + new Comparator() { + + @Override + public int compare(AugmentationSchema augSchema1, + AugmentationSchema augSchema2) { + + if (augSchema1.getTargetPath().getPath().size() > augSchema2 + .getTargetPath().getPath().size()) { + return 1; + } else if (augSchema1.getTargetPath().getPath().size() < augSchema2 + .getTargetPath().getPath().size()) { + return -1; } + return 0; + } + }); - final GeneratedType genDataType = moduleToDataType(module); - final GeneratedType genRpcType = rpcMethodsToGenType(module); - final GeneratedType genNotifyType = notifycationsToGenType(module); + return sortedAugmentations; + } - if (genDataType != null) { - genTypes.add(genDataType); - } - if (genRpcType != null) { - genTypes.add(genRpcType); + private GeneratedType moduleToDataType(final Module module) { + if (module == 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); + } + return moduleDataTypeBuilder.toInstance(); + } + + 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)); + } } - if (genNotifyType != null) { - genTypes.add(genNotifyType); + List nLists = it.allLists(); + if ((nLists != null) && !nLists.isEmpty()) { + for (final ListSchemaNode list : nLists) { + genRPCTypes.addAll(listToGenType(basePackageName, + list)); + } } } - - //FIXME this is quick add of typedefs to generated types from type provider - genTypes.addAll(((TypeProviderImpl)typeProvider).getGeneratedTypeDefs()); } } - return genTypes; + genRPCTypes.add(interfaceBuilder.toInstance()); + return genRPCTypes; } - private GeneratedType moduleToDataType(final Module module) { - if (module != null) { - final Set> typeDefinitions = module - .getTypeDefinitions(); - final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder( - module, "Data"); - - if (moduleDataTypeBuilder != null) { - if (typeDefinitions != null) { - for (final TypeDefinition typedef : typeDefinitions) { - if (isDerivedFromEnumerationType(typedef)) { - final EnumTypeDefinition enumBaseType = enumTypeDefFromExtendedType(typedef); - resolveEnumFromTypeDefinition(enumBaseType, typedef - .getQName().getLocalName(), - moduleDataTypeBuilder); - } - } + 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); - final Set dataNodes = module.getChildNodes(); - resolveTypesFromDataSchemaNode(moduleDataTypeBuilder, dataNodes); - return moduleDataTypeBuilder.toInstance(); + if (schemaIdentities != null && !schemaIdentities.isEmpty()) { + for (final IdentitySchemaNode identity : schemaIdentities) { + genTypes.add(identityToGenType(basePackageName, identity, + context)); } } - return null; + return genTypes; } - 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 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 false; + 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( @@ -202,15 +494,14 @@ 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) && (enumTypeDef.getQName() != null) && (enumTypeDef.getQName().getLocalName() != null)) { - final String enumerationName = BindingGeneratorUtil - .parseToClassName(enumName); + final String enumerationName = parseToClassName(enumName); final EnumBuilder enumBuilder = typeBuilder .addEnumeration(enumerationName); @@ -220,8 +511,8 @@ public class BindingGeneratorImpl implements BindingGenerator { int listIndex = 0; for (final EnumPair enumPair : enums) { if (enumPair != null) { - final String enumPairName = BindingGeneratorUtil - .parseToClassName(enumPair.getName()); + final String enumPairName = parseToClassName(enumPair + .getName()); Integer enumPairValue = enumPair.getValue(); if (enumPairValue == null) { @@ -240,100 +531,215 @@ public class BindingGeneratorImpl implements BindingGenerator { private GeneratedTypeBuilder moduleTypeBuilder(final Module module, final String postfix) { - if (module != null) { - String packageName = resolveBasePackageName(module.getNamespace(), - module.getYangVersion()); - final String moduleName = BindingGeneratorUtil - .parseToClassName(module.getName()) + postfix; - - if (packageName != null) { - packageName = validatePackage(packageName); - return new GeneratedTypeBuilderImpl(packageName, moduleName); + if (module == null) { + throw new IllegalArgumentException( + "Module reference cannot be NULL!"); + } + String packageName = moduleNamespaceToPackageName(module); + final String moduleName = parseToClassName(module.getName()) + postfix; + + return new GeneratedTypeBuilderImpl(packageName, moduleName); + + } + + private List augmentationToGenTypes(final String augmentPackageName, + final AugmentationSchema augSchema) { + if (augmentPackageName == null) { + throw new IllegalArgumentException("Package Name cannot be NULL!"); + } + if (augSchema == null) { + throw new IllegalArgumentException( + "Augmentation Schema cannot be NULL!"); + } + if (augSchema.getTargetPath() == null) { + throw new IllegalStateException( + "Augmentation Schema does not contain Target Path (Target Path is NULL)."); + } + + final List genTypes = new ArrayList<>(); + + // 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 Module targetModule = findParentModule(schemaContext, + targetSchemaNode); + + final String targetBasePackage = moduleNamespaceToPackageName(targetModule); + final String targetPackageName = packageNameForGeneratedType( + targetBasePackage, targetSchemaNode.getPath()); + + final String targetSchemaNodeName = targetSchemaNode.getQName() + .getLocalName(); + final Set augChildNodes = augSchema.getChildNodes(); + final GeneratedTypeBuilder augTypeBuilder = addRawAugmentGenTypeDefinition( + augmentPackageName, targetPackageName, + targetSchemaNodeName, augSchema); + if (augTypeBuilder != null) { + genTypes.add(augTypeBuilder.toInstance()); } + genTypes.addAll(augmentationBodyToGenTypes(augmentPackageName, + augChildNodes)); + } - return null; + return genTypes; } - private GeneratedType rpcMethodsToGenType(final Module module) { - if (module != null) { - final Set rpcDefinitions = module.getRpcs(); - //TODO: add implementation - if ((rpcDefinitions != null) && !rpcDefinitions.isEmpty()) { - final GeneratedTypeBuilder rpcTypeBuilder = moduleTypeBuilder( - module, "Rpc"); + private GeneratedTypeBuilder addRawAugmentGenTypeDefinition( + final String augmentPackageName, final String targetPackageName, + final String targetSchemaNodeName, + final AugmentationSchema augSchema) { + final String targetTypeName = parseToClassName(targetSchemaNodeName); + Map augmentBuilders = genTypeBuilders + .get(augmentPackageName); + if (augmentBuilders == null) { + augmentBuilders = new HashMap<>(); + genTypeBuilders.put(augmentPackageName, augmentBuilders); + } + + final String augTypeName = augGenTypeName(augmentBuilders, + targetTypeName); + final Type targetTypeRef = new ReferencedTypeImpl(targetPackageName, + targetTypeName); + final Set augChildNodes = augSchema.getChildNodes(); - for (final RpcDefinition rpc : rpcDefinitions) { - if (rpc != null) { + final GeneratedTypeBuilder augTypeBuilder = new GeneratedTypeBuilderImpl( + augmentPackageName, augTypeName); - } + augTypeBuilder.addImplementsType(Types.DATA_OBJECT); + augTypeBuilder.addImplementsType(Types + .augmentationTypeFor(targetTypeRef)); + + augSchemaNodeToMethods(augmentPackageName, augTypeBuilder, + augChildNodes); + augmentBuilders.put(augTypeName, augTypeBuilder); + return augTypeBuilder; + } + + private List augmentationBodyToGenTypes( + final String augBasePackageName, + final Set augChildNodes) { + final List genTypes = new ArrayList<>(); + final List augSchemaIts = new ArrayList<>(); + for (final DataSchemaNode childNode : augChildNodes) { + if (childNode instanceof DataNodeContainer) { + augSchemaIts.add(new DataNodeIterator( + (DataNodeContainer) childNode)); + + if (childNode instanceof ContainerSchemaNode) { + genTypes.add(containerToGenType(augBasePackageName, + (ContainerSchemaNode) childNode)); + } else if (childNode instanceof ListSchemaNode) { + genTypes.addAll(listToGenType(augBasePackageName, + (ListSchemaNode) childNode)); } } } - return null; - } - - private GeneratedType notifycationsToGenType(final Module module) { - if (module != null) { - final Set notifications = module - .getNotifications(); - //TODO: add implementation - if ((notifications != null) && !notifications.isEmpty()) { - final GeneratedTypeBuilder notifyTypeBuilder = moduleTypeBuilder( - module, "Notification"); - for (final NotificationDefinition notification : notifications) { - if (notification != null) { + for (final DataNodeIterator it : augSchemaIts) { + final List augContainers = it.allContainers(); + final List augLists = it.allLists(); - } + if ((augContainers != null) && !augContainers.isEmpty()) { + for (final ContainerSchemaNode container : augContainers) { + genTypes.add(containerToGenType(augBasePackageName, + container)); + } + } + if ((augLists != null) && !augLists.isEmpty()) { + for (final ListSchemaNode list : augLists) { + genTypes.addAll(listToGenType(augBasePackageName, list)); } } } - return null; + return genTypes; } - - private List augmentationToGenTypes(final Module module) { - final List augmentGenTypes = new ArrayList(); - - //TODO: add implementation - - return augmentGenTypes; - } - - private GeneratedType containerToGenType(ContainerSchemaNode container) { - if (container == null) { + + private String augGenTypeName( + final Map builders, + final String genTypeName) { + String augTypeName = genTypeName; + + int index = 1; + while ((builders != null) && builders.containsKey(genTypeName + index)) { + index++; + } + augTypeName += index; + return augTypeName; + } + + private GeneratedType containerToGenType(final String basePackageName, + ContainerSchemaNode containerNode) { + if (containerNode == null) { return null; } - final Set schemaNodes = container.getChildNodes(); - final GeneratedTypeBuilder typeBuilder = addRawInterfaceDefinition(container); - resolveTypesFromDataSchemaNode(typeBuilder, schemaNodes); + final String packageName = packageNameForGeneratedType(basePackageName, + containerNode.getPath()); + final Set schemaNodes = containerNode.getChildNodes(); + final GeneratedTypeBuilder typeBuilder = addRawInterfaceDefinition( + packageName, containerNode); + + resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes); return typeBuilder.toInstance(); } - private GeneratedTypeBuilder resolveTypesFromDataSchemaNode( + private GeneratedTypeBuilder resolveDataSchemaNodes( + final String basePackageName, + final GeneratedTypeBuilder typeBuilder, + final Set schemaNodes) { + + if ((schemaNodes != null) && (typeBuilder != null)) { + for (final DataSchemaNode schemaNode : schemaNodes) { + if (schemaNode.isAugmenting()) { + continue; + } + addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, + typeBuilder); + } + } + return typeBuilder; + } + + private GeneratedTypeBuilder augSchemaNodeToMethods( + final String basePackageName, final GeneratedTypeBuilder typeBuilder, final Set schemaNodes) { if ((schemaNodes != null) && (typeBuilder != null)) { - for (final DataSchemaNode node : schemaNodes) { - if (node instanceof LeafSchemaNode) { - resolveLeafSchemaNodeAsMethod(typeBuilder, - (LeafSchemaNode) node); - } else if (node instanceof LeafListSchemaNode) { - resolveLeafListSchemaNode(typeBuilder, - (LeafListSchemaNode) node); - - } else if (node instanceof ContainerSchemaNode) { - resolveContainerSchemaNode(typeBuilder, - (ContainerSchemaNode) node); - } else if (node instanceof ListSchemaNode) { - resolveListSchemaNode(typeBuilder, (ListSchemaNode) node); + for (final DataSchemaNode schemaNode : schemaNodes) { + if (schemaNode.isAugmenting()) { + addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, + typeBuilder); } } } return typeBuilder; } + private void addSchemaNodeToBuilderAsMethod(final String basePackageName, + final DataSchemaNode schemaNode, + final GeneratedTypeBuilder typeBuilder) { + if (schemaNode != null && typeBuilder != null) { + if (schemaNode instanceof LeafSchemaNode) { + resolveLeafSchemaNodeAsMethod(typeBuilder, + (LeafSchemaNode) schemaNode); + } else if (schemaNode instanceof LeafListSchemaNode) { + resolveLeafListSchemaNode(typeBuilder, + (LeafListSchemaNode) schemaNode); + } else if (schemaNode instanceof ContainerSchemaNode) { + resolveContainerSchemaNode(basePackageName, typeBuilder, + (ContainerSchemaNode) schemaNode); + } else if (schemaNode instanceof ListSchemaNode) { + resolveListSchemaNode(basePackageName, typeBuilder, + (ListSchemaNode) schemaNode); + } + } + } + private boolean resolveLeafSchemaNodeAsMethod( final GeneratedTypeBuilder typeBuilder, final LeafSchemaNode leaf) { if ((leaf != null) && (typeBuilder != null)) { @@ -346,53 +752,31 @@ public class BindingGeneratorImpl implements BindingGenerator { if (leafName != null) { final TypeDefinition typeDef = leaf.getType(); - Type type = null; - if (!(typeDef instanceof EnumTypeDefinition) - && !isDerivedFromEnumerationType(typeDef)) { - type = typeProvider + Type returnType = null; + 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) { - type = 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); } - - constructGetter(typeBuilder, leafName, leafDesc, type); - if (!leaf.isConfiguration()) { - constructSetter(typeBuilder, leafName, leafDesc, type); + if (returnType != null) { + constructGetter(typeBuilder, leafName, leafDesc, returnType); + if (!leaf.isConfiguration()) { + constructSetter(typeBuilder, leafName, leafDesc, + returnType); + } + return true; } - return true; - } - } - 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; @@ -412,22 +796,23 @@ public class BindingGeneratorImpl implements BindingGenerator { final TypeDefinition typeDef = leaf.getType(); // TODO: properly resolve enum types - final Type javaType = typeProvider + final Type returnType = typeProvider .javaTypeForSchemaDefinitionType(typeDef); - final GeneratedPropertyBuilder propBuilder = toBuilder - .addProperty(BindingGeneratorUtil - .parseToClassName(leafName)); + if (returnType != null) { + final GeneratedPropertyBuilder propBuilder = toBuilder + .addProperty(parseToClassName(leafName)); - propBuilder.setReadOnly(isReadOnly); - propBuilder.addReturnType(javaType); - propBuilder.addComment(leafDesc); + propBuilder.setReadOnly(isReadOnly); + propBuilder.addReturnType(returnType); + propBuilder.addComment(leafDesc); - toBuilder.addEqualsIdentity(propBuilder); - toBuilder.addHashIdentity(propBuilder); - toBuilder.addToStringProperty(propBuilder); + toBuilder.addEqualsIdentity(propBuilder); + toBuilder.addHashIdentity(propBuilder); + toBuilder.addToStringProperty(propBuilder); - return true; + return true; + } } } return false; @@ -458,14 +843,18 @@ public class BindingGeneratorImpl implements BindingGenerator { return false; } - private boolean resolveContainerSchemaNode( + private boolean resolveContainerSchemaNode(final String basePackageName, final GeneratedTypeBuilder typeBuilder, - final ContainerSchemaNode node) { - if ((node != null) && (typeBuilder != null)) { - final String nodeName = node.getQName().getLocalName(); + final ContainerSchemaNode containerNode) { + if ((containerNode != null) && (typeBuilder != null)) { + final String nodeName = containerNode.getQName().getLocalName(); if (nodeName != null) { - final GeneratedTypeBuilder rawGenType = addRawInterfaceDefinition(node); + final String packageName = packageNameForGeneratedType( + basePackageName, containerNode.getPath()); + + final GeneratedTypeBuilder rawGenType = addRawInterfaceDefinition( + packageName, containerNode); constructGetter(typeBuilder, nodeName, "", rawGenType); return true; @@ -474,17 +863,21 @@ public class BindingGeneratorImpl implements BindingGenerator { return false; } - private boolean resolveListSchemaNode( - final GeneratedTypeBuilder typeBuilder, final ListSchemaNode node) { - if ((node != null) && (typeBuilder != null)) { - final String nodeName = node.getQName().getLocalName(); - - if (nodeName != null) { - final GeneratedTypeBuilder rawGenType = addRawInterfaceDefinition(node); - constructGetter(typeBuilder, nodeName, "", + private boolean resolveListSchemaNode(final String basePackageName, + final GeneratedTypeBuilder typeBuilder, + final ListSchemaNode schemaNode) { + if ((schemaNode != null) && (typeBuilder != null)) { + final String listName = schemaNode.getQName().getLocalName(); + + if (listName != null) { + final String packageName = packageNameForGeneratedType( + basePackageName, schemaNode.getPath()); + final GeneratedTypeBuilder rawGenType = addRawInterfaceDefinition( + packageName, schemaNode); + constructGetter(typeBuilder, listName, "", Types.listTypeFor(rawGenType)); - if (!node.isConfiguration()) { - constructSetter(typeBuilder, nodeName, "", + if (!schemaNode.isConfiguration()) { + constructSetter(typeBuilder, listName, "", Types.listTypeFor(rawGenType)); } return true; @@ -494,25 +887,30 @@ public class BindingGeneratorImpl implements BindingGenerator { } private GeneratedTypeBuilder addRawInterfaceDefinition( - 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; } - final String packageName = BindingGeneratorUtil - .packageNameForGeneratedType(basePackageName, - schemaNode.getPath()); final String schemaNodeName = schemaNode.getQName().getLocalName(); - if ((packageName != null) && (schemaNode != null) - && (schemaNodeName != null)) { - final String genTypeName = BindingGeneratorUtil - .parseToClassName(schemaNodeName); + if ((packageName != null) && (schemaNodeName != null)) { + final String genTypeName = prefix + parseToClassName(schemaNodeName) + ; final GeneratedTypeBuilder newType = new GeneratedTypeBuilderImpl( packageName, genTypeName); + newType.addImplementsType(Types.DATA_OBJECT); + newType.addImplementsType(Types.augmentableTypeFor(newType)); + if (!genTypeBuilders.containsKey(packageName)) { - final Map builders = new HashMap(); + final Map builders = new HashMap<>(); builders.put(genTypeName, newType); genTypeBuilders.put(packageName, builders); } else { @@ -530,14 +928,14 @@ public class BindingGeneratorImpl implements BindingGenerator { private String getterMethodName(final String methodName) { final StringBuilder method = new StringBuilder(); method.append("get"); - method.append(BindingGeneratorUtil.parseToClassName(methodName)); + method.append(parseToClassName(methodName)); return method.toString(); } private String setterMethodName(final String methodName) { final StringBuilder method = new StringBuilder(); method.append("set"); - method.append(BindingGeneratorUtil.parseToClassName(methodName)); + method.append(parseToClassName(methodName)); return method.toString(); } @@ -563,66 +961,85 @@ public class BindingGeneratorImpl implements BindingGenerator { setMethod.addComment(comment); setMethod.addParameter(parameterType, - BindingGeneratorUtil.parseToValidParamName(schemaNodeName)); + parseToValidParamName(schemaNodeName)); setMethod.addReturnType(Types.voidType()); return setMethod; } - private String resolveBasePackageName(final URI moduleNamespace, - final String yangVersion) { - final StringBuilder packageNameBuilder = new StringBuilder(); - - packageNameBuilder.append("org.opendaylight.yang.gen.v"); - packageNameBuilder.append(yangVersion); - packageNameBuilder.append(".rev"); - packageNameBuilder.append(calendar.get(Calendar.YEAR)); - packageNameBuilder.append((calendar.get(Calendar.MONTH) + 1)); - packageNameBuilder.append(calendar.get(Calendar.DAY_OF_MONTH)); - packageNameBuilder.append("."); + private List listToGenType(final String basePackageName, + final ListSchemaNode list) { + if (basePackageName == null) { + throw new IllegalArgumentException( + "Package Name for Generated Type cannot be NULL!"); + } + if (list == null) { + throw new IllegalArgumentException( + "List Schema Node cannot be NULL!"); + } - String namespace = moduleNamespace.toString(); - namespace = namespace.replace(":", "."); - namespace = namespace.replace("-", "."); + final String packageName = packageNameForGeneratedType(basePackageName, + list.getPath()); + final GeneratedTypeBuilder typeBuilder = resolveListTypeBuilder( + packageName, list); + final List listKeys = listKeys(list); + GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, + list, listKeys); - packageNameBuilder.append(namespace); + final Set schemaNodes = list.getChildNodes(); - return packageNameBuilder.toString(); + for (final DataSchemaNode schemaNode : schemaNodes) { + if (schemaNode.isAugmenting()) { + continue; + } + addSchemaNodeToListBuilders(basePackageName, schemaNode, + typeBuilder, genTOBuilder, listKeys); + } + return typeBuildersToGenTypes(typeBuilder, genTOBuilder); } - private List listToGenType(final ListSchemaNode list) { - if (list == null) { - return null; - } - final GeneratedTypeBuilder typeBuilder = resolveListTypeBuilder(list); - final List listKeys = listKeys(list); - GeneratedTOBuilder genTOBuilder = null; - if (listKeys.size() > 0) { - genTOBuilder = resolveListKey(list); + private void addSchemaNodeToListBuilders(final String basePackageName, + final DataSchemaNode schemaNode, + final GeneratedTypeBuilder typeBuilder, + final GeneratedTOBuilder genTOBuilder, final List listKeys) { + if (schemaNode == null) { + throw new IllegalArgumentException( + "Data Schema Node cannot be NULL!"); } - final Set schemaNodes = list.getChildNodes(); - for (final DataSchemaNode node : schemaNodes) { + if (typeBuilder == null) { + throw new IllegalArgumentException( + "Generated Type Builder cannot be NULL!"); + } - if (node instanceof LeafSchemaNode) { - final LeafSchemaNode leaf = (LeafSchemaNode) node; - if (!isPartOfListKey(leaf, listKeys)) { - resolveLeafSchemaNodeAsMethod(typeBuilder, leaf); - } else { - resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true); - } - } else if (node instanceof LeafListSchemaNode) { - resolveLeafListSchemaNode(typeBuilder, - (LeafListSchemaNode) node); - } else if (node instanceof ContainerSchemaNode) { - resolveContainerSchemaNode(typeBuilder, - (ContainerSchemaNode) node); - } else if (node instanceof ListSchemaNode) { - resolveListSchemaNode(typeBuilder, (ListSchemaNode) node); + if (schemaNode instanceof LeafSchemaNode) { + final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode; + if (!isPartOfListKey(leaf, listKeys)) { + resolveLeafSchemaNodeAsMethod(typeBuilder, leaf); + } else { + resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true); } + } else if (schemaNode instanceof LeafListSchemaNode) { + resolveLeafListSchemaNode(typeBuilder, + (LeafListSchemaNode) schemaNode); + } else if (schemaNode instanceof ContainerSchemaNode) { + resolveContainerSchemaNode(basePackageName, typeBuilder, + (ContainerSchemaNode) schemaNode); + } else if (schemaNode instanceof ListSchemaNode) { + resolveListSchemaNode(basePackageName, typeBuilder, + (ListSchemaNode) schemaNode); + } + } + + private List typeBuildersToGenTypes( + final GeneratedTypeBuilder typeBuilder, + GeneratedTOBuilder genTOBuilder) { + final List genTypes = new ArrayList<>(); + if (typeBuilder == null) { + throw new IllegalArgumentException( + "Generated Type Builder cannot be NULL!"); } - final List genTypes = new ArrayList(); if (genTOBuilder != null) { final GeneratedTransferObject genTO = genTOBuilder.toInstance(); constructGetter(typeBuilder, genTO.getName(), @@ -637,13 +1054,10 @@ public class BindingGeneratorImpl implements BindingGenerator { * @param list * @return */ - private GeneratedTOBuilder resolveListKey(final ListSchemaNode list) { - final String packageName = BindingGeneratorUtil - .packageNameForGeneratedType(basePackageName, list.getPath()); + private GeneratedTOBuilder resolveListKey(final String packageName, + final ListSchemaNode list) { final String listName = list.getQName().getLocalName() + "Key"; - - return BindingGeneratorUtil.schemaNodeToTransferObjectBuilder( - packageName, list, listName); + return schemaNodeToTransferObjectBuilder(packageName, list, listName); } private boolean isPartOfListKey(final LeafSchemaNode leaf, @@ -658,7 +1072,7 @@ public class BindingGeneratorImpl implements BindingGenerator { } private List listKeys(final ListSchemaNode list) { - final List listKeys = new ArrayList(); + final List listKeys = new ArrayList<>(); if (list.getKeyDefinition() != null) { final List keyDefinitions = list.getKeyDefinition(); @@ -671,23 +1085,38 @@ public class BindingGeneratorImpl implements BindingGenerator { } private GeneratedTypeBuilder resolveListTypeBuilder( - final ListSchemaNode list) { - final String packageName = BindingGeneratorUtil - .packageNameForGeneratedType(basePackageName, - list.getPath()); + final String packageName, final ListSchemaNode list) { + if (packageName == null) { + throw new IllegalArgumentException( + "Package Name for Generated Type cannot be NULL!"); + } + if (list == null) { + throw new IllegalArgumentException( + "List Schema Node cannot be NULL!"); + } + final String schemaNodeName = list.getQName().getLocalName(); - final String genTypeName = BindingGeneratorUtil - .parseToClassName(schemaNodeName); + final String genTypeName = parseToClassName(schemaNodeName); GeneratedTypeBuilder typeBuilder = null; - if (genTypeBuilders.containsKey(packageName)) { - final Map builders = new HashMap(); + final Map builders = genTypeBuilders + .get(packageName); + if (builders != null) { typeBuilder = builders.get(genTypeName); - - if (null == typeBuilder) { - typeBuilder = addRawInterfaceDefinition(list); - } + } + if (typeBuilder == null) { + typeBuilder = addRawInterfaceDefinition(packageName, list); } return typeBuilder; } + + private GeneratedTOBuilder resolveListKeyTOBuilder( + final String packageName, final ListSchemaNode list, + final List listKeys) { + GeneratedTOBuilder genTOBuilder = null; + if (listKeys.size() > 0) { + genTOBuilder = resolveListKey(packageName, list); + } + return genTOBuilder; + } }