import org.opendaylight.controller.antlrv4.code.gen.YangLexer;
import org.opendaylight.controller.antlrv4.code.gen.YangParser;
import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.controller.yang.model.api.ChoiceNode;
+import org.opendaylight.controller.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.controller.yang.model.api.DataNodeContainer;
+import org.opendaylight.controller.yang.model.api.DataSchemaNode;
import org.opendaylight.controller.yang.model.api.GroupingDefinition;
import org.opendaylight.controller.yang.model.api.IdentitySchemaNode;
+import org.opendaylight.controller.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
+import org.opendaylight.controller.yang.model.api.ListSchemaNode;
import org.opendaylight.controller.yang.model.api.Module;
import org.opendaylight.controller.yang.model.api.SchemaContext;
+import org.opendaylight.controller.yang.model.api.SchemaNode;
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
+import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.controller.yang.model.api.UsesNode;
import org.opendaylight.controller.yang.model.parser.api.YangModelParser;
import org.opendaylight.controller.yang.model.util.ExtendedType;
import org.opendaylight.controller.yang.model.util.IdentityrefType;
import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.controller.yang.parser.builder.api.Builder;
import org.opendaylight.controller.yang.parser.builder.api.DataNodeContainerBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.GroupingMember;
import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeAwareBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.AnyXmlBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.ChoiceBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.DeviationBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.GroupingBuilderImpl;
import org.opendaylight.controller.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.IdentityrefTypeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.LeafSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.ListSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ModuleBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.RpcDefinitionBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.TypeDefinitionBuilderImpl;
import org.opendaylight.controller.yang.parser.builder.impl.UnionTypeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.UsesNodeBuilderImpl;
+import org.opendaylight.controller.yang.parser.builder.impl.UsesNodeBuilderImpl.UsesNodeImpl;
import org.opendaylight.controller.yang.parser.util.ModuleDependencySort;
import org.opendaylight.controller.yang.parser.util.RefineHolder;
import org.opendaylight.controller.yang.parser.util.RefineUtils;
import com.google.common.collect.Sets;
public final class YangParserImpl implements YangModelParser {
-
- private static final Logger logger = LoggerFactory.getLogger(YangParserImpl.class);
+ private static final Logger LOG = LoggerFactory.getLogger(YangParserImpl.class);
@Override
public Set<Module> parseYangModels(final List<File> yangFiles) {
try {
inputStreams.put(new FileInputStream(yangFile), yangFile);
} catch (FileNotFoundException e) {
- logger.warn("Exception while reading yang file: " + yangFile.getName(), e);
+ LOG.warn("Exception while reading yang file: " + yangFile.getName(), e);
}
}
try {
is.close();
} catch (IOException e) {
- logger.debug("Failed to close stream.");
+ LOG.debug("Failed to close stream.");
}
}
try {
inputStreams.put(new FileInputStream(yangFile), yangFile);
} catch (FileNotFoundException e) {
- logger.warn("Exception while reading yang file: " + yangFile.getName(), e);
+ LOG.warn("Exception while reading yang file: " + yangFile.getName(), e);
}
}
try {
is.close();
} catch (IOException e) {
- logger.debug("Failed to close stream.");
+ LOG.debug("Failed to close stream.");
}
}
result = parser.yang();
} catch (IOException e) {
- logger.warn("Exception while reading yang file: " + yangStream, e);
+ LOG.warn("Exception while reading yang file: " + yangStream, e);
}
return result;
}
}
}
resolveAugments(modules);
+ resolveDeviations(modules);
// build
// LinkedHashMap MUST be used otherwise the values will not maintain
}
}
resolveAugmentsWithContext(modules, context);
+ resolveDeviationsWithContext(modules, context);
// build
// LinkedHashMap MUST be used otherwise the values will not maintain
* current module
*/
private void resolveDirtyNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
- final Map<List<String>, TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();
+ final Set<TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();
if (!dirtyNodes.isEmpty()) {
- for (Map.Entry<List<String>, TypeAwareBuilder> entry : dirtyNodes.entrySet()) {
- final TypeAwareBuilder nodeToResolve = entry.getValue();
-
+ for (TypeAwareBuilder nodeToResolve : dirtyNodes) {
if (nodeToResolve instanceof UnionTypeBuilder) {
// special handling for union types
resolveTypeUnion((UnionTypeBuilder) nodeToResolve, modules, module);
private void resolveDirtyNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
final ModuleBuilder module, SchemaContext context) {
- final Map<List<String>, TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();
+ final Set<TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();
if (!dirtyNodes.isEmpty()) {
- for (Map.Entry<List<String>, TypeAwareBuilder> entry : dirtyNodes.entrySet()) {
- final TypeAwareBuilder nodeToResolve = entry.getValue();
-
+ for (TypeAwareBuilder nodeToResolve : dirtyNodes) {
if (nodeToResolve instanceof UnionTypeBuilder) {
// special handling for union types
resolveTypeUnionWithContext((UnionTypeBuilder) nodeToResolve, modules, module, context);
final ModuleBuilder dependentModule = findDependentModuleBuilder(modules, module, unknownTypeQName.getPrefix(),
line);
- final TypeDefinitionBuilder targetTypeBuilder = findTypeDefinitionBuilder(nodeToResolve.getPath(),
- dependentModule, unknownTypeQName.getLocalName(), module.getName(), line);
+ final TypeDefinitionBuilder targetTypeBuilder = findTypeDefinitionBuilder(nodeToResolve, dependentModule,
+ unknownTypeQName.getLocalName(), module.getName(), line);
if (nodeToResolveType instanceof ExtendedType) {
final ExtendedType extType = (ExtendedType) nodeToResolveType;
nodeToResolve.setTypedef(newType);
} else {
- if(nodeToResolve instanceof TypeDefinitionBuilder) {
- TypeDefinitionBuilder tdb = (TypeDefinitionBuilder)nodeToResolve;
- TypeConstraints tc = findConstraintsFromTypeBuilder(nodeToResolve, new TypeConstraints(module.getName(), nodeToResolve.getLine()), modules, module, context);
+ if (nodeToResolve instanceof TypeDefinitionBuilder) {
+ TypeDefinitionBuilder tdb = (TypeDefinitionBuilder) nodeToResolve;
+ TypeConstraints tc = findConstraintsFromTypeBuilder(nodeToResolve,
+ new TypeConstraints(module.getName(), nodeToResolve.getLine()), modules, module, context);
tdb.setLengths(tc.getLength());
tdb.setPatterns(tc.getPatterns());
tdb.setRanges(tc.getRange());
}
} else {
- final TypeDefinitionBuilder targetTypeBuilder = findTypeDefinitionBuilder(nodeToResolve.getPath(),
+ final TypeDefinitionBuilder targetTypeBuilder = findTypeDefinitionBuilder(nodeToResolve,
dependentModuleBuilder, unknownTypeQName.getLocalName(), module.getName(), line);
if (nodeToResolveType instanceof ExtendedType) {
final UnknownType ut = (UnknownType) unionType;
final ModuleBuilder dependentModule = findDependentModuleBuilder(modules, builder, ut.getQName()
.getPrefix(), union.getLine());
- final TypeDefinitionBuilder resolvedType = findTypeDefinitionBuilder(union.getPath(), dependentModule,
- ut.getQName().getLocalName(), builder.getName(), union.getLine());
+ final TypeDefinitionBuilder resolvedType = findTypeDefinitionBuilder(union, dependentModule, ut
+ .getQName().getLocalName(), builder.getName(), union.getLine());
union.setTypedef(resolvedType);
toRemove.add(ut);
} else if (unionType instanceof ExtendedType) {
final UnknownType ut = (UnknownType) extTypeBase;
final ModuleBuilder dependentModule = findDependentModuleBuilder(modules, builder, ut.getQName()
.getPrefix(), union.getLine());
- final TypeDefinitionBuilder targetTypeBuilder = findTypeDefinitionBuilder(union.getPath(),
- dependentModule, ut.getQName().getLocalName(), builder.getName(), union.getLine());
+ final TypeDefinitionBuilder targetTypeBuilder = findTypeDefinitionBuilder(union, dependentModule,
+ ut.getQName().getLocalName(), builder.getName(), union.getLine());
final TypeDefinitionBuilder newType = extendedTypeWithNewBaseTypeBuilder(targetTypeBuilder,
extType, modules, builder, union.getLine());
union.setType(type);
toRemove.add(ut);
} else {
- final TypeDefinitionBuilder resolvedType = findTypeDefinitionBuilder(union.getPath(),
- dependentModuleBuilder, utQName.getLocalName(), builder.getName(), union.getLine());
+ final TypeDefinitionBuilder resolvedType = findTypeDefinitionBuilder(union, dependentModuleBuilder,
+ utQName.getLocalName(), builder.getName(), union.getLine());
union.setTypedef(resolvedType);
toRemove.add(ut);
}
union.setTypedef(newType);
toRemove.add(extType);
} else {
- final TypeDefinitionBuilder targetTypeBuilder = findTypeDefinitionBuilder(union.getPath(),
+ final TypeDefinitionBuilder targetTypeBuilder = findTypeDefinitionBuilder(union,
dependentModuleBuilder, utQName.getLocalName(), builder.getName(), union.getLine());
final TypeDefinitionBuilder newType = extendedTypeWithNewBaseTypeBuilder(targetTypeBuilder,
resolveAugment(modules, module);
// while all augments are not resolved
final Iterator<ModuleBuilder> allModulesIterator = allModulesSet.iterator();
- while (!(module.getAugmentsResolved() == module.getAugments().size())) {
+ while (!(module.getAugmentsResolved() == module.getAllAugments().size())) {
ModuleBuilder nextModule = null;
// try resolve other module augments
try {
* current module
*/
private void resolveAugment(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
- if (module.getAugmentsResolved() < module.getAugments().size()) {
- for (AugmentationSchemaBuilder augmentBuilder : module.getAugments()) {
+ if (module.getAugmentsResolved() < module.getAllAugments().size()) {
+ for (AugmentationSchemaBuilder augmentBuilder : module.getAllAugments()) {
if (!augmentBuilder.isResolved()) {
final SchemaPath augmentTargetSchemaPath = augmentBuilder.getTargetPath();
final ModuleBuilder dependentModule = findDependentModuleBuilder(modules, module, prefix,
augmentBuilder.getLine());
- processAugmentation(augmentBuilder, path, module, qname, dependentModule);
+ processAugmentation(augmentBuilder, path, module, dependentModule);
}
}
/**
* 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.
+ * 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
resolveAugmentWithContext(modules, module, context);
// while all augments are not resolved
final Iterator<ModuleBuilder> allModulesIterator = allModulesSet.iterator();
- while (!(module.getAugmentsResolved() == module.getAugments().size())) {
+ while (!(module.getAugmentsResolved() == module.getAllAugments().size())) {
ModuleBuilder nextModule = null;
// try resolve other module augments
try {
*/
private void resolveAugmentWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
final ModuleBuilder module, final SchemaContext context) {
- if (module.getAugmentsResolved() < module.getAugments().size()) {
+ if (module.getAugmentsResolved() < module.getAllAugments().size()) {
- for (AugmentationSchemaBuilder augmentBuilder : module.getAugments()) {
+ for (AugmentationSchemaBuilder augmentBuilder : module.getAllAugments()) {
final int line = augmentBuilder.getLine();
if (!augmentBuilder.isResolved()) {
processAugmentationOnContext(augmentBuilder, path, module, prefix, line, context);
continue;
} else {
- processAugmentation(augmentBuilder, path, module, qname, dependentModuleBuilder);
+ processAugmentation(augmentBuilder, path, module, dependentModuleBuilder);
}
}
* SchemaContext containing already resolved modules
*/
private void resolveIdentitiesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder module, SchemaContext context) {
+ final ModuleBuilder module, final SchemaContext context) {
final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();
for (IdentitySchemaNodeBuilder identity : identities) {
final String baseIdentityName = identity.getBaseIdentityName();
* module being resolved
*/
private void resolveUsesRefine(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
- final Map<List<String>, UsesNodeBuilder> moduleUses = module.getUsesNodes();
- for (Map.Entry<List<String>, UsesNodeBuilder> entry : moduleUses.entrySet()) {
- final UsesNodeBuilder usesNode = entry.getValue();
+ final List<UsesNodeBuilder> allModuleUses = module.getAllUsesNodes();
+ for (UsesNodeBuilder usesNode : allModuleUses) {
+ // refine
final int line = usesNode.getLine();
final GroupingBuilder targetGrouping = getTargetGroupingFromModules(usesNode, modules, module);
usesNode.setGroupingPath(targetGrouping.getPath());
for (RefineHolder refine : usesNode.getRefines()) {
final SchemaNodeBuilder nodeToRefine = RefineUtils.getRefineNodeFromGroupingBuilder(targetGrouping,
refine, module.getName());
+ if (nodeToRefine instanceof GroupingMember) {
+ ((GroupingMember) nodeToRefine).setAddedByUses(true);
+ }
RefineUtils.performRefine(nodeToRefine, refine, line);
usesNode.addRefineNode(nodeToRefine);
}
+
+ // child nodes
+ processUsesNode(usesNode, targetGrouping);
}
}
* SchemaContext containing already resolved modules
*/
private void resolveUsesRefineWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder module, SchemaContext context) {
- final Map<List<String>, UsesNodeBuilder> moduleUses = module.getUsesNodes();
- for (Map.Entry<List<String>, UsesNodeBuilder> entry : moduleUses.entrySet()) {
- final UsesNodeBuilder usesNode = entry.getValue();
+ final ModuleBuilder module, final SchemaContext context) {
+ final List<UsesNodeBuilder> moduleUses = module.getAllUsesNodes();
+ for (UsesNodeBuilder usesNode : moduleUses) {
final int line = usesNode.getLine();
final GroupingBuilder targetGroupingBuilder = getTargetGroupingFromModules(usesNode, modules, module);
for (RefineHolder refine : usesNode.getRefines()) {
final SchemaNodeBuilder nodeToRefine = RefineUtils.getRefineNodeFromGroupingDefinition(
targetGrouping, refine, module.getName());
+ if (nodeToRefine instanceof GroupingMember) {
+ ((GroupingMember) nodeToRefine).setAddedByUses(true);
+ }
RefineUtils.performRefine(nodeToRefine, refine, line);
usesNode.addRefineNode(nodeToRefine);
}
+
+ processUsesNode(usesNode, targetGrouping);
} else {
usesNode.setGroupingPath(targetGroupingBuilder.getPath());
for (RefineHolder refine : usesNode.getRefines()) {
final SchemaNodeBuilder nodeToRefine = RefineUtils.getRefineNodeFromGroupingBuilder(
targetGroupingBuilder, refine, module.getName());
+ if (nodeToRefine instanceof GroupingMember) {
+ ((GroupingMember) nodeToRefine).setAddedByUses(true);
+ }
RefineUtils.performRefine(nodeToRefine, refine, line);
usesNode.addRefineNode(nodeToRefine);
}
+
+ processUsesNode(usesNode, targetGroupingBuilder);
}
}
}
return null;
}
- List<QName> path = usesBuilder.getPath().getPath();
GroupingBuilder result = null;
- Set<GroupingBuilder> groupings = dependentModule.getModuleGroupings();
+ Set<GroupingBuilder> groupings = dependentModule.getGroupingBuilders();
result = findGroupingBuilder(groupings, groupingName);
+ if (result != null) {
+ return result;
+ }
- if (result == null) {
- Builder currentNode = null;
- final List<String> currentPath = new ArrayList<String>();
- currentPath.add(dependentModule.getName());
-
- for (int i = 0; i < path.size(); i++) {
- QName qname = path.get(i);
- currentPath.add(qname.getLocalName());
- currentNode = dependentModule.getModuleNode(currentPath);
-
- if (currentNode instanceof RpcDefinitionBuilder) {
- groupings = ((RpcDefinitionBuilder) currentNode).getGroupings();
- } else if (currentNode instanceof DataNodeContainerBuilder) {
- groupings = ((DataNodeContainerBuilder) currentNode).getGroupings();
- } else {
- groupings = Collections.emptySet();
- }
+ Builder parent = usesBuilder.getParent();
- result = findGroupingBuilder(groupings, groupingName);
- if (result != null) {
- break;
- }
+ while (parent != null) {
+ if (parent instanceof DataNodeContainerBuilder) {
+ groupings = ((DataNodeContainerBuilder) parent).getGroupingBuilders();
+ } else if (parent instanceof RpcDefinitionBuilder) {
+ groupings = ((RpcDefinitionBuilder) parent).getGroupings();
+ }
+ result = findGroupingBuilder(groupings, groupingName);
+ if (result == null) {
+ parent = parent.getParent();
+ } else {
+ break;
}
}
+ if (result == null) {
+ throw new YangParseException(module.getName(), line, "Referenced grouping '" + groupingName
+ + "' not found.");
+ }
return result;
}
* @return grouping with given name if found, null otherwise
*/
private GroupingDefinition getTargetGroupingFromContext(final UsesNodeBuilder usesBuilder,
- final ModuleBuilder module, SchemaContext context) {
+ final ModuleBuilder module, final SchemaContext context) {
final int line = usesBuilder.getLine();
String groupingString = usesBuilder.getGroupingName();
String groupingPrefix;
return findGroupingDefinition(dependentModule.getGroupings(), groupingName);
}
+ /**
+ * Add nodes defined in target grouping to current context.
+ *
+ * @param usesNode
+ * @param targetGrouping
+ */
+ private void processUsesNode(final UsesNodeBuilder usesNode, final GroupingBuilder targetGrouping) {
+ List<SchemaNodeBuilder> refineNodes = usesNode.getRefineNodes();
+ DataNodeContainerBuilder parent = usesNode.getParent();
+ SchemaPath parentPath = parent.getPath();
+ for (DataSchemaNodeBuilder child : targetGrouping.getChildNodeBuilders()) {
+ if (child != null) {
+ // if node is refined, take it from refined nodes and continue
+ SchemaNodeBuilder refined = getRefined(child.getQName(), refineNodes);
+ if (refined != null) {
+ refined.setPath(createSchemaPath(parentPath, refined.getQName().getLocalName()));
+ parent.addChildNode((DataSchemaNodeBuilder) refined);
+ continue;
+ }
+
+ DataSchemaNodeBuilder newChild = null;
+ if (child instanceof AnyXmlBuilder) {
+ newChild = new AnyXmlBuilder((AnyXmlBuilder) child);
+ } else if (child instanceof ChoiceBuilder) {
+ newChild = new ChoiceBuilder((ChoiceBuilder) child);
+ } else if (child instanceof ContainerSchemaNodeBuilder) {
+ newChild = new ContainerSchemaNodeBuilder((ContainerSchemaNodeBuilder) child);
+ } else if (child instanceof LeafListSchemaNodeBuilder) {
+ newChild = new LeafListSchemaNodeBuilder((LeafListSchemaNodeBuilder) child);
+ } else if (child instanceof LeafSchemaNodeBuilder) {
+ newChild = new LeafSchemaNodeBuilder((LeafSchemaNodeBuilder) child);
+ } else if (child instanceof ListSchemaNodeBuilder) {
+ newChild = new ListSchemaNodeBuilder((ListSchemaNodeBuilder) child);
+ }
+
+ if (newChild == null) {
+ throw new YangParseException(usesNode.getLine(),
+ "Unknown member of target grouping while resolving uses node.");
+ }
+
+ if (newChild instanceof GroupingMember) {
+ ((GroupingMember) newChild).setAddedByUses(true);
+ }
+
+ newChild.setPath(createSchemaPath(parentPath, newChild.getQName().getLocalName()));
+ parent.addChildNode(newChild);
+ }
+ }
+ for (GroupingBuilder g : targetGrouping.getGroupingBuilders()) {
+ GroupingBuilder newGrouping = new GroupingBuilderImpl(g);
+ newGrouping.setAddedByUses(true);
+ newGrouping.setPath(createSchemaPath(parentPath, newGrouping.getQName().getLocalName()));
+ parent.addGrouping(newGrouping);
+ }
+ for (TypeDefinitionBuilder td : targetGrouping.getTypeDefinitionBuilders()) {
+ TypeDefinitionBuilder newType = new TypeDefinitionBuilderImpl(td);
+ newType.setAddedByUses(true);
+ newType.setPath(createSchemaPath(parentPath, newType.getQName().getLocalName()));
+ parent.addTypedef(newType);
+ }
+ for (UsesNodeBuilder un : targetGrouping.getUses()) {
+ UsesNodeBuilder newUses = new UsesNodeBuilderImpl(un);
+ newUses.setAddedByUses(true);
+ // uses has not path
+ parent.addUsesNode(newUses);
+ }
+ for (UnknownSchemaNodeBuilder un : targetGrouping.getUnknownNodeBuilders()) {
+ UnknownSchemaNodeBuilder newUn = new UnknownSchemaNodeBuilder(un);
+ newUn.setAddedByUses(true);
+ newUn.setPath(createSchemaPath(parentPath, un.getQName().getLocalName()));
+ parent.addUnknownNodeBuilder(newUn);
+ }
+ }
+
+ private void processUsesNode(final UsesNodeBuilder usesNode, final GroupingDefinition targetGrouping) {
+ final int line = usesNode.getLine();
+ List<SchemaNodeBuilder> refineNodes = usesNode.getRefineNodes();
+ DataNodeContainerBuilder parent = usesNode.getParent();
+ SchemaPath parentPath = parent.getPath();
+ for (DataSchemaNode child : targetGrouping.getChildNodes()) {
+ if (child != null) {
+ // if node is refined, take it from refined nodes and continue
+ SchemaNodeBuilder refined = getRefined(child.getQName(), refineNodes);
+ if (refined != null) {
+ refined.setPath(createSchemaPath(parentPath, refined.getQName().getLocalName()));
+ parent.addChildNode((DataSchemaNodeBuilder) refined);
+ continue;
+ }
+
+ DataSchemaNodeBuilder newChild = null;
+ if (child instanceof AnyXmlSchemaNode) {
+ newChild = createAnyXml((AnyXmlSchemaNode) child, line);
+ } else if (child instanceof ChoiceNode) {
+ newChild = createChoice((ChoiceNode) child, line);
+ } else if (child instanceof ContainerSchemaNode) {
+ newChild = createContainer((ContainerSchemaNode) child, line);
+ } else if (child instanceof LeafListSchemaNode) {
+ newChild = createLeafList((LeafListSchemaNode) child, line);
+ } else if (child instanceof LeafSchemaNode) {
+ newChild = createLeafBuilder((LeafSchemaNode) child, line);
+ } else if (child instanceof ListSchemaNode) {
+ newChild = createList((ListSchemaNode) child, line);
+ }
+
+ if (newChild == null) {
+ throw new YangParseException(usesNode.getLine(),
+ "Unknown member of target grouping while resolving uses node.");
+ }
+
+ if (newChild instanceof GroupingMember) {
+ ((GroupingMember) newChild).setAddedByUses(true);
+ }
+ newChild.setPath(createSchemaPath(parentPath, newChild.getQName().getLocalName()));
+ parent.addChildNode(newChild);
+ }
+ }
+ for (GroupingDefinition g : targetGrouping.getGroupings()) {
+ GroupingBuilder newGrouping = createGrouping(g, line);
+ newGrouping.setAddedByUses(true);
+ newGrouping.setPath(createSchemaPath(parentPath, newGrouping.getQName().getLocalName()));
+ parent.addGrouping(newGrouping);
+ }
+ for (TypeDefinition<?> td : targetGrouping.getTypeDefinitions()) {
+ TypeDefinitionBuilder newType = createTypedef((ExtendedType) td, line);
+ newType.setAddedByUses(true);
+ newType.setPath(createSchemaPath(parentPath, newType.getQName().getLocalName()));
+ parent.addTypedef(newType);
+ }
+ for (UsesNode un : targetGrouping.getUses()) {
+ if (un instanceof UsesNodeImpl) {
+ UsesNodeBuilder newUses = new UsesNodeBuilderImpl(((UsesNodeImpl) un).toBuilder());
+ newUses.setAddedByUses(true);
+ // uses has not path
+ parent.addUsesNode(newUses);
+ }
+ }
+ for (UnknownSchemaNode un : targetGrouping.getUnknownSchemaNodes()) {
+ UnknownSchemaNodeBuilder newNode = createUnknownSchemaNode(un, line);
+ newNode.setAddedByUses(true);
+ newNode.setPath(createSchemaPath(parentPath, un.getQName().getLocalName()));
+ parent.addUnknownNodeBuilder(newNode);
+ }
+ }
+
private QName findFullQName(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module,
final IdentityrefTypeBuilder idref) {
QName result = null;
}
private void resolveUnknownNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
- for (UnknownSchemaNodeBuilder usnb : module.getUnknownNodes()) {
+ for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {
QName nodeType = usnb.getNodeType();
if (nodeType.getNamespace() == null || nodeType.getRevision() == null) {
try {
nodeType.getPrefix(), nodeType.getLocalName());
usnb.setNodeType(newNodeType);
} catch (YangParseException e) {
- logger.debug(module.getName(), usnb.getLine(), "Failed to find unknown node type: " + nodeType);
+ LOG.debug(module.getName(), usnb.getLine(), "Failed to find unknown node type: " + nodeType);
}
}
}
}
private void resolveUnknownNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder module, SchemaContext context) {
- for (UnknownSchemaNodeBuilder unknownNodeBuilder : module.getUnknownNodes()) {
+ final ModuleBuilder module, final SchemaContext context) {
+ for (UnknownSchemaNodeBuilder unknownNodeBuilder : module.getAllUnknownNodes()) {
QName nodeType = unknownNodeBuilder.getNodeType();
if (nodeType.getNamespace() == null || nodeType.getRevision() == null) {
try {
unknownNodeBuilder.setNodeType(newNodeType);
} catch (YangParseException e) {
- logger.debug(module.getName(), unknownNodeBuilder.getLine(), "Failed to find unknown node type: "
+ LOG.debug(module.getName(), unknownNodeBuilder.getLine(), "Failed to find unknown node type: "
+ nodeType);
}
}
}
}
+ 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);
+ }
+ }
+ }
+
+ private void resolveDeviation(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
+ for (DeviationBuilder dev : module.getDeviations()) {
+ 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 = findDependentModuleBuilder(modules, module, prefix, line);
+ processDeviation(dev, dependentModuleBuilder, path, module);
+ }
+ }
+
+ 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);
+ }
+ }
+ }
+
+ private void resolveDeviationWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final ModuleBuilder module, final SchemaContext context) {
+ for (DeviationBuilder dev : module.getDeviations()) {
+ 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();
+ }
+ String name = null;
+
+ ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module, prefix, line);
+ if (dependentModuleBuilder == null) {
+ Module dependentModule = findModuleFromContext(context, module, prefix, line);
+ Object currentParent = dependentModule;
+
+ for (int i = 0; i < path.size(); i++) {
+ if (currentParent == null) {
+ throw new YangParseException(module.getName(), line, "Failed to find deviation target.");
+ }
+ QName q = path.get(i);
+ name = q.getLocalName();
+ if (currentParent instanceof DataNodeContainer) {
+ currentParent = ((DataNodeContainer) currentParent).getDataChildByName(name);
+ }
+ }
+
+ if (currentParent == null) {
+ throw new YangParseException(module.getName(), line, "Failed to find 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 (int i = 0; i < path.size(); i++) {
+ if (currentParent == null) {
+ throw new YangParseException(module.getName(), line, "Failed to find deviation target.");
+ }
+ QName q = path.get(i);
+ String name = q.getLocalName();
+ if (currentParent instanceof DataNodeContainerBuilder) {
+ currentParent = ((DataNodeContainerBuilder) currentParent).getDataChildByName(name);
+ }
+ }
+
+ if (currentParent == null || !(currentParent instanceof SchemaNodeBuilder)) {
+ throw new YangParseException(module.getName(), line, "Failed to find deviation target.");
+ }
+ dev.setTargetPath(((SchemaNodeBuilder) currentParent).getPath());
+ }
+
}
Code Review / controller.git / blobdiff