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.*;
+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.IOException;
import java.io.InputStream;
import java.net.URI;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.TreeMap;
+import java.util.*;
import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.CommonTokenStream;
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.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleImport;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+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.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.DeviationBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ExtensionBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.IdentityrefTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.*;
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.slf4j.LoggerFactory;
import com.google.common.base.Preconditions;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
+
public final class YangParserImpl implements YangModelParser {
private static final Logger LOG = LoggerFactory.getLogger(YangParserImpl.class);
FileInputStream yangFileStream = null;
LinkedHashMap<InputStream, File> streamToFileMap = new LinkedHashMap<>();
-
try {
yangFileStream = new FileInputStream(yangFile);
streamToFileMap.put(yangFileStream, yangFile);
}
}
- Map<InputStream, ModuleBuilder> parsedBuilders = parseModuleBuilders(new ArrayList<>(streamToFileMap.keySet()),
+ 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);
-
- ModuleBuilder[] builders = new ModuleBuilder[moduleBuilders.size()];
- moduleBuilders.toArray(builders);
-
- // module dependency graph sorted
- List<ModuleBuilder> sorted = ModuleDependencySort.sort(builders);
-
- final LinkedHashMap<String, TreeMap<Date, ModuleBuilder>> modules = orderModules(sorted);
- return new LinkedHashSet<>(build(modules).values());
+ 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) {
- return Sets.newLinkedHashSet(parseYangModelsMapped(yangFiles).values());
+ 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) {
- final Map<InputStream, File> inputStreams = Maps.newHashMap();
-
- 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);
- }
+ 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);
}
+ }
- Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();
- final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(
- Lists.newArrayList(inputStreams.keySet()), builderToStreamMap);
+ 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.");
- }
+ for (InputStream is : inputStreams.keySet()) {
+ try {
+ is.close();
+ } catch (IOException e) {
+ LOG.debug("Failed to close stream.");
}
+ }
- return new LinkedHashSet<>(buildWithContext(modules, context).values());
+ final Collection<Module> unsorted = buildWithContext(modules, context).values();
+ if (context != null) {
+ for (Module m : context.getModules()) {
+ if (!unsorted.contains(m)) {
+ unsorted.add(m);
+ }
+ }
}
- return Collections.emptySet();
+ return new LinkedHashSet<>(ModuleDependencySort.sort(unsorted.toArray(new Module[unsorted.size()])));
}
@Override
public Set<Module> parseYangModelsFromStreams(final List<InputStream> yangModelStreams) {
- return Sets.newHashSet(parseYangModelsFromStreamsMapped(yangModelStreams).values());
+ 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) {
- Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();
- final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuildersWithContext(
- yangModelStreams, builderToStreamMap, context);
- return new LinkedHashSet<>(buildWithContext(modules, context).values());
+ if (yangModelStreams == null) {
+ return Collections.emptySet();
}
- return Collections.emptySet();
- }
- @Override
- public Map<File, Module> parseYangModelsMapped(List<File> yangFiles) {
- if (yangFiles != null) {
- final Map<InputStream, File> inputStreams = Maps.newHashMap();
-
- 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);
+ 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()])));
+ }
- Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();
- final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(
- Lists.newArrayList(inputStreams.keySet()), builderToStreamMap);
+ @Override
+ public Map<File, Module> parseYangModelsMapped(List<File> yangFiles) {
+ if (yangFiles == null) {
+ return Collections.emptyMap();
+ }
- for (InputStream is : inputStreams.keySet()) {
- try {
- is.close();
- } catch (IOException e) {
- LOG.debug("Failed to close stream.");
- }
+ 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);
}
+ }
- Map<File, Module> retVal = Maps.newLinkedHashMap();
- Map<ModuleBuilder, Module> builderToModuleMap = build(modules);
+ List<InputStream> yangModelStreams = new ArrayList<>(inputStreams.keySet());
+ Map<ModuleBuilder, InputStream> builderToStreamMap = new HashMap<>();
+ Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(yangModelStreams, builderToStreamMap,
+ null);
- for (Entry<ModuleBuilder, Module> builderToModule : builderToModuleMap.entrySet()) {
- retVal.put(inputStreams.get(builderToStreamMap.get(builderToModule.getKey())),
- builderToModule.getValue());
+ for (InputStream is : inputStreams.keySet()) {
+ try {
+ is.close();
+ } catch (IOException e) {
+ LOG.debug("Failed to close stream.");
}
+ }
- return retVal;
+ 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 Collections.emptyMap();
+ return result;
}
@Override
public Map<InputStream, Module> parseYangModelsFromStreamsMapped(final List<InputStream> yangModelStreams) {
- Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();
+ if (yangModelStreams == null) {
+ return Collections.emptyMap();
+ }
- final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(yangModelStreams,
- builderToStreamMap);
- Map<InputStream, Module> retVal = Maps.newLinkedHashMap();
+ 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);
-
- for (Entry<ModuleBuilder, Module> builderToModule : builderToModuleMap.entrySet()) {
- retVal.put(builderToStreamMap.get(builderToModule.getKey()), builderToModule.getValue());
+ 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 retVal;
+ return result;
}
@Override
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<>();
// 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<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuilders(final List<InputStream> yangFileStreams,
- Map<ModuleBuilder, InputStream> streamToBuilderMap) {
- return resolveModuleBuildersWithContext(yangFileStreams, streamToBuilderMap, null);
+ 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 Map<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuildersWithContext(
- final List<InputStream> yangFileStreams, final Map<ModuleBuilder, InputStream> streamToBuilderMap,
- final SchemaContext context) {
+ 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().putAll(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);
} else {
sorted = ModuleDependencySort.sortWithContext(context, builders);
}
-
return orderModules(sorted);
}
* @return modules ordered by name and revision
*/
private LinkedHashMap<String, TreeMap<Date, ModuleBuilder>> orderModules(List<ModuleBuilder> modules) {
- // LinkedHashMap must be used to preserve order
- LinkedHashMap<String, TreeMap<Date, ModuleBuilder>> result = new LinkedHashMap<>();
+ final LinkedHashMap<String, TreeMap<Date, ModuleBuilder>> result = new LinkedHashMap<>();
for (final ModuleBuilder builder : modules) {
if (builder == null) {
continue;
}
private void filterImports(ModuleBuilder main, List<ModuleBuilder> other, List<ModuleBuilder> filtered) {
- for (ModuleImport mi : main.getModuleImports()) {
+ 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) {
}
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
resolveUsesTargetGrouping(modules, null);
resolveUsesForGroupings(modules, null);
resolveUsesForNodes(modules, null);
- resolveAugments(modules);
+ resolveAugments(modules, null);
resolveDeviations(modules);
// build
resolveUsesTargetGrouping(modules, context);
resolveUsesForGroupings(modules, context);
resolveUsesForNodes(modules, context);
- resolveAugmentsWithContext(modules, context);
+ resolveAugments(modules, context);
resolveDeviationsWithContext(modules, context);
// build
throw new YangParseException(module.getName(), idref.getLine(), "Failed to find base identity");
}
idref.setBaseIdentity(identity);
- nodeToResolve.setType(idref.build(null));
+ nodeToResolve.setType(idref.build());
} else {
resolveType(nodeToResolve, modules, module);
}
IdentitySchemaNodeBuilder identity = findBaseIdentity(modules, module, idref.getBaseString(),
idref.getLine());
idref.setBaseIdentity(identity);
- nodeToResolve.setType(idref.build(null));
+ nodeToResolve.setType(idref.build());
} else {
resolveTypeWithContext(nodeToResolve, modules, module, context);
}
}
private void correctPathForAugmentNodes(DataSchemaNodeBuilder node, SchemaPath parentPath) {
- node.setPath(ParserUtils.createSchemaPath(parentPath, node.getQName()));
+ SchemaPath newPath = ParserUtils.createSchemaPath(parentPath, node.getQName());
+ node.setPath(newPath);
if (node instanceof DataNodeContainerBuilder) {
for (DataSchemaNodeBuilder child : ((DataNodeContainerBuilder) node).getChildNodeBuilders()) {
correctPathForAugmentNodes(child, node.getPath());
}
}
- }
-
- /**
- * Go through all augment definitions and perform augmentation. It is
- * expected that modules are already sorted by their dependencies.
- *
- * @param modules
- * all loaded modules
- */
- private void resolveAugments(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
- // 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());
- }
- }
-
- checkAugmentMandatoryNodes(allAugments);
-
- for (int i = 0; i < allAugments.size(); i++) {
- // pick one augment
- final AugmentationSchemaBuilder augment = allAugments.get(i);
- // create collection of others
- List<AugmentationSchemaBuilder> others = new ArrayList<>(allAugments);
- others.remove(augment);
-
- // try to resolve it
- boolean resolved = resolveAugment(modules, augment);
- // while not resolved
- int j = 0;
- while (!(resolved) && j < others.size()) {
- // try to resolve next augment
- resolveAugment(modules, others.get(j));
- // then try to resolve first again
- resolved = resolveAugment(modules, augment);
- j++;
-
- }
-
- if (!resolved) {
- throw new YangParseException(augment.getModuleName(), augment.getLine(),
- "Error in augment parsing: failed to find augment target");
+ if (node instanceof ChoiceBuilder) {
+ for (ChoiceCaseBuilder child : ((ChoiceBuilder)node).getCases()) {
+ correctPathForAugmentNodes(child, node.getPath());
}
}
}
}
}
- /**
- * Search for augment target and perform augmentation.
- *
- * @param modules
- * all loaded modules
- * @param augment
- * augment to resolve
- * @return true if target node found, false otherwise
- */
- private boolean resolveAugment(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final AugmentationSchemaBuilder augment) {
- if (augment.isResolved()) {
- return true;
- }
-
- int line = augment.getLine();
- ModuleBuilder module = getParentModule(augment);
- List<QName> path = augment.getTargetPath().getPath();
- Builder augmentParent = augment.getParent();
-
- Builder firstNodeParent;
- if (augmentParent instanceof ModuleBuilder) {
- // if augment is defined under module, parent of first node is
- // target module
- final QName firstNameInPath = path.get(0);
- String prefix = firstNameInPath.getPrefix();
- if (prefix == null) {
- prefix = module.getPrefix();
- }
- firstNodeParent = findModuleFromBuilders(modules, module, prefix, line);
- } else if (augmentParent instanceof UsesNodeBuilder) {
- firstNodeParent = augmentParent.getParent();
- } else {
- // augment can be defined only under module or uses
- throw new YangParseException(augment.getModuleName(), line,
- "Failed to parse augment: Unresolved parent of augment: " + augmentParent);
- }
-
- return processAugmentation(augment, firstNodeParent, path);
- }
-
/**
* Go through all augment definitions and resolve them. This method works in
* same way as {@link #resolveAugments(Map)} except that if target node is
* @param context
* SchemaContext containing already resolved modules
*/
- private void resolveAugmentsWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final SchemaContext context) {
- // collect augments from all loaded modules
- final List<AugmentationSchemaBuilder> allAugments = new ArrayList<>();
+ 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()) {
- allAugments.addAll(inner.getValue().getAllAugments());
+ all.add(inner.getValue());
}
}
- for (int i = 0; i < allAugments.size(); i++) {
- // pick augment from list
- final AugmentationSchemaBuilder augment = allAugments.get(i);
- // try to resolve it
- boolean resolved = resolveAugmentWithContext(modules, augment, context);
- // while not resolved
- int j = i + 1;
- while (!(resolved) && j < allAugments.size()) {
- // try to resolve next augment
- resolveAugmentWithContext(modules, allAugments.get(j), context);
- // then try to resolve first again
- resolved = resolveAugmentWithContext(modules, augment, context);
- j++;
- }
+ 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()]));
+ }
- if (!resolved) {
- throw new YangParseException(augment.getModuleName(), augment.getLine(),
- "Error in augment parsing: failed to find augment target");
+ // resolve other augments
+ for (ModuleBuilder mb : sorted) {
+ if (mb != null) {
+ List<AugmentationSchemaBuilder> augments = mb.getAllAugments();
+ checkAugmentMandatoryNodes(augments);
+ 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);
+ }
+
/**
- * Search for augment target and perform augmentation.
+ * 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 augment
- * augment to resolve
* @param context
- * SchemaContext containing already resolved modules
- * @return true if target node found, false otherwise
+ * schema context
+ * @param line
+ * current line
+ * @return
*/
- private boolean resolveAugmentWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final AugmentationSchemaBuilder augment, final SchemaContext context) {
- if (augment.isResolved()) {
- return true;
- }
- int line = augment.getLine();
- ModuleBuilder module = getParentModule(augment);
- List<QName> path = augment.getTargetNodeSchemaPath().getPath();
- final QName firstNameInPath = path.get(0);
- String prefix = firstNameInPath.getPrefix();
- if (prefix == null) {
- prefix = module.getPrefix();
- }
- Builder augmentParent = augment.getParent();
- Builder currentParent;
- if (augmentParent instanceof ModuleBuilder) {
- // if augment is defined under module, first parent is target module
- currentParent = findModuleFromBuilders(modules, module, prefix, line);
- } else if (augmentParent instanceof UsesNodeBuilder) {
- currentParent = augmentParent.getParent();
+ 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 {
- // augment can be defined only under module or uses
- throw new YangParseException(augment.getModuleName(), augment.getLine(),
- "Error in augment parsing: Unresolved parent of augment: " + augmentParent);
+ targetModule = findModuleFromBuilders(modules, module, qname.getPrefix(), line);
}
- if (currentParent == null) {
- return processAugmentationOnContext(augment, path, module, prefix, context);
- } else {
- return processAugmentation(augment, currentParent, path);
+ 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;
}
/**
* module being resolved
*/
private void resolveIdentities(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
- final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();
+ final Set<IdentitySchemaNodeBuilder> identities = module.getAddedIdentities();
for (IdentitySchemaNodeBuilder identity : identities) {
final String baseIdentityName = identity.getBaseIdentityName();
final int line = identity.getLine();
*/
private void resolveIdentitiesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
final ModuleBuilder module, final SchemaContext context) {
- final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();
+ final Set<IdentitySchemaNodeBuilder> identities = module.getAddedIdentities();
for (IdentitySchemaNodeBuilder identity : identities) {
final String baseIdentityName = identity.getBaseIdentityName();
final int line = identity.getLine();
private void resolveUses(UsesNodeBuilder usesNode,
final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
if (!usesNode.isResolved()) {
- final int line = usesNode.getLine();
DataNodeContainerBuilder parent = usesNode.getParent();
ModuleBuilder module = ParserUtils.getParentModule(parent);
GroupingBuilder target = GroupingUtils.getTargetGroupingFromModules(usesNode, modules, module);
if (target == null) {
- URI ns = null;
- Date rev = null;
- String prefix = null;
- if (parent instanceof AugmentationSchemaBuilder || parent instanceof ModuleBuilder) {
- ns = module.getNamespace();
- rev = module.getRevision();
- prefix = module.getPrefix();
- } else {
- ns = ((DataSchemaNodeBuilder) parent).getQName().getNamespace();
- rev = ((DataSchemaNodeBuilder) parent).getQName().getRevision();
- prefix = ((DataSchemaNodeBuilder) parent).getQName().getPrefix();
- }
-
- Set<DataSchemaNodeBuilder> childNodes = GroupingUtils.getTargetGroupingDefinitionNodesWithNewNamespace(
- usesNode, ns, rev, prefix, module.getName(), line);
- parent.getChildNodeBuilders().addAll(childNodes);
- Set<TypeDefinitionBuilder> typedefs = GroupingUtils
- .getTargetGroupingDefinitionTypedefsWithNewNamespace(usesNode, ns, rev, prefix,
- module.getName(), line);
- parent.getTypeDefinitionBuilders().addAll(typedefs);
- Set<GroupingBuilder> groupings = GroupingUtils.getTargetGroupingDefinitionGroupingsWithNewNamespace(
- usesNode, ns, rev, prefix, module.getName(), line);
- parent.getGroupingBuilders().addAll(groupings);
- List<UnknownSchemaNodeBuilder> unknownNodes = GroupingUtils
- .getTargetGroupingDefinitionUnknownNodesWithNewNamespace(usesNode, ns, rev, prefix,
- module.getName(), line);
- parent.getUnknownNodeBuilders().addAll(unknownNodes);
+ resolveUsesWithContext(usesNode);
usesNode.setResolved(true);
-
for (AugmentationSchemaBuilder augment : usesNode.getAugmentations()) {
- processAugmentationOnContext(augment, augment.getTargetPath().getPath(), module, prefix, context);
+ resolveUsesAugment(augment, module, modules, context);
}
- GroupingUtils.performRefine(usesNode);
} else {
parent.getChildNodeBuilders().addAll(target.instantiateChildNodes(parent));
parent.getTypeDefinitionBuilders().addAll(target.instantiateTypedefs(parent));
parent.getGroupingBuilders().addAll(target.instantiateGroupings(parent));
- parent.getUnknownNodeBuilders().addAll(target.instantiateUnknownNodes(parent));
+ parent.getUnknownNodes().addAll(target.instantiateUnknownNodes(parent));
usesNode.setResolved(true);
-
for (AugmentationSchemaBuilder augment : usesNode.getAugmentations()) {
- processAugmentation(augment, parent, augment.getTargetPath().getPath());
+ resolveUsesAugment(augment, module, modules, context);
}
- GroupingUtils.performRefine(usesNode);
}
+ 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);
}
}
try {
ModuleBuilder dependentModule = findModuleFromBuilders(modules, module, nodeType.getPrefix(),
usnb.getLine());
- for (ExtensionBuilder extension : dependentModule.getExtensions()) {
+ for (ExtensionBuilder extension : dependentModule.getAddedExtensions()) {
if (extension.getQName().getLocalName().equals(nodeType.getLocalName())) {
usnb.setNodeType(extension.getQName());
usnb.setExtensionBuilder(extension);
}
}
} else {
- for (ExtensionBuilder extension : dependentModuleBuilder.getExtensions()) {
+ for (ExtensionBuilder extension : dependentModuleBuilder.getAddedExtensions()) {
if (extension.getQName().getLocalName().equals(nodeType.getLocalName())) {
usnb.setExtensionBuilder(extension);
break;
* module in which resolve deviations
*/
private void resolveDeviation(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
- for (DeviationBuilder dev : module.getDeviations()) {
+ for (DeviationBuilder dev : module.getDeviationBuilders()) {
int line = dev.getLine();
SchemaPath targetPath = dev.getTargetPath();
List<QName> path = targetPath.getPath();
*/
private void resolveDeviationWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
final ModuleBuilder module, final SchemaContext context) {
- for (DeviationBuilder dev : module.getDeviations()) {
+ for (DeviationBuilder dev : module.getDeviationBuilders()) {
int line = dev.getLine();
SchemaPath targetPath = dev.getTargetPath();
List<QName> path = targetPath.getPath();