import java.io.FileNotFoundException;
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 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.parser.api.YangModelParser;
-import org.opendaylight.yangtools.yang.model.util.IdentityrefType;
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.slf4j.Logger;
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;
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 = parseModuleBuilders(
+ 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());
+ }
+
@Override
public Set<Module> parseYangModels(final List<File> yangFiles) {
return Sets.newLinkedHashSet(parseYangModelsMapped(yangFiles).values());
}
Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();
-
final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(
Lists.newArrayList(inputStreams.keySet()), builderToStreamMap);
}
}
- return new LinkedHashSet<Module>(buildWithContext(modules, context).values());
+ return new LinkedHashSet<>(buildWithContext(modules, context).values());
}
return Collections.emptySet();
}
Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();
final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuildersWithContext(
yangModelStreams, builderToStreamMap, context);
- return new LinkedHashSet<Module>(buildWithContext(modules, context).values());
+ return new LinkedHashSet<>(buildWithContext(modules, context).values());
}
return Collections.emptySet();
}
return new SchemaContextImpl(modules);
}
- private ModuleBuilder[] parseModuleBuilders(List<InputStream> inputStreams,
+ private Map<InputStream, ModuleBuilder> parseModuleBuilders(List<InputStream> inputStreams,
Map<ModuleBuilder, InputStream> streamToBuilderMap) {
final ParseTreeWalker walker = new ParseTreeWalker();
- final List<ParseTree> trees = parseStreams(inputStreams);
- final ModuleBuilder[] builders = new ModuleBuilder[trees.size()];
+ final Map<InputStream, ParseTree> trees = parseStreams(inputStreams);
+ final Map<InputStream, ModuleBuilder> builders = new LinkedHashMap<>();
// validate yang
- new YangModelBasicValidator(walker).validate(trees);
+ new YangModelBasicValidator(walker).validate(new ArrayList<>(trees.values()));
- YangParserListenerImpl yangModelParser = null;
- for (int i = 0; i < trees.size(); i++) {
+ YangParserListenerImpl yangModelParser;
+ for(Map.Entry<InputStream, ParseTree> entry : trees.entrySet()) {
yangModelParser = new YangParserListenerImpl();
- walker.walk(yangModelParser, trees.get(i));
+ 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, inputStreams.get(i));
- builders[i] = moduleBuilder;
+ streamToBuilderMap.put(moduleBuilder, entry.getKey());
+ builders.put(entry.getKey(), moduleBuilder);
}
+
return builders;
}
private Map<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuildersWithContext(
final List<InputStream> yangFileStreams, final Map<ModuleBuilder, InputStream> streamToBuilderMap,
final SchemaContext context) {
- final ModuleBuilder[] builders = parseModuleBuilders(yangFileStreams, streamToBuilderMap);
-
- // LinkedHashMap must be used to preserve order
- final LinkedHashMap<String, TreeMap<Date, ModuleBuilder>> modules = new LinkedHashMap<String, TreeMap<Date, ModuleBuilder>>();
+ Map<InputStream, ModuleBuilder> parsedBuilders = parseModuleBuilders(yangFileStreams, streamToBuilderMap);
+ ModuleBuilder[] builders = new ModuleBuilder[parsedBuilders.size()];
+ parsedBuilders.values().toArray(builders);
// module dependency graph sorted
- List<ModuleBuilder> sorted = null;
+ List<ModuleBuilder> sorted;
if (context == null) {
sorted = ModuleDependencySort.sort(builders);
} else {
sorted = ModuleDependencySort.sortWithContext(context, builders);
}
- for (final ModuleBuilder builder : sorted) {
+ 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) {
+ // LinkedHashMap must be used to preserve order
+ LinkedHashMap<String, TreeMap<Date, ModuleBuilder>> result = new LinkedHashMap<>();
+ for (final ModuleBuilder builder : modules) {
if (builder == null) {
continue;
}
if (builderRevision == null) {
builderRevision = new Date(0L);
}
- TreeMap<Date, ModuleBuilder> builderByRevision = modules.get(builderName);
+ TreeMap<Date, ModuleBuilder> builderByRevision = result.get(builderName);
if (builderByRevision == null) {
- builderByRevision = new TreeMap<Date, ModuleBuilder>();
+ builderByRevision = new TreeMap<>();
}
builderByRevision.put(builderRevision, builder);
- modules.put(builderName, builderByRevision);
+ result.put(builderName, builderByRevision);
}
- return modules;
+ return result;
}
- private List<ParseTree> parseStreams(final List<InputStream> yangStreams) {
- final List<ParseTree> trees = new ArrayList<ParseTree>();
+ private void filterImports(ModuleBuilder main, List<ModuleBuilder> other, List<ModuleBuilder> filtered) {
+ for (ModuleImport mi : main.getModuleImports()) {
+ 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.add(parseStream(yangStream));
+ trees.put(yangStream, parseStream(yangStream));
}
return trees;
}
private Map<ModuleBuilder, Module> build(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
// fix unresolved nodes
- resolveAugmentsTargetPath(modules);
+ resolveAugmentsTargetPath(modules, null);
resolveUsesTargetGrouping(modules, null);
resolveDirtyNodes(modules);
resolveAugments(modules);
resolveDeviations(modules);
// build
- final Map<ModuleBuilder, Module> result = new LinkedHashMap<ModuleBuilder, Module>();
+ final Map<ModuleBuilder, Module> result = new LinkedHashMap<>();
for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- final Map<Date, Module> modulesByRevision = new HashMap<Date, Module>();
for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
final ModuleBuilder moduleBuilder = childEntry.getValue();
final Module module = moduleBuilder.build();
- modulesByRevision.put(childEntry.getKey(), module);
result.put(moduleBuilder, module);
}
}
private Map<ModuleBuilder, Module> buildWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
final SchemaContext context) {
// fix unresolved nodes
- // TODO
- // fixAugmentsTargetPath(modules);
+ resolveAugmentsTargetPath(modules, context);
resolveUsesTargetGrouping(modules, context);
resolvedDirtyNodesWithContext(modules, context);
resolveAugmentsWithContext(modules, context);
resolveUses(modules, true);
+ resolvedUsesPostProcessing(modules, true);
resolveDeviationsWithContext(modules, context);
// build
- final Map<ModuleBuilder, Module> result = new LinkedHashMap<ModuleBuilder, Module>();
+ final Map<ModuleBuilder, Module> result = new LinkedHashMap<>();
for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- final Map<Date, Module> modulesByRevision = new HashMap<Date, Module>();
for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
final ModuleBuilder moduleBuilder = childEntry.getValue();
final Module module = moduleBuilder.build();
- modulesByRevision.put(childEntry.getKey(), module);
result.put(moduleBuilder, module);
}
}
for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
final ModuleBuilder module = childEntry.getValue();
- resolveDirtyNodes(modules, module);
- resolveIdentities(modules, module);
resolveUnknownNodes(modules, module);
+ resolveIdentities(modules, module);
+ resolveDirtyNodes(modules, module);
}
}
}
for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
final ModuleBuilder module = childEntry.getValue();
- resolveDirtyNodesWithContext(modules, module, context);
- resolveIdentitiesWithContext(modules, module, context);
resolveUnknownNodesWithContext(modules, module, context);
+ resolveIdentitiesWithContext(modules, module, context);
+ resolveDirtyNodesWithContext(modules, module, context);
}
}
}
} else if (nodeToResolve.getTypedef() instanceof IdentityrefTypeBuilder) {
// special handling for identityref types
IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder) nodeToResolve.getTypedef();
- nodeToResolve.setType(new IdentityrefType(findFullQName(modules, module, idref), idref.getPath()));
+ 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(null));
} else {
resolveType(nodeToResolve, modules, module);
}
} else if (nodeToResolve.getTypedef() instanceof IdentityrefTypeBuilder) {
// special handling for identityref types
IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder) nodeToResolve.getTypedef();
- nodeToResolve.setType(new IdentityrefType(findFullQName(modules, module, idref), idref.getPath()));
+ IdentitySchemaNodeBuilder identity = findBaseIdentity(modules, module, idref.getBaseString(),
+ idref.getLine());
+ idref.setBaseIdentity(identity);
+ nodeToResolve.setType(idref.build(null));
} else {
resolveTypeWithContext(nodeToResolve, modules, module, context);
}
* @param modules
* all loaded modules
*/
- private void resolveAugmentsTargetPath(final Map<String, TreeMap<Date, ModuleBuilder>> 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 (AugmentationSchemaBuilder augment : allAugments) {
- setCorrectAugmentTargetPath(modules, augment);
+ setCorrectAugmentTargetPath(modules, augment, context);
}
}
private void setCorrectAugmentTargetPath(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final AugmentationSchemaBuilder augmentBuilder) {
- ModuleBuilder module = ParserUtils.getParentModule(augmentBuilder);
- SchemaPath oldSchemaPath = augmentBuilder.getTargetPath();
+ 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<>();
for (QName qn : oldPath) {
- ModuleBuilder currentModule = null;
- String prefix = qn.getPrefix();
- if (prefix == null || "".equals(prefix)) {
- currentModule = module;
- } else {
- currentModule = ParserUtils.findDependentModuleBuilder(modules, module, prefix,
- augmentBuilder.getLine());
+ 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();
+ }
}
- QName newQName = new QName(currentModule.getNamespace(), currentModule.getRevision(), prefix,
- qn.getLocalName());
- newPath.add(newQName);
+ newPath.add(new QName(ns, rev, pref, qn.getLocalName()));
}
- augmentBuilder.setTargetPath(new SchemaPath(newPath, augmentBuilder.getTargetPath().isAbsolute()));
+ augment.setTargetNodeSchemaPath(new SchemaPath(newPath, augment.getTargetPath().isAbsolute()));
}
/**
List<QName> path = augment.getTargetPath().getPath();
Builder augmentParent = augment.getParent();
- Builder firstNodeParent = null;
+ Builder firstNodeParent;
if (augmentParent instanceof ModuleBuilder) {
// if augment is defined under module, parent of first node is
// target module
if (prefix == null) {
prefix = module.getPrefix();
}
- firstNodeParent = findDependentModuleBuilder(modules, module, prefix, line);
+ firstNodeParent = findModuleFromBuilders(modules, module, prefix, line);
} else if (augmentParent instanceof UsesNodeBuilder) {
firstNodeParent = augmentParent.getParent();
} else {
}
int line = augment.getLine();
ModuleBuilder module = getParentModule(augment);
- List<QName> path = augment.getTargetPath().getPath();
+ 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 = null;
-
+ Builder currentParent;
if (augmentParent instanceof ModuleBuilder) {
// if augment is defined under module, first parent is target module
- currentParent = findDependentModuleBuilder(modules, module, prefix, line);
+ currentParent = findModuleFromBuilders(modules, module, prefix, line);
} else if (augmentParent instanceof UsesNodeBuilder) {
currentParent = augmentParent.getParent();
} else {
final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();
for (IdentitySchemaNodeBuilder identity : identities) {
final String baseIdentityName = identity.getBaseIdentityName();
+ final int line = identity.getLine();
if (baseIdentityName != null) {
- String baseIdentityPrefix = null;
- String baseIdentityLocalName = null;
- if (baseIdentityName.contains(":")) {
- final String[] splitted = baseIdentityName.split(":");
- baseIdentityPrefix = splitted[0];
- baseIdentityLocalName = splitted[1];
+ IdentitySchemaNodeBuilder baseIdentity = findBaseIdentity(modules, module, baseIdentityName, line);
+ if (baseIdentity == null) {
+ throw new YangParseException(module.getName(), identity.getLine(), "Failed to find base identity");
} else {
- baseIdentityPrefix = module.getPrefix();
- baseIdentityLocalName = baseIdentityName;
- }
- final ModuleBuilder dependentModule = findDependentModuleBuilder(modules, module, baseIdentityPrefix,
- identity.getLine());
-
- final Set<IdentitySchemaNodeBuilder> dependentModuleIdentities = dependentModule.getIdentities();
- for (IdentitySchemaNodeBuilder idBuilder : dependentModuleIdentities) {
- if (idBuilder.getQName().getLocalName().equals(baseIdentityLocalName)) {
- identity.setBaseIdentity(idBuilder);
- }
+ identity.setBaseIdentity(baseIdentity);
}
}
}
final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();
for (IdentitySchemaNodeBuilder identity : identities) {
final String baseIdentityName = identity.getBaseIdentityName();
+ final int line = identity.getLine();
if (baseIdentityName != null) {
- String baseIdentityPrefix = null;
- String baseIdentityLocalName = null;
- if (baseIdentityName.contains(":")) {
- final String[] splitted = baseIdentityName.split(":");
- baseIdentityPrefix = splitted[0];
- baseIdentityLocalName = splitted[1];
+ IdentitySchemaNodeBuilder baseIdentity = findBaseIdentity(modules, module, baseIdentityName, line);
+ if (baseIdentity == null) {
+ IdentitySchemaNode baseId = findBaseIdentityFromContext(modules, module, baseIdentityName, line,
+ context);
+ identity.setBaseIdentity(baseId);
} else {
- baseIdentityPrefix = module.getPrefix();
- baseIdentityLocalName = baseIdentityName;
- }
- final ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module,
- baseIdentityPrefix, identity.getLine());
-
- if (dependentModuleBuilder == null) {
- final Module dependentModule = findModuleFromContext(context, module, baseIdentityPrefix,
- identity.getLine());
- final Set<IdentitySchemaNode> dependentModuleIdentities = dependentModule.getIdentities();
- for (IdentitySchemaNode idNode : dependentModuleIdentities) {
- if (idNode.getQName().getLocalName().equals(baseIdentityLocalName)) {
- identity.setBaseIdentity(idNode);
- }
- }
- } else {
- final Set<IdentitySchemaNodeBuilder> dependentModuleIdentities = dependentModuleBuilder
- .getIdentities();
- for (IdentitySchemaNodeBuilder idBuilder : dependentModuleIdentities) {
- if (idBuilder.getQName().getLocalName().equals(baseIdentityLocalName)) {
- identity.setBaseIdentity(idBuilder);
- }
- }
+ identity.setBaseIdentity(baseIdentity);
}
}
}
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 = null;
boolean dataCollected = module.isAllUsesDataCollected();
+ List<UsesNodeBuilder> usesNodes;
while (!dataCollected) {
usesNodes = new ArrayList<>(module.getAllUsesNodes());
for (UsesNodeBuilder usesNode : usesNodes) {
for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {
QName nodeType = usnb.getNodeType();
try {
- ModuleBuilder dependentModule = findDependentModuleBuilder(modules, module, nodeType.getPrefix(),
+ ModuleBuilder dependentModule = findModuleFromBuilders(modules, module, nodeType.getPrefix(),
usnb.getLine());
for (ExtensionBuilder extension : dependentModule.getExtensions()) {
if (extension.getQName().getLocalName().equals(nodeType.getLocalName())) {
for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {
QName nodeType = usnb.getNodeType();
try {
- ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module,
+ ModuleBuilder dependentModuleBuilder = findModuleFromBuilders(modules, module,
nodeType.getPrefix(), usnb.getLine());
if (dependentModuleBuilder == null) {
prefix = module.getPrefix();
}
- ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module, prefix, line);
+ ModuleBuilder dependentModuleBuilder = findModuleFromBuilders(modules, module, prefix, line);
processDeviation(dev, dependentModuleBuilder, path, module);
}
}
if (prefix == null) {
prefix = module.getPrefix();
}
- String name = null;
- ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module, prefix, line);
+ ModuleBuilder dependentModuleBuilder = findModuleFromBuilders(modules, module, prefix, line);
if (dependentModuleBuilder == null) {
- Module dependentModule = findModuleFromContext(context, module, prefix, line);
- Object currentParent = dependentModule;
+ Object currentParent = findModuleFromContext(context, module, prefix, line);
- for (int i = 0; i < path.size(); i++) {
+ for (QName q : path) {
if (currentParent == null) {
throw new YangParseException(module.getName(), line, FAIL_DEVIATION_TARGET);
}
- QName q = path.get(i);
- name = q.getLocalName();
+ String name = q.getLocalName();
if (currentParent instanceof DataNodeContainer) {
currentParent = ((DataNodeContainer) currentParent).getDataChildByName(name);
}
final int line = dev.getLine();
Builder currentParent = dependentModuleBuilder;
- for (int i = 0; i < path.size(); i++) {
+ for (QName q : path) {
if (currentParent == null) {
throw new YangParseException(module.getName(), line, FAIL_DEVIATION_TARGET);
}
- QName q = path.get(i);
String name = q.getLocalName();
if (currentParent instanceof DataNodeContainerBuilder) {
currentParent = ((DataNodeContainerBuilder) currentParent).getDataChildByName(name);