package org.opendaylight.mdsal.binding.javav2.generator.yang.types;
import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.encodeAngleBrackets;
+import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.packageNameWithNamespacePrefix;
+import static org.opendaylight.mdsal.binding.javav2.generator.util.Types.getOuterClassPackageName;
import static org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeGenHelper.addStringRegExAsConstant;
import static org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeGenHelper.baseTypeDefForExtendedType;
import static org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeGenHelper.getAllTypedefs;
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifier;
-import org.opendaylight.mdsal.binding.javav2.generator.util.NonJavaCharsConverter;
+import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer;
import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedPropertyBuilderImpl;
import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
* @throws IllegalArgumentException
* <ul>
* <li>if <code>typeDefinition</code> equal null</li>
- * <li>if Qname of <code>typeDefinition</code> equal null</li>
+ * <li>if QName of <code>typeDefinition</code> equal null</li>
* <li>if name of <code>typeDefinition</code> equal null</li>
* </ul>
*/
}
modulesSortedByDependency.stream().filter(module -> module != null).forEach(module -> {
- final String basePackageName = getRootPackageName(module);
+ final String basePackageName = packageNameWithNamespacePrefix(getRootPackageName(module),
+ BindingNamespaceType.Typedef);
final List<TypeDefinition<?>> typeDefinitions = getAllTypedefs(module);
final List<TypeDefinition<?>> listTypeDefinitions = sortTypeDefinitionAccordingDepth(typeDefinitions);
if (listTypeDefinitions != null) {
if (typeDef instanceof BitsTypeDefinition) {
final BitsTypeDefinition bitsTypeDefinition = (BitsTypeDefinition) typeDef;
- final GeneratedTOBuilderImpl genTOBuilder = new GeneratedTOBuilderImpl(basePackageName, typeDefName);
+ final GeneratedTOBuilderImpl genTOBuilder = new GeneratedTOBuilderImpl(basePackageName, typeDefName, true, false);
final String typedefDescription = encodeAngleBrackets(typeDef.getDescription());
genTOBuilder.setDescription(typedefDescription);
for (final Bit bit : bitList) {
final String name = bit.getName();
genPropertyBuilder =
- genTOBuilder.addProperty(NonJavaCharsConverter.convertIdentifier(name, JavaIdentifier.METHOD));
+ genTOBuilder.addProperty(JavaIdentifierNormalizer.normalizeSpecificIdentifier(name, JavaIdentifier.METHOD));
genPropertyBuilder.setReadOnly(true);
genPropertyBuilder.setReturnType(BaseYangTypes.BOOLEAN_TYPE);
* <ul>
* <li>if <code>basePackageName</code> is null</li>
* <li>if <code>typedef</code> is null</li>
- * <li>if Qname of <code>typedef</code> is null</li>
+ * <li>if QName of <code>typedef</code> is null</li>
* </ul>
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
final Module module = findParentModule(schemaContext, parentNode);
final GeneratedTOBuilderImpl unionGenTOBuilder;
- if (typeDefName != null && !typeDefName.isEmpty()) {
- unionGenTOBuilder = new GeneratedTOBuilderImpl(basePackageName, typeDefName);
- final String typedefDescription = encodeAngleBrackets(typedef.getDescription());
- unionGenTOBuilder.setDescription(typedefDescription);
- unionGenTOBuilder.setReference(typedef.getReference());
- unionGenTOBuilder.setSchemaPath((List) typedef.getPath().getPathFromRoot());
- unionGenTOBuilder.setModuleName(module.getName());
- } else {
- unionGenTOBuilder = typedefToTransferObject(basePackageName, typedef, module.getName());
- }
+ unionGenTOBuilder = new GeneratedTOBuilderImpl(basePackageName, typeDefName, true, false);
+ final String typedefDescription = encodeAngleBrackets(typedef.getDescription());
+ unionGenTOBuilder.setDescription(typedefDescription);
+ unionGenTOBuilder.setReference(typedef.getReference());
+ unionGenTOBuilder.setSchemaPath((List) typedef.getPath().getPathFromRoot());
+ unionGenTOBuilder.setModuleName(module.getName());
generatedTOBuilders.add(unionGenTOBuilder);
unionGenTOBuilder.setIsUnion(true);
resolveExtendedSubtypeAsUnion(unionGenTOBuilder, unionType, regularExpressions,
parentNode, schemaContext, genTypeDefsContextMap);
} else if (unionType instanceof UnionTypeDefinition) {
- generatedTOBuilders.addAll(resolveUnionSubtypeAsUnion(unionGenTOBuilder, (UnionTypeDefinition) unionType,
- basePackageName, parentNode, schemaContext, genTypeDefsContextMap));
+ generatedTOBuilders.add(resolveUnionSubtypeAsUnion(unionGenTOBuilder, (UnionTypeDefinition) unionType,
+ unionGenTOBuilder.getFullyQualifiedName(), parentNode, schemaContext, genTypeDefsContextMap));
} else if (unionType instanceof EnumTypeDefinition) {
final Enumeration enumeration = addInnerEnumerationToTypeBuilder((EnumTypeDefinition) unionType,
unionTypeName, unionGenTOBuilder);
}
Type returnType = javaTypeForExtendedType(typeDefinition, schemaContext, genTypeDefsContextMap);
- if (r != null && returnType instanceof GeneratedTransferObject) {
+ if (r != null && !r.isEmpty() && returnType instanceof GeneratedTransferObject) {
final GeneratedTransferObject gto = (GeneratedTransferObject) returnType;
final Module module = findParentModule(schemaContext, parentNode);
+ final Module module1 = findParentModule(schemaContext, typeDefinition);
final String basePackageName = BindingMapping.getRootPackageName(module);
final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, typeDefinition
.getPath(), BindingNamespaceType.Typedef);
- final String genTOName = NonJavaCharsConverter.normalizeClassIdentifier(packageName, typedefName);
+ final String genTOName =
+ JavaIdentifierNormalizer.normalizeSpecificIdentifier(typedefName, JavaIdentifier.CLASS);
final String name = packageName + "." + genTOName;
- if (!(returnType.getFullyQualifiedName().equals(name))) {
+ if (module.equals(module1) && !(returnType.getFullyQualifiedName().equals(name))) {
returnType = shadedTOWithRestrictions(gto, r);
}
}
addUnitsToGenTO(genTOBuilder, typedef.getUnits());
makeSerializable((GeneratedTOBuilderImpl) genTOBuilder);
returnType = genTOBuilder.toInstance();
- // union builder
- final GeneratedTOBuilder unionBuilder = new GeneratedTOBuilderImpl(genTOBuilder.getPackageName(),
- genTOBuilder.getName() + "Builder");
- unionBuilder.setIsUnionBuilder(true);
- final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
- method.setReturnType(returnType);
- method.addParameter(Types.STRING, "defaultValue");
- method.setAccessModifier(AccessModifier.PUBLIC);
- method.setStatic(true);
- Set<Type> types = additionalTypes.get(module);
- if (types == null) {
- types = Sets.newHashSet(unionBuilder.toInstance());
- additionalTypes.put(module, types);
- } else {
- types.add(unionBuilder.toInstance());
- }
} else if (innerTypeDefinition instanceof EnumTypeDefinition) {
// enums are automatically Serializable
final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) innerTypeDefinition;
final TypeDefinition<?> baseTypeDef = baseTypeDefForExtendedType(typeDefinition);
Type returnType = javaTypeForLeafrefOrIdentityRef(baseTypeDef, typeDefinition, schemaContext, genTypeDefsContextMap);
if (returnType == null) {
- if (baseTypeDef instanceof EnumTypeDefinition) {
- final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) baseTypeDef;
- returnType = provideTypeForEnum(enumTypeDef, typedefName, typeDefinition, schemaContext);
- } else {
- final Module module = findParentModule(schemaContext, typeDefinition);
- final Restrictions r = BindingGeneratorUtil.getRestrictions(typeDefinition);
- if (module != null) {
- final Map<Date, Map<String, Type>> modulesByDate = genTypeDefsContextMap.get(module.getName());
- final Map<String, Type> genTOs = modulesByDate.get(module.getRevision());
- if (genTOs != null) {
- returnType = genTOs.get(typedefName);
- }
- if (returnType == null) {
- returnType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER.javaTypeForSchemaDefinitionType(
- baseTypeDef, typeDefinition, r);
- }
+ final Module module = findParentModule(schemaContext, typeDefinition);
+ final Restrictions r = BindingGeneratorUtil.getRestrictions(typeDefinition);
+ if (module != null) {
+ final Map<Date, Map<String, Type>> modulesByDate = genTypeDefsContextMap.get(module.getName());
+ final Map<String, Type> genTOs = modulesByDate.get(module.getRevision());
+ if (genTOs != null) {
+ returnType = genTOs.get(typedefName);
+ }
+ if (returnType == null) {
+ returnType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER.javaTypeForSchemaDefinitionType(
+ baseTypeDef, typeDefinition, r);
}
}
}
final String basePackageName = BindingMapping.getRootPackageName(module);
final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, identity.getPath
- (), BindingNamespaceType.Typedef);
- final String genTypeName =
- NonJavaCharsConverter.normalizeClassIdentifier(packageName, identity.getQName().getLocalName());
+ (), BindingNamespaceType.Identity);
+
+ final String genTypeName = JavaIdentifierNormalizer.normalizeSpecificIdentifier(identity.getQName().getLocalName(),
+ JavaIdentifier.CLASS);
final Type baseType = Types.typeForClass(Class.class);
- final Type paramType = Types.wildcardTypeFor(packageName, genTypeName);
+ final Type paramType = Types.wildcardTypeFor(packageName, genTypeName, true, true);
return Types.parameterizedTypeFor(baseType, paramType);
}
private static void updateUnionTypeAsProperty(final GeneratedTOBuilder unionGenTransObject, final Type type, final String propertyName) {
if (unionGenTransObject != null && type != null && !unionGenTransObject.containsProperty(propertyName)) {
final GeneratedPropertyBuilder propBuilder = unionGenTransObject
- .addProperty(NonJavaCharsConverter.convertIdentifier(propertyName, JavaIdentifier.METHOD));
+ .addProperty(JavaIdentifierNormalizer.normalizeSpecificIdentifier(propertyName, JavaIdentifier.METHOD));
propBuilder.setReturnType(type);
unionGenTransObject.addEqualsIdentity(propBuilder);
* bigger one due to recursive call of
* <code>provideGeneratedTOBuildersForUnionTypeDef</code> method.
*/
- private List<GeneratedTOBuilder> resolveUnionSubtypeAsUnion(final GeneratedTOBuilder
+ private GeneratedTOBuilder resolveUnionSubtypeAsUnion(final GeneratedTOBuilder
parentUnionGenTOBuilder, final UnionTypeDefinition unionSubtype, final String basePackageName,
final SchemaNode parentNode, final SchemaContext schemaContext, final Map<String, Map<Date, Map<String, Type>>> genTypeDefsContextMap) {
final String newTOBuilderName = provideAvailableNameForGenTOBuilder(parentUnionGenTOBuilder.getName());
- final List<GeneratedTOBuilder> subUnionGenTOBUilders = provideGeneratedTOBuildersForUnionTypeDef(
+ final GeneratedTOBuilder subUnionGenTOBUilder = provideGeneratedTOBuilderForUnionTypeDef(
basePackageName, unionSubtype, newTOBuilderName, parentNode, schemaContext, genTypeDefsContextMap);
final GeneratedPropertyBuilder propertyBuilder;
propertyBuilder = parentUnionGenTOBuilder
- .addProperty(NonJavaCharsConverter.convertIdentifier(newTOBuilderName, JavaIdentifier.METHOD));
- propertyBuilder.setReturnType(subUnionGenTOBUilders.get(0));
+ .addProperty(JavaIdentifierNormalizer.normalizeSpecificIdentifier(newTOBuilderName, JavaIdentifier.METHOD));
+ propertyBuilder.setReturnType(subUnionGenTOBUilder);
parentUnionGenTOBuilder.addEqualsIdentity(propertyBuilder);
parentUnionGenTOBuilder.addToStringProperty(propertyBuilder);
- return subUnionGenTOBUilders;
+ return subUnionGenTOBUilder;
}
/**
* @return generated TO builder with the list of enclosed generated TO
* builders
*/
- private GeneratedTOBuilder provideGeneratedTOBuilderForUnionTypeDef(final String basePackageName,
+ public GeneratedTOBuilder provideGeneratedTOBuilderForUnionTypeDef(final String basePackageName,
final UnionTypeDefinition typedef, final String typeDefName, final SchemaNode parentNode, final SchemaContext
schemaContext, final Map<String, Map<Date, Map<String, Type>>> genTypeDefsContextMap) {
resultTOBuilder.addEnclosingTransferObject(genTOBuilder);
}
- resultTOBuilder.addProperty("value").setReturnType(Types.CHAR_ARRAY);
+ final GeneratedPropertyBuilder genPropBuilder;
+
+ genPropBuilder = resultTOBuilder.addProperty("value").setReturnType(Types.CHAR_ARRAY).setReadOnly(false);
+ resultTOBuilder.addEqualsIdentity(genPropBuilder);
+ resultTOBuilder.addHashIdentity(genPropBuilder);
+ resultTOBuilder.addToStringProperty(genPropBuilder);
+
+ provideGeneratedTOBuilderForUnionBuilder(findParentModule(schemaContext, parentNode), resultTOBuilder);
+
return resultTOBuilder;
}
+
+ private GeneratedTOBuilder provideGeneratedTOBuilderForUnionBuilder(final Module parentModule,
+ final GeneratedTOBuilder genTOBuilder) {
+ final String outerCls = Types.getOuterClassName(genTOBuilder);
+ final StringBuilder name;
+ if (outerCls != null) {
+ name = new StringBuilder(outerCls);
+ } else {
+ name = new StringBuilder();
+ }
+ name.append(genTOBuilder.getName());
+ name.append("Builder");
+ final GeneratedTOBuilderImpl unionBuilder = new GeneratedTOBuilderImpl(getOuterClassPackageName(genTOBuilder),
+ name.toString(), true);
+ unionBuilder.setIsUnionBuilder(true);
+
+ final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
+ method.setReturnType(genTOBuilder);
+ method.addParameter(Types.STRING, "defaultValue");
+ method.setAccessModifier(AccessModifier.PUBLIC);
+ method.setStatic(true);
+
+ final Set<Type> types = this.getAdditionalTypes().get(parentModule);
+ if (types == null) {
+ this.getAdditionalTypes().put(parentModule,
+ Sets.newHashSet(unionBuilder.toInstance()));
+ } else {
+ types.add(unionBuilder.toInstance());
+ }
+
+ return unionBuilder;
+ }
+
/**
* Wraps code which handle case when union subtype is of the type
* <code>ExtendedType</code>.
final String unionTypeName = unionSubtype.getQName().getLocalName();
final Type genTO = findGenTO(unionTypeName, unionSubtype, schemaContext, genTypeDefsContextMap);
if (genTO != null) {
- updateUnionTypeAsProperty(parentUnionGenTOBuilder, genTO, genTO.getName());
+ updateUnionTypeAsProperty(parentUnionGenTOBuilder, genTO, unionTypeName);
} else {
final TypeDefinition<?> baseType = baseTypeDefForExtendedType(unionSubtype);
if (unionTypeName.equals(baseType.getQName().getLocalName())) {