<plugin>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-maven-plugin</artifactId>
- <version>4.0.7</version>
+ <version>5.0.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>4.0.7</version>
+ <version>5.0.0-SNAPSHOT</version>
<type>pom</type>
<scope>import</scope>
</dependency>
*/
package org.opendaylight.mdsal.binding.yang.unified.doc.generator
-import com.google.common.collect.Iterables
-import com.google.common.collect.Lists
import java.io.BufferedWriter
import java.io.File
import java.io.IOException
import org.opendaylight.yangtools.yang.model.api.SchemaPath
import org.opendaylight.yangtools.yang.model.api.TypeDefinition
import org.opendaylight.yangtools.yang.model.api.UsesNode
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition
import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition
«FOR augment : module.augmentations»
<li>
<h3 id="«schemaPathToString(module, augment.targetPath, context, augment)»">
- Target [«typeAnchorLink(augment.targetPath,schemaPathToString(module, augment.targetPath, context, augment))»]</h3>
+ Target [«typeAnchorLink(augment.targetPath.asSchemaPath, schemaPathToString(module, augment.targetPath, context, augment))»]</h3>
«augment.description»
Status: «strong(String.valueOf(augment.status))»
«IF augment.reference !== null»
return ''
}
- private def parseTargetPath(SchemaPath path) {
- val List<DataSchemaNode> nodes = new ArrayList<DataSchemaNode>();
- for (QName pathElement : path.pathFromRoot) {
+ private def parseTargetPath(SchemaNodeIdentifier path) {
+ val nodes = new ArrayList<DataSchemaNode>();
+ for (QName pathElement : path.nodeIdentifiers) {
val module = ctx.findModule(pathElement.module)
if (module.isPresent) {
var foundNode = module.get.getDataChildByName(pathElement)
lastNodeInTargetPath = nodes.get(nodes.size() - 1)
}
- val List<DataSchemaNode> targetPathNodes = new ArrayList<DataSchemaNode>();
+ val targetPathNodes = new ArrayList<DataSchemaNode>();
targetPathNodes.add(lastNodeInTargetPath)
return targetPathNodes
}
private def printChoiceNode(ChoiceSchemaNode child) {
- val List<CaseSchemaNode> cases = new ArrayList(child.cases.values);
- if(!cases.empty) {
+ val cases = new ArrayList(child.cases)
+ if (!cases.empty) {
val CaseSchemaNode aCase = cases.get(0)
- for(caseChildNode : aCase.childNodes)
+ for (caseChildNode : aCase.childNodes)
printAugmentedNode(caseChildNode)
}
}
private def dispatch CharSequence tree(ChoiceSchemaNode node,YangInstanceIdentifier path) '''
«node.nodeName» (choice)
- «casesTree(node.cases.values, path)»
+ «casesTree(node.cases, path)»
'''
- def casesTree(Collection<CaseSchemaNode> nodes, YangInstanceIdentifier path) '''
+ def casesTree(Collection<? extends CaseSchemaNode> nodes, YangInstanceIdentifier path) '''
<ul>
«FOR node : nodes»
<li>
def String typeAnchorLink(SchemaPath path, CharSequence text) {
if(path !== null) {
- val lastElement = Iterables.getLast(path.pathFromRoot)
+ val lastElement = path.lastComponent
val ns = lastElement.namespace
if (ns == this.currentModule.namespace) {
return '''<a href="#«path.schemaPathToId»">«text»</a>'''
return '''
«printInfo(node, "choice")»
«listItem("default case", node.defaultCase.map([ CaseSchemaNode n | n.getQName.localName]).orElse(null))»
- «FOR caseNode : node.cases.values»
+ «FOR caseNode : node.cases»
«caseNode.printSchemaNodeInfo»
«ENDFOR»
</ul>
def CharSequence printUses(UsesNode usesNode) {
return '''
- «strong(listItem("uses", typeAnchorLink(usesNode.groupingPath, usesNode.groupingPath.pathTowardsRoot.iterator.next.localName)))»
+ «strong(listItem("uses", typeAnchorLink(usesNode.sourceGrouping.path, usesNode.sourceGrouping.path.pathTowardsRoot.iterator.next.localName)))»
<ul>
<li>refines:
<ul>
</ul>
</li>
«FOR augment : usesNode.augmentations»
- «typeAnchorLink(augment.targetPath,schemaPathToString(currentModule, augment.targetPath, ctx, augment))»
+ «typeAnchorLink(augment.targetPath.asSchemaPath, schemaPathToString(currentModule, augment.targetPath, ctx, augment))»
«ENDFOR»
</ul>
'''
'''
private def dispatch CharSequence printInfo(ChoiceSchemaNode node, int level, YangInstanceIdentifier path) '''
- «val Set<DataSchemaNode> choiceCases = new HashSet(node.cases.values)»
+ «val Set<DataSchemaNode> choiceCases = new HashSet(node.cases)»
«choiceCases.printChildren(level, path)»
'''
return it.toString;
}
- private def String schemaPathToString(Module module, SchemaPath schemaPath, EffectiveModelContext ctx, DataNodeContainer dataNode) {
- val List<QName> path = Lists.newArrayList(schemaPath.pathFromRoot);
+ private def String schemaPathToString(Module module, SchemaNodeIdentifier schemaPath, EffectiveModelContext ctx,
+ DataNodeContainer dataNode) {
+ val path = schemaPath.nodeIdentifiers
val StringBuilder pathString = new StringBuilder()
- if (schemaPath.absolute) {
+ if (schemaPath instanceof Absolute) {
pathString.append('/')
}
result.append('/')
}
if (path !== null && !path.empty) {
- val List<QName> actual = new ArrayList()
+ val actual = new ArrayList()
var i = 0;
for (pathElement : path) {
actual.add(pathElement)
'''
private def dispatch isAddedBy(SchemaNode node) {
- return false;
+ return false
}
private def dispatch isAddedBy(DataSchemaNode node) {
- if (node.augmenting || node.addedByUses) {
- return true
- } else {
- return false;
- }
+ return node.augmenting || node.addedByUses
}
private def dispatch nodeName(SchemaNode node) '''
import java.net.URI
import java.nio.charset.StandardCharsets
import java.util.ArrayList
+import java.util.Collection
import java.util.HashSet
import java.util.List
-import java.util.Set
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode
this.buildContext = buildContext
}
- def generate(EffectiveModelContext context, Set<Module> modules) {
+ def generate(EffectiveModelContext context, Collection<? extends Module> modules) {
val result = new HashSet;
this.context = context
for (module : modules) {
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.sonatype.plexus.build.incremental.DefaultBuildContext;
public void testListGeneration() throws Exception {
final List<File> sourceFiles = getSourceFiles("/doc-gen");
final EffectiveModelContext context = YangParserTestUtils.parseYangFiles(sourceFiles);
- final Set<Module> modules = context.getModules();
final DocumentationGeneratorImpl generator = new DocumentationGeneratorImpl();
generator.setBuildContext(new DefaultBuildContext());
- Collection<File> generatedFiles = generator.generateSources(context, GENERATOR_OUTPUT_DIR, modules,
- module -> Optional.empty());
+ Collection<File> generatedFiles = generator.generateSources(context, GENERATOR_OUTPUT_DIR,
+ Set.copyOf(context.getModules()), module -> Optional.empty());
assertEquals(4, generatedFiles.size());
}
final EffectiveModelContext context = YangParserTestUtils.parseYangFiles(sourceFiles);
CodeGeneratorImpl codegen = new CodeGeneratorImpl();
codegen.setBuildContext(new DefaultBuildContext());
- codegen.generateSources(context, sourcesOutputDir, context.getModules(),
+ codegen.generateSources(context, sourcesOutputDir, Set.copyOf(context.getModules()),
module -> Optional.of(resourceDirPath + File.separator + module.getName()
+ YangConstants.RFC6020_YANG_FILE_EXTENSION));
}
codegen.setResourceBaseDir(null);
codegen.setMavenProject(new MavenProject());
codegen.setAdditionalConfig(ImmutableMap.of("test", "test"));
- Collection<File> files = codegen.generateSources(context, null, context.getModules(),
+ Collection<File> files = codegen.generateSources(context, null, Set.copyOf(context.getModules()),
module -> Optional.of(module.getName()));
assertFalse(files.isEmpty());
files.forEach(file -> {
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.sonatype.plexus.build.incremental.DefaultBuildContext;
public void testListGeneration() throws Exception {
final List<File> sourceFiles = getSourceFiles("/wadl-gen");
final EffectiveModelContext context = YangParserTestUtils.parseYangFiles(sourceFiles);
- final Set<Module> modules = context.getModules();
final WadlGenerator generator = new WadlGenerator();
generator.setBuildContext(new DefaultBuildContext());
- Collection<File> generatedWadlFiles = generator.generateSources(context, GENERATOR_OUTPUT_DIR, modules,
- module -> Optional.empty());
+ Collection<File> generatedWadlFiles = generator.generateSources(context, GENERATOR_OUTPUT_DIR,
+ Set.copyOf(context.getModules()), module -> Optional.empty());
assertEquals(3, generatedWadlFiles.size());
generatedWadlFiles.forEach(file -> assertTrue(file.exists()));
}
public void testListGenerationWithoutPath() throws Exception {
final List<File> sourceFiles = getSourceFiles("/wadl-gen");
final EffectiveModelContext context = YangParserTestUtils.parseYangFiles(sourceFiles);
- final Set<Module> modules = context.getModules();
final WadlGenerator generator = new WadlGenerator();
generator.setBuildContext(new DefaultBuildContext());
- Collection<File> generatedWadlFiles = generator.generateSources(context, null, modules,
+ Collection<File> generatedWadlFiles = generator.generateSources(context, null, Set.copyOf(context.getModules()),
module -> Optional.empty());
assertEquals(3, generatedWadlFiles.size());
generatedWadlFiles.forEach(file -> {
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-codec</artifactId>
</dependency>
+
+ <!-- FIXME: MDSAL-392: this is ugly, we should be looking this up,
+ but then we may want to end up doing something
+ completely different in thes artifacts -->
<dependency>
- <!-- FIXME: MDSAL-392: this is ugly, we should be looking this up,
- but then we may want to end up doing something
- completely different in this artifact -->
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-generator-impl</artifactId>
</dependency>
+
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-runtime-spi</artifactId>
<groupId>org.osgi</groupId>
<artifactId>org.osgi.core</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>osgi.cmpn</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<configuration>
<instructions>
<Bundle-Name>${project.groupId}.${project.artifactId}</Bundle-Name>
- <Bundle-Activator>org.opendaylight.mdsal.binding.dom.codec.osgi.impl.Activator</Bundle-Activator>
</instructions>
</configuration>
</plugin>
/*
- * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ * Copyright (c) 2020 PANTHEON.tech, s.r.o. 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,
*/
package org.opendaylight.mdsal.binding.dom.codec.osgi.impl;
-import java.util.ArrayList;
-import java.util.List;
import org.opendaylight.binding.runtime.api.ClassLoadingStrategy;
import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
import org.opendaylight.binding.runtime.spi.ModuleInfoBackedContext;
-import org.osgi.framework.BundleActivator;
-import org.osgi.framework.BundleContext;
-import org.osgi.framework.ServiceRegistration;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+import org.osgi.service.component.ComponentContext;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Reference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class Activator implements BundleActivator {
- private static final Logger LOG = LoggerFactory.getLogger(Activator.class);
+@Component(immediate = true)
+public final class BindingClassLoadingStrategy implements ClassLoadingStrategy {
+ private static final Logger LOG = LoggerFactory.getLogger(BindingClassLoadingStrategy.class);
- private final List<ServiceRegistration<?>> registrations = new ArrayList<>(2);
+ @Reference
+ YangParserFactory factory = null;
private ModuleInfoBundleTracker bundleTracker = null;
+ private ModuleInfoBackedContext moduleInfoBackedContext = null;
- @Override
- public void start(final BundleContext context) {
+ @Activate
+ void activate(final ComponentContext ctx) {
LOG.info("Binding-DOM codec starting");
- final ModuleInfoBackedContext moduleInfoBackedContext = ModuleInfoBackedContext.create(
+ moduleInfoBackedContext = ModuleInfoBackedContext.create("binding-dom-codec", factory,
// FIXME: This is the fallback strategy, it should not be needed
GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy());
moduleInfoBackedContext);
LOG.debug("Starting Binding-DOM codec bundle tracker");
- bundleTracker = new ModuleInfoBundleTracker(context, registry);
+ bundleTracker = new ModuleInfoBundleTracker(ctx.getBundleContext(), registry);
bundleTracker.open();
- LOG.debug("Registering Binding-DOM codec services");
- registrations.add(context.registerService(ClassLoadingStrategy.class, moduleInfoBackedContext, null));
-
LOG.info("Binding-DOM codec started");
}
- @Override
- public void stop(final BundleContext context) {
+ @Deactivate
+ void deactivate() {
LOG.info("Binding-DOM codec stopping");
-
- LOG.debug("Unregistering Binding-DOM codec services");
- registrations.forEach(ServiceRegistration::unregister);
- registrations.clear();
-
LOG.debug("Stopping Binding-DOM codec bundle tracker");
bundleTracker.close();
-
+ moduleInfoBackedContext = null;
+ bundleTracker = null;
LOG.info("Binding-DOM codec stopped");
}
+
+ @Override
+ public Class<?> loadClass(final String fullyQualifiedName) throws ClassNotFoundException {
+ return moduleInfoBackedContext.loadClass(fullyQualifiedName);
+ }
}
} else if (nodeSchema instanceof ChoiceSchemaNode) {
boolean haveAddressable = false;
boolean haveUnaddressable = false;
- for (CaseSchemaNode child : ((ChoiceSchemaNode) nodeSchema).getCases().values()) {
+ for (CaseSchemaNode child : ((ChoiceSchemaNode) nodeSchema).getCases()) {
switch (computeChildAddressabilitySummary(child)) {
case ADDRESSABLE:
haveAddressable = true;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
* Comparator based on augment target path.
*/
private static final Comparator<AugmentationSchemaNode> AUGMENT_COMP = (o1, o2) -> {
- final Iterator<QName> thisIt = o1.getTargetPath().getPathFromRoot().iterator();
- final Iterator<QName> otherIt = o2.getTargetPath().getPathFromRoot().iterator();
+ final Iterator<QName> thisIt = o1.getTargetPath().getNodeIdentifiers().iterator();
+ final Iterator<QName> otherIt = o2.getTargetPath().getNodeIdentifiers().iterator();
while (thisIt.hasNext()) {
if (!otherIt.hasNext()) {
private Optional<ActionDefinition> findOrigAction(final DataNodeContainer parent, final ActionDefinition action) {
for (UsesNode uses : parent.getUses()) {
- final GroupingDefinition grp = findUsedGrouping(uses);
+ final GroupingDefinition grp = uses.getSourceGrouping();
final Optional<ActionDefinition> found = grp.findAction(action.getQName());
if (found.isPresent()) {
final ActionDefinition result = found.get();
"Augmentation Schema does not contain Target Path (Target Path is NULL).");
processUsesAugments(augSchema, context, false);
- final SchemaPath targetPath = augSchema.getTargetPath();
+ final SchemaNodeIdentifier targetPath = augSchema.getTargetPath();
SchemaNode targetSchemaNode = null;
- targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);
+ // FIXME: can we use findDataSchemaNode() instead?
+ targetSchemaNode = findDataSchemaNode(schemaContext, targetPath.getNodeIdentifiers());
if (targetSchemaNode instanceof DataSchemaNode && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) {
if (targetSchemaNode instanceof DerivableSchemaNode) {
targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal().orElse(null);
"Augmentation Schema does not contain Target Path (Target Path is NULL).");
processUsesAugments(augSchema, context, inGrouping);
- final SchemaPath targetPath = augSchema.getTargetPath();
+ final SchemaNodeIdentifier targetPath = augSchema.getTargetPath();
final SchemaNode targetSchemaNode = findOriginalTargetFromGrouping(targetPath, usesNode);
if (targetSchemaNode == null) {
throw new IllegalArgumentException("augment target not found: " + targetPath);
}
}
- private GroupingDefinition findUsedGrouping(final UsesNode uses) {
- final SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, uses.getGroupingPath()
- .getPathFromRoot());
- if (targetGrouping instanceof GroupingDefinition) {
- return (GroupingDefinition) targetGrouping;
- }
-
- throw new IllegalArgumentException("Failed to resolve used grouping for " + uses);
- }
-
/**
* Convenient method to find node added by uses statement.
*
* @param parentUsesNode parent of uses node
* @return node from its original location in grouping
*/
- private DataSchemaNode findOriginalTargetFromGrouping(final SchemaPath targetPath, final UsesNode parentUsesNode) {
- SchemaNode result = findUsedGrouping(parentUsesNode);
- for (final QName node : targetPath.getPathFromRoot()) {
+ private static DataSchemaNode findOriginalTargetFromGrouping(final SchemaNodeIdentifier targetPath,
+ final UsesNode parentUsesNode) {
+ SchemaNode result = parentUsesNode.getSourceGrouping();
+ for (final QName node : targetPath.getNodeIdentifiers()) {
if (result instanceof DataNodeContainer) {
- final QName resultNode = node.withModule(result.getQName().getModule());
+ final QName resultNode = node.bindTo(result.getQName().getModule());
result = ((DataNodeContainer) result).getDataChildByName(resultNode);
} else if (result instanceof ChoiceSchemaNode) {
result = findNamedCase((ChoiceSchemaNode) result, node.getLocalName());
checkArgument(refChoiceType != null, "Referenced Choice Type cannot be NULL.");
checkArgument(choiceNode != null, "ChoiceNode cannot be NULL.");
- for (final CaseSchemaNode caseNode : choiceNode.getCases().values()) {
+ for (final CaseSchemaNode caseNode : choiceNode.getCases()) {
if (caseNode != null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {
final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode);
caseTypeBuilder.addImplementsType(refChoiceType);
if (parent instanceof AugmentationSchemaNode) {
final AugmentationSchemaNode augSchema = (AugmentationSchemaNode) parent;
- final SchemaPath targetPath = augSchema.getTargetPath();
- SchemaNode targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);
+ final SchemaNodeIdentifier targetPath = augSchema.getTargetPath();
+ // FIXME: can we use findDataSchemaNode?
+ SchemaNode targetSchemaNode = findNodeInSchemaContext(schemaContext,
+ targetPath.getNodeIdentifiers());
if (targetSchemaNode instanceof DataSchemaNode
&& ((DataSchemaNode) targetSchemaNode).isAddedByUses()) {
if (targetSchemaNode instanceof DerivableSchemaNode) {
}
private static CaseSchemaNode findNamedCase(final ChoiceSchemaNode choice, final String caseName) {
- final List<CaseSchemaNode> cases = choice.findCaseNodes(caseName);
+ final List<? extends CaseSchemaNode> cases = choice.findCaseNodes(caseName);
return cases.isEmpty() ? null : cases.get(0);
}
private GeneratedTypeBuilder addImplementedInterfaceFromUses(final DataNodeContainer dataNodeContainer,
final GeneratedTypeBuilder builder) {
for (final UsesNode usesNode : dataNodeContainer.getUses()) {
- final GeneratedTypeBuilder genType = findGroupingByPath(usesNode.getGroupingPath());
+ final GeneratedTypeBuilder genType = findGrouping(usesNode.getSourceGrouping());
if (genType == null) {
- throw new IllegalStateException("Grouping " + usesNode.getGroupingPath() + "is not resolved for "
- + builder.getName());
+ throw new IllegalStateException("Grouping " + usesNode.getSourceGrouping().getQName()
+ + " is not resolved for " + builder.getName());
}
builder.addImplementsType(genType.build());
return null;
}
+ private GeneratedTypeBuilder findGrouping(final GroupingDefinition grouping) {
+ for (final ModuleContext ctx : genCtx.values()) {
+ final GeneratedTypeBuilder result = ctx.getGrouping(grouping.getPath());
+ if (result != null) {
+ return result;
+ }
+ }
+ return null;
+ }
+
private GeneratedTypeBuilder findGroupingByPath(final SchemaPath path) {
for (final ModuleContext ctx : genCtx.values()) {
final GeneratedTypeBuilder result = ctx.getGrouping(path);
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
public class GroupingDefinitionDependencySort {
* @return set of nodes where every one contains wrapped grouping definition
*/
private Set<Node> groupingDefinitionsToNodes(final Collection<? extends GroupingDefinition> groupingDefinitions) {
- final Map<SchemaPath, Node> nodeMap = new HashMap<>();
+ final Map<GroupingDefinition, Node> nodeMap = new HashMap<>();
final Set<Node> resultNodes = new HashSet<>();
for (final GroupingDefinition groupingDefinition : groupingDefinitions) {
final Node node = new NodeWrappedType(groupingDefinition);
- nodeMap.put(groupingDefinition.getPath(), node);
+ nodeMap.put(groupingDefinition, node);
resultNodes.add(node);
}
Set<UsesNode> usesNodes = getAllUsesNodes(groupingDefinition);
for (UsesNode usesNode : usesNodes) {
- SchemaPath schemaPath = usesNode.getGroupingPath();
- if (schemaPath != null) {
- Node nodeTo = nodeMap.get(schemaPath);
- if (nodeTo != null) {
- nodeWrappedType.addEdge(nodeTo);
- }
+ Node nodeTo = nodeMap.get(usesNode.getSourceGrouping());
+ if (nodeTo != null) {
+ nodeWrappedType.addEdge(nodeTo);
}
}
}
if (childNode instanceof DataNodeContainer) {
ret.addAll(getAllUsesNodes((DataNodeContainer) childNode));
} else if (childNode instanceof ChoiceSchemaNode) {
- for (CaseSchemaNode choiceCaseNode : ((ChoiceSchemaNode) childNode).getCases().values()) {
+ for (CaseSchemaNode choiceCaseNode : ((ChoiceSchemaNode) childNode).getCases()) {
ret.addAll(getAllUsesNodes(choiceCaseNode));
}
}
} else if (childNode instanceof ListSchemaNode) {
fillRecursively(list, (ListSchemaNode) childNode);
} else if (childNode instanceof ChoiceSchemaNode) {
- for (final CaseSchemaNode caseNode : ((ChoiceSchemaNode) childNode).getCases().values()) {
+ for (CaseSchemaNode caseNode : ((ChoiceSchemaNode) childNode).getCases()) {
fillRecursively(list, caseNode);
}
}
private static @NonNull Optional<CaseSchemaNode> findInstantiatedCase(final ChoiceSchemaNode instantiatedChoice,
final CaseSchemaNode originalDefinition) {
- CaseSchemaNode potential = instantiatedChoice.getCaseNodeByName(originalDefinition.getQName());
+ CaseSchemaNode potential = instantiatedChoice.findCase(originalDefinition.getQName()).orElse(null);
if (originalDefinition.equals(potential)) {
return Optional.of(potential);
}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
+import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException;
private static final class WithFallback extends ModuleInfoBackedContext {
private final @NonNull ClassLoadingStrategy fallback;
- WithFallback(final ClassLoadingStrategy fallback) {
+ WithFallback(final YangTextSchemaContextResolver resolver, final ClassLoadingStrategy fallback) {
+ super(resolver);
this.fallback = requireNonNull(fallback);
}
}
});
- private final YangTextSchemaContextResolver ctxResolver = YangTextSchemaContextResolver.create("binding-context");
+ private final YangTextSchemaContextResolver ctxResolver;
@GuardedBy("this")
private final ListMultimap<String, AbstractRegisteredModuleInfo> packageToInfoReg =
private final ListMultimap<SourceIdentifier, AbstractRegisteredModuleInfo> sourceToInfoReg =
MultimapBuilder.hashKeys().arrayListValues().build();
- ModuleInfoBackedContext() {
- // Hidden on purpose
+ ModuleInfoBackedContext(final YangTextSchemaContextResolver resolver) {
+ this.ctxResolver = requireNonNull(resolver);
}
@Beta
}
public static ModuleInfoBackedContext create() {
- return new ModuleInfoBackedContext();
+ return create("unnamed");
+ }
+
+ public static ModuleInfoBackedContext create(final String id) {
+ return new ModuleInfoBackedContext(YangTextSchemaContextResolver.create(id));
}
public static ModuleInfoBackedContext create(final ClassLoadingStrategy loadingStrategy) {
- return new WithFallback(loadingStrategy);
+ return create("unnamed", loadingStrategy);
+ }
+
+ public static ModuleInfoBackedContext create(final String id, final ClassLoadingStrategy loadingStrategy) {
+ return new WithFallback(YangTextSchemaContextResolver.create(id), loadingStrategy);
+ }
+
+ public static ModuleInfoBackedContext create(final String id, final YangParserFactory factory) {
+ return new ModuleInfoBackedContext(YangTextSchemaContextResolver.create(id, factory));
+ }
+
+ public static ModuleInfoBackedContext create(final String id, final YangParserFactory factory,
+ final ClassLoadingStrategy loadingStrategy) {
+ return new WithFallback(YangTextSchemaContextResolver.create(id, factory), loadingStrategy);
}
@Override
<artifactId>org.osgi.core</artifactId>
<scope>provided</scope>
</dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>osgi.cmpn</artifactId>
+ <scope>provided</scope>
+ </dependency>
<dependency>
<groupId>org.apache.aries.blueprint</groupId>
<artifactId>blueprint-maven-plugin-annotation</artifactId>
<link>https://commons.apache.org/proper/commons-lang/javadocs/api-3.9/</link>
<link>https://commons.apache.org/proper/commons-codec/apidocs/</link>
- <link>https://www.javadoc.io/doc/org.opendaylight.yangtools/yangtools-docs/4.0.7/</link>
+ <link>https://www.javadoc.io/doc/org.opendaylight.yangtools/yangtools-docs/5.0.0-SNAPSHOT/</link>
</links>
<groups>
<group>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>4.0.7</version>
+ <version>5.0.0-SNAPSHOT</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>4.0.7</version>
+ <version>5.0.0-SNAPSHOT</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-binding-api">
<feature name="odl-mdsal-binding-api">
- <feature version="[4,5)">odl-yangtools-data-api</feature>
+ <feature version="[5,6)">odl-yangtools-data-api</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-binding-base">
<feature name="odl-mdsal-binding-base">
- <feature version="[4,5)">odl-yangtools-common</feature>
+ <feature version="[5,6)">odl-yangtools-common</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-binding-runtime">
<feature name="odl-mdsal-binding-runtime">
- <feature version="[4,5)">odl-yangtools-data</feature>
- <feature version="[4,5)">odl-yangtools-parser</feature>
+ <feature version="[5,6)">odl-yangtools-data</feature>
+ <feature version="[5,6)">odl-yangtools-parser</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-common">
<feature name="odl-mdsal-common">
- <feature version="[4,5)">odl-yangtools-common</feature>
+ <feature version="[5,6)">odl-yangtools-common</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-dom-api">
<feature name="odl-mdsal-dom-api">
- <feature version="[4,5)">odl-yangtools-data-api</feature>
+ <feature version="[5,6)">odl-yangtools-data-api</feature>
</feature>
</features>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-dom-broker">
<feature name="odl-mdsal-dom-broker">
<feature version="[6,7)">odl-lmax-3</feature>
- <feature version="[4,5)">odl-yangtools-data</feature>
- <feature version="[4,5)">odl-yangtools-parser</feature>
+ <feature version="[5,6)">odl-yangtools-data</feature>
+ <feature version="[5,6)">odl-yangtools-parser</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-eos-common">
<feature name="odl-mdsal-eos-common">
- <feature version="[4,5)">odl-yangtools-data-api</feature>
+ <feature version="[5,6)">odl-yangtools-data-api</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-exp-yanglib-api">
<feature name="odl-mdsal-exp-yanglib-api">
- <feature version="[4,5)">odl-yangtools-data-api</feature>
+ <feature version="[5,6)">odl-yangtools-data-api</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-uint24-netty">
<feature name="odl-mdsal-uint24-netty">
- <feature version="[4,5)">odl-yangtools-netty</feature>
+ <feature version="[5,6)">odl-yangtools-netty</feature>
</feature>
</features>
Code Review / mdsal.git / commitdiff