"Failed to find target node from grouping for augmentation " + augSchema + " in module " +
module.name);
}
- }
+ }\r
if (targetSchemaNode !== null) {
var targetTypeBuilder = findChildNodeByPath(targetSchemaNode.path)
checkArgument(basePackageName !== null, "Base Package Name cannot be NULL.");
checkArgument(choiceNode !== null, "Choice Schema Node cannot be NULL.");
- val packageName = packageNameForGeneratedType(basePackageName, choiceNode.path);
- val choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode);
- constructGetter(parent, choiceNode.QName.localName, choiceNode.description, choiceTypeBuilder);
- choiceTypeBuilder.addImplementsType(DataContainer.typeForClass);
- genCtx.get(module).addChildNodeType(choiceNode.path, choiceTypeBuilder)
- generateTypesFromChoiceCases(module, basePackageName, parent, choiceTypeBuilder.toInstance, choiceNode);
+ if (!choiceNode.addedByUses) {
+ val packageName = packageNameForGeneratedType(basePackageName, choiceNode.path);
+ val choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode);
+ constructGetter(parent, choiceNode.QName.localName, choiceNode.description, choiceTypeBuilder);
+ choiceTypeBuilder.addImplementsType(DataContainer.typeForClass);
+ genCtx.get(module).addChildNodeType(choiceNode.path, choiceTypeBuilder)
+ generateTypesFromChoiceCases(module, basePackageName, parent, choiceTypeBuilder.toInstance, choiceNode);
+ }
}
/**\r
*/
package org.opendaylight.yangtools.sal.binding.generator.impl;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
import java.io.File;
import java.io.FileInputStream;
import java.lang.reflect.Method;
import java.net.URI;
import java.net.URISyntaxException;
-import java.util.*;
-
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.*;
+import org.opendaylight.yangtools.yang.parser.builder.impl.AnyXmlBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ConstraintsBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
-import org.opendaylight.yangtools.yang.parser.util.GroupingUtils;
import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
import org.opendaylight.yangtools.yang.parser.util.RefineUtils;
assertTrue("Must element in 'lflst' is missing.", mustLflstFound);
}
+ @Ignore
@Test
public void usesInGroupingDependenciesTest() {
loadTestResources();
for (UsesNodeBuilder usesNodeBuilder : usesNodeBuilders) {
if (usesNodeBuilder.getGroupingPathAsString().equals("grp")) {
refineHolders = usesNodeBuilder.getRefines();
- GroupingUtils.updateUsesParent(usesNodeBuilder);
+ // FIXME
+ //GroupingUtils.updateUsesParent(usesNodeBuilder);
dataSchemaNodeBuilders = usesNodeBuilder.getParent().getChildNodeBuilders();
break;
}
*/
package org.opendaylight.yangtools.yang.parser.builder.api;
+import java.util.Set;
+
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.YangNode;
+import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
/**
* Interface for builders of 'grouping' statement.
void setQName(QName qname);
+ Set<DataSchemaNodeBuilder> instantiateChildNodes(Builder newParent);
+
+ Set<TypeDefinitionBuilder> instantiateTypedefs(Builder newParent);
+
+ Set<GroupingBuilder> instantiateGroupings(Builder newParent);
+
+ Set<UnknownSchemaNodeBuilder> instantiateUnknownNodes(Builder newParent);
+
}
*/
void setDataCollected(boolean dataCollected);
+ boolean isResolved();
+
+ void setResolved(boolean resolved);
+
}
package org.opendaylight.yangtools.yang.parser.builder.impl;
import java.util.Collections;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.util.Comparators;
+import org.opendaylight.yangtools.yang.parser.util.CopyUtils;
+import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class GroupingBuilderImpl extends AbstractDataNodeContainerBuilder implements GroupingBuilder {
return instance;
}
+ @Override
+ public Set<DataSchemaNodeBuilder> instantiateChildNodes(Builder newParent) {
+ final Set<DataSchemaNodeBuilder> nodes = new HashSet<>();
+ for (DataSchemaNodeBuilder node : addedChildNodes) {
+ DataSchemaNodeBuilder copy = CopyUtils.copy(node, newParent, true);
+ ParserUtils.setNodeAddedByUses(copy);
+ nodes.add(copy);
+ }
+ return nodes;
+ }
+
+ @Override
+ public Set<TypeDefinitionBuilder> instantiateTypedefs(Builder newParent) {
+ final Set<TypeDefinitionBuilder> nodes = new HashSet<>();
+ for (TypeDefinitionBuilder node : addedTypedefs) {
+ TypeDefinitionBuilder copy = CopyUtils.copy(node, newParent, true);
+ nodes.add(copy);
+ }
+ return nodes;
+ }
+
+ @Override
+ public Set<GroupingBuilder> instantiateGroupings(Builder newParent) {
+ final Set<GroupingBuilder> nodes = new HashSet<>();
+ for (GroupingBuilder node : addedGroupings) {
+ GroupingBuilder copy = CopyUtils.copy(node, newParent, true);
+ copy.setAddedByUses(true);
+ for (DataSchemaNodeBuilder childNode : copy.getChildNodeBuilders()) {
+ ParserUtils.setNodeAddedByUses(childNode);
+ }
+ nodes.add(copy);
+ }
+ return nodes;
+ }
+
+ @Override
+ public Set<UnknownSchemaNodeBuilder> instantiateUnknownNodes(Builder newParent) {
+ final Set<UnknownSchemaNodeBuilder> nodes = new HashSet<>();
+ for (UnknownSchemaNodeBuilder node : addedUnknownNodes) {
+ UnknownSchemaNodeBuilder copy = CopyUtils.copy(node, newParent, true);
+ copy.setAddedByUses(true);
+ nodes.add(copy);
+ }
+ return nodes;
+ }
@Override
public void setQName(QName qname) {
private String prefix;
private Date revision;
- private final Deque<Builder> actualPath = new LinkedList<Builder>();
- private final Set<TypeAwareBuilder> dirtyNodes = new HashSet<TypeAwareBuilder>();
+ private final Deque<Builder> actualPath = new LinkedList<>();
+ private final Set<TypeAwareBuilder> dirtyNodes = new HashSet<>();
private final Set<ModuleImport> imports = new HashSet<ModuleImport>();
+
private final Set<AugmentationSchema> augments = new HashSet<>();
private final List<AugmentationSchemaBuilder> augmentBuilders = new ArrayList<>();
- private final List<AugmentationSchemaBuilder> allAugments = new ArrayList<AugmentationSchemaBuilder>();
- private final List<UsesNodeBuilder> allUsesNodes = new ArrayList<UsesNodeBuilder>();
- private final Set<RpcDefinition> rpcs = new TreeSet<RpcDefinition>(Comparators.SCHEMA_NODE_COMP);
- private final Set<RpcDefinitionBuilder> addedRpcs = new HashSet<RpcDefinitionBuilder>();
- private final Set<NotificationDefinition> notifications = new TreeSet<NotificationDefinition>(Comparators.SCHEMA_NODE_COMP);
- private final Set<NotificationBuilder> addedNotifications = new HashSet<NotificationBuilder>();
+ private final List<AugmentationSchemaBuilder> allAugments = new ArrayList<>();
+
+ private final List<GroupingBuilder> allGroupings = new ArrayList<>();
+
+ private final List<UsesNodeBuilder> allUsesNodes = new ArrayList<>();
+
+ private final Set<RpcDefinition> rpcs = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<RpcDefinitionBuilder> addedRpcs = new HashSet<>();
+
+ private final Set<NotificationDefinition> notifications = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<NotificationBuilder> addedNotifications = new HashSet<>();
+
private final Set<IdentitySchemaNode> identities = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
- private final Set<IdentitySchemaNodeBuilder> addedIdentities = new HashSet<IdentitySchemaNodeBuilder>();
- private final Set<FeatureDefinition> features = new TreeSet<FeatureDefinition>(Comparators.SCHEMA_NODE_COMP);
+ private final Set<IdentitySchemaNodeBuilder> addedIdentities = new HashSet<>();
+
+ private final Set<FeatureDefinition> features = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
private final Set<FeatureBuilder> addedFeatures = new HashSet<>();
+
private final Set<Deviation> deviations = new HashSet<>();
private final Set<DeviationBuilder> deviationBuilders = new HashSet<>();
+
private final List<ExtensionDefinition> extensions = new ArrayList<>();
private final List<ExtensionBuilder> addedExtensions = new ArrayList<>();
+
private final List<UnknownSchemaNodeBuilder> allUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
public ModuleBuilder(final String name) {
return addedIdentities;
}
+ public List<GroupingBuilder> getAllGroupings() {
+ return allGroupings;
+ }
+
public List<UsesNodeBuilder> getAllUsesNodes() {
return allUsesNodes;
}
}
}
+ allGroupings.add(builder);
return builder;
}
private GroupingBuilder groupingBuilder;
private boolean addedByUses;
private boolean augmenting;
+ private boolean resolved;
private AugmentationSchemaBuilder parentAugment;
private final Set<AugmentationSchema> augments = new HashSet<>();
private final Set<AugmentationSchemaBuilder> addedAugments = new HashSet<>();
public boolean isAddedByUses() {
return addedByUses;
}
-
@Override
public void setAddedByUses(final boolean addedByUses) {
this.addedByUses = addedByUses;
this.augmenting = augmenting;
}
+ @Override
+ public boolean isResolved() {
+ return resolved;
+ }
+
+ @Override
+ public void setResolved(boolean resolved) {
+ this.resolved = resolved;
+ }
+
@Override
public AugmentationSchemaBuilder getParentAugment() {
return parentAugment;
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 org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.DeviationBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ExtensionBuilder;
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.util.GroupingSort;
import org.opendaylight.yangtools.yang.parser.util.GroupingUtils;
import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;
import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
try {
yangFileStream = new FileInputStream(yangFile);
streamToFileMap.put(yangFileStream, yangFile);
- } catch(FileNotFoundException e) {
+ } catch (FileNotFoundException e) {
LOG.warn("Exception while reading yang file: " + yangFile.getName(), e);
}
if (dependency.isFile()) {
streamToFileMap.put(new FileInputStream(dependency), dependency);
}
- } catch(FileNotFoundException e) {
+ } 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>());
+ Map<InputStream, ModuleBuilder> parsedBuilders = parseModuleBuilders(new ArrayList<>(streamToFileMap.keySet()),
+ new HashMap<ModuleBuilder, InputStream>());
ModuleBuilder main = parsedBuilders.get(yangFileStream);
List<ModuleBuilder> moduleBuilders = new ArrayList<>();
new YangModelBasicValidator(walker).validate(new ArrayList<>(trees.values()));
YangParserListenerImpl yangModelParser;
- for(Map.Entry<InputStream, ParseTree> entry : trees.entrySet()) {
+ for (Map.Entry<InputStream, ParseTree> entry : trees.entrySet()) {
yangModelParser = new YangParserListenerImpl();
walker.walk(yangModelParser, entry.getValue());
ModuleBuilder moduleBuilder = yangModelParser.getModuleBuilder();
private Map<ModuleBuilder, Module> build(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
// fix unresolved nodes
+ resolveDirtyNodes(modules);
resolveAugmentsTargetPath(modules, null);
resolveUsesTargetGrouping(modules, null);
- resolveDirtyNodes(modules);
+ resolveUsesForGroupings(modules, null);
+ resolveUsesForNodes(modules, null);
resolveAugments(modules);
- resolveUses(modules, false);
- resolvedUsesPostProcessing(modules, false);
resolveDeviations(modules);
// build
private Map<ModuleBuilder, Module> buildWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
final SchemaContext context) {
// fix unresolved nodes
+ resolvedDirtyNodesWithContext(modules, context);
resolveAugmentsTargetPath(modules, context);
resolveUsesTargetGrouping(modules, context);
- resolvedDirtyNodesWithContext(modules, context);
+ resolveUsesForGroupings(modules, context);
+ resolveUsesForNodes(modules, context);
resolveAugmentsWithContext(modules, context);
- resolveUses(modules, true);
- resolvedUsesPostProcessing(modules, true);
resolveDeviationsWithContext(modules, context);
// build
SchemaPath oldSchemaPath = augment.getTargetPath();
List<QName> oldPath = oldSchemaPath.getPath();
List<QName> newPath = new ArrayList<>();
- for (QName qn : oldPath) {
- URI ns = module.getNamespace();
- Date rev = module.getRevision();
- String pref = module.getPrefix();
- String localPrefix = qn.getPrefix();
- if (localPrefix != null && !("".equals(localPrefix))) {
- ModuleBuilder currentModule = ParserUtils.findModuleFromBuilders(modules, module, localPrefix,
- augment.getLine());
- if (currentModule == null) {
- Module m = ParserUtils.findModuleFromContext(context, module, localPrefix, augment.getLine());
- if (m == null) {
- throw new YangParseException(module.getName(), augment.getLine(), "Module with prefix "
- + localPrefix + " not found.");
+
+ Builder parent = augment.getParent();
+ if (parent instanceof UsesNodeBuilder) {
+ DataNodeContainerBuilder usesParent = ((UsesNodeBuilder) parent).getParent();
+ newPath.addAll(usesParent.getPath().getPath());
+
+ URI ns;
+ Date revision;
+ String prefix;
+ QName baseQName = usesParent.getQName();
+ if (baseQName == null) {
+ ModuleBuilder m = ParserUtils.getParentModule(usesParent);
+ ns = m.getNamespace();
+ revision = m.getRevision();
+ prefix = m.getPrefix();
+ } else {
+ ns = baseQName.getNamespace();
+ revision = baseQName.getRevision();
+ prefix = baseQName.getPrefix();
+ }
+
+ for (QName qn : oldSchemaPath.getPath()) {
+ newPath.add(new QName(ns, revision, prefix, qn.getLocalName()));
+ }
+ } else {
+
+ for (QName qn : oldPath) {
+ URI ns = module.getNamespace();
+ Date rev = module.getRevision();
+ String pref = module.getPrefix();
+ String localPrefix = qn.getPrefix();
+ if (localPrefix != null && !("".equals(localPrefix))) {
+ ModuleBuilder currentModule = ParserUtils.findModuleFromBuilders(modules, module, localPrefix,
+ augment.getLine());
+ if (currentModule == null) {
+ Module m = ParserUtils.findModuleFromContext(context, module, localPrefix, augment.getLine());
+ if (m == null) {
+ throw new YangParseException(module.getName(), augment.getLine(), "Module with prefix "
+ + localPrefix + " not found.");
+ }
+ ns = m.getNamespace();
+ rev = m.getRevision();
+ pref = m.getPrefix();
+ } else {
+ ns = currentModule.getNamespace();
+ rev = currentModule.getRevision();
+ pref = currentModule.getPrefix();
}
- ns = m.getNamespace();
- rev = m.getRevision();
- pref = m.getPrefix();
- } else {
- ns = currentModule.getNamespace();
- rev = currentModule.getRevision();
- pref = currentModule.getPrefix();
}
+ newPath.add(new QName(ns, rev, pref, qn.getLocalName()));
}
- newPath.add(new QName(ns, rev, pref, qn.getLocalName()));
}
augment.setTargetNodeSchemaPath(new SchemaPath(newPath, augment.getTargetPath().isAbsolute()));
+
+ for (DataSchemaNodeBuilder childNode : augment.getChildNodeBuilders()) {
+ correctPathForAugmentNodes(childNode, augment.getTargetNodeSchemaPath());
+ }
+ }
+
+ private void correctPathForAugmentNodes(DataSchemaNodeBuilder node, SchemaPath parentPath) {
+ node.setPath(ParserUtils.createSchemaPath(parentPath, node.getQName()));
+ if (node instanceof DataNodeContainerBuilder) {
+ for (DataSchemaNodeBuilder child : ((DataNodeContainerBuilder) node).getChildNodeBuilders()) {
+ correctPathForAugmentNodes(child, node.getPath());
+ }
+ }
}
/**
for (DataSchemaNodeBuilder childNode : augment.getChildNodeBuilders()) {
if (childNode.getConstraints().isMandatory()) {
throw new YangParseException(augment.getModuleName(), augment.getLine(),
- "Error in augment parsing: cannot augment mandatory node");
+ "Error in augment parsing: cannot augment mandatory node "
+ + childNode.getQName().getLocalName());
}
}
}
}
}
- /**
- * Copy data from uses target. Augmentations have to be resolved already.
- *
- * @param modules
- * all loaded modules
- * @param resolveWithContext
- * boolean value which says whether
- * {@link GroupingUtils#collectUsesDataFromContext(UsesNodeBuilder)
- * collectUsesDataFromContext} should be used for processing of
- * individual uses node.
- */
- private void resolveUses(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final boolean resolveWithContext) {
+ private void resolveUsesForGroupings(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
+ final Set<GroupingBuilder> allGroupings = new HashSet<>();
for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
ModuleBuilder module = inner.getValue();
- boolean dataCollected = module.isAllUsesDataCollected();
-
- List<UsesNodeBuilder> usesNodes;
- while (!dataCollected) {
- usesNodes = new ArrayList<>(module.getAllUsesNodes());
- for (UsesNodeBuilder usesNode : usesNodes) {
- if (!usesNode.isDataCollected()) {
- if (resolveWithContext && usesNode.getGroupingBuilder() == null) {
- GroupingUtils.collectUsesDataFromContext(usesNode);
- } else {
- GroupingUtils.collectUsesData(usesNode);
- }
- }
- }
- dataCollected = module.isAllUsesDataCollected();
- }
+ allGroupings.addAll(module.getAllGroupings());
+ }
+ }
+ final List<GroupingBuilder> sorted = GroupingSort.sort(allGroupings);
+ for (GroupingBuilder gb : sorted) {
+ List<UsesNodeBuilder> usesNodes = new ArrayList<>(GroupingSort.getAllUsesNodes(gb));
+ Collections.sort(usesNodes, new GroupingUtils.UsesComparator());
+ for (UsesNodeBuilder usesNode : usesNodes) {
+ resolveUses(usesNode, modules, context);
}
}
}
- /**
- * Update uses parent and perform refinement.
- *
- * @param modules
- * all loaded modules
- * @param resolveWithContext
- * boolean value which says whether
- * {@link GroupingUtils#collectUsesDataFromContext(UsesNodeBuilder)
- * collectUsesDataFromContext} should be used for processing of
- * individual uses node.
- */
- private void resolvedUsesPostProcessing(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final boolean resolveWithContext) {
- // new loop is must because in collecting data process new uses could
- // be created
- final List<UsesNodeBuilder> allModulesUses = new ArrayList<>();
+ private void resolveUsesForNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
- allModulesUses.addAll(inner.getValue().getAllUsesNodes());
+ ModuleBuilder module = inner.getValue();
+ List<UsesNodeBuilder> usesNodes = module.getAllUsesNodes();
+ Collections.sort(usesNodes, new GroupingUtils.UsesComparator());
+ for (UsesNodeBuilder usesNode : usesNodes) {
+ resolveUses(usesNode, modules, context);
+ }
}
}
+ }
- for (UsesNodeBuilder usesNode : allModulesUses) {
- GroupingUtils.updateUsesParent(usesNode);
- GroupingUtils.performRefine(usesNode);
- }
+ 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();
+ }
- if (!resolveWithContext) {
- for (UsesNodeBuilder usesNode : allModulesUses) {
- if (usesNode.isCopy()) {
- usesNode.getParent().getUsesNodes().remove(usesNode);
+ 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);
+ usesNode.setResolved(true);
+
+ for (AugmentationSchemaBuilder augment : usesNode.getAugmentations()) {
+ processAugmentationOnContext(augment, augment.getTargetPath().getPath(), module, prefix, 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));
+ usesNode.setResolved(true);
+
+ for (AugmentationSchemaBuilder augment : usesNode.getAugmentations()) {
+ processAugmentation(augment, parent, augment.getTargetPath().getPath());
+ }
+ GroupingUtils.performRefine(usesNode);
}
}
}
for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {
QName nodeType = usnb.getNodeType();
try {
- ModuleBuilder dependentModuleBuilder = findModuleFromBuilders(modules, module,
- nodeType.getPrefix(), usnb.getLine());
+ ModuleBuilder dependentModuleBuilder = findModuleFromBuilders(modules, module, nodeType.getPrefix(),
+ usnb.getLine());
if (dependentModuleBuilder == null) {
Module dependentModule = findModuleFromContext(context, module, nodeType.getPrefix(),
import java.util.ArrayList;
import java.util.Collections;
-import java.util.HashSet;
import java.util.List;
import java.util.Set;
copy.getRefines().addAll(old.getRefines());
copy.setAugmenting(old.isAugmenting());
copy.setParentAugment(old.getParentAugment());
-
- // target child nodes
- Set<DataSchemaNodeBuilder> newTargetChildren = new HashSet<>();
- for (DataSchemaNodeBuilder dnb : old.getTargetChildren()) {
- newTargetChildren.add(copy(dnb, newParent, true));
- }
- copy.getTargetChildren().addAll(newTargetChildren);
-
- // target typedefs
- Set<TypeDefinitionBuilder> newTargetTypedefs = new HashSet<>();
- for (TypeDefinitionBuilder tdb : old.getTargetTypedefs()) {
- newTargetTypedefs.add(copy(tdb, newParent, true));
- }
- copy.getTargetTypedefs().addAll(newTargetTypedefs);
-
- // target groupings
- Set<GroupingBuilder> newTargetGroupings = new HashSet<>();
- for (GroupingBuilder gb : old.getTargetGroupings()) {
- newTargetGroupings.add(copy(gb, newParent, true));
- }
- copy.getTargetGroupings().addAll(newTargetGroupings);
-
- // target unknown nodes
- Set<UnknownSchemaNodeBuilder> newTargetUnknownNodes = new HashSet<>();
- for (UnknownSchemaNodeBuilder unb : old.getTargetUnknownNodes()) {
- newTargetUnknownNodes.add(copy(unb, newParent, true));
- }
- copy.getTargetUnknownNodes().addAll(newTargetUnknownNodes);
-
- // add new uses to collection of uses in module
- ModuleBuilder module = ParserUtils.getParentModule(newParent);
- module.getAllUsesNodes().add(copy);
-
return copy;
}
return copy;
}
- static UnknownSchemaNodeBuilder copy(UnknownSchemaNodeBuilder old, Builder newParent, boolean updateQName) {
+ public static UnknownSchemaNodeBuilder copy(UnknownSchemaNodeBuilder old, Builder newParent, boolean updateQName) {
DataBean data = getdata(old, newParent, updateQName);
QName newQName = data.qname;
SchemaPath newSchemaPath = data.schemaPath;
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.util;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
+import org.opendaylight.yangtools.yang.parser.util.TopologicalSort.Node;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
+public class GroupingSort {
+
+ /**
+ * Sorts set <code>groupingDefinitions</code> according to the mutual
+ * dependencies.<br />
+ *
+ * Elements of <code>groupingDefinitions</code> are firstly transformed to
+ * {@link org.opendaylight.yangtools.yang.parser.util.TopologicalSort.Node
+ * Node} interfaces and then are sorted by
+ * {@link org.opendaylight.yangtools.yang.parser.util.TopologicalSort#sort(Set)
+ * sort()} method of <code>TopologicalSort</code>.<br />
+ * <br />
+ *
+ *
+ * <i>Definition of dependency relation:<br />
+ * The first <code>GroupingDefinition</code> object (in this context)
+ * depends on second <code>GroupingDefinition</code> object if the first one
+ * contains in its set of <code>UsesNode</code> (obtained through
+ * {@link org.opendaylight.yangtools.yang.model.api.DataNodeContainer#getUses()
+ * getUses} method) reference to the second one.</i>
+ *
+ * @param groupingDefinitions
+ * set of grouping definition which should be sorted according to
+ * mutual dependencies
+ * @return list of grouping definitiond which are sorted by mutual
+ * dependencies
+ * @throws IllegalArgumentException
+ * if <code>groupingDefinitions</code>
+ *
+ */
+ public static List<GroupingBuilder> sort(final Collection<GroupingBuilder> groupingDefinitions) {
+ if (groupingDefinitions == null) {
+ throw new IllegalArgumentException("Set of Type Definitions " + "cannot be NULL!");
+ }
+
+ final List<GroupingBuilder> resultGroupingDefinitions = new ArrayList<GroupingBuilder>();
+ final Set<Node> unsorted = groupingDefinitionsToNodes(groupingDefinitions);
+ final List<Node> sortedNodes = TopologicalSort.sort(unsorted);
+ for (Node node : sortedNodes) {
+ NodeWrappedType nodeWrappedType = (NodeWrappedType) node;
+ resultGroupingDefinitions.add((GroupingBuilder) (nodeWrappedType.getWrappedType()));
+ }
+ return resultGroupingDefinitions;
+
+ }
+
+ /**
+ * Wraps every grouping definition to node type and adds to every node
+ * information about dependencies.
+ *
+ * The map with mapping from schema path (represents grouping definition) to
+ * node is created. For every created node (next <i>nodeFrom</i>) is for its
+ * wrapped grouping definition passed the set of its <i>uses nodes</i>
+ * through. For every uses node is found its wrapping node (next as
+ * <i>nodeTo</i>). This dependency relationship between nodeFrom and all
+ * found nodesTo is modeled with creating of one edge from nodeFrom to
+ * nodeTo.
+ *
+ *
+ * @param groupingDefinitions
+ * set of goruping definition which will be wrapped to nodes
+ *
+ * @return set of nodes where every one contains wrapped grouping definition
+ */
+ private static Set<Node> groupingDefinitionsToNodes(final Collection<GroupingBuilder> groupingDefinitions) {
+ final Map<SchemaPath, Node> nodeMap = Maps.newHashMap();
+ final Set<Node> resultNodes = Sets.newHashSet();
+
+ for (final GroupingBuilder groupingDefinition : groupingDefinitions) {
+ final Node node = new NodeWrappedType(groupingDefinition);
+ nodeMap.put(groupingDefinition.getPath(), node);
+ resultNodes.add(node);
+ }
+
+ for (final Node node : resultNodes) {
+ final NodeWrappedType nodeWrappedType = (NodeWrappedType) node;
+ final GroupingBuilder groupingDefinition = (GroupingBuilder) nodeWrappedType.getWrappedType();
+
+ if (groupingDefinition.getQName().getLocalName().equals("rp-object")) {
+ System.out.println();
+ }
+
+ Set<UsesNodeBuilder> usesNodes = getAllUsesNodes(groupingDefinition);
+ for (UsesNodeBuilder usesNode : usesNodes) {
+ SchemaPath schemaPath = usesNode.getGroupingBuilder().getPath();
+ Node nodeTo = nodeMap.get(schemaPath);
+ if (nodeTo == null) {
+ throw new IllegalArgumentException("target grouping not found for uses " + usesNode);
+ }
+ nodeWrappedType.addEdge(nodeTo);
+ }
+ }
+
+ return resultNodes;
+ }
+
+ /**
+ * Returns the set of the uses nodes which are get from uses in
+ * <code>container</code>, from uses in groupings inside
+ * <code>container</code> and from uses inside child nodes of the
+ * <code>container</code>.
+ *
+ * @param container
+ * data node container which can contain some uses of grouping
+ * @return set of uses nodes which were find in <code>container</code>.
+ */
+ public static Set<UsesNodeBuilder> getAllUsesNodes(DataNodeContainerBuilder container) {
+ Set<UsesNodeBuilder> ret = new HashSet<>();
+ Set<UsesNodeBuilder> usesNodes = container.getUsesNodes();
+ ret.addAll(usesNodes);
+
+ for (UsesNodeBuilder usesNode : usesNodes) {
+ for (AugmentationSchemaBuilder augment : usesNode.getAugmentations()) {
+ ret.addAll(getAllUsesNodes(augment));
+ }
+ }
+ Set<GroupingBuilder> groupings = container.getGroupingBuilders();
+ for (GroupingBuilder groupingDefinition : groupings) {
+ ret.addAll(getAllUsesNodes(groupingDefinition));
+ }
+ Set<DataSchemaNodeBuilder> childNodes = container.getChildNodeBuilders();
+ for (DataSchemaNodeBuilder childNode : childNodes) {
+ if (childNode instanceof DataNodeContainerBuilder) {
+ ret.addAll(getAllUsesNodes((DataNodeContainerBuilder) childNode));
+ } else if (childNode instanceof ChoiceBuilder) {
+ Set<ChoiceCaseBuilder> cases = ((ChoiceBuilder) childNode).getCases();
+ for (ChoiceCaseBuilder choiceCaseNode : cases) {
+ ret.addAll(getAllUsesNodes(choiceCaseNode));
+ }
+ }
+ }
+ return ret;
+ }
+
+}
import java.net.URI;
import java.util.ArrayList;
+import java.util.Comparator;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.util.ExtendedType;
-import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingMember;
-import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
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.ChoiceBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
public static GroupingBuilder getTargetGroupingFromModules(final UsesNodeBuilder usesBuilder,
final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
final int line = usesBuilder.getLine();
+
final String groupingString = usesBuilder.getGroupingPathAsString();
String groupingPrefix;
String groupingName;
return null;
}
- private static void setNodeAugmenting(DataSchemaNodeBuilder node) {
- node.setAugmenting(true);
- if (node instanceof DataNodeContainerBuilder) {
- for (DataSchemaNodeBuilder child : ((DataNodeContainerBuilder)node).getChildNodeBuilders()) {
- setNodeAugmenting(child);
- }
- }
- if (node instanceof ChoiceBuilder) {
- for (ChoiceCaseBuilder child : ((ChoiceBuilder)node).getCases()) {
- setNodeAugmenting(child);
- }
- }
- }
-
- /**
- * Add nodes defined in uses target grouping to uses parent.
- *
- * @param usesNode
- * yang uses node which will be instantiated in current location
- */
- public static void updateUsesParent(UsesNodeBuilder usesNode) {
- DataNodeContainerBuilder parent = usesNode.getParent();
- ModuleBuilder module = ParserUtils.getParentModule(parent);
- URI ns = module.getNamespace();
- Date rev = module.getRevision();
- String prefix = module.getPrefix();
-
- SchemaPath parentPath = parent.getPath();
- if (parent instanceof AugmentationSchemaBuilder) {
- parentPath = ((AugmentationSchemaBuilder) parent).getTargetNodeSchemaPath();
- }
-
- // child nodes
- for (DataSchemaNodeBuilder child : usesNode.getTargetChildren()) {
- setAddedByUsesToNode(child);
-
- if (usesNode.isAugmenting()) {
- //child.setAugmenting(true);
- setNodeAugmenting(child);
- }
- if (usesNode.isAugmenting() && !(usesNode.getParentAugment().getParent() instanceof UsesNodeBuilder)) {
- AugmentationSchemaBuilder parentAugment = usesNode.getParentAugment();
- ModuleBuilder m = ParserUtils.getParentModule(parentAugment);
- correctNodePathForUsesNodes(child, parentPath, m);
- } else {
- child.setQName(new QName(ns, rev, prefix, child.getQName().getLocalName()));
- correctNodePathForUsesNodes(child, parentPath, module);
- }
-
- parent.addChildNode(child);
- }
-
- // groupings
- for (GroupingBuilder gb : usesNode.getTargetGroupings()) {
- setAddedByUsesToNode(gb);
- gb.setQName(new QName(ns, rev, prefix, gb.getQName().getLocalName()));
- correctNodePathForUsesNodes(gb, parentPath, module);
- parent.addGrouping(gb);
- }
-
- // typedefs
- for (TypeDefinitionBuilder tdb : usesNode.getTargetTypedefs()) {
- setAddedByUsesToNode(tdb);
- tdb.setQName(new QName(ns, rev, prefix, tdb.getQName().getLocalName()));
- correctNodePathForUsesNodes(tdb, parentPath, module);
- parent.addTypedef(tdb);
- }
-
- // unknown nodes
- for (UnknownSchemaNodeBuilder un : usesNode.getTargetUnknownNodes()) {
- un.setAddedByUses(true);
- un.setQName(new QName(ns, rev, prefix, un.getQName().getLocalName()));
- correctNodePathForUsesNodes(un, parentPath, module);
- parent.addUnknownNodeBuilder(un);
- }
- }
-
- private static void setAddedByUsesToNode(GroupingMember node) {
- node.setAddedByUses(true);
- if (node instanceof DataNodeContainerBuilder) {
- for (DataSchemaNodeBuilder child : ((DataNodeContainerBuilder) node).getChildNodeBuilders()) {
- setAddedByUsesToNode(child);
-
- }
- } else if (node instanceof ChoiceBuilder) {
- for (ChoiceCaseBuilder caseNode : ((ChoiceBuilder) node).getCases()) {
- setAddedByUsesToNode((caseNode));
- }
- }
- }
-
- /**
- * Read data defined in target grouping builder, make a copy and add them to
- * uses node builder.
- *
- * @param usesNode
- * uses node builder
- */
- public static void collectUsesData(UsesNodeBuilder usesNode) {
- collectTargetChildNodes(usesNode);
- collectTargetTypedefs(usesNode);
- collectTargetGroupings(usesNode);
- collectTargetUnknownNodes(usesNode);
- usesNode.setDataCollected(true);
- }
-
- /**
- * Read child nodes defined in target grouping and make a copy of them.
- *
- * @param usesNode
- * uses node for which data will be collected
- */
- private static void collectTargetChildNodes(UsesNodeBuilder usesNode) {
- final GroupingBuilder target = usesNode.getGroupingBuilder();
- final Set<DataSchemaNodeBuilder> collection = new HashSet<>();
- addChildNodeToCollection(usesNode, collection, target.getChildNodeBuilders(), usesNode.getParent());
-
- for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
- Set<DataSchemaNodeBuilder> targetUsesChildNodes = collectTargetUsesChildNodes(targetUses,
- usesNode.getParent());
- addChildNodeToCollection(usesNode, collection, targetUsesChildNodes, usesNode.getParent());
- }
- usesNode.getTargetChildren().addAll(collection);
- }
-
- private static Set<DataSchemaNodeBuilder> collectTargetUsesChildNodes(UsesNodeBuilder usesNode,
- DataNodeContainerBuilder parent) {
- final GroupingBuilder target = usesNode.getGroupingBuilder();
- final Set<DataSchemaNodeBuilder> collection = new HashSet<>(usesNode.getTargetChildren());
- addChildNodeToCollection(usesNode, collection, target.getChildNodeBuilders(), parent);
-
- for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
- Set<DataSchemaNodeBuilder> targetUsesChildNodes = collectTargetUsesChildNodes(targetUses, parent);
- addChildNodeToCollection(usesNode, collection, targetUsesChildNodes, parent);
- }
- return collection;
- }
-
- private static void addChildNodeToCollection(UsesNodeBuilder usesNode, Set<DataSchemaNodeBuilder> collection,
- Set<DataSchemaNodeBuilder> allNodes, Builder parent) {
- for (DataSchemaNodeBuilder childNode : allNodes) {
- boolean exists = false;
- for (DataSchemaNodeBuilder usesChildNode : usesNode.getTargetChildren()) {
- if (usesChildNode.getQName().getLocalName().equals(childNode.getQName().getLocalName())) {
- exists = true;
- break;
- }
- }
- if (!exists) {
- DataSchemaNodeBuilder copy = CopyUtils.copy(childNode, parent, true);
- setAddedByUsesToNode(copy);
- collection.add(copy);
- }
- }
- }
-
- /**
- * Read typedefs defined in target grouping and make a copy of them.
- *
- * @param usesNode
- * uses node for which data will be collected
- */
- private static void collectTargetTypedefs(UsesNodeBuilder usesNode) {
- final GroupingBuilder target = usesNode.getGroupingBuilder();
- Set<TypeDefinitionBuilder> collection = new HashSet<>();
- addTypedefToCollection(usesNode, collection, target.getTypeDefinitionBuilders(), usesNode.getParent());
-
- for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
- Set<TypeDefinitionBuilder> targetUsesTypedefs = collectTargetUsesTypedefs(targetUses, usesNode.getParent());
- addTypedefToCollection(usesNode, collection, targetUsesTypedefs, usesNode.getParent());
- }
- usesNode.getTargetTypedefs().addAll(collection);
- }
-
- private static Set<TypeDefinitionBuilder> collectTargetUsesTypedefs(UsesNodeBuilder usesNode,
- DataNodeContainerBuilder parent) {
- final GroupingBuilder target = usesNode.getGroupingBuilder();
- Set<TypeDefinitionBuilder> collection = new HashSet<>(usesNode.getTargetTypedefs());
- addTypedefToCollection(usesNode, collection, target.getTypeDefinitionBuilders(), parent);
-
- for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
- Set<TypeDefinitionBuilder> targetUsesTypedefs = collectTargetUsesTypedefs(targetUses, parent);
- addTypedefToCollection(usesNode, collection, targetUsesTypedefs, parent);
- }
- return collection;
- }
-
- private static void addTypedefToCollection(UsesNodeBuilder usesNode, Set<TypeDefinitionBuilder> collection,
- Set<TypeDefinitionBuilder> allTypedefs, Builder parent) {
- for (TypeDefinitionBuilder childNode : allTypedefs) {
- boolean exists = false;
- for (TypeDefinitionBuilder usesTypedef : usesNode.getTargetTypedefs()) {
- if (usesTypedef.getQName().getLocalName().equals(childNode.getQName().getLocalName())) {
- exists = true;
- break;
- }
- }
- if (!exists) {
- TypeDefinitionBuilder copy = CopyUtils.copy(childNode, parent, true);
- collection.add(copy);
- }
- }
- }
-
- /**
- * Read groupings defined in target grouping and make a copy of them.
- *
- * @param usesNode
- * uses node for which data will be collected
- */
- private static void collectTargetGroupings(UsesNodeBuilder usesNode) {
- final GroupingBuilder target = usesNode.getGroupingBuilder();
- Set<GroupingBuilder> collection = new HashSet<>();
- addGroupingToCollection(usesNode, collection, target.getGroupingBuilders(), usesNode.getParent());
-
- for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
- Set<GroupingBuilder> targetUsesGrouping = collectTargetGroupings(targetUses, usesNode.getParent());
- addGroupingToCollection(usesNode, collection, targetUsesGrouping, usesNode.getParent());
- }
- usesNode.getTargetGroupings().addAll(collection);
- }
-
- private static Set<GroupingBuilder> collectTargetGroupings(UsesNodeBuilder usesNode, DataNodeContainerBuilder parent) {
- final GroupingBuilder target = usesNode.getGroupingBuilder();
- Set<GroupingBuilder> collection = new HashSet<>(usesNode.getTargetGroupings());
- addGroupingToCollection(usesNode, collection, target.getGroupingBuilders(), parent);
-
- for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
- Set<GroupingBuilder> targetUsesGroupings = collectTargetGroupings(targetUses, parent);
- addGroupingToCollection(usesNode, collection, targetUsesGroupings, parent);
- }
- return collection;
- }
-
- private static void addGroupingToCollection(UsesNodeBuilder usesNode, Set<GroupingBuilder> collection,
- Set<GroupingBuilder> allGroupings, Builder parent) {
- for (GroupingBuilder childNode : allGroupings) {
- boolean exists = false;
- for (GroupingBuilder usesGrouping : usesNode.getTargetGroupings()) {
- if (usesGrouping.getQName().getLocalName().equals(childNode.getQName().getLocalName())) {
- exists = true;
- break;
- }
- }
- if (!exists) {
- GroupingBuilder copy = CopyUtils.copy(childNode, parent, true);
- collection.add(copy);
- }
- }
- }
-
- /**
- * Read unknown nodes defined in target grouping and make a copy of them.
- *
- * @param usesNode
- * uses node for which data will be collected
- */
- private static void collectTargetUnknownNodes(UsesNodeBuilder usesNode) {
- final GroupingBuilder target = usesNode.getGroupingBuilder();
- final List<UnknownSchemaNodeBuilder> collection = new ArrayList<>();
- addUnknownNodeToCollection(usesNode, collection, target.getUnknownNodeBuilders(), usesNode.getParent());
-
- for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
- List<UnknownSchemaNodeBuilder> targetUsesUnknownNodes = collectTargetUnknownNodes(targetUses,
- usesNode.getParent());
- addUnknownNodeToCollection(usesNode, collection, targetUsesUnknownNodes, usesNode.getParent());
- }
- usesNode.getTargetUnknownNodes().addAll(collection);
- }
-
- private static List<UnknownSchemaNodeBuilder> collectTargetUnknownNodes(UsesNodeBuilder usesNode,
- DataNodeContainerBuilder parent) {
- final GroupingBuilder target = usesNode.getGroupingBuilder();
- List<UnknownSchemaNodeBuilder> collection = new ArrayList<>(usesNode.getTargetUnknownNodes());
- addUnknownNodeToCollection(usesNode, collection, target.getUnknownNodeBuilders(), parent);
-
- for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
- List<UnknownSchemaNodeBuilder> targetUsesUnknownNodes = collectTargetUnknownNodes(targetUses, parent);
- addUnknownNodeToCollection(usesNode, collection, targetUsesUnknownNodes, parent);
- }
- return collection;
- }
-
- private static void addUnknownNodeToCollection(UsesNodeBuilder usesNode, List<UnknownSchemaNodeBuilder> collection,
- List<UnknownSchemaNodeBuilder> allUnknownNodes, Builder parent) {
- for (UnknownSchemaNodeBuilder childNode : allUnknownNodes) {
- boolean exists = false;
- for (UnknownSchemaNodeBuilder usesUnknownNode : usesNode.getTargetUnknownNodes()) {
- if (usesUnknownNode.getQName().getLocalName().equals(childNode.getQName().getLocalName())) {
- exists = true;
- break;
- }
- }
- if (!exists) {
- UnknownSchemaNodeBuilder copy = CopyUtils.copy(childNode, parent, true);
- collection.add(copy);
- }
- }
- }
-
- /**
- * Read data defined in target grouping definition, make a copy and add them
- * to uses node builder.
- *
- * @param usesNode
- * uses node builder
- */
- public static void collectUsesDataFromContext(UsesNodeBuilder usesNode) {
- DataNodeContainerBuilder parent = usesNode.getParent();
- URI namespace = parent.getQName().getNamespace();
- Date revision = parent.getQName().getRevision();
- String prefix = parent.getQName().getPrefix();
- String moduleName = parent.getModuleName();
- int line = parent.getLine();
-
- // child nodes
- copyGroupingNodesToUsesNode(usesNode, namespace, revision, prefix, moduleName, line);
-
- // groupings
- final Set<GroupingBuilder> newGroupings = new HashSet<>();
- for (GroupingDefinition g : usesNode.getGroupingDefinition().getGroupings()) {
- QName newQName = new QName(namespace, revision, prefix, g.getQName().getLocalName());
- GroupingBuilder newGrouping = CopyUtils.createGrouping(g, newQName, moduleName, line);
- newGrouping.setAddedByUses(true);
- newGroupings.add(newGrouping);
- }
- usesNode.getTargetGroupings().addAll(newGroupings);
-
- // typedefs
- final Set<TypeDefinitionBuilder> newTypedefs = new HashSet<>();
- for (TypeDefinition<?> td : usesNode.getGroupingDefinition().getTypeDefinitions()) {
- QName newQName = new QName(namespace, revision, prefix, td.getQName().getLocalName());
- TypeDefinitionBuilder newType = CopyUtils.createTypedef((ExtendedType) td, newQName, moduleName, line);
- newType.setAddedByUses(true);
- newTypedefs.add(newType);
- }
- usesNode.getTargetTypedefs().addAll(newTypedefs);
-
- // unknown nodes
- final List<UnknownSchemaNodeBuilder> newUnknownNodes = new ArrayList<>();
- for (UnknownSchemaNode un : usesNode.getGroupingDefinition().getUnknownSchemaNodes()) {
- QName newQName = new QName(namespace, revision, prefix, un.getQName().getLocalName());
- UnknownSchemaNodeBuilder newNode = CopyUtils.createUnknownSchemaNode(un, newQName, moduleName, line);
- newNode.setAddedByUses(true);
- newUnknownNodes.add(newNode);
- }
- usesNode.getTargetUnknownNodes().addAll(newUnknownNodes);
-
- usesNode.setDataCollected(true);
- }
-
/**
* Read data defined in target grouping definition, make a copy and add them
* to uses node builder.
* string with parent prefix
* @param moduleName
* string with parent module name
- * @param lineNumber
- * number with YANG file row where is the parent defined
+ * @param line
+ * line from YANG file where parent node is defined
*/
- private static void copyGroupingNodesToUsesNode(final UsesNodeBuilder usesNode, final URI namespace,
- final Date revision, final String prefix, final String moduleName, final int lineNumber) {
+ public static Set<DataSchemaNodeBuilder> getTargetGroupingDefinitionNodesWithNewNamespace(
+ final UsesNodeBuilder usesNode, final URI namespace, final Date revision, final String prefix,
+ final String moduleName, final int line) {
final Set<DataSchemaNodeBuilder> newChildren = new HashSet<>();
for (DataSchemaNode child : usesNode.getGroupingDefinition().getChildNodes()) {
if (child != null) {
DataSchemaNodeBuilder newChild = null;
QName newQName = new QName(namespace, revision, prefix, child.getQName().getLocalName());
if (child instanceof AnyXmlSchemaNode) {
- newChild = CopyUtils.createAnyXml((AnyXmlSchemaNode) child, newQName, moduleName, lineNumber);
+ newChild = CopyUtils.createAnyXml((AnyXmlSchemaNode) child, newQName, moduleName, line);
} else if (child instanceof ChoiceNode) {
- newChild = CopyUtils.createChoice((ChoiceNode) child, newQName, moduleName, lineNumber);
+ newChild = CopyUtils.createChoice((ChoiceNode) child, newQName, moduleName, line);
} else if (child instanceof ContainerSchemaNode) {
- newChild = CopyUtils.createContainer((ContainerSchemaNode) child, newQName, moduleName, lineNumber);
+ newChild = CopyUtils.createContainer((ContainerSchemaNode) child, newQName, moduleName, line);
} else if (child instanceof LeafListSchemaNode) {
- newChild = CopyUtils.createLeafList((LeafListSchemaNode) child, newQName, moduleName, lineNumber);
+ newChild = CopyUtils.createLeafList((LeafListSchemaNode) child, newQName, moduleName, line);
} else if (child instanceof LeafSchemaNode) {
- newChild = CopyUtils.createLeafBuilder((LeafSchemaNode) child, newQName, moduleName, lineNumber);
+ newChild = CopyUtils.createLeafBuilder((LeafSchemaNode) child, newQName, moduleName, line);
} else if (child instanceof ListSchemaNode) {
- newChild = CopyUtils.createList((ListSchemaNode) child, newQName, moduleName, lineNumber);
+ newChild = CopyUtils.createList((ListSchemaNode) child, newQName, moduleName, line);
}
if (newChild == null) {
- throw new YangParseException(moduleName, lineNumber,
+ throw new YangParseException(moduleName, line,
"Unknown member of target grouping while resolving uses node.");
}
newChildren.add(newChild);
}
}
- usesNode.getTargetChildren().addAll(newChildren);
-
+ return newChildren;
}
- /**
- * Correct schema path of nodes added by uses statement.
- *
- * @param node
- * node added by uses statement
- * @param parentSchemaPath
- * schema path of parent node
- * @param parentModule
- * current parent node module
- */
- private static void correctNodePathForUsesNodes(final SchemaNodeBuilder node, final SchemaPath parentSchemaPath,
- final ModuleBuilder parentModule) {
- // set correct path
- List<QName> targetNodePath = new ArrayList<>(parentSchemaPath.getPath());
- QName qname = new QName(parentModule.getNamespace(), parentModule.getRevision(), parentModule.getPrefix(),
- node.getQName().getLocalName());
- targetNodePath.add(qname);
- if (node instanceof DataSchemaNodeBuilder) {
- ((DataSchemaNodeBuilder)node).setQName(qname);
+ public static Set<TypeDefinitionBuilder> getTargetGroupingDefinitionTypedefsWithNewNamespace(
+ UsesNodeBuilder usesNode, URI namespace, Date revision, String prefix, String moduleName, int line) {
+ final Set<TypeDefinitionBuilder> newTypedefs = new HashSet<>();
+ for (TypeDefinition<?> td : usesNode.getGroupingDefinition().getTypeDefinitions()) {
+ QName newQName = new QName(namespace, revision, prefix, td.getQName().getLocalName());
+ TypeDefinitionBuilder newType = CopyUtils.createTypedef((ExtendedType) td, newQName, moduleName, line);
+ newType.setAddedByUses(true);
+ newTypedefs.add(newType);
}
- node.setPath(new SchemaPath(targetNodePath, true));
-
+ return newTypedefs;
+ }
- // set correct path for all child nodes
- if (node instanceof DataNodeContainerBuilder) {
- DataNodeContainerBuilder dataNodeContainer = (DataNodeContainerBuilder) node;
- for (DataSchemaNodeBuilder child : dataNodeContainer.getChildNodeBuilders()) {
- correctNodePathForUsesNodes(child, node.getPath(), parentModule);
- }
+ public static Set<GroupingBuilder> getTargetGroupingDefinitionGroupingsWithNewNamespace(UsesNodeBuilder usesNode,
+ URI namespace, Date revision, String prefix, String moduleName, int line) {
+ final Set<GroupingBuilder> newGroupings = new HashSet<>();
+ for (GroupingDefinition g : usesNode.getGroupingDefinition().getGroupings()) {
+ QName newQName = new QName(namespace, revision, prefix, g.getQName().getLocalName());
+ GroupingBuilder newGrouping = CopyUtils.createGrouping(g, newQName, moduleName, line);
+ newGrouping.setAddedByUses(true);
+ newGroupings.add(newGrouping);
}
+ return newGroupings;
+ }
- // set correct path for all cases
- if (node instanceof ChoiceBuilder) {
- ChoiceBuilder choiceBuilder = (ChoiceBuilder) node;
- for (ChoiceCaseBuilder choiceCaseBuilder : choiceBuilder.getCases()) {
- correctNodePathForUsesNodes(choiceCaseBuilder, node.getPath(), parentModule);
- }
+ public static List<UnknownSchemaNodeBuilder> getTargetGroupingDefinitionUnknownNodesWithNewNamespace(
+ UsesNodeBuilder usesNode, URI namespace, Date revision, String prefix, String moduleName, int line) {
+ final List<UnknownSchemaNodeBuilder> newUnknownNodes = new ArrayList<>();
+ for (UnknownSchemaNode un : usesNode.getGroupingDefinition().getUnknownSchemaNodes()) {
+ QName newQName = new QName(namespace, revision, prefix, un.getQName().getLocalName());
+ UnknownSchemaNodeBuilder newNode = CopyUtils.createUnknownSchemaNode(un, newQName, moduleName, line);
+ newNode.setAddedByUses(true);
+ newUnknownNodes.add(newNode);
}
+ return newUnknownNodes;
}
/**
}
}
+ public static class UsesComparator implements Comparator<UsesNodeBuilder> {
+ @Override
+ public int compare(UsesNodeBuilder o1, UsesNodeBuilder o2) {
+ return getElementPosition(o2) - getElementPosition(o1);
+ }
+ }
+
+ private static int getElementPosition(UsesNodeBuilder usesNode) {
+ int i = 0;
+ Builder parent = usesNode.getParent();
+ while (!(parent instanceof ModuleBuilder)) {
+ parent = parent.getParent();
+ i++;
+ }
+ return i;
+ }
+
}
--- /dev/null
+package org.opendaylight.yangtools.yang.parser.util;
+
+import org.opendaylight.yangtools.yang.parser.util.TopologicalSort.NodeImpl;
+
+public final class NodeWrappedType extends NodeImpl {
+ /**
+ * The payload which is saved inside Node
+ */
+ private final Object wrappedType;
+
+ /**
+ * Create new instance of class <code>NodeWrappedType</code>.
+ *
+ * @param wrappedType
+ * object with payload data
+ */
+ NodeWrappedType(Object wrappedType) {
+ this.wrappedType = wrappedType;
+ }
+
+ /**
+ * Gets payload from class
+ *
+ * @return object with <code>wrappedType</code>
+ */
+ Object getWrappedType() {
+ return wrappedType;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof NodeWrappedType)) {
+ return false;
+ }
+ NodeWrappedType nodeWrappedType = (NodeWrappedType) o;
+ if (!wrappedType.equals(nodeWrappedType.wrappedType)) {
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return wrappedType.hashCode();
+ }
+
+ @Override
+ public String toString() {
+ return "NodeWrappedType{" + "wrappedType=" + wrappedType + '}';
+ }
+
+}
import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder.NotificationDefinitionImpl;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget
import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder
+import java.net.URI
+import org.opendaylight.yangtools.yang.parser.builder.api.GroupingMember
public final class ParserUtils {
return new SchemaPath(path, schemaPath.isAbsolute());
}
+ public static def SchemaPath correctSchemaPath(SchemaPath old, URI ns, Date revision, String prefix) {
+ val List<QName> newPath = new ArrayList();
+ for (name : old.path) {
+ newPath.add(new QName(ns, revision, prefix, name.localName))
+ }
+ return new SchemaPath(newPath, old.absolute)
+ }
+
/**
* Get module import referenced by given prefix.
*
public static def void fillAugmentTarget(AugmentationSchemaBuilder augment, DataNodeContainerBuilder target) {
for (DataSchemaNodeBuilder child : augment.getChildNodeBuilders()) {
val childCopy = CopyUtils.copy(child, target, false);
- setNodeAugmenting(childCopy, augment);
+ if (augment.parent instanceof UsesNodeBuilder) {
+ setNodeAddedByUses(childCopy);
+ }
+ setNodeAugmenting(childCopy);
correctNodePath(child, target.getPath());
correctNodePath(childCopy, target.getPath());
try {
"Failed to perform augmentation: " + e.getMessage());
}
}
- for (UsesNodeBuilder usesNode : augment.getUsesNodes()) {
- val copy = CopyUtils.copyUses(usesNode, target);
- copy.setAugmenting(true);
- target.addUsesNode(copy);
- }
}
- private static def void setNodeAugmenting(DataSchemaNodeBuilder child, AugmentationSchemaBuilder augment) {
+ private static def void setNodeAugmenting(DataSchemaNodeBuilder child) {
child.setAugmenting(true);
if (child instanceof DataNodeContainerBuilder) {
val DataNodeContainerBuilder dataNodeChild = child as DataNodeContainerBuilder;
for (inner : dataNodeChild.getChildNodeBuilders()) {
- setNodeAugmenting(inner, augment);
+ setNodeAugmenting(inner);
}
- for (uses : dataNodeChild.getUsesNodes()) {
- uses.setParentAugment(augment);
- uses.setAugmenting(true);
+ } else if (child instanceof ChoiceBuilder) {
+ val ChoiceBuilder choiceChild = child as ChoiceBuilder;
+ for (inner : choiceChild.cases) {
+ setNodeAugmenting(inner);
+ }
+ }
+ }
+
+ public static def void setNodeAddedByUses(GroupingMember child) {
+ child.setAddedByUses(true);
+ if (child instanceof DataNodeContainerBuilder) {
+ val DataNodeContainerBuilder dataNodeChild = child as DataNodeContainerBuilder;
+ for (inner : dataNodeChild.getChildNodeBuilders()) {
+ setNodeAddedByUses(inner);
}
} else if (child instanceof ChoiceBuilder) {
val ChoiceBuilder choiceChild = child as ChoiceBuilder;
for (inner : choiceChild.cases) {
- setNodeAugmenting(inner, augment);
+ setNodeAddedByUses(inner);
}
}
}
public static def void fillAugmentTarget(AugmentationSchemaBuilder augment, ChoiceBuilder target) {
for (DataSchemaNodeBuilder builder : augment.getChildNodeBuilders()) {
val childCopy = CopyUtils.copy(builder, target, false);
- setNodeAugmenting(childCopy, augment)
+ if (augment.parent instanceof UsesNodeBuilder) {
+ setNodeAddedByUses(childCopy);
+ }
+ setNodeAugmenting(childCopy)
correctNodePath(builder, target.getPath());
correctNodePath(childCopy, target.getPath());
target.addCase(childCopy);
fail("YangParseException should by thrown");
}
} catch (YangParseException e) {
- String expected = "Error in module 'testfile7' at line 18: Error in augment parsing: cannot augment mandatory node";
+ String expected = "Error in module 'testfile7' at line 18: Error in augment parsing: cannot augment mandatory node linkleaf";
assertEquals(expected, e.getMessage());
}
}
Code Review / yangtools.git / commitdiff