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%2Fyang%2Ftypes%2FTypeProviderImpl.java;h=4824fa75fd000be4910397bc7bd02f3e3775d6ad;hp=96069c273c071b96d3594b484055f0c32913a6f1;hb=3e438a825b58c4789cbad87f4e0a9a328b78a778;hpb=ff1b4a79cca00743a00c3b0b1100bd0ab2b2fb31 diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/yang/types/TypeProviderImpl.java b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/yang/types/TypeProviderImpl.java index 96069c273c..4824fa75fd 100644 --- a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/yang/types/TypeProviderImpl.java +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/yang/types/TypeProviderImpl.java @@ -7,7 +7,9 @@ */ package org.opendaylight.controller.sal.binding.yang.types; +import org.apache.commons.lang.StringEscapeUtils; import org.opendaylight.controller.binding.generator.util.ReferencedTypeImpl; +import org.opendaylight.controller.binding.generator.util.TypeConstants; import org.opendaylight.controller.binding.generator.util.Types; import org.opendaylight.controller.binding.generator.util.generated.type.builder.EnumerationBuilderImpl; import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl; @@ -21,13 +23,13 @@ import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedT import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTypeBuilder; import org.opendaylight.controller.yang.common.QName; import org.opendaylight.controller.yang.model.api.*; -import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition; +import org.opendaylight.controller.yang.model.api.type.*; +import org.opendaylight.controller.yang.model.api.type.BitsTypeDefinition.Bit; import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition.EnumPair; -import org.opendaylight.controller.yang.model.api.type.IdentityrefTypeDefinition; -import org.opendaylight.controller.yang.model.api.type.LeafrefTypeDefinition; -import org.opendaylight.controller.yang.model.api.type.UnionTypeDefinition; import org.opendaylight.controller.yang.model.util.ExtendedType; +import org.opendaylight.controller.yang.model.util.StringType; +import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -53,48 +55,41 @@ public final class TypeProviderImpl implements TypeProvider { resolveTypeDefsFromContext(); } - public void putReferencedType(final SchemaPath refTypePath, - final Type refType) { + public void putReferencedType(final SchemaPath refTypePath, final Type refType) { if (refTypePath == null) { - throw new IllegalArgumentException("Path reference of " + - "Enumeration Type Definition cannot be NULL!"); + throw new IllegalArgumentException("Path reference of " + "Enumeration Type Definition cannot be NULL!"); } if (refType == null) { - throw new IllegalArgumentException("Reference to Enumeration " + - "Type cannot be NULL!"); + throw new IllegalArgumentException("Reference to Enumeration " + "Type cannot be NULL!"); } referencedTypes.put(refTypePath, refType); } /* * (non-Javadoc) - * + * * @see org.opendaylight.controller.yang.model.type.provider.TypeProvider# * javaTypeForYangType(java.lang.String) */ @Override public Type javaTypeForYangType(String type) { - Type t = BaseYangTypes.BASE_YANG_TYPES_PROVIDER - .javaTypeForYangType(type); + Type t = BaseYangTypes.BASE_YANG_TYPES_PROVIDER.javaTypeForYangType(type); return t; } @Override - public Type javaTypeForSchemaDefinitionType( - final TypeDefinition typeDefinition) { + public Type javaTypeForSchemaDefinitionType(final TypeDefinition typeDefinition) { Type returnType = null; if (typeDefinition == null) { - throw new IllegalArgumentException("Type Definition cannot be " + - "NULL!"); + throw new IllegalArgumentException("Type Definition cannot be NULL!"); } if (typeDefinition.getQName() == null) { - throw new IllegalArgumentException("Type Definition cannot have " + - "non specified QName (QName cannot be NULL!)"); + throw new IllegalArgumentException( + "Type Definition cannot have non specified QName (QName cannot be NULL!)"); } if (typeDefinition.getQName().getLocalName() == null) { - throw new IllegalArgumentException("Type Definitions Local Name " + - "cannot be NULL!"); + throw new IllegalArgumentException("Type Definitions Local Name cannot be NULL!"); } final String typedefName = typeDefinition.getQName().getLocalName(); if (typeDefinition instanceof ExtendedType) { @@ -104,18 +99,15 @@ public final class TypeProviderImpl implements TypeProvider { final LeafrefTypeDefinition leafref = (LeafrefTypeDefinition) baseTypeDef; returnType = provideTypeForLeafref(leafref); } else if (baseTypeDef instanceof IdentityrefTypeDefinition) { - final IdentityrefTypeDefinition idref = (IdentityrefTypeDefinition)typeDefinition; + final IdentityrefTypeDefinition idref = (IdentityrefTypeDefinition) baseTypeDef; returnType = returnTypeForIdentityref(idref); } else if (baseTypeDef instanceof EnumTypeDefinition) { final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) baseTypeDef; - returnType = resolveEnumFromTypeDefinition(enumTypeDef, - typedefName); + returnType = resolveEnumFromTypeDefinition(enumTypeDef, typedefName); } else { - final Module module = findParentModuleForTypeDefinition(schemaContext, - typeDefinition); + final Module module = findParentModuleForTypeDefinition(schemaContext, typeDefinition); if (module != null) { - final Map genTOs = genTypeDefsContextMap - .get(module.getName()); + final Map genTOs = genTypeDefsContextMap.get(module.getName()); if (genTOs != null) { returnType = genTOs.get(typedefName); } @@ -130,32 +122,31 @@ public final class TypeProviderImpl implements TypeProvider { final LeafrefTypeDefinition leafref = (LeafrefTypeDefinition) typeDefinition; returnType = provideTypeForLeafref(leafref); } else if (typeDefinition instanceof IdentityrefTypeDefinition) { - final IdentityrefTypeDefinition idref = (IdentityrefTypeDefinition)typeDefinition; + final IdentityrefTypeDefinition idref = (IdentityrefTypeDefinition) typeDefinition; returnType = returnTypeForIdentityref(idref); } else { - returnType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER - .javaTypeForSchemaDefinitionType(typeDefinition); + returnType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER.javaTypeForSchemaDefinitionType(typeDefinition); } } - //TODO: add throw exception when we will be able to resolve ALL yang + // TODO: add throw exception when we will be able to resolve ALL yang // types! -// if (returnType == null) { -// throw new IllegalArgumentException("Type Provider can't resolve " + -// "type for specified Type Definition " + typedefName); -// } + // if (returnType == null) { + // throw new IllegalArgumentException("Type Provider can't resolve " + + // "type for specified Type Definition " + typedefName); + // } return returnType; } - + private Type returnTypeForIdentityref(IdentityrefTypeDefinition idref) { QName baseIdQName = idref.getIdentity(); Module module = schemaContext.findModuleByNamespace(baseIdQName.getNamespace()); IdentitySchemaNode identity = null; - for(IdentitySchemaNode id : module.getIdentities()) { - if(id.getQName().equals(baseIdQName)) { + for (IdentitySchemaNode id : module.getIdentities()) { + if (id.getQName().equals(baseIdQName)) { identity = id; } } - if(identity == null) { + if (identity == null) { throw new IllegalArgumentException("Target identity '" + baseIdQName + "' do not exists"); } @@ -169,34 +160,28 @@ public final class TypeProviderImpl implements TypeProvider { return returnType; } - public Type generatedTypeForExtendedDefinitionType( - final TypeDefinition typeDefinition) { + public Type generatedTypeForExtendedDefinitionType(final TypeDefinition typeDefinition) { Type returnType = null; if (typeDefinition == null) { - throw new IllegalArgumentException("Type Definition cannot be " + - "NULL!"); + throw new IllegalArgumentException("Type Definition cannot be NULL!"); } if (typeDefinition.getQName() == null) { - throw new IllegalArgumentException("Type Definition cannot have " + - "non specified QName (QName cannot be NULL!)"); + throw new IllegalArgumentException( + "Type Definition cannot have non specified QName (QName cannot be NULL!)"); } if (typeDefinition.getQName() == null) { - throw new IllegalArgumentException("Type Definitions Local Name " + - "cannot be NULL!"); + throw new IllegalArgumentException("Type Definitions Local Name cannot be NULL!"); } final String typedefName = typeDefinition.getQName().getLocalName(); if (typeDefinition instanceof ExtendedType) { final TypeDefinition baseTypeDef = baseTypeDefForExtendedType(typeDefinition); - if (!(baseTypeDef instanceof LeafrefTypeDefinition) - && !(baseTypeDef instanceof IdentityrefTypeDefinition)) { - final Module module = findParentModuleForTypeDefinition(schemaContext, - typeDefinition); + if (!(baseTypeDef instanceof LeafrefTypeDefinition) && !(baseTypeDef instanceof IdentityrefTypeDefinition)) { + final Module module = findParentModuleForTypeDefinition(schemaContext, typeDefinition); if (module != null) { - final Map genTOs = genTypeDefsContextMap - .get(module.getName()); + final Map genTOs = genTypeDefsContextMap.get(module.getName()); if (genTOs != null) { returnType = genTOs.get(typedefName); } @@ -206,11 +191,9 @@ public final class TypeProviderImpl implements TypeProvider { return returnType; } - private TypeDefinition baseTypeDefForExtendedType( - final TypeDefinition extendTypeDef) { + private TypeDefinition baseTypeDefForExtendedType(final TypeDefinition extendTypeDef) { if (extendTypeDef == null) { - throw new IllegalArgumentException("Type Definiition reference " + - "cannot be NULL!"); + throw new IllegalArgumentException("Type Definiition reference cannot be NULL!"); } final TypeDefinition baseTypeDef = extendTypeDef.getBaseType(); if (baseTypeDef instanceof ExtendedType) { @@ -224,13 +207,11 @@ public final class TypeProviderImpl implements TypeProvider { public Type provideTypeForLeafref(final LeafrefTypeDefinition leafrefType) { Type returnType = null; if (leafrefType == null) { - throw new IllegalArgumentException("Leafref Type Definition " + - "reference cannot be NULL!"); + throw new IllegalArgumentException("Leafref Type Definition reference cannot be NULL!"); } if (leafrefType.getPathStatement() == null) { - throw new IllegalArgumentException("The Path Statement for " + - "Leafref Type Definition cannot be NULL!"); + throw new IllegalArgumentException("The Path Statement for Leafref Type Definition cannot be NULL!"); } final RevisionAwareXPath xpath = leafrefType.getPathStatement(); @@ -244,18 +225,15 @@ public final class TypeProviderImpl implements TypeProvider { if (module != null) { final DataSchemaNode dataNode; if (xpath.isAbsolute()) { - dataNode = findDataSchemaNode(schemaContext, module, - xpath); + dataNode = findDataSchemaNode(schemaContext, module, xpath); } else { - dataNode = findDataSchemaNodeForRelativeXPath(schemaContext, - module, leafrefType, xpath); + dataNode = findDataSchemaNodeForRelativeXPath(schemaContext, module, leafrefType, xpath); } if (leafContainsEnumDefinition(dataNode)) { returnType = referencedTypes.get(dataNode.getPath()); } else if (leafListContainsEnumDefinition(dataNode)) { - returnType = Types.listTypeFor(referencedTypes.get( - dataNode.getPath())); + returnType = Types.listTypeFor(referencedTypes.get(dataNode.getPath())); } else { returnType = resolveTypeFromDataSchemaNode(dataNode); } @@ -275,8 +253,7 @@ public final class TypeProviderImpl implements TypeProvider { return false; } - private boolean leafListContainsEnumDefinition( - final DataSchemaNode dataNode) { + private boolean leafListContainsEnumDefinition(final DataSchemaNode dataNode) { if (dataNode instanceof LeafListSchemaNode) { final LeafListSchemaNode leafList = (LeafListSchemaNode) dataNode; if (leafList.getType() instanceof EnumTypeDefinition) { @@ -286,23 +263,18 @@ public final class TypeProviderImpl implements TypeProvider { return false; } - private Enumeration resolveEnumFromTypeDefinition( - final EnumTypeDefinition enumTypeDef, final String enumName) { + private Enumeration resolveEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final String enumName) { if (enumTypeDef == null) { - throw new IllegalArgumentException("EnumTypeDefinition reference " + - "cannot be NULL!"); + throw new IllegalArgumentException("EnumTypeDefinition reference cannot be NULL!"); } if (enumTypeDef.getValues() == null) { - throw new IllegalArgumentException("EnumTypeDefinition MUST " + - "contain at least ONE value definition!"); + throw new IllegalArgumentException("EnumTypeDefinition MUST contain at least ONE value definition!"); } if (enumTypeDef.getQName() == null) { - throw new IllegalArgumentException("EnumTypeDefinition MUST " + - "contain NON-NULL QName!"); + throw new IllegalArgumentException("EnumTypeDefinition MUST contain NON-NULL QName!"); } if (enumTypeDef.getQName().getLocalName() == null) { - throw new IllegalArgumentException("Local Name in " + - "EnumTypeDefinition QName cannot be NULL!"); + throw new IllegalArgumentException("Local Name in EnumTypeDefinition QName cannot be NULL!"); } final String enumerationName = parseToClassName(enumName); @@ -310,56 +282,45 @@ public final class TypeProviderImpl implements TypeProvider { Module module = findParentModuleForTypeDefinition(schemaContext, enumTypeDef); final String basePackageName = moduleNamespaceToPackageName(module); - final EnumBuilder enumBuilder = new EnumerationBuilderImpl( - basePackageName, enumerationName); + final EnumBuilder enumBuilder = new EnumerationBuilderImpl(basePackageName, enumerationName); updateEnumPairsFromEnumTypeDef(enumTypeDef, enumBuilder); return enumBuilder.toInstance(null); } - private EnumBuilder resolveInnerEnumFromTypeDefinition( - final EnumTypeDefinition enumTypeDef, final String enumName, + private EnumBuilder resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final String enumName, final GeneratedTypeBuilder typeBuilder) { if (enumTypeDef == null) { - throw new IllegalArgumentException("EnumTypeDefinition reference " + - "cannot be NULL!"); + throw new IllegalArgumentException("EnumTypeDefinition reference cannot be NULL!"); } if (enumTypeDef.getValues() == null) { - throw new IllegalArgumentException("EnumTypeDefinition MUST " + - "contain at least ONE value definition!"); + throw new IllegalArgumentException("EnumTypeDefinition MUST contain at least ONE value definition!"); } if (enumTypeDef.getQName() == null) { - throw new IllegalArgumentException("EnumTypeDefinition MUST " + - "contain NON-NULL QName!"); + throw new IllegalArgumentException("EnumTypeDefinition MUST contain NON-NULL QName!"); } if (enumTypeDef.getQName().getLocalName() == null) { - throw new IllegalArgumentException("Local Name in " + - "EnumTypeDefinition QName cannot be NULL!"); + throw new IllegalArgumentException("Local Name in EnumTypeDefinition QName cannot be NULL!"); } if (typeBuilder == null) { - throw new IllegalArgumentException("Generated Type Builder " + - "reference cannot be NULL!"); + throw new IllegalArgumentException("Generated Type Builder reference cannot be NULL!"); } final String enumerationName = parseToClassName(enumName); - final EnumBuilder enumBuilder = typeBuilder - .addEnumeration(enumerationName); + final EnumBuilder enumBuilder = typeBuilder.addEnumeration(enumerationName); updateEnumPairsFromEnumTypeDef(enumTypeDef, enumBuilder); return enumBuilder; } - private void updateEnumPairsFromEnumTypeDef( - final EnumTypeDefinition enumTypeDef, - final EnumBuilder enumBuilder) { + private void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef, final EnumBuilder enumBuilder) { if (enumBuilder != null) { final List enums = enumTypeDef.getValues(); if (enums != null) { int listIndex = 0; for (final EnumPair enumPair : enums) { if (enumPair != null) { - final String enumPairName = parseToClassName(enumPair - .getName()); + final String enumPairName = parseToClassName(enumPair.getName()); Integer enumPairValue = enumPair.getValue(); if (enumPairValue == null) { @@ -390,8 +351,7 @@ public final class TypeProviderImpl implements TypeProvider { private void resolveTypeDefsFromContext() { final Set modules = schemaContext.getModules(); if (modules == null) { - throw new IllegalArgumentException("Sef of Modules cannot be " + - "NULL!"); + throw new IllegalArgumentException("Sef of Modules cannot be NULL!"); } for (final Module module : modules) { if (module == null) { @@ -400,8 +360,7 @@ public final class TypeProviderImpl implements TypeProvider { final String moduleName = module.getName(); final String basePackageName = moduleNamespaceToPackageName(module); - final Set> typeDefinitions = module - .getTypeDefinitions(); + final Set> typeDefinitions = module.getTypeDefinitions(); final Map typeMap = new HashMap<>(); genTypeDefsContextMap.put(moduleName, typeMap); @@ -410,20 +369,17 @@ public final class TypeProviderImpl implements TypeProvider { for (final TypeDefinition typedef : typeDefinitions) { typedefToGeneratedType(basePackageName, moduleName, typedef); } - final List extUnions = UnionDependencySort - .sort(typeDefinitions); + final List extUnions = UnionDependencySort.sort(typeDefinitions); for (final ExtendedType extUnionType : extUnions) { - addUnionGeneratedTypeDefinition(basePackageName, extUnionType); + addUnionGeneratedTypeDefinition(basePackageName, extUnionType, null); } } } } - private Type typedefToGeneratedType(final String basePackageName, - final String moduleName, final TypeDefinition typedef) { - if ((basePackageName != null) && (moduleName != null) - && (typedef != null) && (typedef.getQName() != null)) { - + private Type typedefToGeneratedType(final String basePackageName, final String moduleName, + final TypeDefinition typedef) { + if ((basePackageName != null) && (moduleName != null) && (typedef != null) && (typedef.getQName() != null)) { final String typedefName = typedef.getQName().getLocalName(); final TypeDefinition baseTypeDefinition = baseTypeDefForExtendedType(typedef); @@ -432,19 +388,22 @@ public final class TypeProviderImpl implements TypeProvider { Type returnType; if (baseTypeDefinition instanceof EnumTypeDefinition) { final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) baseTypeDefinition; - returnType = resolveEnumFromTypeDefinition(enumTypeDef, + returnType = resolveEnumFromTypeDefinition(enumTypeDef, typedefName); + + } else if (baseTypeDefinition instanceof BitsTypeDefinition) { + final BitsTypeDefinition bitsTypeDefinition = (BitsTypeDefinition) baseTypeDefinition; + GeneratedTOBuilder genTOBuilder = bitsTypedefToTransferObject(basePackageName, bitsTypeDefinition, typedefName); + returnType = genTOBuilder.toInstance(); } else { final Type javaType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER .javaTypeForSchemaDefinitionType(baseTypeDefinition); - returnType = wrapJavaTypeIntoTO(basePackageName, typedef, - javaType); + returnType = wrapJavaTypeIntoTO(basePackageName, typedef, javaType); } if (returnType != null) { - final Map typeMap = genTypeDefsContextMap.get - (moduleName); + final Map typeMap = genTypeDefsContextMap.get(moduleName); if (typeMap != null) { typeMap.put(typedefName, returnType); } @@ -455,136 +414,210 @@ public final class TypeProviderImpl implements TypeProvider { return null; } - private GeneratedTransferObject wrapJavaTypeIntoTO( - final String basePackageName, final TypeDefinition typedef, + private GeneratedTransferObject wrapJavaTypeIntoTO(final String basePackageName, final TypeDefinition typedef, final Type javaType) { if (javaType != null) { final String typedefName = typedef.getQName().getLocalName(); final String propertyName = parseToValidParamName(typedefName); - final GeneratedTOBuilder genTOBuilder = typedefToTransferObject( - basePackageName, typedef); + final GeneratedTOBuilder genTOBuilder = typedefToTransferObject(basePackageName, typedef); - final GeneratedPropertyBuilder genPropBuilder = genTOBuilder - .addProperty(propertyName); + final GeneratedPropertyBuilder genPropBuilder = genTOBuilder.addProperty(propertyName); - genPropBuilder.addReturnType(javaType); + genPropBuilder.setReturnType(javaType); genTOBuilder.addEqualsIdentity(genPropBuilder); genTOBuilder.addHashIdentity(genPropBuilder); genTOBuilder.addToStringProperty(genPropBuilder); + + if (typedef instanceof ExtendedType) { + final List regExps = resolveRegExpressionsFromTypedef((ExtendedType) typedef); + addStringRegExAsConstant(genTOBuilder, regExps); + } + return genTOBuilder.toInstance(); } return null; } - private void addUnionGeneratedTypeDefinition(final String basePackageName, - final TypeDefinition typedef) { + public GeneratedTOBuilder addUnionGeneratedTypeDefinition(final String basePackageName, + final TypeDefinition typedef, String typeDefName) { if (basePackageName == null) { - throw new IllegalArgumentException("Base Package Name cannot be " + - "NULL!"); + throw new IllegalArgumentException("Base Package Name cannot be NULL!"); } if (typedef == null) { - throw new IllegalArgumentException("Type Definition cannot be " + - "NULL!"); + throw new IllegalArgumentException("Type Definition cannot be NULL!"); } if (typedef.getQName() == null) { - throw new IllegalArgumentException("Type Definition cannot have " + - "non specified QName (QName cannot be NULL!)"); + throw new IllegalArgumentException( + "Type Definition cannot have non specified QName (QName cannot be NULL!)"); } final TypeDefinition baseTypeDefinition = typedef.getBaseType(); - if ((baseTypeDefinition != null) - && (baseTypeDefinition instanceof UnionTypeDefinition)) { + if ((baseTypeDefinition != null) && (baseTypeDefinition instanceof UnionTypeDefinition)) { + final Module parentModule = findParentModuleForTypeDefinition(schemaContext, typedef); final UnionTypeDefinition unionTypeDef = (UnionTypeDefinition) baseTypeDefinition; - final List> unionTypes = unionTypeDef - .getTypes(); - final Module parentModule = findParentModuleForTypeDefinition(schemaContext, - typedef); + final List> unionTypes = unionTypeDef.getTypes(); Map genTOsMap = null; if (parentModule != null && parentModule.getName() != null) { genTOsMap = genTypeDefsContextMap.get(parentModule.getName()); } - final GeneratedTOBuilder unionGenTransObject = typedefToTransferObject( - basePackageName, typedef); - if ((unionTypes != null) && (unionGenTransObject != null)) { - for (final TypeDefinition unionType : unionTypes) { - final String typeName = unionType.getQName() - .getLocalName(); - if (unionType instanceof ExtendedType) { - final Module unionTypeModule = findParentModuleForTypeDefinition(schemaContext, - unionType); - if (unionTypeModule != null && unionTypeModule.getName() != null) { - final Map innerGenTOs = genTypeDefsContextMap - .get(unionTypeModule.getName()); - - final GeneratedTransferObject genTransferObject = - (GeneratedTransferObject) innerGenTOs.get(typeName); - if (genTransferObject != null) { - updateUnionTypeAsProperty(unionGenTransObject, - genTransferObject, - genTransferObject.getName()); + final GeneratedTOBuilder unionGenTransObject; + if (typeDefName != null && !typeDefName.isEmpty()) { + final String typeName = parseToClassName(typeDefName); + unionGenTransObject = new GeneratedTOBuilderImpl(basePackageName, typeName); + } else { + unionGenTransObject = typedefToTransferObject(basePackageName, typedef); + } + unionGenTransObject.setIsUnion(true); + + final List regularExpressions = new ArrayList(); + for (final TypeDefinition unionType : unionTypes) { + final String typeName = unionType.getQName().getLocalName(); + if (unionType instanceof ExtendedType) { + final Module unionTypeModule = findParentModuleForTypeDefinition(schemaContext, unionType); + if (unionTypeModule != null && unionTypeModule.getName() != null) { + final Map innerGenTOs = genTypeDefsContextMap.get(unionTypeModule.getName()); + + final GeneratedTransferObject genTransferObject = (GeneratedTransferObject) innerGenTOs + .get(typeName); + if (genTransferObject != null) { + updateUnionTypeAsProperty(unionGenTransObject, genTransferObject, + genTransferObject.getName()); + } else { + final TypeDefinition baseType = baseTypeDefForExtendedType(unionType); + if (typeName.equals(baseType.getQName().getLocalName())) { + final Type javaType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER + .javaTypeForSchemaDefinitionType(baseType); + if (javaType != null) { + updateUnionTypeAsProperty(unionGenTransObject, javaType, typeName); + } + } + if (baseType instanceof StringType) { + regularExpressions.addAll(resolveRegExpressionsFromTypedef((ExtendedType) unionType)); } - } - } else if (unionType instanceof EnumTypeDefinition) { - final EnumBuilder - enumBuilder = resolveInnerEnumFromTypeDefinition( - (EnumTypeDefinition) unionType, typeName, - unionGenTransObject); - final Type enumRefType = new ReferencedTypeImpl( - enumBuilder.getPackageName(), - enumBuilder.getName()); - updateUnionTypeAsProperty(unionGenTransObject, - enumRefType, typeName); - } else { - final Type javaType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER - .javaTypeForSchemaDefinitionType(unionType); - if (javaType != null) { - updateUnionTypeAsProperty(unionGenTransObject, - javaType, typeName); } } + } else if (unionType instanceof EnumTypeDefinition) { + final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition((EnumTypeDefinition) unionType, + typeName, unionGenTransObject); + final Type enumRefType = new ReferencedTypeImpl(enumBuilder.getPackageName(), enumBuilder.getName()); + updateUnionTypeAsProperty(unionGenTransObject, enumRefType, typeName); + } else { + final Type javaType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER + .javaTypeForSchemaDefinitionType(unionType); + if (javaType != null) { + updateUnionTypeAsProperty(unionGenTransObject, javaType, typeName); + } } - genTOsMap.put(typedef.getQName().getLocalName(), - unionGenTransObject.toInstance()); } + if (!regularExpressions.isEmpty()) { + addStringRegExAsConstant(unionGenTransObject, regularExpressions); + } + + genTOsMap.put(typedef.getQName().getLocalName(), unionGenTransObject.toInstance()); + return unionGenTransObject; } + return null; } - private void updateUnionTypeAsProperty( - final GeneratedTOBuilder unionGenTransObject, final Type type, + private void updateUnionTypeAsProperty(final GeneratedTOBuilder unionGenTransObject, final Type type, final String propertyName) { if (unionGenTransObject != null && type != null) { - final GeneratedPropertyBuilder propBuilder = - unionGenTransObject.addProperty(parseToValidParamName( - propertyName)); - propBuilder.addReturnType(type); - propBuilder.setReadOnly(false); - - if (!(type instanceof Enumeration)) { - unionGenTransObject.addEqualsIdentity(propBuilder); - unionGenTransObject.addHashIdentity(propBuilder); - unionGenTransObject.addToStringProperty(propBuilder); + if (!unionGenTransObject.containsProperty(propertyName)) { + final GeneratedPropertyBuilder propBuilder = unionGenTransObject + .addProperty(parseToValidParamName(propertyName)); + propBuilder.setReturnType(type); + + if (!(type instanceof Enumeration)) { + unionGenTransObject.addEqualsIdentity(propBuilder); + unionGenTransObject.addHashIdentity(propBuilder); + unionGenTransObject.addToStringProperty(propBuilder); + } } } } - private GeneratedTOBuilder typedefToTransferObject( - final String basePackageName, final TypeDefinition typedef) { + private GeneratedTOBuilder typedefToTransferObject(final String basePackageName, final TypeDefinition typedef) { - final String packageName = packageNameForGeneratedType(basePackageName, - typedef.getPath()); + final String packageName = packageNameForGeneratedType(basePackageName, typedef.getPath()); final String typeDefTOName = typedef.getQName().getLocalName(); - if ((packageName != null) && (typedef != null) - && (typeDefTOName != null)) { + if ((packageName != null) && (typedef != null) && (typeDefTOName != null)) { final String genTOName = parseToClassName(typeDefTOName); - final GeneratedTOBuilder newType = new GeneratedTOBuilderImpl( - packageName, genTOName); + final GeneratedTOBuilder newType = new GeneratedTOBuilderImpl(packageName, genTOName); return newType; } return null; } + + public GeneratedTOBuilder bitsTypedefToTransferObject(final String basePackageName, + final TypeDefinition typeDef, String typeDefName) { + + if (typeDef == null) { + throw new IllegalArgumentException("typeDef cannot be NULL!"); + } + if (basePackageName == null) { + throw new IllegalArgumentException("Base Package Name cannot be NULL!"); + } + + if (typeDef instanceof BitsTypeDefinition) { + BitsTypeDefinition bitsTypeDefinition = (BitsTypeDefinition) typeDef; + + final String typeName = parseToClassName(typeDefName); + final GeneratedTOBuilder genTOBuilder = new GeneratedTOBuilderImpl(basePackageName, typeName); + + final List bitList = bitsTypeDefinition.getBits(); + GeneratedPropertyBuilder genPropertyBuilder; + for (final Bit bit : bitList) { + String name = bit.getName(); + genPropertyBuilder = genTOBuilder.addProperty(parseToValidParamName(name)); + genPropertyBuilder.setReadOnly(false); + genPropertyBuilder.setReturnType(BaseYangTypes.BOOLEAN_TYPE); + + genTOBuilder.addEqualsIdentity(genPropertyBuilder); + genTOBuilder.addHashIdentity(genPropertyBuilder); + genTOBuilder.addToStringProperty(genPropertyBuilder); + } + + return genTOBuilder; + } + return null; + } + + private List resolveRegExpressionsFromTypedef(ExtendedType typedef) { + final List regExps = new ArrayList(); + if (typedef == null) { + throw new IllegalArgumentException("typedef can't be null"); + } + final TypeDefinition strTypeDef = baseTypeDefForExtendedType(typedef); + if (strTypeDef instanceof StringType) { + final List patternConstraints = typedef.getPatterns(); + if (!patternConstraints.isEmpty()) { + String regEx; + String modifiedRegEx; + for (PatternConstraint patternConstraint : patternConstraints) { + regEx = patternConstraint.getRegularExpression(); + modifiedRegEx = StringEscapeUtils.escapeJava(regEx); + regExps.add(modifiedRegEx); + } + } + } + return regExps; + } + + private void addStringRegExAsConstant(GeneratedTOBuilder genTOBuilder, List regularExpressions) { + if (genTOBuilder == null) + throw new IllegalArgumentException("genTOBuilder can't be null"); + if (regularExpressions == null) + throw new IllegalArgumentException("regularExpressions can't be null"); + + if (!regularExpressions.isEmpty()) { + genTOBuilder.addConstant(Types.listTypeFor(BaseYangTypes.STRING_TYPE), TypeConstants.PATTERN_CONSTANT_NAME, + regularExpressions); + } + } + }