X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?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=f650004ba22e92d9bb419305edcd4e1d16c81540;hb=refs%2Fchanges%2F03%2F703%2F1;hp=6bb7907a74ab50be2720c4c37fb75ec4f1cd794d;hpb=a1124bebabbd033f4f19f991ce8e3b0b45e18d29;p=controller.git 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 6bb7907a74..f650004ba2 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 @@ -28,11 +28,15 @@ 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.util.ExtendedType; +import org.opendaylight.controller.yang.model.util.StringType; +import org.opendaylight.controller.yang.model.util.UnionType; + import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; +import java.util.TreeMap; import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.*; import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.*; @@ -54,42 +58,38 @@ 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!"); } 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!"); @@ -106,14 +106,11 @@ public final class TypeProviderImpl implements TypeProvider { 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); } @@ -131,8 +128,7 @@ public final class TypeProviderImpl implements TypeProvider { 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 @@ -167,14 +163,14 @@ 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!"); } 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!"); @@ -184,14 +180,11 @@ public final class TypeProviderImpl implements TypeProvider { 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); } @@ -201,8 +194,7 @@ 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!"); } @@ -229,26 +221,22 @@ public final class TypeProviderImpl implements TypeProvider { final String strXPath = xpath.toString(); if (strXPath != null) { - if (strXPath.matches(".*//[.* | .*//].*")) { + if (strXPath.contains("[")) { returnType = Types.typeForClass(Object.class); } else { - final Module module = findParentModuleForTypeDefinition( - schemaContext, leafrefType); + final Module module = findParentModuleForTypeDefinition(schemaContext, leafrefType); 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); } @@ -278,8 +266,7 @@ 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!"); } @@ -295,18 +282,15 @@ public final class TypeProviderImpl implements TypeProvider { final String enumerationName = parseToClassName(enumName); - Module module = findParentModuleForTypeDefinition(schemaContext, - enumTypeDef); + 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!"); @@ -325,24 +309,21 @@ public final class TypeProviderImpl implements TypeProvider { } 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) { @@ -382,56 +363,55 @@ 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 List> listTypeDefinitions = sortTypeDefinitionAccordingDepth(typeDefinitions); final Map typeMap = new HashMap<>(); genTypeDefsContextMap.put(moduleName, typeMap); - if ((typeDefinitions != null) && (basePackageName != null)) { - for (final TypeDefinition typedef : typeDefinitions) { + if ((listTypeDefinitions != null) && (basePackageName != null)) { + for (final TypeDefinition typedef : listTypeDefinitions) { typedefToGeneratedType(basePackageName, moduleName, typedef); } - final List extUnions = UnionDependencySort - .sort(typeDefinitions); - for (final ExtendedType extUnionType : extUnions) { - addUnionGeneratedTypeDefinition(basePackageName, - extUnionType); - } } } } - 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); - if (!(baseTypeDefinition instanceof LeafrefTypeDefinition) - && !(baseTypeDefinition instanceof IdentityrefTypeDefinition)) { - Type returnType; - if (baseTypeDefinition instanceof EnumTypeDefinition) { - final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) baseTypeDefinition; - returnType = resolveEnumFromTypeDefinition(enumTypeDef, + final TypeDefinition innerTypeDefinition = typedef.getBaseType(); + if (!(innerTypeDefinition instanceof LeafrefTypeDefinition) + && !(innerTypeDefinition instanceof IdentityrefTypeDefinition)) { + Type returnType = null; + if (innerTypeDefinition instanceof ExtendedType) { + ExtendedType extendedTypeDef = (ExtendedType) innerTypeDefinition; + returnType = resolveExtendedTypeFromTypeDef(extendedTypeDef, basePackageName, typedefName, + moduleName); + } else if (innerTypeDefinition instanceof UnionTypeDefinition) { + final GeneratedTOBuilder genTOBuilder = addUnionGeneratedTypeDefinition(basePackageName, typedef, typedefName); + returnType = genTOBuilder.toInstance(); + } else if (innerTypeDefinition instanceof EnumTypeDefinition) { + final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) innerTypeDefinition; + returnType = resolveEnumFromTypeDefinition(enumTypeDef, typedefName); - } else if (baseTypeDefinition instanceof BitsTypeDefinition) { - final BitsTypeDefinition bitsTypeDefinition = (BitsTypeDefinition) baseTypeDefinition; - returnType = bitsTypedefToTransferObject(bitsTypeDefinition, - basePackageName, typedefName); + } else if (innerTypeDefinition instanceof BitsTypeDefinition) { + final BitsTypeDefinition bitsTypeDefinition = (BitsTypeDefinition) innerTypeDefinition; + final GeneratedTOBuilder genTOBuilder = bitsTypedefToTransferObject(basePackageName, + bitsTypeDefinition, typedefName); + returnType = genTOBuilder.toInstance(); } else { final Type javaType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER - .javaTypeForSchemaDefinitionType(baseTypeDefinition); + .javaTypeForSchemaDefinitionType(innerTypeDefinition); - 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); } @@ -442,18 +422,15 @@ 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.setReturnType(javaType); genTOBuilder.addEqualsIdentity(genPropBuilder); @@ -461,28 +438,17 @@ public final class TypeProviderImpl implements TypeProvider { genTOBuilder.addToStringProperty(genPropBuilder); if (javaType == BaseYangTypes.STRING_TYPE) { if (typedef instanceof ExtendedType) { - List patternConstraints = ((ExtendedType) typedef).getPatterns(); - List regularExpressions = new ArrayList(); - String regEx; - String modifiedRegEx; - for (PatternConstraint ptrnCons : patternConstraints) { - regEx = ptrnCons.getRegularExpression(); - modifiedRegEx = StringEscapeUtils.escapeJava(regEx); - regularExpressions.add(modifiedRegEx); - } - - genTOBuilder.addConstant(Types.listTypeFor(BaseYangTypes.STRING_TYPE), - TypeConstants.PATTERN_CONSTANT_NAME, regularExpressions); + 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!"); } @@ -490,131 +456,276 @@ public final class TypeProviderImpl implements TypeProvider { 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); 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()); + Type genTransferObject = null; + if (innerGenTOs != null) { + genTransferObject = innerGenTOs.get(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); + 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); + } } - 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.setReturnType(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; } - private GeneratedTransferObject bitsTypedefToTransferObject( - final BitsTypeDefinition bitsTypeDefinition, final String basePackageName, final String typedefName) { + public GeneratedTOBuilder bitsTypedefToTransferObject(final String basePackageName, + final TypeDefinition typeDef, String typeDefName) { - if (bitsTypeDefinition == null) { - throw new IllegalArgumentException("Bits TypeDefinition cannot be NULL!"); + 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); + } + } + + private GeneratedTransferObject resolveExtendedTypeFromTypeDef(final ExtendedType extendedType, + final String basePackageName, final String typedefName, final String moduleName) { + + if (extendedType == null) { + throw new IllegalArgumentException("Extended type cannot be NULL!"); + } + if (basePackageName == null) { + throw new IllegalArgumentException("String with base package name cannot be NULL!"); + } if (typedefName == null) { - throw new IllegalArgumentException("Type Definition Local Name cannot be NULL!"); + throw new IllegalArgumentException("String with type definition name cannot be NULL!"); } final String typeDefName = parseToClassName(typedefName); + final String lowTypeDef = extendedType.getQName().getLocalName(); final GeneratedTOBuilder genTOBuilder = new GeneratedTOBuilderImpl(basePackageName, typeDefName); - 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); + final Map typeMap = genTypeDefsContextMap.get(moduleName); + if (typeMap != null) { + Type type = typeMap.get(lowTypeDef); + if (type instanceof GeneratedTransferObject) { + genTOBuilder.setExtendsType((GeneratedTransferObject) type); + } } + return genTOBuilder.toInstance(); } - + + /** + * The method find out for each type definition how many immersion (depth) + * is necessary to get to the base type. Every type definition is inserted + * to the map which key is depth and value is list of type definitions with + * equal depth. In next step are lists from this map concatenated to one + * list in ascending order according to their depth. All type definitions + * are in the list behind all type definitions on which depends. + * + * @param unsortedTypeDefinitions + * represents list of type definitions + * @return list of type definitions sorted according their each other + * dependencies (type definitions which are depend on other type + * definitions are in list behind them). + */ + private List> sortTypeDefinitionAccordingDepth( + final Set> unsortedTypeDefinitions) { + List> sortedTypeDefinition = new ArrayList<>(); + + Map>> typeDefinitionsDepths = new TreeMap<>(); + for (TypeDefinition unsortedTypeDefinition : unsortedTypeDefinitions) { + final int depth = getTypeDefinitionDepth(unsortedTypeDefinition); + List> typeDefinitionsConcreteDepth = typeDefinitionsDepths.get(depth); + if (typeDefinitionsConcreteDepth == null) { + typeDefinitionsConcreteDepth = new ArrayList>(); + typeDefinitionsDepths.put(depth, typeDefinitionsConcreteDepth); + } + typeDefinitionsConcreteDepth.add(unsortedTypeDefinition); + } + + Set depths = typeDefinitionsDepths.keySet(); // keys are in + // ascending order + for (Integer depth : depths) { + sortedTypeDefinition.addAll(typeDefinitionsDepths.get(depth)); + } + + return sortedTypeDefinition; + } + + /** + * The method return how many immersion is necessary to get from type + * definition to base type. + * + * @param typeDefinition + * is type definition for which is depth looked for. + * @return how many immersion is necessary to get from type definition to + * base type + */ + private int getTypeDefinitionDepth(final TypeDefinition typeDefinition) { + if (typeDefinition == null) { + throw new IllegalArgumentException("Type definition can't be null"); + } + int depth = 1; + TypeDefinition baseType = typeDefinition.getBaseType(); + + if (baseType instanceof ExtendedType) { + depth = depth + getTypeDefinitionDepth(typeDefinition.getBaseType()); + } else if (baseType instanceof UnionType) { + List> childTypeDefinitions = ((UnionType) baseType).getTypes(); + int maxChildDepth = 0; + int childDepth = 1; + for (TypeDefinition childTypeDefinition : childTypeDefinitions) { + childDepth = childDepth + getTypeDefinitionDepth(childTypeDefinition.getBaseType()); + if (childDepth > maxChildDepth) { + maxChildDepth = childDepth; + } + } + return maxChildDepth; + } + return depth; + } + }