X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fsal%2Fyang-prototype%2Fcode-generator%2Fyang-model-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fyang%2Fmodel%2Fparser%2Fimpl%2FYangModelParserImpl.java;h=27a65c1168f24fa822f1c13175d4c4a5a0cef0e2;hb=6e72d221f55cfac71ee6e594b62cb5af9672614a;hp=81a5c9701f365a9df1f6964615623e18557a077f;hpb=e2ef18c530a0bb668d7806c419fea95edd5aae53;p=controller.git diff --git a/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/model/parser/impl/YangModelParserImpl.java b/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/model/parser/impl/YangModelParserImpl.java index 81a5c9701f..27a65c1168 100644 --- a/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/model/parser/impl/YangModelParserImpl.java +++ b/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/model/parser/impl/YangModelParserImpl.java @@ -14,7 +14,6 @@ import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.Calendar; -import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.HashSet; @@ -41,8 +40,6 @@ 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.model.api.type.BinaryTypeDefinition; -import org.opendaylight.controller.yang.model.api.type.BitsTypeDefinition; -import org.opendaylight.controller.yang.model.api.type.BitsTypeDefinition.Bit; import org.opendaylight.controller.yang.model.api.type.DecimalTypeDefinition; import org.opendaylight.controller.yang.model.api.type.IntegerTypeDefinition; import org.opendaylight.controller.yang.model.api.type.LengthConstraint; @@ -58,14 +55,12 @@ import org.opendaylight.controller.yang.model.parser.builder.api.TypeAwareBuilde import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionBuilder; import org.opendaylight.controller.yang.model.parser.builder.impl.IdentitySchemaNodeBuilder; import org.opendaylight.controller.yang.model.parser.builder.impl.ModuleBuilder; +import org.opendaylight.controller.yang.model.parser.builder.impl.TypedefBuilder; import org.opendaylight.controller.yang.model.parser.builder.impl.UnionTypeBuilder; import org.opendaylight.controller.yang.model.parser.util.TypeConstraints; import org.opendaylight.controller.yang.model.parser.util.YangParseException; -import org.opendaylight.controller.yang.model.util.BinaryType; -import org.opendaylight.controller.yang.model.util.BitsType; -import org.opendaylight.controller.yang.model.util.StringType; +import org.opendaylight.controller.yang.model.util.ExtendedType; import org.opendaylight.controller.yang.model.util.UnknownType; -import org.opendaylight.controller.yang.model.util.YangTypesConverter; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -75,39 +70,37 @@ public class YangModelParserImpl implements YangModelParser { .getLogger(YangModelParserImpl.class); @Override - public Module parseYangModel(String yangFile) { + public Module parseYangModel(final String yangFile) { final Map> modules = resolveModuleBuildersFromStreams(yangFile); - Set result = build(modules); + final Set result = build(modules); return result.iterator().next(); } @Override - public Set parseYangModels(String... yangFiles) { + public Set parseYangModels(final String... yangFiles) { final Map> modules = resolveModuleBuildersFromStreams(yangFiles); - Set result = build(modules); - return result; + return build(modules); } @Override public Set parseYangModelsFromStreams( - InputStream... yangModelStreams) { + final InputStream... yangModelStreams) { final Map> modules = resolveModuleBuildersFromStreams(yangModelStreams); - Set result = build(modules); - return result; + return build(modules); } @Override - public SchemaContext resolveSchemaContext(Set modules) { + public SchemaContext resolveSchemaContext(final Set modules) { return new SchemaContextImpl(modules); } private Map> resolveModuleBuildersFromStreams( String... yangFiles) { InputStream[] streams = new InputStream[yangFiles.length]; + FileInputStream inStream = null; for (int i = 0; i < yangFiles.length; i++) { final String yangFileName = yangFiles[i]; final File yangFile = new File(yangFileName); - FileInputStream inStream = null; try { inStream = new FileInputStream(yangFile); } catch (FileNotFoundException e) { @@ -126,8 +119,9 @@ public class YangModelParserImpl implements YangModelParser { final List trees = parseStreams(yangFiles); final ModuleBuilder[] builders = new ModuleBuilder[trees.size()]; + YangModelParserListenerImpl yangModelParser = null; for (int i = 0; i < trees.size(); i++) { - final YangModelParserListenerImpl yangModelParser = new YangModelParserListenerImpl(); + yangModelParser = new YangModelParserListenerImpl(); walker.walk(yangModelParser, trees.get(i)); builders[i] = yangModelParser.getModuleBuilder(); } @@ -150,7 +144,7 @@ public class YangModelParserImpl implements YangModelParser { } private List parseStreams(InputStream... yangStreams) { - List trees = new ArrayList(); + final List trees = new ArrayList(); for (InputStream yangStream : yangStreams) { trees.add(parseStream(yangStream)); } @@ -178,9 +172,10 @@ public class YangModelParserImpl implements YangModelParser { for (Map.Entry childEntry : entry.getValue() .entrySet()) { ModuleBuilder moduleBuilder = childEntry.getValue(); - validateBuilder(modules, moduleBuilder); + validateModule(modules, moduleBuilder); } } + // build final Set result = new HashSet(); for (Map.Entry> entry : modules @@ -189,19 +184,18 @@ public class YangModelParserImpl implements YangModelParser { for (Map.Entry childEntry : entry.getValue() .entrySet()) { ModuleBuilder moduleBuilder = childEntry.getValue(); - modulesByRevision.put(childEntry.getKey(), - moduleBuilder.build()); - result.add(moduleBuilder.build()); + Module module = moduleBuilder.build(); + modulesByRevision.put(childEntry.getKey(), module); + result.add(module); } } - return result; } - private void validateBuilder( + private void validateModule( Map> modules, ModuleBuilder builder) { - resolveTypedefs(modules, builder); + resolveDirtyNodes(modules, builder); resolveAugments(modules, builder); resolveIdentities(modules, builder); } @@ -215,116 +209,280 @@ public class YangModelParserImpl implements YangModelParser { * @param module * current module */ - private void resolveTypedefs( + private void resolveDirtyNodes( Map> modules, ModuleBuilder module) { - Map, TypeAwareBuilder> dirtyNodes = module.getDirtyNodes(); - if (dirtyNodes.size() == 0) { - return; - } else { + final Map, TypeAwareBuilder> dirtyNodes = module + .getDirtyNodes(); + if (!dirtyNodes.isEmpty()) { for (Map.Entry, TypeAwareBuilder> entry : dirtyNodes .entrySet()) { - TypeAwareBuilder typeToResolve = entry.getValue(); + TypeAwareBuilder typeToResolve = entry.getValue(); if (typeToResolve instanceof UnionTypeBuilder) { - resolveUnionTypeBuilder(modules, module, - (UnionTypeBuilder) typeToResolve); + UnionTypeBuilder union = (UnionTypeBuilder) typeToResolve; + List> unionTypes = union.getTypes(); + List toRemove = new ArrayList(); + for (TypeDefinition td : unionTypes) { + if (td instanceof UnknownType) { + UnknownType unknownType = (UnknownType) td; + TypeDefinitionBuilder resolvedType = findTargetTypeUnion( + typeToResolve, unknownType, modules, module); + union.setType(resolvedType); + toRemove.add(unknownType); + } + } + unionTypes.removeAll(toRemove); } else { - UnknownType ut = (UnknownType) typeToResolve.getType(); - TypeDefinition resolvedType = findTargetType(ut, - modules, module); + TypeDefinitionBuilder resolvedType = findTargetType( + typeToResolve, modules, module); typeToResolve.setType(resolvedType); } } } } - private UnionTypeBuilder resolveUnionTypeBuilder( + private TypeDefinitionBuilder findTargetType( + TypeAwareBuilder typeToResolve, + Map> modules, + ModuleBuilder builder) { + TypeConstraints constraints = new TypeConstraints(); + + TypeDefinitionBuilder targetType = findTypedef(typeToResolve, modules, + builder); + TypeConstraints tConstraints = findConstraints(typeToResolve, + constraints, modules, builder); + targetType.setRanges(tConstraints.getRange()); + targetType.setLengths(tConstraints.getLength()); + targetType.setPatterns(tConstraints.getPatterns()); + targetType.setFractionDigits(tConstraints.getFractionDigits()); + + return targetType; + } + + private TypeDefinitionBuilder findTargetTypeUnion( + TypeAwareBuilder typeToResolve, UnknownType unknownType, + Map> modules, + ModuleBuilder builder) { + TypeConstraints constraints = new TypeConstraints(); + + TypeDefinitionBuilder targetType = findTypedefUnion(typeToResolve, + unknownType, modules, builder); + TypeConstraints tConstraints = findConstraints(typeToResolve, + constraints, modules, builder); + targetType.setRanges(tConstraints.getRange()); + targetType.setLengths(tConstraints.getLength()); + targetType.setPatterns(tConstraints.getPatterns()); + targetType.setFractionDigits(tConstraints.getFractionDigits()); + + return targetType; + } + + private TypeDefinitionBuilder findTypedef(TypeAwareBuilder typeToResolve, + Map> modules, + ModuleBuilder builder) { + + TypeDefinition baseTypeToResolve = typeToResolve.getType(); + if (baseTypeToResolve != null + && !(baseTypeToResolve instanceof UnknownType)) { + return (TypeDefinitionBuilder) typeToResolve; + } + + UnknownType unknownType = (UnknownType) typeToResolve.getType(); + + QName unknownTypeQName = unknownType.getQName(); + String unknownTypeName = unknownTypeQName.getLocalName(); + String unknownTypePrefix = unknownTypeQName.getPrefix(); + + // search for module which contains referenced typedef + ModuleBuilder dependentModule = findDependentModule(modules, builder, + unknownTypePrefix); + TypeDefinitionBuilder lookedUpBuilder = findTypedefBuilder( + dependentModule.getModuleTypedefs(), unknownTypeName); + + TypeDefinitionBuilder lookedUpBuilderCopy = copyTypedefBuilder( + lookedUpBuilder, typeToResolve instanceof TypeDefinitionBuilder); + TypeDefinitionBuilder resolvedCopy = resolveCopiedBuilder( + lookedUpBuilderCopy, modules, dependentModule); + return resolvedCopy; + } + + private TypeDefinitionBuilder findTypedefUnion( + TypeAwareBuilder typeToResolve, UnknownType unknownType, Map> modules, - ModuleBuilder builder, UnionTypeBuilder unionTypeBuilderToResolve) { - List> resolvedTypes = new ArrayList>(); - List> typesToRemove = new ArrayList>(); - - for (TypeDefinition td : unionTypeBuilderToResolve.getTypes()) { - if (td instanceof UnknownType) { - TypeDefinition resolvedType = findTargetType( - (UnknownType) td, modules, builder); - resolvedTypes.add(resolvedType); - typesToRemove.add(td); + ModuleBuilder builder) { + + TypeDefinition baseTypeToResolve = typeToResolve.getType(); + if (baseTypeToResolve != null + && !(baseTypeToResolve instanceof UnknownType)) { + return (TypeDefinitionBuilder) typeToResolve; + } + + QName unknownTypeQName = unknownType.getQName(); + String unknownTypeName = unknownTypeQName.getLocalName(); + String unknownTypePrefix = unknownTypeQName.getPrefix(); + + // search for module which contains referenced typedef + ModuleBuilder dependentModule = findDependentModule(modules, builder, + unknownTypePrefix); + TypeDefinitionBuilder lookedUpBuilder = findTypedefBuilder( + dependentModule.getModuleTypedefs(), unknownTypeName); + + TypeDefinitionBuilder lookedUpBuilderCopy = copyTypedefBuilder( + lookedUpBuilder, typeToResolve instanceof TypeDefinitionBuilder); + TypeDefinitionBuilder resolvedCopy = resolveCopiedBuilder( + lookedUpBuilderCopy, modules, dependentModule); + return resolvedCopy; + } + + private TypeDefinitionBuilder copyTypedefBuilder(TypeDefinitionBuilder old, + boolean seekByTypedefBuilder) { + if (old instanceof UnionTypeBuilder) { + UnionTypeBuilder oldUnion = (UnionTypeBuilder) old; + UnionTypeBuilder newUnion = new UnionTypeBuilder(); + for (TypeDefinition td : oldUnion.getTypes()) { + newUnion.setType(td); + } + for (TypeDefinitionBuilder tdb : oldUnion.getTypedefs()) { + newUnion.setType(copyTypedefBuilder(tdb, true)); } + return newUnion; } - List> unionTypeBuilderTypes = unionTypeBuilderToResolve - .getTypes(); - unionTypeBuilderTypes.addAll(resolvedTypes); - unionTypeBuilderTypes.removeAll(typesToRemove); + QName oldQName = old.getQName(); + QName newQName = new QName(oldQName.getNamespace(), + oldQName.getRevision(), oldQName.getPrefix(), + oldQName.getLocalName()); + TypeDefinitionBuilder tdb = new TypedefBuilder(newQName); + + tdb.setRanges(old.getRanges()); + tdb.setLengths(old.getLengths()); + tdb.setPatterns(old.getPatterns()); - return unionTypeBuilderToResolve; + TypeDefinition oldType = old.getType(); + if (oldType == null) { + tdb.setType(old.getTypedef()); + } else { + tdb.setType(oldType); + } + + if (!seekByTypedefBuilder) { + tdb.setDescription(old.getDescription()); + tdb.setReference(old.getReference()); + tdb.setStatus(old.getStatus()); + tdb.setDefaultValue(old.getDefaultValue()); + tdb.setUnits(old.getUnits()); + } + return tdb; } - private TypeDefinition findTargetType(UnknownType ut, + private TypeDefinitionBuilder resolveCopiedBuilder( + TypeDefinitionBuilder copied, Map> modules, ModuleBuilder builder) { - TypeConstraints constraints = new TypeConstraints(); - // RANGE - List ranges = ut.getRangeStatements(); - constraints.addRanges(ranges); - // LENGTH - List lengths = ut.getLengthStatements(); - constraints.addLengths(lengths); - // PATTERN - List patterns = ut.getPatterns(); - constraints.addPatterns(patterns); - // Fraction Digits - Integer fractionDigits = ut.getFractionDigits(); - - Map foundedTypeDefinitionBuilder = findTypeDefinitionBuilderWithConstraints( - constraints, modules, ut, builder); - TypeDefinitionBuilder targetType = foundedTypeDefinitionBuilder - .entrySet().iterator().next().getKey(); - - TypeDefinition targetTypeBaseType = targetType.getBaseType(); - targetTypeBaseType = mergeConstraints(targetTypeBaseType, constraints, - fractionDigits); - - return targetTypeBaseType; + if (copied instanceof UnionTypeBuilder) { + UnionTypeBuilder union = (UnionTypeBuilder) copied; + List> unionTypes = union.getTypes(); + List toRemove = new ArrayList(); + for (TypeDefinition td : unionTypes) { + if (td instanceof UnknownType) { + UnknownType unknownType = (UnknownType) td; + TypeDefinitionBuilder resolvedType = findTargetTypeUnion( + union, unknownType, modules, builder); + union.setType(resolvedType); + toRemove.add(unknownType); + } + } + unionTypes.removeAll(toRemove); + + return union; + } + + TypeDefinition base = copied.getType(); + TypeDefinitionBuilder baseTdb = copied.getTypedef(); + if (base != null && !(base instanceof UnknownType)) { + return copied; + } else if (base instanceof UnknownType) { + UnknownType unknownType = (UnknownType) base; + QName unknownTypeQName = unknownType.getQName(); + String unknownTypePrefix = unknownTypeQName.getPrefix(); + ModuleBuilder dependentModule = findDependentModule(modules, + builder, unknownTypePrefix); + TypeDefinitionBuilder unknownTypeBuilder = findTypedef(copied, + modules, dependentModule); + copied.setType(unknownTypeBuilder); + return copied; + } else if (base == null && baseTdb != null) { + // make a copy of baseTypeDef and call again + TypeDefinitionBuilder baseTdbCopy = copyTypedefBuilder(baseTdb, + true); + TypeDefinitionBuilder baseTdbCopyResolved = resolveCopiedBuilder( + baseTdbCopy, modules, builder); + copied.setType(baseTdbCopyResolved); + return copied; + } else { + throw new IllegalStateException( + "TypeDefinitionBuilder in unexpected state"); + } } - /** - * Traverse through all referenced types chain until base YANG type is - * founded. - * - * @param constraints - * current type constraints - * @param modules - * all available modules - * @param unknownType - * unknown type - * @param builder - * current module - * @return map, where key is type referenced and value is its constraints - */ - private Map findTypeDefinitionBuilderWithConstraints( - TypeConstraints constraints, + private TypeDefinitionBuilder findTypedef(QName unknownTypeQName, Map> modules, - UnknownType unknownType, ModuleBuilder builder) { - Map result = new HashMap(); - QName unknownTypeQName = unknownType.getQName(); + ModuleBuilder builder) { + String unknownTypeName = unknownTypeQName.getLocalName(); String unknownTypePrefix = unknownTypeQName.getPrefix(); // search for module which contains referenced typedef - ModuleBuilder dependentModuleBuilder = findDependentModule(modules, - builder, unknownTypePrefix); + ModuleBuilder dependentModule = findDependentModule(modules, builder, + unknownTypePrefix); TypeDefinitionBuilder lookedUpBuilder = findTypedefBuilder( - dependentModuleBuilder.getModuleTypedefs(), unknownTypeName); + dependentModule.getModuleTypedefs(), unknownTypeName); + + TypeDefinitionBuilder copied = copyTypedefBuilder(lookedUpBuilder, true); + return copied; + } + + private TypeConstraints findConstraints(TypeAwareBuilder typeToResolve, + TypeConstraints constraints, + Map> modules, + ModuleBuilder builder) { + + // union type cannot be restricted + if (typeToResolve instanceof UnionTypeBuilder) { + return constraints; + } // if referenced type is UnknownType again, search recursively with // current constraints - TypeDefinition referencedType = lookedUpBuilder.getBaseType(); - if (referencedType instanceof UnknownType) { + TypeDefinition referencedType = typeToResolve.getType(); + if (referencedType == null) { + TypeDefinitionBuilder tdb = (TypeDefinitionBuilder) typeToResolve; + final List ranges = tdb.getRanges(); + constraints.addRanges(ranges); + final List lengths = tdb.getLengths(); + constraints.addLengths(lengths); + final List patterns = tdb.getPatterns(); + constraints.addPatterns(patterns); + final Integer fractionDigits = tdb.getFractionDigits(); + constraints.setFractionDigits(fractionDigits); + return constraints; + } else if (referencedType instanceof ExtendedType) { + ExtendedType ext = (ExtendedType) referencedType; + final List ranges = ext.getRanges(); + constraints.addRanges(ranges); + final List lengths = ext.getLengths(); + constraints.addLengths(lengths); + final List patterns = ext.getPatterns(); + constraints.addPatterns(patterns); + final Integer fractionDigits = ext.getFractionDigits(); + constraints.setFractionDigits(fractionDigits); + return findConstraints( + findTypedef(ext.getQName(), modules, builder), constraints, + modules, builder); + } else if (referencedType instanceof UnknownType) { UnknownType unknown = (UnknownType) referencedType; final List ranges = unknown.getRangeStatements(); @@ -334,13 +492,25 @@ public class YangModelParserImpl implements YangModelParser { constraints.addLengths(lengths); final List patterns = unknown.getPatterns(); constraints.addPatterns(patterns); - return findTypeDefinitionBuilderWithConstraints(constraints, - modules, unknown, dependentModuleBuilder); + final Integer fractionDigits = unknown.getFractionDigits(); + constraints.setFractionDigits(fractionDigits); + + String unknownTypePrefix = unknown.getQName().getPrefix(); + if (unknownTypePrefix == null || "".equals(unknownTypePrefix)) { + unknownTypePrefix = builder.getPrefix(); + } + ModuleBuilder dependentModule = findDependentModule(modules, + builder, unknown.getQName().getPrefix()); + TypeDefinitionBuilder unknownTypeBuilder = findTypedef( + unknown.getQName(), modules, builder); + return findConstraints(unknownTypeBuilder, constraints, modules, + dependentModule); } else { + // HANDLE BASE YANG TYPE mergeConstraints(referencedType, constraints); - result.put(lookedUpBuilder, constraints); - return result; + return constraints; } + } /** @@ -370,55 +540,7 @@ public class YangModelParserImpl implements YangModelParser { } /** - * Merge curent constraints with founded type constraints - * - * @param targetTypeBaseType - * @param constraints - * @param fractionDigits - * @return - */ - private TypeDefinition mergeConstraints( - TypeDefinition targetTypeBaseType, TypeConstraints constraints, - Integer fractionDigits) { - String targetTypeBaseTypeName = targetTypeBaseType.getQName() - .getLocalName(); - // enumeration, leafref and identityref omitted because they have no - // restrictions - if (targetTypeBaseType instanceof DecimalTypeDefinition) { - List ranges = constraints.getRange(); - Integer fd = fractionDigits == null ? constraints - .getFractionDigits() : fractionDigits; - targetTypeBaseType = YangTypesConverter - .javaTypeForBaseYangDecimal64Type(ranges, fd); - } else if (targetTypeBaseType instanceof IntegerTypeDefinition) { - List ranges = constraints.getRange(); - if (targetTypeBaseTypeName.startsWith("int")) { - targetTypeBaseType = YangTypesConverter - .javaTypeForBaseYangSignedIntegerType( - targetTypeBaseTypeName, ranges); - } else { - targetTypeBaseType = YangTypesConverter - .javaTypeForBaseYangUnsignedIntegerType( - targetTypeBaseTypeName, ranges); - } - } else if (targetTypeBaseType instanceof StringTypeDefinition) { - List lengths = constraints.getLength(); - List patterns = constraints.getPatterns(); - targetTypeBaseType = new StringType(lengths, patterns); - } else if (targetTypeBaseType instanceof BitsTypeDefinition) { - BitsTypeDefinition bitsType = (BitsTypeDefinition) targetTypeBaseType; - List bits = bitsType.getBits(); - targetTypeBaseType = new BitsType(bits); - } else if (targetTypeBaseType instanceof BinaryTypeDefinition) { - List lengths = constraints.getLength(); - List bytes = Collections.emptyList(); - targetTypeBaseType = new BinaryType(bytes, lengths, null); - } - return targetTypeBaseType; - } - - /** - * Pull restriction from base type and add them to given constraints + * Pull restriction from referenced type and add them to given constraints * * @param referencedType * @param constraints @@ -609,9 +731,9 @@ public class YangModelParserImpl implements YangModelParser { } private Date createEpochTime() { - Calendar c = Calendar.getInstance(); - c.setTimeInMillis(0); - return c.getTime(); + Calendar calendar = Calendar.getInstance(); + calendar.setTimeInMillis(0); + return calendar.getTime(); } private static class SchemaContextImpl implements SchemaContext {