-/*\r
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.\r
- *\r
- * This program and the accompanying materials are made available under the\r
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
- * and is available at http://www.eclipse.org/legal/epl-v10.html\r
- */\r
-package org.opendaylight.yangtools.yang.parser.impl;\r
-\r
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.*;\r
-import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.*;\r
-\r
-import java.io.File;\r
-import java.io.FileInputStream;\r
-import java.io.FileNotFoundException;\r
-import java.io.IOException;\r
-import java.io.InputStream;\r
-import java.util.ArrayList;\r
-import java.util.Collections;\r
-import java.util.Date;\r
-import java.util.HashMap;\r
-import java.util.LinkedHashMap;\r
-import java.util.LinkedHashSet;\r
-import java.util.List;\r
-import java.util.Map;\r
-import java.util.Map.Entry;\r
-import java.util.Set;\r
-import java.util.TreeMap;\r
-\r
-import org.antlr.v4.runtime.ANTLRInputStream;\r
-import org.antlr.v4.runtime.CommonTokenStream;\r
-import org.antlr.v4.runtime.tree.ParseTree;\r
-import org.antlr.v4.runtime.tree.ParseTreeWalker;\r
-import org.opendaylight.yangtools.antlrv4.code.gen.YangLexer;\r
-import org.opendaylight.yangtools.antlrv4.code.gen.YangParser;\r
-import org.opendaylight.yangtools.yang.common.QName;\r
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;\r
-import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;\r
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;\r
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;\r
-import org.opendaylight.yangtools.yang.model.api.Module;\r
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;\r
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;\r
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;\r
-import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;\r
-import org.opendaylight.yangtools.yang.model.util.IdentityrefType;\r
-import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;\r
-import org.opendaylight.yangtools.yang.parser.builder.api.Builder;\r
-import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;\r
-import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;\r
-import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;\r
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;\r
-import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;\r
-import org.opendaylight.yangtools.yang.parser.builder.impl.DeviationBuilder;\r
-import org.opendaylight.yangtools.yang.parser.builder.impl.ExtensionBuilder;\r
-import org.opendaylight.yangtools.yang.parser.builder.impl.IdentitySchemaNodeBuilder;\r
-import org.opendaylight.yangtools.yang.parser.builder.impl.IdentityrefTypeBuilder;\r
-import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;\r
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;\r
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;\r
-import org.opendaylight.yangtools.yang.parser.util.GroupingUtils;\r
-import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;\r
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;\r
-import org.opendaylight.yangtools.yang.parser.util.YangParseException;\r
-import org.opendaylight.yangtools.yang.validator.YangModelBasicValidator;\r
-import org.slf4j.Logger;\r
-import org.slf4j.LoggerFactory;\r
-\r
-import com.google.common.collect.Lists;\r
-import com.google.common.collect.Maps;\r
-import com.google.common.collect.Sets;\r
-\r
-public final class YangParserImpl implements YangModelParser {\r
- private static final Logger LOG = LoggerFactory.getLogger(YangParserImpl.class);\r
-\r
- @Override\r
- public Set<Module> parseYangModels(final List<File> yangFiles) {\r
- return Sets.newLinkedHashSet(parseYangModelsMapped(yangFiles).values());\r
- }\r
-\r
- @Override\r
- public Set<Module> parseYangModels(final List<File> yangFiles, final SchemaContext context) {\r
- if (yangFiles != null) {\r
- final Map<InputStream, File> inputStreams = Maps.newHashMap();\r
-\r
- for (final File yangFile : yangFiles) {\r
- try {\r
- inputStreams.put(new FileInputStream(yangFile), yangFile);\r
- } catch (FileNotFoundException e) {\r
- LOG.warn("Exception while reading yang file: " + yangFile.getName(), e);\r
- }\r
- }\r
-\r
- Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();\r
-\r
- final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(\r
- Lists.newArrayList(inputStreams.keySet()), builderToStreamMap);\r
-\r
- for (InputStream is : inputStreams.keySet()) {\r
- try {\r
- is.close();\r
- } catch (IOException e) {\r
- LOG.debug("Failed to close stream.");\r
- }\r
- }\r
-\r
- return new LinkedHashSet<Module>(buildWithContext(modules, context).values());\r
- }\r
- return Collections.emptySet();\r
- }\r
-\r
- @Override\r
- public Set<Module> parseYangModelsFromStreams(final List<InputStream> yangModelStreams) {\r
- return Sets.newHashSet(parseYangModelsFromStreamsMapped(yangModelStreams).values());\r
- }\r
-\r
- @Override\r
- public Set<Module> parseYangModelsFromStreams(final List<InputStream> yangModelStreams, SchemaContext context) {\r
- if (yangModelStreams != null) {\r
- Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();\r
- final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuildersWithContext(\r
- yangModelStreams, builderToStreamMap, context);\r
- return new LinkedHashSet<Module>(buildWithContext(modules, context).values());\r
- }\r
- return Collections.emptySet();\r
- }\r
-\r
- @Override\r
- public Map<File, Module> parseYangModelsMapped(List<File> yangFiles) {\r
- if (yangFiles != null) {\r
- final Map<InputStream, File> inputStreams = Maps.newHashMap();\r
-\r
- for (final File yangFile : yangFiles) {\r
- try {\r
- inputStreams.put(new FileInputStream(yangFile), yangFile);\r
- } catch (FileNotFoundException e) {\r
- LOG.warn("Exception while reading yang file: " + yangFile.getName(), e);\r
- }\r
- }\r
-\r
- Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();\r
- final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(\r
- Lists.newArrayList(inputStreams.keySet()), builderToStreamMap);\r
-\r
- for (InputStream is : inputStreams.keySet()) {\r
- try {\r
- is.close();\r
- } catch (IOException e) {\r
- LOG.debug("Failed to close stream.");\r
- }\r
- }\r
-\r
- Map<File, Module> retVal = Maps.newLinkedHashMap();\r
- Map<ModuleBuilder, Module> builderToModuleMap = build(modules);\r
-\r
- for (Entry<ModuleBuilder, Module> builderToModule : builderToModuleMap.entrySet()) {\r
- retVal.put(inputStreams.get(builderToStreamMap.get(builderToModule.getKey())),\r
- builderToModule.getValue());\r
- }\r
-\r
- return retVal;\r
- }\r
- return Collections.emptyMap();\r
- }\r
-\r
- @Override\r
- public Map<InputStream, Module> parseYangModelsFromStreamsMapped(final List<InputStream> yangModelStreams) {\r
- Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();\r
-\r
- final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(yangModelStreams,\r
- builderToStreamMap);\r
- Map<InputStream, Module> retVal = Maps.newLinkedHashMap();\r
- Map<ModuleBuilder, Module> builderToModuleMap = build(modules);\r
-\r
- for (Entry<ModuleBuilder, Module> builderToModule : builderToModuleMap.entrySet()) {\r
- retVal.put(builderToStreamMap.get(builderToModule.getKey()), builderToModule.getValue());\r
- }\r
- return retVal;\r
- }\r
-\r
- @Override\r
- public SchemaContext resolveSchemaContext(final Set<Module> modules) {\r
- return new SchemaContextImpl(modules);\r
- }\r
-\r
- private ModuleBuilder[] parseModuleBuilders(List<InputStream> inputStreams,\r
- Map<ModuleBuilder, InputStream> streamToBuilderMap) {\r
-\r
- final ParseTreeWalker walker = new ParseTreeWalker();\r
- final List<ParseTree> trees = parseStreams(inputStreams);\r
- final ModuleBuilder[] builders = new ModuleBuilder[trees.size()];\r
-\r
- // validate yang\r
- new YangModelBasicValidator(walker).validate(trees);\r
-\r
- YangParserListenerImpl yangModelParser = null;\r
- for (int i = 0; i < trees.size(); i++) {\r
- yangModelParser = new YangParserListenerImpl();\r
- walker.walk(yangModelParser, trees.get(i));\r
- ModuleBuilder moduleBuilder = yangModelParser.getModuleBuilder();\r
-\r
- // We expect the order of trees and streams has to be the same\r
- streamToBuilderMap.put(moduleBuilder, inputStreams.get(i));\r
- builders[i] = moduleBuilder;\r
- }\r
- return builders;\r
- }\r
-\r
- private Map<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuilders(final List<InputStream> yangFileStreams,\r
- Map<ModuleBuilder, InputStream> streamToBuilderMap) {\r
- return resolveModuleBuildersWithContext(yangFileStreams, streamToBuilderMap, null);\r
- }\r
-\r
- private Map<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuildersWithContext(\r
- final List<InputStream> yangFileStreams, final Map<ModuleBuilder, InputStream> streamToBuilderMap,\r
- final SchemaContext context) {\r
- final ModuleBuilder[] builders = parseModuleBuilders(yangFileStreams, streamToBuilderMap);\r
-\r
- // LinkedHashMap must be used to preserve order\r
- final LinkedHashMap<String, TreeMap<Date, ModuleBuilder>> modules = new LinkedHashMap<String, TreeMap<Date, ModuleBuilder>>();\r
-\r
- // module dependency graph sorted\r
- List<ModuleBuilder> sorted = null;\r
- if (context == null) {\r
- sorted = ModuleDependencySort.sort(builders);\r
- } else {\r
- sorted = ModuleDependencySort.sortWithContext(context, builders);\r
- }\r
-\r
- for (final ModuleBuilder builder : sorted) {\r
- if (builder == null) {\r
- continue;\r
- }\r
- final String builderName = builder.getName();\r
- Date builderRevision = builder.getRevision();\r
- if (builderRevision == null) {\r
- builderRevision = new Date(0L);\r
- }\r
- TreeMap<Date, ModuleBuilder> builderByRevision = modules.get(builderName);\r
- if (builderByRevision == null) {\r
- builderByRevision = new TreeMap<Date, ModuleBuilder>();\r
- }\r
- builderByRevision.put(builderRevision, builder);\r
- modules.put(builderName, builderByRevision);\r
- }\r
- return modules;\r
- }\r
-\r
- private List<ParseTree> parseStreams(final List<InputStream> yangStreams) {\r
- final List<ParseTree> trees = new ArrayList<ParseTree>();\r
- for (InputStream yangStream : yangStreams) {\r
- trees.add(parseStream(yangStream));\r
- }\r
- return trees;\r
- }\r
-\r
- private ParseTree parseStream(final InputStream yangStream) {\r
- ParseTree result = null;\r
- try {\r
- final ANTLRInputStream input = new ANTLRInputStream(yangStream);\r
- final YangLexer lexer = new YangLexer(input);\r
- final CommonTokenStream tokens = new CommonTokenStream(lexer);\r
- final YangParser parser = new YangParser(tokens);\r
- parser.removeErrorListeners();\r
- parser.addErrorListener(new YangErrorListener());\r
-\r
- result = parser.yang();\r
- } catch (IOException e) {\r
- LOG.warn("Exception while reading yang file: " + yangStream, e);\r
- }\r
- return result;\r
- }\r
-\r
- private Map<ModuleBuilder, Module> build(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {\r
- // fix unresolved nodes\r
- findUsesTargets(modules, null);\r
- resolveDirtyNodes(modules);\r
- resolveAugments(modules);\r
- resolveUses(modules);\r
- resolveDeviations(modules);\r
-\r
- // build\r
- final Map<ModuleBuilder, Module> result = new LinkedHashMap<ModuleBuilder, Module>();\r
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
- final Map<Date, Module> modulesByRevision = new HashMap<Date, Module>();\r
- for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {\r
- final ModuleBuilder moduleBuilder = childEntry.getValue();\r
- final Module module = moduleBuilder.build();\r
- modulesByRevision.put(childEntry.getKey(), module);\r
- result.put(moduleBuilder, module);\r
- }\r
- }\r
- return result;\r
- }\r
-\r
- private Map<ModuleBuilder, Module> buildWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
- final SchemaContext context) {\r
- // fix unresolved nodes\r
- findUsesTargets(modules, context);\r
- resolvedDirtyNodesWithContext(modules, context);\r
- resolveAugmentsWithContext(modules, context);\r
- resolveUsesWithContext(modules, context);\r
- resolveDeviationsWithContext(modules, context);\r
-\r
- // build\r
- final Map<ModuleBuilder, Module> result = new LinkedHashMap<ModuleBuilder, Module>();\r
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
- final Map<Date, Module> modulesByRevision = new HashMap<Date, Module>();\r
- for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {\r
- final ModuleBuilder moduleBuilder = childEntry.getValue();\r
- final Module module = moduleBuilder.build();\r
- modulesByRevision.put(childEntry.getKey(), module);\r
- result.put(moduleBuilder, module);\r
- }\r
- }\r
- return result;\r
- }\r
-\r
- private void resolveDirtyNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {\r
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
- for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {\r
- final ModuleBuilder module = childEntry.getValue();\r
- resolveDirtyNodes(modules, module);\r
- resolveIdentities(modules, module);\r
- resolveUnknownNodes(modules, module);\r
- }\r
- }\r
- }\r
-\r
- private void resolvedDirtyNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
- final SchemaContext context) {\r
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
- for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {\r
- final ModuleBuilder module = childEntry.getValue();\r
- resolveDirtyNodesWithContext(modules, module, context);\r
- resolveIdentitiesWithContext(modules, module, context);\r
- resolveUnknownNodesWithContext(modules, module, context);\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Search for dirty nodes (node which contains UnknownType) and resolve\r
- * unknown types.\r
- *\r
- * @param modules\r
- * all available modules\r
- * @param module\r
- * current module\r
- */\r
- private void resolveDirtyNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {\r
- final Set<TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();\r
- if (!dirtyNodes.isEmpty()) {\r
- for (TypeAwareBuilder nodeToResolve : dirtyNodes) {\r
- if (nodeToResolve instanceof UnionTypeBuilder) {\r
- // special handling for union types\r
- resolveTypeUnion((UnionTypeBuilder) nodeToResolve, modules, module);\r
- } else if (nodeToResolve.getTypedef() instanceof IdentityrefTypeBuilder) {\r
- // special handling for identityref types\r
- IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder) nodeToResolve.getTypedef();\r
- nodeToResolve.setType(new IdentityrefType(findFullQName(modules, module, idref), idref.getPath()));\r
- } else {\r
- resolveType(nodeToResolve, modules, module);\r
- }\r
- }\r
- }\r
- }\r
-\r
- private void resolveDirtyNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
- final ModuleBuilder module, SchemaContext context) {\r
- final Set<TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();\r
- if (!dirtyNodes.isEmpty()) {\r
- for (TypeAwareBuilder nodeToResolve : dirtyNodes) {\r
- if (nodeToResolve instanceof UnionTypeBuilder) {\r
- // special handling for union types\r
- resolveTypeUnionWithContext((UnionTypeBuilder) nodeToResolve, modules, module, context);\r
- } else if (nodeToResolve.getTypedef() instanceof IdentityrefTypeBuilder) {\r
- // special handling for identityref types\r
- IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder) nodeToResolve.getTypedef();\r
- nodeToResolve.setType(new IdentityrefType(findFullQName(modules, module, idref), idref.getPath()));\r
- } else {\r
- resolveTypeWithContext(nodeToResolve, modules, module, context);\r
- }\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Go through all augment definitions and perform augmentation. It is\r
- * expected that modules are already sorted by their dependencies.\r
- *\r
- * @param modules\r
- * all loaded modules\r
- */\r
- private void resolveAugments(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {\r
- // collect augments from all loaded modules\r
- final List<AugmentationSchemaBuilder> allAugments = new ArrayList<>();\r
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
- allAugments.addAll(inner.getValue().getAllAugments());\r
- }\r
- }\r
-\r
- for (int i = 0; i < allAugments.size(); i++) {\r
- // pick one augment\r
- final AugmentationSchemaBuilder augment = allAugments.get(i);\r
- // create collection of others\r
- List<AugmentationSchemaBuilder> others = new ArrayList<>(allAugments);\r
- others.remove(augment);\r
-\r
- // try to resolve it\r
- boolean resolved = resolveAugment(modules, augment);\r
- // while not resolved\r
- int j = 0;\r
- while (!(resolved) && j < others.size()) {\r
- // try to resolve next augment\r
- resolveAugment(modules, others.get(j));\r
- // then try to resolve first again\r
- resolved = resolveAugment(modules, augment);\r
- j++;\r
-\r
- }\r
-\r
- if (!resolved) {\r
- throw new YangParseException(augment.getModuleName(), augment.getLine(),\r
- "Error in augment parsing: failed to find augment target");\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Search for augment target and perform augmentation.\r
- *\r
- * @param modules\r
- * all loaded modules\r
- * @param augmentBuilder\r
- * augment to resolve\r
- * @return true if target node found, false otherwise\r
- */\r
- private boolean resolveAugment(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
- final AugmentationSchemaBuilder augmentBuilder) {\r
- if (augmentBuilder.isResolved()) {\r
- return true;\r
- }\r
-\r
- int line = augmentBuilder.getLine();\r
- ModuleBuilder module = getParentModule(augmentBuilder);\r
- List<QName> path = augmentBuilder.getTargetPath().getPath();\r
- Builder augmentParent = augmentBuilder.getParent();\r
-\r
- Builder firstNodeParent = null;\r
- if (augmentParent instanceof ModuleBuilder) {\r
- // if augment is defined under module, parent of first node is\r
- // target module\r
- final QName firstNameInPath = path.get(0);\r
- String prefix = firstNameInPath.getPrefix();\r
- if (prefix == null) {\r
- prefix = module.getPrefix();\r
- }\r
- firstNodeParent = findDependentModuleBuilder(modules, module, prefix, line);\r
- } else if (augmentParent instanceof UsesNodeBuilder) {\r
- firstNodeParent = augmentParent.getParent();\r
- } else {\r
- // augment can be defined only under module or uses\r
- throw new YangParseException(augmentBuilder.getModuleName(), line,\r
- "Failed to parse augment: Unresolved parent of augment: " + augmentParent);\r
- }\r
-\r
- return processAugmentation(augmentBuilder, firstNodeParent, path);\r
- }\r
-\r
- /**\r
- * Go through all augment definitions and resolve them. This method works in\r
- * same way as {@link #resolveAugments(Map)} except that if target node is\r
- * not found in loaded modules, it search for target node in given context.\r
- *\r
- * @param modules\r
- * all loaded modules\r
- * @param context\r
- * SchemaContext containing already resolved modules\r
- */\r
- private void resolveAugmentsWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
- final SchemaContext context) {\r
- // collect augments from all loaded modules\r
- final List<AugmentationSchemaBuilder> allAugments = new ArrayList<>();\r
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
- allAugments.addAll(inner.getValue().getAllAugments());\r
- }\r
- }\r
-\r
- for (int i = 0; i < allAugments.size(); i++) {\r
- // pick augment from list\r
- final AugmentationSchemaBuilder augment = allAugments.get(i);\r
- // try to resolve it\r
- boolean resolved = resolveAugmentWithContext(modules, augment, context);\r
- // while not resolved\r
- int j = i + 1;\r
- while (!(resolved) && j < allAugments.size()) {\r
- // try to resolve next augment\r
- resolveAugmentWithContext(modules, allAugments.get(j), context);\r
- // then try to resolve first again\r
- resolved = resolveAugmentWithContext(modules, augment, context);\r
- j++;\r
- }\r
-\r
- if (!resolved) {\r
- throw new YangParseException(augment.getModuleName(), augment.getLine(),\r
- "Error in augment parsing: failed to find augment target");\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Search for augment target and perform augmentation.\r
- *\r
- * @param modules\r
- * all loaded modules\r
- * @param augment\r
- * augment to resolve\r
- * @param context\r
- * SchemaContext containing already resolved modules\r
- * @return true if target node found, false otherwise\r
- */\r
- private boolean resolveAugmentWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
- final AugmentationSchemaBuilder augment, final SchemaContext context) {\r
- if (augment.isResolved()) {\r
- return true;\r
- }\r
- int line = augment.getLine();\r
- ModuleBuilder module = getParentModule(augment);\r
- List<QName> path = augment.getTargetPath().getPath();\r
- final QName firstNameInPath = path.get(0);\r
- String prefix = firstNameInPath.getPrefix();\r
- if (prefix == null) {\r
- prefix = module.getPrefix();\r
- }\r
- Builder augmentParent = augment.getParent();\r
- Builder currentParent = null;\r
-\r
- if (augmentParent instanceof ModuleBuilder) {\r
- // if augment is defined under module, first parent is target module\r
- currentParent = findDependentModuleBuilder(modules, module, prefix, line);\r
- } else if (augmentParent instanceof UsesNodeBuilder) {\r
- currentParent = augmentParent.getParent();\r
- } else {\r
- // augment can be defined only under module or uses\r
- throw new YangParseException(augment.getModuleName(), augment.getLine(),\r
- "Error in augment parsing: Unresolved parent of augment: " + augmentParent);\r
- }\r
-\r
- if (currentParent == null) {\r
- return processAugmentationOnContext(augment, path, module, prefix, context);\r
- } else {\r
- return processAugmentation(augment, currentParent, path);\r
- }\r
- }\r
-\r
- /**\r
- * Go through identity statements defined in current module and resolve\r
- * their 'base' statement if present.\r
- *\r
- * @param modules\r
- * all modules\r
- * @param module\r
- * module being resolved\r
- */\r
- private void resolveIdentities(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {\r
- final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();\r
- for (IdentitySchemaNodeBuilder identity : identities) {\r
- final String baseIdentityName = identity.getBaseIdentityName();\r
- if (baseIdentityName != null) {\r
- String baseIdentityPrefix = null;\r
- String baseIdentityLocalName = null;\r
- if (baseIdentityName.contains(":")) {\r
- final String[] splitted = baseIdentityName.split(":");\r
- baseIdentityPrefix = splitted[0];\r
- baseIdentityLocalName = splitted[1];\r
- } else {\r
- baseIdentityPrefix = module.getPrefix();\r
- baseIdentityLocalName = baseIdentityName;\r
- }\r
- final ModuleBuilder dependentModule = findDependentModuleBuilder(modules, module, baseIdentityPrefix,\r
- identity.getLine());\r
-\r
- final Set<IdentitySchemaNodeBuilder> dependentModuleIdentities = dependentModule.getIdentities();\r
- for (IdentitySchemaNodeBuilder idBuilder : dependentModuleIdentities) {\r
- if (idBuilder.getQName().getLocalName().equals(baseIdentityLocalName)) {\r
- identity.setBaseIdentity(idBuilder);\r
- }\r
- }\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Go through identity statements defined in current module and resolve\r
- * their 'base' statement. Method tries to find base identity in given\r
- * modules. If base identity is not found, method will search it in context.\r
- *\r
- * @param modules\r
- * all loaded modules\r
- * @param module\r
- * current module\r
- * @param context\r
- * SchemaContext containing already resolved modules\r
- */\r
- private void resolveIdentitiesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
- final ModuleBuilder module, final SchemaContext context) {\r
- final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();\r
- for (IdentitySchemaNodeBuilder identity : identities) {\r
- final String baseIdentityName = identity.getBaseIdentityName();\r
- if (baseIdentityName != null) {\r
- String baseIdentityPrefix = null;\r
- String baseIdentityLocalName = null;\r
- if (baseIdentityName.contains(":")) {\r
- final String[] splitted = baseIdentityName.split(":");\r
- baseIdentityPrefix = splitted[0];\r
- baseIdentityLocalName = splitted[1];\r
- } else {\r
- baseIdentityPrefix = module.getPrefix();\r
- baseIdentityLocalName = baseIdentityName;\r
- }\r
- final ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module,\r
- baseIdentityPrefix, identity.getLine());\r
-\r
- if (dependentModuleBuilder == null) {\r
- final Module dependentModule = findModuleFromContext(context, module, baseIdentityPrefix,\r
- identity.getLine());\r
- final Set<IdentitySchemaNode> dependentModuleIdentities = dependentModule.getIdentities();\r
- for (IdentitySchemaNode idNode : dependentModuleIdentities) {\r
- if (idNode.getQName().getLocalName().equals(baseIdentityLocalName)) {\r
- identity.setBaseIdentity(idNode);\r
- }\r
- }\r
- } else {\r
- final Set<IdentitySchemaNodeBuilder> dependentModuleIdentities = dependentModuleBuilder\r
- .getIdentities();\r
- for (IdentitySchemaNodeBuilder idBuilder : dependentModuleIdentities) {\r
- if (idBuilder.getQName().getLocalName().equals(baseIdentityLocalName)) {\r
- identity.setBaseIdentity(idBuilder);\r
- }\r
- }\r
- }\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Find and add reference of uses target grouping.\r
- *\r
- * @param modules\r
- * all loaded modules\r
- * @param context\r
- * SchemaContext containing already resolved modules or null if\r
- * context is not available\r
- */\r
- private void findUsesTargets(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {\r
- final List<UsesNodeBuilder> allUses = new ArrayList<>();\r
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
- allUses.addAll(inner.getValue().getAllUsesNodes());\r
- }\r
- }\r
- for (UsesNodeBuilder usesNode : allUses) {\r
- ModuleBuilder module = ParserUtils.getParentModule(usesNode);\r
- final GroupingBuilder targetGroupingBuilder = GroupingUtils.getTargetGroupingFromModules(usesNode, modules,\r
- module);\r
- if (targetGroupingBuilder == null) {\r
- if (context == null) {\r
- throw new YangParseException(module.getName(), usesNode.getLine(), "Referenced grouping '"\r
- + usesNode.getGroupingPathAsString() + "' not found.");\r
- } else {\r
- GroupingDefinition targetGroupingDefinition = GroupingUtils.getTargetGroupingFromContext(usesNode,\r
- module, context);\r
- usesNode.setGroupingDefinition(targetGroupingDefinition);\r
- }\r
- } else {\r
- usesNode.setGrouping(targetGroupingBuilder);\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Copy data from uses target, update uses parent and perform refinement.\r
- * Augmentations have to be resolved already.\r
- *\r
- * @param modules\r
- * all loaded modules\r
- */\r
- private void resolveUses(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {\r
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
- ModuleBuilder module = inner.getValue();\r
- List<UsesNodeBuilder> usesNodes = null;\r
- boolean dataCollected = module.isAllUsesDataCollected();\r
-\r
- while (!dataCollected) {\r
- usesNodes = new ArrayList<>(module.getAllUsesNodes());\r
- for (UsesNodeBuilder usesNode : usesNodes) {\r
- if (!usesNode.isDataCollected()) {\r
- GroupingUtils.collectUsesData(usesNode);\r
- }\r
- }\r
- dataCollected = module.isAllUsesDataCollected();\r
- }\r
- }\r
- }\r
-\r
- // new loop is must because in collecting data process new uses could\r
- // be created\r
- final List<UsesNodeBuilder> allModulesUses = new ArrayList<>();\r
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
- allModulesUses.addAll(inner.getValue().getAllUsesNodes());\r
- }\r
- }\r
-\r
- for (UsesNodeBuilder usesNode : allModulesUses) {\r
- GroupingUtils.updateUsesParent(usesNode);\r
- GroupingUtils.performRefine(usesNode);\r
- }\r
- for (UsesNodeBuilder usesNode : allModulesUses) {\r
- GroupingUtils.fixUsesNodesPath(usesNode);\r
- }\r
-\r
- for (UsesNodeBuilder usesNode : allModulesUses) {\r
- if (usesNode.isCopy()) {\r
- usesNode.getParent().getUsesNodes().remove(usesNode);\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Copy data from uses target, update uses parent and perform refinement.\r
- * Augmentations have to be resolved already.\r
- *\r
- * @param modules\r
- * all loaded modules\r
- * @param context\r
- * SchemaContext containing already resolved modules\r
- */\r
- private void resolveUsesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
- final SchemaContext context) {\r
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
- ModuleBuilder module = inner.getValue();\r
- List<UsesNodeBuilder> usesNodes = null;\r
- boolean dataCollected = module.isAllUsesDataCollected();\r
-\r
- while (!dataCollected) {\r
- usesNodes = new ArrayList<>(module.getAllUsesNodes());\r
- for (UsesNodeBuilder usesNode : usesNodes) {\r
- if (!usesNode.isDataCollected()) {\r
- if (usesNode.getGroupingBuilder() == null) {\r
- GroupingUtils.collectUsesDataFromContext(usesNode);\r
- } else {\r
- GroupingUtils.collectUsesData(usesNode);\r
- }\r
- }\r
- }\r
- dataCollected = module.isAllUsesDataCollected();\r
- }\r
- }\r
- }\r
-\r
- // new loop is must because in collecting data process new uses could\r
- // be created\r
- final List<UsesNodeBuilder> allModulesUses = new ArrayList<>();\r
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
- allModulesUses.addAll(inner.getValue().getAllUsesNodes());\r
- }\r
- }\r
-\r
- for (UsesNodeBuilder usesNode : allModulesUses) {\r
- GroupingUtils.updateUsesParent(usesNode);\r
- GroupingUtils.performRefine(usesNode);\r
- }\r
- for (UsesNodeBuilder usesNode : allModulesUses) {\r
- GroupingUtils.fixUsesNodesPath(usesNode);\r
- }\r
- }\r
-\r
- private void resolveUnknownNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {\r
- for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {\r
- QName nodeType = usnb.getNodeType();\r
- try {\r
- ModuleBuilder dependentModule = findDependentModuleBuilder(modules, module, nodeType.getPrefix(),\r
- usnb.getLine());\r
- for (ExtensionBuilder extension : dependentModule.getExtensions()) {\r
- if (extension.getQName().getLocalName().equals(nodeType.getLocalName())) {\r
- usnb.setNodeType(extension.getQName());\r
- usnb.setExtensionBuilder(extension);\r
- break;\r
- }\r
- }\r
- } catch (YangParseException e) {\r
- throw new YangParseException(module.getName(), usnb.getLine(), "Failed to resolve node " + usnb\r
- + ": no such extension definition found.");\r
- }\r
- }\r
- }\r
-\r
- private void resolveUnknownNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
- final ModuleBuilder module, final SchemaContext context) {\r
- for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {\r
- QName nodeType = usnb.getNodeType();\r
- try {\r
- ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module,\r
- nodeType.getPrefix(), usnb.getLine());\r
-\r
- if (dependentModuleBuilder == null) {\r
- Module dependentModule = findModuleFromContext(context, module, nodeType.getPrefix(),\r
- usnb.getLine());\r
- for (ExtensionDefinition e : dependentModule.getExtensionSchemaNodes()) {\r
- if (e.getQName().getLocalName().equals(nodeType.getLocalName())) {\r
- usnb.setNodeType(new QName(e.getQName().getNamespace(), e.getQName().getRevision(),\r
- nodeType.getPrefix(), e.getQName().getLocalName()));\r
- usnb.setExtensionDefinition(e);\r
- break;\r
- }\r
- }\r
- } else {\r
- for (ExtensionBuilder extension : dependentModuleBuilder.getExtensions()) {\r
- if (extension.getQName().getLocalName().equals(nodeType.getLocalName())) {\r
- usnb.setExtensionBuilder(extension);\r
- break;\r
- }\r
- }\r
- }\r
-\r
- } catch (YangParseException e) {\r
- throw new YangParseException(module.getName(), usnb.getLine(), "Failed to resolve node " + usnb\r
- + ": no such extension definition found.");\r
- }\r
-\r
- }\r
- }\r
-\r
- /**\r
- * Traverse through modules and resolve their deviation statements.\r
- *\r
- * @param modules\r
- * all loaded modules\r
- */\r
- private void resolveDeviations(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {\r
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
- ModuleBuilder b = inner.getValue();\r
- resolveDeviation(modules, b);\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Traverse through module and resolve its deviation statements.\r
- *\r
- * @param modules\r
- * all loaded modules\r
- * @param module\r
- * module in which resolve deviations\r
- */\r
- private void resolveDeviation(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {\r
- for (DeviationBuilder dev : module.getDeviations()) {\r
- int line = dev.getLine();\r
- SchemaPath targetPath = dev.getTargetPath();\r
- List<QName> path = targetPath.getPath();\r
- QName q0 = path.get(0);\r
- String prefix = q0.getPrefix();\r
- if (prefix == null) {\r
- prefix = module.getPrefix();\r
- }\r
-\r
- ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module, prefix, line);\r
- processDeviation(dev, dependentModuleBuilder, path, module);\r
- }\r
- }\r
-\r
- /**\r
- * Traverse through modules and resolve their deviation statements with\r
- * given context.\r
- *\r
- * @param modules\r
- * all loaded modules\r
- * @param context\r
- * already resolved context\r
- */\r
- private void resolveDeviationsWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
- final SchemaContext context) {\r
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
- ModuleBuilder b = inner.getValue();\r
- resolveDeviationWithContext(modules, b, context);\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Traverse through module and resolve its deviation statements with given\r
- * context.\r
- *\r
- * @param modules\r
- * all loaded modules\r
- * @param module\r
- * module in which resolve deviations\r
- * @param context\r
- * already resolved context\r
- */\r
- private void resolveDeviationWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
- final ModuleBuilder module, final SchemaContext context) {\r
- for (DeviationBuilder dev : module.getDeviations()) {\r
- int line = dev.getLine();\r
- SchemaPath targetPath = dev.getTargetPath();\r
- List<QName> path = targetPath.getPath();\r
- QName q0 = path.get(0);\r
- String prefix = q0.getPrefix();\r
- if (prefix == null) {\r
- prefix = module.getPrefix();\r
- }\r
- String name = null;\r
-\r
- ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module, prefix, line);\r
- if (dependentModuleBuilder == null) {\r
- Module dependentModule = findModuleFromContext(context, module, prefix, line);\r
- Object currentParent = dependentModule;\r
-\r
- for (int i = 0; i < path.size(); i++) {\r
- if (currentParent == null) {\r
- throw new YangParseException(module.getName(), line, "Failed to find deviation target.");\r
- }\r
- QName q = path.get(i);\r
- name = q.getLocalName();\r
- if (currentParent instanceof DataNodeContainer) {\r
- currentParent = ((DataNodeContainer) currentParent).getDataChildByName(name);\r
- }\r
- }\r
-\r
- if (currentParent == null) {\r
- throw new YangParseException(module.getName(), line, "Failed to find deviation target.");\r
- }\r
- if (currentParent instanceof SchemaNode) {\r
- dev.setTargetPath(((SchemaNode) currentParent).getPath());\r
- }\r
-\r
- } else {\r
- processDeviation(dev, dependentModuleBuilder, path, module);\r
- }\r
- }\r
- }\r
-\r
- /**\r
- * Correct deviation target path in deviation builder.\r
- *\r
- * @param dev\r
- * deviation\r
- * @param dependentModuleBuilder\r
- * module containing deviation target\r
- * @param path\r
- * current deviation target path\r
- * @param module\r
- * current module\r
- */\r
- private void processDeviation(final DeviationBuilder dev, final ModuleBuilder dependentModuleBuilder,\r
- final List<QName> path, final ModuleBuilder module) {\r
- final int line = dev.getLine();\r
- Builder currentParent = dependentModuleBuilder;\r
-\r
- for (int i = 0; i < path.size(); i++) {\r
- if (currentParent == null) {\r
- throw new YangParseException(module.getName(), line, "Failed to find deviation target.");\r
- }\r
- QName q = path.get(i);\r
- String name = q.getLocalName();\r
- if (currentParent instanceof DataNodeContainerBuilder) {\r
- currentParent = ((DataNodeContainerBuilder) currentParent).getDataChildByName(name);\r
- }\r
- }\r
-\r
- if (currentParent == null || !(currentParent instanceof SchemaNodeBuilder)) {\r
- throw new YangParseException(module.getName(), line, "Failed to find deviation target.");\r
- }\r
- dev.setTargetPath(((SchemaNodeBuilder) currentParent).getPath());\r
- }\r
-\r
-}\r
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.impl;
+
+import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.*;
+import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.resolveType;
+import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.resolveTypeUnion;
+import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.resolveTypeUnionWithContext;
+import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.resolveTypeWithContext;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.util.*;
+
+import org.antlr.v4.runtime.ANTLRInputStream;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import org.opendaylight.yangtools.antlrv4.code.gen.YangLexer;
+import org.opendaylight.yangtools.antlrv4.code.gen.YangParser;
+import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.YangContext;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.*;
+import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
+import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
+import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.*;
+import org.opendaylight.yangtools.yang.parser.util.Comparators;
+import org.opendaylight.yangtools.yang.parser.util.GroupingSort;
+import org.opendaylight.yangtools.yang.parser.util.GroupingUtils;
+import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;
+import org.opendaylight.yangtools.yang.parser.util.NamedFileInputStream;
+import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
+import org.opendaylight.yangtools.yang.parser.util.YangParseException;
+import org.opendaylight.yangtools.yang.validator.YangModelBasicValidator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Preconditions;
+
+
+public final class YangParserImpl implements YangModelParser {
+ private static final Logger LOG = LoggerFactory.getLogger(YangParserImpl.class);
+
+ private static final String FAIL_DEVIATION_TARGET = "Failed to find deviation target.";
+
+ @Override
+ public Set<Module> parseYangModels(final File yangFile, final File directory) {
+ Preconditions.checkState(yangFile.exists(), yangFile + " does not exists");
+ Preconditions.checkState(directory.exists(), directory + " does not exists");
+ Preconditions.checkState(directory.isDirectory(), directory + " is not a directory");
+
+ final String yangFileName = yangFile.getName();
+ final String[] fileList = directory.list();
+ Preconditions.checkNotNull(fileList, directory + " not found");
+
+ FileInputStream yangFileStream = null;
+ LinkedHashMap<InputStream, File> streamToFileMap = new LinkedHashMap<>();
+ try {
+ yangFileStream = new FileInputStream(yangFile);
+ streamToFileMap.put(yangFileStream, yangFile);
+ } catch (FileNotFoundException e) {
+ LOG.warn("Exception while reading yang file: " + yangFile.getName(), e);
+ }
+
+ for (String fileName : fileList) {
+ if (fileName.equals(yangFileName)) {
+ continue;
+ }
+ File dependency = new File(directory, fileName);
+ try {
+ if (dependency.isFile()) {
+ streamToFileMap.put(new FileInputStream(dependency), dependency);
+ }
+ } catch (FileNotFoundException e) {
+ LOG.warn("Exception while reading yang file: " + fileName, e);
+ }
+ }
+
+ Map<InputStream, ModuleBuilder> parsedBuilders = parseBuilders(new ArrayList<>(streamToFileMap.keySet()),
+ new HashMap<ModuleBuilder, InputStream>());
+ ModuleBuilder main = parsedBuilders.get(yangFileStream);
+
+ List<ModuleBuilder> moduleBuilders = new ArrayList<>();
+ moduleBuilders.add(main);
+ filterImports(main, new ArrayList<>(parsedBuilders.values()), moduleBuilders);
+ Collection<ModuleBuilder> result = resolveSubmodules(moduleBuilders);
+
+ // module builders sorted by dependencies
+ ModuleBuilder[] builders = new ModuleBuilder[result.size()];
+ result.toArray(builders);
+ List<ModuleBuilder> sortedBuilders = ModuleDependencySort.sort(builders);
+ LinkedHashMap<String, TreeMap<Date, ModuleBuilder>> modules = orderModules(sortedBuilders);
+ Collection<Module> unsorted = build(modules).values();
+ return new LinkedHashSet<>(ModuleDependencySort.sort(unsorted.toArray(new Module[unsorted.size()])));
+ }
+
+ @Override
+ public Set<Module> parseYangModels(final List<File> yangFiles) {
+ Collection<Module> unsorted = parseYangModelsMapped(yangFiles).values();
+ return new LinkedHashSet<>(ModuleDependencySort.sort(unsorted.toArray(new Module[unsorted.size()])));
+ }
+
+ @Override
+ public Set<Module> parseYangModels(final List<File> yangFiles, final SchemaContext context) {
+ if (yangFiles == null) {
+ return Collections.emptySet();
+ }
+
+ final Map<InputStream, File> inputStreams = new HashMap<>();
+ for (final File yangFile : yangFiles) {
+ try {
+ inputStreams.put(new FileInputStream(yangFile), yangFile);
+ } catch (FileNotFoundException e) {
+ LOG.warn("Exception while reading yang file: " + yangFile.getName(), e);
+ }
+ }
+
+ List<InputStream> yangModelStreams = new ArrayList<>(inputStreams.keySet());
+ Map<ModuleBuilder, InputStream> builderToStreamMap = new HashMap<>();
+ Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(yangModelStreams,
+ builderToStreamMap, null);
+
+ for (InputStream is : inputStreams.keySet()) {
+ try {
+ is.close();
+ } catch (IOException e) {
+ LOG.debug("Failed to close stream.");
+ }
+ }
+
+ final Collection<Module> unsorted = buildWithContext(modules, context).values();
+ if (context != null) {
+ for (Module m : context.getModules()) {
+ if (!unsorted.contains(m)) {
+ unsorted.add(m);
+ }
+ }
+ }
+ return new LinkedHashSet<>(ModuleDependencySort.sort(unsorted.toArray(new Module[unsorted.size()])));
+ }
+
+ @Override
+ public Set<Module> parseYangModelsFromStreams(final List<InputStream> yangModelStreams) {
+ Collection<Module> unsorted = parseYangModelsFromStreamsMapped(yangModelStreams).values();
+ return new LinkedHashSet<>(ModuleDependencySort.sort(unsorted.toArray(new Module[unsorted.size()])));
+ }
+
+ @Override
+ public Set<Module> parseYangModelsFromStreams(final List<InputStream> yangModelStreams, SchemaContext context) {
+ if (yangModelStreams == null) {
+ return Collections.emptySet();
+ }
+
+ final Map<ModuleBuilder, InputStream> builderToStreamMap = new HashMap<>();
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(yangModelStreams,
+ builderToStreamMap, context);
+ final Set<Module> unsorted = new LinkedHashSet<>(buildWithContext(modules, context).values());
+ if (context != null) {
+ for (Module m : context.getModules()) {
+ if (!unsorted.contains(m)) {
+ unsorted.add(m);
+ }
+ }
+ }
+ return new LinkedHashSet<>(ModuleDependencySort.sort(unsorted.toArray(new Module[unsorted.size()])));
+ }
+
+ @Override
+ public Map<File, Module> parseYangModelsMapped(List<File> yangFiles) {
+ if (yangFiles == null) {
+ return Collections.emptyMap();
+ }
+
+ final Map<InputStream, File> inputStreams = new HashMap<>();
+ for (final File yangFile : yangFiles) {
+ try {
+
+ inputStreams.put(new FileInputStream(yangFile), yangFile);
+ } catch (FileNotFoundException e) {
+ LOG.warn("Exception while reading yang file: " + yangFile.getName(), e);
+ }
+ }
+
+ List<InputStream> yangModelStreams = new ArrayList<>(inputStreams.keySet());
+ Map<ModuleBuilder, InputStream> builderToStreamMap = new HashMap<>();
+ Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(yangModelStreams, builderToStreamMap,
+ null);
+
+ for (InputStream is : inputStreams.keySet()) {
+ try {
+ is.close();
+ } catch (IOException e) {
+ LOG.debug("Failed to close stream.");
+ }
+ }
+
+ Map<File, Module> result = new LinkedHashMap<>();
+ Map<ModuleBuilder, Module> builderToModuleMap = build(modules);
+ Set<ModuleBuilder> keyset = builderToModuleMap.keySet();
+ List<ModuleBuilder> sorted = ModuleDependencySort.sort(keyset.toArray(new ModuleBuilder[keyset.size()]));
+ for (ModuleBuilder key : sorted) {
+ result.put(inputStreams.get(builderToStreamMap.get(key)), builderToModuleMap.get(key));
+ }
+ return result;
+ }
+
+ @Override
+ public Map<InputStream, Module> parseYangModelsFromStreamsMapped(final List<InputStream> yangModelStreams) {
+ if (yangModelStreams == null) {
+ return Collections.emptyMap();
+ }
+
+ Map<ModuleBuilder, InputStream> builderToStreamMap = new HashMap<>();
+ Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(yangModelStreams, builderToStreamMap,
+ null);
+ Map<InputStream, Module> result = new LinkedHashMap<>();
+ Map<ModuleBuilder, Module> builderToModuleMap = build(modules);
+ Set<ModuleBuilder> keyset = builderToModuleMap.keySet();
+ List<ModuleBuilder> sorted = ModuleDependencySort.sort(keyset.toArray(new ModuleBuilder[keyset.size()]));
+ for (ModuleBuilder key : sorted) {
+ result.put(builderToStreamMap.get(key), builderToModuleMap.get(key));
+ }
+ return result;
+ }
+
+ @Override
+ public SchemaContext resolveSchemaContext(final Set<Module> modules) {
+ return new SchemaContextImpl(modules);
+ }
+
+ private Map<InputStream, ModuleBuilder> parseModuleBuilders(List<InputStream> inputStreams,
+ Map<ModuleBuilder, InputStream> streamToBuilderMap) {
+ Map<InputStream, ModuleBuilder> modules = parseBuilders(inputStreams, streamToBuilderMap);
+ Map<InputStream, ModuleBuilder> result = resolveSubmodules(modules);
+ return result;
+ }
+
+ private Map<InputStream, ModuleBuilder> parseBuilders(List<InputStream> inputStreams,
+ Map<ModuleBuilder, InputStream> streamToBuilderMap) {
+ final ParseTreeWalker walker = new ParseTreeWalker();
+ final Map<InputStream, ParseTree> trees = parseStreams(inputStreams);
+ final Map<InputStream, ModuleBuilder> builders = new LinkedHashMap<>();
+
+ // validate yang
+ new YangModelBasicValidator(walker).validate(new ArrayList<>(trees.values()));
+
+ YangParserListenerImpl yangModelParser;
+ for (Map.Entry<InputStream, ParseTree> entry : trees.entrySet()) {
+ InputStream is = entry.getKey();
+ String path = null;
+ if (is instanceof NamedFileInputStream) {
+ NamedFileInputStream nis = (NamedFileInputStream)is;
+ path = nis.getFileDestination();
+ }
+ yangModelParser = new YangParserListenerImpl(path);
+ walker.walk(yangModelParser, entry.getValue());
+ ModuleBuilder moduleBuilder = yangModelParser.getModuleBuilder();
+
+ // We expect the order of trees and streams has to be the same
+ streamToBuilderMap.put(moduleBuilder, entry.getKey());
+
+ builders.put(entry.getKey(), moduleBuilder);
+ }
+
+ return builders;
+ }
+
+ private Map<InputStream, ModuleBuilder> resolveSubmodules(Map<InputStream, ModuleBuilder> builders) {
+ Map<InputStream, ModuleBuilder> modules = new HashMap<>();
+ Set<ModuleBuilder> submodules = new HashSet<>();
+ for (Map.Entry<InputStream, ModuleBuilder> entry : builders.entrySet()) {
+ ModuleBuilder moduleBuilder = entry.getValue();
+ if (moduleBuilder.isSubmodule()) {
+ submodules.add(moduleBuilder);
+ } else {
+ modules.put(entry.getKey(), moduleBuilder);
+ }
+ }
+
+ Collection<ModuleBuilder> values = modules.values();
+ for (ModuleBuilder submodule : submodules) {
+ for (ModuleBuilder module : values) {
+ if (module.getName().equals(submodule.getBelongsTo())) {
+ addSubmoduleToModule(submodule, module);
+ }
+ }
+ }
+ return modules;
+ }
+
+ private Collection<ModuleBuilder> resolveSubmodules(Collection<ModuleBuilder> builders) {
+ Collection<ModuleBuilder> modules = new HashSet<>();
+ Set<ModuleBuilder> submodules = new HashSet<>();
+ for (ModuleBuilder moduleBuilder : builders) {
+ if (moduleBuilder.isSubmodule()) {
+ submodules.add(moduleBuilder);
+ } else {
+ modules.add(moduleBuilder);
+ }
+ }
+
+ for (ModuleBuilder submodule : submodules) {
+ for (ModuleBuilder module : modules) {
+ if (module.getName().equals(submodule.getBelongsTo())) {
+ addSubmoduleToModule(submodule, module);
+ }
+ }
+ }
+ return modules;
+ }
+
+ private void addSubmoduleToModule(ModuleBuilder submodule, ModuleBuilder module) {
+ submodule.setParent(module);
+ module.getDirtyNodes().addAll(submodule.getDirtyNodes());
+ module.getModuleImports().addAll(submodule.getModuleImports());
+ module.getAugments().addAll(submodule.getAugments());
+ module.getAugmentBuilders().addAll(submodule.getAugmentBuilders());
+ module.getAllAugments().addAll(submodule.getAllAugments());
+ module.getChildNodeBuilders().addAll(submodule.getChildNodeBuilders());
+ module.getChildNodes().addAll(submodule.getChildNodes());
+ module.getGroupings().addAll(submodule.getGroupings());
+ module.getGroupingBuilders().addAll(submodule.getGroupingBuilders());
+ module.getTypeDefinitions().addAll(submodule.getTypeDefinitions());
+ module.getTypeDefinitionBuilders().addAll(submodule.getTypeDefinitionBuilders());
+ module.getUsesNodes().addAll(submodule.getUsesNodes());
+ module.getUsesNodeBuilders().addAll(submodule.getUsesNodeBuilders());
+ module.getAllGroupings().addAll(submodule.getAllGroupings());
+ module.getAllUsesNodes().addAll(submodule.getAllUsesNodes());
+ module.getRpcs().addAll(submodule.getRpcs());
+ module.getAddedRpcs().addAll(submodule.getAddedRpcs());
+ module.getNotifications().addAll(submodule.getNotifications());
+ module.getAddedNotifications().addAll(submodule.getAddedNotifications());
+ module.getIdentities().addAll(submodule.getIdentities());
+ module.getAddedIdentities().addAll(submodule.getAddedIdentities());
+ module.getFeatures().addAll(submodule.getFeatures());
+ module.getAddedFeatures().addAll(submodule.getAddedFeatures());
+ module.getDeviations().addAll(submodule.getDeviations());
+ module.getDeviationBuilders().addAll(submodule.getDeviationBuilders());
+ module.getExtensions().addAll(submodule.getExtensions());
+ module.getAddedExtensions().addAll(submodule.getAddedExtensions());
+ module.getUnknownNodes().addAll(submodule.getUnknownNodes());
+ module.getAllUnknownNodes().addAll(submodule.getAllUnknownNodes());
+ }
+
+ private Map<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuilders(final List<InputStream> yangFileStreams,
+ final Map<ModuleBuilder, InputStream> streamToBuilderMap, final SchemaContext context) {
+ Map<InputStream, ModuleBuilder> parsedBuilders = parseModuleBuilders(yangFileStreams, streamToBuilderMap);
+ ModuleBuilder[] builders = new ModuleBuilder[parsedBuilders.size()];
+ parsedBuilders.values().toArray(builders);
+
+ // module dependency graph sorted
+ List<ModuleBuilder> sorted;
+ if (context == null) {
+ sorted = ModuleDependencySort.sort(builders);
+ } else {
+ sorted = ModuleDependencySort.sortWithContext(context, builders);
+ }
+ return orderModules(sorted);
+ }
+
+ /**
+ * Order modules by name and revision.
+ *
+ * @param modules
+ * modules to order
+ * @return modules ordered by name and revision
+ */
+ private LinkedHashMap<String, TreeMap<Date, ModuleBuilder>> orderModules(List<ModuleBuilder> modules) {
+ final LinkedHashMap<String, TreeMap<Date, ModuleBuilder>> result = new LinkedHashMap<>();
+ for (final ModuleBuilder builder : modules) {
+ if (builder == null) {
+ continue;
+ }
+ final String builderName = builder.getName();
+ Date builderRevision = builder.getRevision();
+ if (builderRevision == null) {
+ builderRevision = new Date(0L);
+ }
+ TreeMap<Date, ModuleBuilder> builderByRevision = result.get(builderName);
+ if (builderByRevision == null) {
+ builderByRevision = new TreeMap<>();
+ }
+ builderByRevision.put(builderRevision, builder);
+ result.put(builderName, builderByRevision);
+ }
+ return result;
+ }
+
+ private void filterImports(ModuleBuilder main, List<ModuleBuilder> other, List<ModuleBuilder> filtered) {
+ Set<ModuleImport> imports = main.getModuleImports();
+
+ // if this is submodule, add parent to filtered and pick its imports
+ if (main.isSubmodule()) {
+ TreeMap<Date, ModuleBuilder> dependencies = new TreeMap<>();
+ for (ModuleBuilder mb : other) {
+ if (mb.getName().equals(main.getBelongsTo())) {
+ dependencies.put(mb.getRevision(), mb);
+ }
+ }
+ ModuleBuilder parent = dependencies.get(dependencies.firstKey());
+ filtered.add(parent);
+ imports.addAll(parent.getModuleImports());
+ }
+
+ for (ModuleImport mi : imports) {
+ for (ModuleBuilder builder : other) {
+ if (mi.getModuleName().equals(builder.getModuleName())) {
+ if (mi.getRevision() == null) {
+ if (!filtered.contains(builder)) {
+ filtered.add(builder);
+ filterImports(builder, other, filtered);
+ }
+ } else {
+ if (mi.getRevision().equals(builder.getRevision())) {
+ if (!filtered.contains(builder)) {
+ filtered.add(builder);
+ filterImports(builder, other, filtered);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ private Map<InputStream, ParseTree> parseStreams(final List<InputStream> yangStreams) {
+ final Map<InputStream, ParseTree> trees = new HashMap<>();
+ for (InputStream yangStream : yangStreams) {
+ trees.put(yangStream, parseStream(yangStream));
+ }
+ return trees;
+ }
+
+ private ParseTree parseStream(final InputStream yangStream) {
+ ParseTree result = null;
+ try {
+ final ANTLRInputStream input = new ANTLRInputStream(yangStream);
+ final YangLexer lexer = new YangLexer(input);
+ final CommonTokenStream tokens = new CommonTokenStream(lexer);
+ final YangParser parser = new YangParser(tokens);
+ parser.removeErrorListeners();
+ YangErrorListener errorListener = new YangErrorListener();
+ parser.addErrorListener(errorListener);
+ result = parser.yang();
+ errorListener.validate();
+ } catch (IOException e) {
+ LOG.warn("Exception while reading yang file: " + yangStream, e);
+ }
+ return result;
+ }
+
+ public static YangContext parseStreamWithoutErrorListeners(final InputStream yangStream) {
+ YangContext result = null;
+ try {
+ final ANTLRInputStream input = new ANTLRInputStream(yangStream);
+ final YangLexer lexer = new YangLexer(input);
+ final CommonTokenStream tokens = new CommonTokenStream(lexer);
+ final YangParser parser = new YangParser(tokens);
+ parser.removeErrorListeners();
+ result = parser.yang();
+ } catch (IOException e) {
+ LOG.warn("Exception while reading yang file: " + yangStream, e);
+ }
+ return result;
+ }
+
+ private Map<ModuleBuilder, Module> build(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
+ // fix unresolved nodes
+ resolveDirtyNodes(modules);
+ resolveAugmentsTargetPath(modules, null);
+ resolveUsesTargetGrouping(modules, null);
+ resolveUsesForGroupings(modules, null);
+ resolveUsesForNodes(modules, null);
+ resolveAugments(modules, null);
+ resolveDeviations(modules);
+
+ // build
+ final Map<ModuleBuilder, Module> result = new LinkedHashMap<>();
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
+ final ModuleBuilder moduleBuilder = childEntry.getValue();
+ final Module module = moduleBuilder.build();
+ result.put(moduleBuilder, module);
+ }
+ }
+ return result;
+ }
+
+ private Map<ModuleBuilder, Module> buildWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final SchemaContext context) {
+ // fix unresolved nodes
+ resolvedDirtyNodesWithContext(modules, context);
+ resolveAugmentsTargetPath(modules, context);
+ resolveUsesTargetGrouping(modules, context);
+ resolveUsesForGroupings(modules, context);
+ resolveUsesForNodes(modules, context);
+ resolveAugments(modules, context);
+ resolveDeviationsWithContext(modules, context);
+
+ // build
+ final Map<ModuleBuilder, Module> result = new LinkedHashMap<>();
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
+ final ModuleBuilder moduleBuilder = childEntry.getValue();
+ final Module module = moduleBuilder.build();
+ result.put(moduleBuilder, module);
+ }
+ }
+ return result;
+ }
+
+ private void resolveDirtyNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
+ final ModuleBuilder module = childEntry.getValue();
+ resolveUnknownNodes(modules, module);
+ resolveIdentities(modules, module);
+ resolveDirtyNodes(modules, module);
+ }
+ }
+ }
+
+ private void resolvedDirtyNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final SchemaContext context) {
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
+ final ModuleBuilder module = childEntry.getValue();
+ resolveUnknownNodesWithContext(modules, module, context);
+ resolveIdentitiesWithContext(modules, module, context);
+ resolveDirtyNodesWithContext(modules, module, context);
+ }
+ }
+ }
+
+ /**
+ * Search for dirty nodes (node which contains UnknownType) and resolve
+ * unknown types.
+ *
+ * @param modules
+ * all available modules
+ * @param module
+ * current module
+ */
+ private void resolveDirtyNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
+ final Set<TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();
+ if (!dirtyNodes.isEmpty()) {
+ for (TypeAwareBuilder nodeToResolve : dirtyNodes) {
+ if (nodeToResolve instanceof UnionTypeBuilder) {
+ // special handling for union types
+ resolveTypeUnion((UnionTypeBuilder) nodeToResolve, modules, module);
+ } else if (nodeToResolve.getTypedef() instanceof IdentityrefTypeBuilder) {
+ // special handling for identityref types
+ IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder) nodeToResolve.getTypedef();
+ IdentitySchemaNodeBuilder identity = findBaseIdentity(modules, module, idref.getBaseString(),
+ idref.getLine());
+ if (identity == null) {
+ throw new YangParseException(module.getName(), idref.getLine(), "Failed to find base identity");
+ }
+ idref.setBaseIdentity(identity);
+ nodeToResolve.setType(idref.build());
+ } else {
+ resolveType(nodeToResolve, modules, module);
+ }
+ }
+ }
+ }
+
+ private void resolveDirtyNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final ModuleBuilder module, SchemaContext context) {
+ final Set<TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();
+ if (!dirtyNodes.isEmpty()) {
+ for (TypeAwareBuilder nodeToResolve : dirtyNodes) {
+ if (nodeToResolve instanceof UnionTypeBuilder) {
+ // special handling for union types
+ resolveTypeUnionWithContext((UnionTypeBuilder) nodeToResolve, modules, module, context);
+ } else if (nodeToResolve.getTypedef() instanceof IdentityrefTypeBuilder) {
+ // special handling for identityref types
+ IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder) nodeToResolve.getTypedef();
+ IdentitySchemaNodeBuilder identity = findBaseIdentity(modules, module, idref.getBaseString(),
+ idref.getLine());
+ idref.setBaseIdentity(identity);
+ nodeToResolve.setType(idref.build());
+ } else {
+ resolveTypeWithContext(nodeToResolve, modules, module, context);
+ }
+ }
+ }
+ }
+
+ /**
+ * Correct augment target path.
+ *
+ * @param modules
+ * all loaded modules
+ */
+ private void resolveAugmentsTargetPath(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ SchemaContext context) {
+ // collect augments from all loaded modules
+ final List<AugmentationSchemaBuilder> allAugments = new ArrayList<>();
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
+ allAugments.addAll(inner.getValue().getAllAugments());
+ }
+ }
+
+ for (AugmentationSchemaBuilder augment : allAugments) {
+ setCorrectAugmentTargetPath(modules, augment, context);
+ }
+ }
+
+ private void setCorrectAugmentTargetPath(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final AugmentationSchemaBuilder augment, final SchemaContext context) {
+ ModuleBuilder module = ParserUtils.getParentModule(augment);
+ SchemaPath oldSchemaPath = augment.getTargetPath();
+ List<QName> oldPath = oldSchemaPath.getPath();
+ List<QName> newPath = new ArrayList<>();
+
+ Builder parent = augment.getParent();
+ if (parent instanceof UsesNodeBuilder) {
+ DataNodeContainerBuilder usesParent = ((UsesNodeBuilder) parent).getParent();
+ newPath.addAll(usesParent.getPath().getPath());
+
+ URI ns;
+ Date revision;
+ String prefix;
+ QName baseQName = usesParent.getQName();
+ if (baseQName == null) {
+ ModuleBuilder m = ParserUtils.getParentModule(usesParent);
+ ns = m.getNamespace();
+ revision = m.getRevision();
+ prefix = m.getPrefix();
+ } else {
+ ns = baseQName.getNamespace();
+ revision = baseQName.getRevision();
+ prefix = baseQName.getPrefix();
+ }
+
+ for (QName qn : oldSchemaPath.getPath()) {
+ newPath.add(new QName(ns, revision, prefix, qn.getLocalName()));
+ }
+ } else {
+
+ for (QName qn : oldPath) {
+ URI ns = module.getNamespace();
+ Date rev = module.getRevision();
+ String pref = module.getPrefix();
+ String localPrefix = qn.getPrefix();
+ if (localPrefix != null && !("".equals(localPrefix))) {
+ ModuleBuilder currentModule = ParserUtils.findModuleFromBuilders(modules, module, localPrefix,
+ augment.getLine());
+ if (currentModule == null) {
+ Module m = ParserUtils.findModuleFromContext(context, module, localPrefix, augment.getLine());
+ if (m == null) {
+ throw new YangParseException(module.getName(), augment.getLine(), "Module with prefix "
+ + localPrefix + " not found.");
+ }
+ ns = m.getNamespace();
+ rev = m.getRevision();
+ pref = m.getPrefix();
+ } else {
+ ns = currentModule.getNamespace();
+ rev = currentModule.getRevision();
+ pref = currentModule.getPrefix();
+ }
+ }
+ newPath.add(new QName(ns, rev, pref, qn.getLocalName()));
+ }
+ }
+ augment.setTargetNodeSchemaPath(new SchemaPath(newPath, augment.getTargetPath().isAbsolute()));
+
+ for (DataSchemaNodeBuilder childNode : augment.getChildNodeBuilders()) {
+ correctPathForAugmentNodes(childNode, augment.getTargetNodeSchemaPath());
+ }
+ }
+
+ private void correctPathForAugmentNodes(DataSchemaNodeBuilder node, SchemaPath parentPath) {
+ SchemaPath newPath = ParserUtils.createSchemaPath(parentPath, node.getQName());
+ node.setPath(newPath);
+ if (node instanceof DataNodeContainerBuilder) {
+ for (DataSchemaNodeBuilder child : ((DataNodeContainerBuilder) node).getChildNodeBuilders()) {
+ correctPathForAugmentNodes(child, node.getPath());
+ }
+ }
+ if (node instanceof ChoiceBuilder) {
+ for (ChoiceCaseBuilder child : ((ChoiceBuilder)node).getCases()) {
+ correctPathForAugmentNodes(child, node.getPath());
+ }
+ }
+ }
+
+ /**
+ * Check augments for mandatory nodes. If the target node is in another
+ * module, then nodes added by the augmentation MUST NOT be mandatory nodes.
+ * If mandatory node is found, throw an exception.
+ *
+ * @param augments
+ * augments to check
+ */
+ private void checkAugmentMandatoryNodes(Collection<AugmentationSchemaBuilder> augments) {
+ for (AugmentationSchemaBuilder augment : augments) {
+ String augmentPrefix = augment.getTargetPath().getPath().get(0).getPrefix();
+ ModuleBuilder module = ParserUtils.getParentModule(augment);
+ String modulePrefix = module.getPrefix();
+
+ if (augmentPrefix == null || augmentPrefix.isEmpty() || augmentPrefix.equals(modulePrefix)) {
+ continue;
+ }
+
+ for (DataSchemaNodeBuilder childNode : augment.getChildNodeBuilders()) {
+ if (childNode.getConstraints().isMandatory()) {
+ throw new YangParseException(augment.getModuleName(), augment.getLine(),
+ "Error in augment parsing: cannot augment mandatory node "
+ + childNode.getQName().getLocalName());
+ }
+ }
+ }
+ }
+
+ /**
+ * Go through all augment definitions and resolve them. This method works in
+ * same way as {@link #resolveAugments(Map)} except that if target node is
+ * not found in loaded modules, it search for target node in given context.
+ *
+ * @param modules
+ * all loaded modules
+ * @param context
+ * SchemaContext containing already resolved modules
+ */
+ private void resolveAugments(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
+ List<ModuleBuilder> all = new ArrayList<>();
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
+ all.add(inner.getValue());
+ }
+ }
+
+ List<ModuleBuilder> sorted;
+ if (context == null) {
+ sorted = ModuleDependencySort.sort(all.toArray(new ModuleBuilder[all.size()]));
+ } else {
+ sorted = ModuleDependencySort.sortWithContext(context, all.toArray(new ModuleBuilder[all.size()]));
+ }
+
+ for (ModuleBuilder mb : sorted) {
+ if (mb != null) {
+ List<AugmentationSchemaBuilder> augments = mb.getAllAugments();
+ checkAugmentMandatoryNodes(augments);
+ Collections.sort(augments, Comparators.AUGMENT_COMP);
+ for (AugmentationSchemaBuilder augment : augments) {
+ if (!(augment.isResolved())) {
+ boolean resolved = resolveAugment(augment, mb, modules, context);
+ if (!resolved) {
+ throw new YangParseException(augment.getModuleName(), augment.getLine(),
+ "Error in augment parsing: failed to find augment target: " + augment);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ private boolean resolveUsesAugment(final AugmentationSchemaBuilder augment, final ModuleBuilder module,
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
+ if (augment.isResolved()) {
+ return true;
+ }
+
+ UsesNodeBuilder usesNode = (UsesNodeBuilder) augment.getParent();
+ DataNodeContainerBuilder parentNode = usesNode.getParent();
+ SchemaNodeBuilder targetNode;
+ if (parentNode instanceof ModuleBuilder) {
+ targetNode = findSchemaNodeInModule(augment.getTargetPath().getPath(), (ModuleBuilder)parentNode);
+ } else {
+ targetNode = findSchemaNode(augment.getTargetPath().getPath(), (SchemaNodeBuilder)parentNode);
+ }
+
+ fillAugmentTarget(augment, targetNode);
+ augment.setResolved(true);
+ return true;
+ }
+
+ private boolean resolveAugment(final AugmentationSchemaBuilder augment, final ModuleBuilder module,
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
+ if (augment.isResolved()) {
+ return true;
+ }
+
+ List<QName> targetPath = augment.getTargetPath().getPath();
+ ModuleBuilder targetModule = findTargetModule(targetPath.get(0), module, modules, context, augment.getLine());
+ if (targetModule == null) {
+ throw new YangParseException(module.getModuleName(), augment.getLine(), "Failed to resolve augment "
+ + augment);
+ }
+
+ return processAugmentation(augment, targetModule);
+ }
+
+ /**
+ * Find module from loaded modules or from context based on given qname. If
+ * module is found in context, create wrapper over this module and add it to
+ * collection of loaded modules.
+ *
+ * @param qname
+ * @param module
+ * current module
+ * @param modules
+ * all loaded modules
+ * @param context
+ * schema context
+ * @param line
+ * current line
+ * @return
+ */
+ private ModuleBuilder findTargetModule(final QName qname, final ModuleBuilder module,
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context, final int line) {
+ ModuleBuilder targetModule = null;
+
+ String prefix = qname.getPrefix();
+ if (prefix == null || prefix.equals("")) {
+ targetModule = module;
+ } else {
+ targetModule = findModuleFromBuilders(modules, module, qname.getPrefix(), line);
+ }
+
+ if (targetModule == null && context != null) {
+ Module m = findModuleFromContext(context, module, prefix, line);
+ targetModule = new ModuleBuilder(m);
+ DataSchemaNode firstNode = m.getDataChildByName(qname.getLocalName());
+ DataSchemaNodeBuilder firstNodeWrapped = wrapChildNode(targetModule.getModuleName(), line, firstNode,
+ targetModule.getPath(), firstNode.getQName());
+ targetModule.addChildNode(firstNodeWrapped);
+
+ TreeMap<Date, ModuleBuilder> map = new TreeMap<>();
+ map.put(targetModule.getRevision(), targetModule);
+ modules.put(targetModule.getModuleName(), map);
+ }
+
+ return targetModule;
+ }
+
+ /**
+ * Go through identity statements defined in current module and resolve
+ * their 'base' statement if present.
+ *
+ * @param modules
+ * all modules
+ * @param module
+ * module being resolved
+ */
+ private void resolveIdentities(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
+ final Set<IdentitySchemaNodeBuilder> identities = module.getAddedIdentities();
+ for (IdentitySchemaNodeBuilder identity : identities) {
+ final String baseIdentityName = identity.getBaseIdentityName();
+ final int line = identity.getLine();
+ if (baseIdentityName != null) {
+ IdentitySchemaNodeBuilder baseIdentity = findBaseIdentity(modules, module, baseIdentityName, line);
+ if (baseIdentity == null) {
+ throw new YangParseException(module.getName(), identity.getLine(), "Failed to find base identity");
+ } else {
+ identity.setBaseIdentity(baseIdentity);
+ }
+ }
+ }
+ }
+
+ /**
+ * Go through identity statements defined in current module and resolve
+ * their 'base' statement. Method tries to find base identity in given
+ * modules. If base identity is not found, method will search it in context.
+ *
+ * @param modules
+ * all loaded modules
+ * @param module
+ * current module
+ * @param context
+ * SchemaContext containing already resolved modules
+ */
+ private void resolveIdentitiesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final ModuleBuilder module, final SchemaContext context) {
+ final Set<IdentitySchemaNodeBuilder> identities = module.getAddedIdentities();
+ for (IdentitySchemaNodeBuilder identity : identities) {
+ final String baseIdentityName = identity.getBaseIdentityName();
+ final int line = identity.getLine();
+ if (baseIdentityName != null) {
+ IdentitySchemaNodeBuilder baseIdentity = findBaseIdentity(modules, module, baseIdentityName, line);
+ if (baseIdentity == null) {
+ IdentitySchemaNode baseId = findBaseIdentityFromContext(modules, module, baseIdentityName, line,
+ context);
+ identity.setBaseIdentity(baseId);
+ } else {
+ identity.setBaseIdentity(baseIdentity);
+ }
+ }
+ }
+ }
+
+ /**
+ * Find and add reference of uses target grouping.
+ *
+ * @param modules
+ * all loaded modules
+ * @param context
+ * SchemaContext containing already resolved modules or null if
+ * context is not available
+ */
+ private void resolveUsesTargetGrouping(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final SchemaContext context) {
+ final List<UsesNodeBuilder> allUses = new ArrayList<>();
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
+ allUses.addAll(inner.getValue().getAllUsesNodes());
+ }
+ }
+ for (UsesNodeBuilder usesNode : allUses) {
+ ModuleBuilder module = ParserUtils.getParentModule(usesNode);
+ final GroupingBuilder targetGroupingBuilder = GroupingUtils.getTargetGroupingFromModules(usesNode, modules,
+ module);
+ if (targetGroupingBuilder == null) {
+ if (context == null) {
+ throw new YangParseException(module.getName(), usesNode.getLine(), "Referenced grouping '"
+ + usesNode.getGroupingPathAsString() + "' not found.");
+ } else {
+ GroupingDefinition targetGroupingDefinition = GroupingUtils.getTargetGroupingFromContext(usesNode,
+ module, context);
+ usesNode.setGroupingDefinition(targetGroupingDefinition);
+ }
+ } else {
+ usesNode.setGrouping(targetGroupingBuilder);
+ }
+ }
+ }
+
+ private void resolveUsesForGroupings(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
+ final Set<GroupingBuilder> allGroupings = new HashSet<>();
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
+ ModuleBuilder module = inner.getValue();
+ allGroupings.addAll(module.getAllGroupings());
+ }
+ }
+ final List<GroupingBuilder> sorted = GroupingSort.sort(allGroupings);
+ for (GroupingBuilder gb : sorted) {
+ List<UsesNodeBuilder> usesNodes = new ArrayList<>(GroupingSort.getAllUsesNodes(gb));
+ Collections.sort(usesNodes, new GroupingUtils.UsesComparator());
+ for (UsesNodeBuilder usesNode : usesNodes) {
+ resolveUses(usesNode, modules, context);
+ }
+ }
+ }
+
+ private void resolveUsesForNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
+ ModuleBuilder module = inner.getValue();
+ List<UsesNodeBuilder> usesNodes = module.getAllUsesNodes();
+ Collections.sort(usesNodes, new GroupingUtils.UsesComparator());
+ for (UsesNodeBuilder usesNode : usesNodes) {
+ resolveUses(usesNode, modules, context);
+ }
+ }
+ }
+ }
+
+ private void resolveUses(UsesNodeBuilder usesNode,
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
+ if (!usesNode.isResolved()) {
+ DataNodeContainerBuilder parent = usesNode.getParent();
+ ModuleBuilder module = ParserUtils.getParentModule(parent);
+ GroupingBuilder target = GroupingUtils.getTargetGroupingFromModules(usesNode, modules, module);
+ if (target == null) {
+ resolveUsesWithContext(usesNode);
+ usesNode.setResolved(true);
+ for (AugmentationSchemaBuilder augment : usesNode.getAugmentations()) {
+ resolveUsesAugment(augment, module, modules, context);
+ }
+ } else {
+ parent.getChildNodeBuilders().addAll(target.instantiateChildNodes(parent));
+ parent.getTypeDefinitionBuilders().addAll(target.instantiateTypedefs(parent));
+ parent.getGroupingBuilders().addAll(target.instantiateGroupings(parent));
+ parent.getUnknownNodes().addAll(target.instantiateUnknownNodes(parent));
+ usesNode.setResolved(true);
+ for (AugmentationSchemaBuilder augment : usesNode.getAugmentations()) {
+ resolveUsesAugment(augment, module, modules, context);
+ }
+ }
+ GroupingUtils.performRefine(usesNode);
+ }
+ }
+
+ private void resolveUsesWithContext(UsesNodeBuilder usesNode) {
+ final int line = usesNode.getLine();
+ DataNodeContainerBuilder parent = usesNode.getParent();
+ ModuleBuilder module = ParserUtils.getParentModule(parent);
+ SchemaPath parentPath;
+ URI ns = null;
+ Date rev = null;
+ String pref = null;
+ if (parent instanceof AugmentationSchemaBuilder || parent instanceof ModuleBuilder) {
+ ns = module.getNamespace();
+ rev = module.getRevision();
+ pref = module.getPrefix();
+ if (parent instanceof AugmentationSchemaBuilder) {
+ parentPath = ((AugmentationSchemaBuilder)parent).getTargetNodeSchemaPath();
+ } else {
+ parentPath = ((ModuleBuilder)parent).getPath();
+ }
+ } else {
+ ns = ((DataSchemaNodeBuilder) parent).getQName().getNamespace();
+ rev = ((DataSchemaNodeBuilder) parent).getQName().getRevision();
+ pref = ((DataSchemaNodeBuilder) parent).getQName().getPrefix();
+ parentPath = ((DataSchemaNodeBuilder)parent).getPath();
+ }
+
+ GroupingDefinition gd = usesNode.getGroupingDefinition();
+
+ Set<DataSchemaNodeBuilder> childNodes = wrapChildNodes(module.getModuleName(), line,
+ gd.getChildNodes(), parentPath, ns, rev, pref);
+ parent.getChildNodeBuilders().addAll(childNodes);
+ for (DataSchemaNodeBuilder childNode : childNodes) {
+ setNodeAddedByUses(childNode);
+ }
+
+ Set<TypeDefinitionBuilder> typedefs = wrapTypedefs(module.getModuleName(), line, gd, parentPath, ns,
+ rev, pref);
+ parent.getTypeDefinitionBuilders().addAll(typedefs);
+ for (TypeDefinitionBuilder typedef : typedefs) {
+ setNodeAddedByUses(typedef);
+ }
+
+ Set<GroupingBuilder> groupings = wrapGroupings(module.getModuleName(), line, usesNode
+ .getGroupingDefinition().getGroupings(), parentPath, ns, rev, pref);
+ parent.getGroupingBuilders().addAll(groupings);
+ for (GroupingBuilder gb : groupings) {
+ setNodeAddedByUses(gb);
+ }
+
+ List<UnknownSchemaNodeBuilder> unknownNodes = wrapUnknownNodes(module.getModuleName(), line,
+ gd.getUnknownSchemaNodes(), parentPath, ns, rev, pref);
+ parent.getUnknownNodes().addAll(unknownNodes);
+ for (UnknownSchemaNodeBuilder un : unknownNodes) {
+ un.setAddedByUses(true);
+ }
+ }
+
+ private void resolveUnknownNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
+ for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {
+ QName nodeType = usnb.getNodeType();
+ try {
+ ModuleBuilder dependentModule = findModuleFromBuilders(modules, module, nodeType.getPrefix(),
+ usnb.getLine());
+ for (ExtensionBuilder extension : dependentModule.getAddedExtensions()) {
+ if (extension.getQName().getLocalName().equals(nodeType.getLocalName())) {
+ usnb.setNodeType(extension.getQName());
+ usnb.setExtensionBuilder(extension);
+ break;
+ }
+ }
+ } catch (YangParseException e) {
+ throw new YangParseException(module.getName(), usnb.getLine(), "Failed to resolve node " + usnb
+ + ": no such extension definition found.", e);
+ }
+ }
+ }
+
+ private void resolveUnknownNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final ModuleBuilder module, final SchemaContext context) {
+ for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {
+ QName nodeType = usnb.getNodeType();
+ try {
+ ModuleBuilder dependentModuleBuilder = findModuleFromBuilders(modules, module, nodeType.getPrefix(),
+ usnb.getLine());
+
+ if (dependentModuleBuilder == null) {
+ Module dependentModule = findModuleFromContext(context, module, nodeType.getPrefix(),
+ usnb.getLine());
+ for (ExtensionDefinition e : dependentModule.getExtensionSchemaNodes()) {
+ if (e.getQName().getLocalName().equals(nodeType.getLocalName())) {
+ usnb.setNodeType(new QName(e.getQName().getNamespace(), e.getQName().getRevision(),
+ nodeType.getPrefix(), e.getQName().getLocalName()));
+ usnb.setExtensionDefinition(e);
+ break;
+ }
+ }
+ } else {
+ for (ExtensionBuilder extension : dependentModuleBuilder.getAddedExtensions()) {
+ if (extension.getQName().getLocalName().equals(nodeType.getLocalName())) {
+ usnb.setExtensionBuilder(extension);
+ break;
+ }
+ }
+ }
+
+ } catch (YangParseException e) {
+ throw new YangParseException(module.getName(), usnb.getLine(), "Failed to resolve node " + usnb
+ + ": no such extension definition found.", e);
+ }
+
+ }
+ }
+
+ /**
+ * Traverse through modules and resolve their deviation statements.
+ *
+ * @param modules
+ * all loaded modules
+ */
+ private void resolveDeviations(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
+ ModuleBuilder b = inner.getValue();
+ resolveDeviation(modules, b);
+ }
+ }
+ }
+
+ /**
+ * Traverse through module and resolve its deviation statements.
+ *
+ * @param modules
+ * all loaded modules
+ * @param module
+ * module in which resolve deviations
+ */
+ private void resolveDeviation(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
+ for (DeviationBuilder dev : module.getDeviationBuilders()) {
+ int line = dev.getLine();
+ SchemaPath targetPath = dev.getTargetPath();
+ List<QName> path = targetPath.getPath();
+ QName q0 = path.get(0);
+ String prefix = q0.getPrefix();
+ if (prefix == null) {
+ prefix = module.getPrefix();
+ }
+
+ ModuleBuilder dependentModuleBuilder = findModuleFromBuilders(modules, module, prefix, line);
+ processDeviation(dev, dependentModuleBuilder, path, module);
+ }
+ }
+
+ /**
+ * Traverse through modules and resolve their deviation statements with
+ * given context.
+ *
+ * @param modules
+ * all loaded modules
+ * @param context
+ * already resolved context
+ */
+ private void resolveDeviationsWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final SchemaContext context) {
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
+ ModuleBuilder b = inner.getValue();
+ resolveDeviationWithContext(modules, b, context);
+ }
+ }
+ }
+
+ /**
+ * Traverse through module and resolve its deviation statements with given
+ * context.
+ *
+ * @param modules
+ * all loaded modules
+ * @param module
+ * module in which resolve deviations
+ * @param context
+ * already resolved context
+ */
+ private void resolveDeviationWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final ModuleBuilder module, final SchemaContext context) {
+ for (DeviationBuilder dev : module.getDeviationBuilders()) {
+ int line = dev.getLine();
+ SchemaPath targetPath = dev.getTargetPath();
+ List<QName> path = targetPath.getPath();
+ QName q0 = path.get(0);
+ String prefix = q0.getPrefix();
+ if (prefix == null) {
+ prefix = module.getPrefix();
+ }
+
+ ModuleBuilder dependentModuleBuilder = findModuleFromBuilders(modules, module, prefix, line);
+ if (dependentModuleBuilder == null) {
+ Object currentParent = findModuleFromContext(context, module, prefix, line);
+
+ for (QName q : path) {
+ if (currentParent == null) {
+ throw new YangParseException(module.getName(), line, FAIL_DEVIATION_TARGET);
+ }
+ String name = q.getLocalName();
+ if (currentParent instanceof DataNodeContainer) {
+ currentParent = ((DataNodeContainer) currentParent).getDataChildByName(name);
+ }
+ }
+
+ if (currentParent == null) {
+ throw new YangParseException(module.getName(), line, FAIL_DEVIATION_TARGET);
+ }
+ if (currentParent instanceof SchemaNode) {
+ dev.setTargetPath(((SchemaNode) currentParent).getPath());
+ }
+
+ } else {
+ processDeviation(dev, dependentModuleBuilder, path, module);
+ }
+ }
+ }
+
+ /**
+ * Correct deviation target path in deviation builder.
+ *
+ * @param dev
+ * deviation
+ * @param dependentModuleBuilder
+ * module containing deviation target
+ * @param path
+ * current deviation target path
+ * @param module
+ * current module
+ */
+ private void processDeviation(final DeviationBuilder dev, final ModuleBuilder dependentModuleBuilder,
+ final List<QName> path, final ModuleBuilder module) {
+ final int line = dev.getLine();
+ Builder currentParent = dependentModuleBuilder;
+
+ for (QName q : path) {
+ if (currentParent == null) {
+ throw new YangParseException(module.getName(), line, FAIL_DEVIATION_TARGET);
+ }
+ String name = q.getLocalName();
+ if (currentParent instanceof DataNodeContainerBuilder) {
+ currentParent = ((DataNodeContainerBuilder) currentParent).getDataChildByName(name);
+ }
+ }
+
+ if (!(currentParent instanceof SchemaNodeBuilder)) {
+ throw new YangParseException(module.getName(), line, FAIL_DEVIATION_TARGET);
+ }
+ dev.setTargetPath(((SchemaNodeBuilder) currentParent).getPath());
+ }
+
+}