<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<plugin>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-maven-plugin</artifactId>
- <version>6.0.5</version>
+ <version>7.0.1-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>6.0.5</version>
+ <version>7.0.1-SNAPSHOT</version>
<type>pom</type>
<scope>import</scope>
</dependency>
import java.nio.file.Files
import java.util.ArrayList
import java.util.Collection
+import java.util.IdentityHashMap
import java.util.HashMap
import java.util.HashSet
import java.util.LinkedHashMap
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode
+import org.opendaylight.yangtools.yang.model.api.MandatoryAware
import org.opendaylight.yangtools.yang.model.api.Module
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition
import org.opendaylight.yangtools.yang.model.api.SchemaNode
import org.opendaylight.yangtools.yang.model.api.SchemaPath
+import org.opendaylight.yangtools.yang.model.api.TypeAware
import org.opendaylight.yangtools.yang.model.api.TypeDefinition
import org.opendaylight.yangtools.yang.model.api.UsesNode
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement
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.LengthConstraint
static val Logger LOG = LoggerFactory.getLogger(GeneratorImpl)
- val Map<String, String> imports = new HashMap();
- var Module currentModule;
- var EffectiveModelContext ctx;
+ val Map<String, String> imports = new HashMap()
+ val Map<TypeDefinition<?>, SchemaPath> types = new IdentityHashMap
+ var Module currentModule
+ var EffectiveModelContext ctx
var File path
StringBuilder augmentChildNodesAsString
DataSchemaNode lastNodeInTargetPath = null
- def generate(BuildContext buildContext, EffectiveModelContext context, File targetPath, Set<Module> modulesToGen)
- throws IOException {
- path = targetPath;
+ new(EffectiveModelContext context) {
+ this.ctx = context
+ fillTypes(SchemaPath.ROOT, context.moduleStatements.values)
+ }
+
+ private def void fillTypes(SchemaPath path, Collection<? extends EffectiveStatement<?, ?>> stmts) {
+ for (stmt : stmts) {
+ val arg = stmt.argument
+ if (arg instanceof QName) {
+ val stmtPath = path.createChild(arg)
+ if (stmt instanceof TypeDefinition) {
+ types.putIfAbsent(stmt, stmtPath)
+ } else if (stmt instanceof TypeAware) {
+ val type = stmt.type
+ val typePath = stmtPath.createChild(type.QName)
+ types.putIfAbsent(type, typePath)
+ }
+
+ fillTypes(stmtPath, stmt.effectiveSubstatements)
+ }
+ }
+ }
+
+ def generate(BuildContext buildContext, File targetPath, Set<Module> modulesToGen) throws IOException {
+ path = targetPath
Files.createDirectories(path.getParentFile().toPath())
- val it = new HashSet;
+ val it = new HashSet
for (module : modulesToGen) {
- add(generateDocumentation(buildContext, module, context));
+ add(generateDocumentation(buildContext, module))
}
return it;
}
- def generateDocumentation(BuildContext buildContext, Module module, EffectiveModelContext ctx) {
+ def generateDocumentation(BuildContext buildContext, Module module) {
val destination = new File(path, '''«module.name».html''')
- this.ctx = ctx;
module.imports.forEach[importModule | this.imports.put(importModule.prefix, importModule.moduleName)]
var OutputStreamWriter fw
var BufferedWriter bw
try {
fw = new OutputStreamWriter(buildContext.newFileOutputStream(destination), StandardCharsets.UTF_8)
bw = new BufferedWriter(fw)
- currentModule = module;
- bw.append(generate(module, ctx));
+ currentModule = module
+ bw.append(generate(module, ctx))
} catch (IOException e) {
LOG.error("Failed to emit file {}", destination, e);
} finally {
fw.close();
}
}
- return destination;
+ return destination
}
def generate(Module module, EffectiveModelContext ctx) '''
if(node instanceof LeafSchemaNode) {
return '''
«printInfo(node, "leaf")»
- «listItem("type", typeAnchorLink(node.type?.path, node.type.QName.localName))»
+ «listItem("type", typeAnchorLink(types.get(node.type), node.type.QName.localName))»
«listItem("units", node.type.units.orElse(null))»
«listItem("default", node.type.defaultValue.map([ Object o | o.toString]).orElse(null))»
</ul>
def CharSequence printUses(UsesNode usesNode) {
return '''
- «strong(listItem("uses", typeAnchorLink(usesNode.sourceGrouping.path, usesNode.sourceGrouping.path.pathTowardsRoot.iterator.next.localName)))»
+ «strong(listItem("uses", typeAnchorLink(usesNode.sourceGrouping.path, usesNode.sourceGrouping.QName.localName)))»
<ul>
<li>refines:
<ul>
return '''
<li>«strong(localLink(newPath,node.QName.localName))» (container)
<ul>
- <li>configuration data: «strong(String.valueOf(node.configuration))»</li>
+ «node.configurationDataItem»
</ul>
</li>
'''
return '''
<li>«strong(localLink(newPath,node.QName.localName))» (list)
<ul>
- <li>configuration data: «strong(String.valueOf(node.configuration))»</li>
+ «node.configurationDataItem»
</ul>
</li>
'''
return '''
<li>«strong((node.QName.localName))» (anyxml)
<ul>
- <li>configuration data: «strong(String.valueOf(node.configuration))»</li>
- <li>mandatory: «strong(String.valueOf(node.mandatory))»</li>
+ «node.configurationDataItem»
+ «node.mandatoryItem»
</ul>
</li>
'''
return '''
<li>«strong((node.QName.localName))» (leaf)
<ul>
- <li>configuration data: «strong(String.valueOf(node.configuration))»</li>
- <li>mandatory: «strong(String.valueOf(node.mandatory))»</li>
+ «node.configurationDataItem»
+ «node.mandatoryItem»
</ul>
</li>
'''
return '''
<li>«strong((node.QName.localName))» (leaf-list)
<ul>
- <li>configuration data: «strong(String.valueOf(node.configuration))»</li>
+ «node.configurationDataItem»
</ul>
</li>
'''
<a href="#«FOR cmp : identifier.pathArguments SEPARATOR "/"»«cmp.nodeType.localName»«ENDFOR»">«text»</a>
'''
+ private static def String configurationDataItem(DataSchemaNode node) {
+ return node.effectiveConfig
+ .map([config | "<li>configuration data: " + strong(String.valueOf(config)) + "</li>"])
+ .orElse("")
+ }
+
+ private static def CharSequence mandatoryItem(MandatoryAware node) '''
+ <li>mandatory: «strong(String.valueOf(node.mandatory))»</li>
+ '''
private def dispatch YangInstanceIdentifier append(YangInstanceIdentifier identifier, ContainerSchemaNode node) {
return identifier.node(node.QName);
def toBaseStmt(TypeDefinition<?> baseType) '''
«IF baseType !== null»
- «listItem("Base type", typeAnchorLink(baseType?.path, baseType.QName.localName))»
+ «listItem("Base type", typeAnchorLink(types.get(baseType), baseType.QName.localName))»
«ENDIF»
'''
-
-
/* #################### UTILITY #################### */
- private def String strong(CharSequence str) '''<strong>«str»</strong>'''
- private def italic(CharSequence str) '''<i>«str»</i>'''
+ private def static String strong(CharSequence str) '''<strong>«str»</strong>'''
+ private def static italic(CharSequence str) '''<i>«str»</i>'''
def CharSequence descAndRefLi(SchemaNode node) '''
«listItem("Description", node.description.orElse(null))»
import org.opendaylight.yangtools.yang2sources.spi.ModuleResourceResolver;
import org.sonatype.plexus.build.incremental.BuildContext;
-public class DocumentationGeneratorImpl extends GeneratorImpl implements BasicCodeGenerator, BuildContextAware {
+public class DocumentationGeneratorImpl implements BasicCodeGenerator, BuildContextAware {
private BuildContext buildContext;
@Override
public Collection<File> generateSources(final EffectiveModelContext context, final File outputBaseDir,
final Set<Module> currentModules, final ModuleResourceResolver moduleResourcePathResolver)
throws IOException {
- return generate(buildContext, context, outputBaseDir, currentModules);
+ return new GeneratorImpl(context).generate(buildContext, outputBaseDir, currentModules);
}
}
import java.io.File
import java.io.IOException
import java.io.OutputStreamWriter
-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 org.opendaylight.yangtools.yang.common.XMLNamespace
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode
<method name="DELETE" />
'''
- private def representation(URI prefix, String name) '''
+ private def representation(XMLNamespace prefix, String name) '''
«val elementData = name»
<representation mediaType="application/xml" element="«elementData»"/>
<representation mediaType="text/xml" element="«elementData»"/>
}
@Override
- public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode<?, ?> input) {
+ public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode input) {
final QName rpcType = rpc.getType();
final CurrentAdapterSerializer serializer = adapterContext.currentSerializer();
final DataObject bindingInput = input != null ? deserialize(serializer, rpcType, input) : null;
}
private DataObject deserialize(final CurrentAdapterSerializer serializer, final QName rpcType,
- final NormalizedNode<?, ?> input) {
+ final NormalizedNode input) {
if (ENABLE_CODEC_SHORTCUT && input instanceof BindingLazyContainerNode) {
return ((BindingLazyContainerNode<?>) input).getDataObject();
}
@Override
public final <U extends DataObject> void put(final LogicalDatastoreType store, final InstanceIdentifier<U> path,
final U data) {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized("put", path, data);
+ final Entry<YangInstanceIdentifier, NormalizedNode> normalized = toNormalized("put", path, data);
getDelegate().put(store, normalized.getKey(), normalized.getValue());
}
public final <U extends DataObject> void mergeParentStructurePut(final LogicalDatastoreType store,
final InstanceIdentifier<U> path, final U data) {
final CurrentAdapterSerializer serializer = adapterContext().currentSerializer();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized(serializer, "put", path,
- data);
+ final Entry<YangInstanceIdentifier, NormalizedNode> normalized = toNormalized(serializer, "put", path, data);
ensureParentsByMerge(serializer, store, normalized.getKey(), path);
getDelegate().put(store, normalized.getKey(), normalized.getValue());
}
@Override
public final <D extends DataObject> void merge(final LogicalDatastoreType store, final InstanceIdentifier<D> path,
final D data) {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized("merge", path, data);
+ final Entry<YangInstanceIdentifier, NormalizedNode> normalized = toNormalized("merge", path, data);
getDelegate().merge(store, normalized.getKey(), normalized.getValue());
}
public final <U extends DataObject> void mergeParentStructureMerge(final LogicalDatastoreType store,
final InstanceIdentifier<U> path, final U data) {
final CurrentAdapterSerializer serializer = adapterContext().currentSerializer();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized(serializer, "merge", path,
- data);
+ final Entry<YangInstanceIdentifier, NormalizedNode> normalized = toNormalized(serializer, "merge", path, data);
ensureParentsByMerge(serializer, store, normalized.getKey(), path);
getDelegate().merge(store, normalized.getKey(), normalized.getValue());
}
final YangInstanceIdentifier domPath, final InstanceIdentifier<?> path) {
final YangInstanceIdentifier parentPath = domPath.getParent();
if (parentPath != null && !parentPath.isEmpty()) {
- final NormalizedNode<?, ?> parentNode = ImmutableNodes.fromInstanceId(
+ final NormalizedNode parentNode = ImmutableNodes.fromInstanceId(
serializer.getRuntimeContext().getEffectiveModelContext(), parentPath);
getDelegate().merge(store, YangInstanceIdentifier.create(parentNode.getIdentifier()), parentNode);
}
}
- private <U extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalized(
- final String operation, final InstanceIdentifier<U> path, final U data) {
+ private <U extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode> toNormalized(final String operation,
+ final InstanceIdentifier<U> path, final U data) {
return toNormalized(adapterContext().currentSerializer(), operation, path, data);
}
- private static <U extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalized(
+ private static <U extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode> toNormalized(
final CurrentAdapterSerializer serializer, final String operation, final InstanceIdentifier<U> path,
final U data) {
checkArgument(!path.isWildcarded(), "Cannot %s data into wildcarded path %s", operation, path);
UNKNOWN;
public static BindingStructuralType from(final DataTreeCandidateNode domChildNode) {
- Optional<NormalizedNode<?, ?>> dataBased = domChildNode.getDataAfter();
+ Optional<NormalizedNode> dataBased = domChildNode.getDataAfter();
if (!dataBased.isPresent()) {
dataBased = domChildNode.getDataBefore();
}
return UNKNOWN;
}
- static BindingStructuralType from(final NormalizedNode<?, ?> data) {
+ static BindingStructuralType from(final NormalizedNode data) {
if (isNotAddressable(data)) {
return NOT_ADDRESSABLE;
}
}
}
- private static boolean isVisibleContainer(final NormalizedNode<?, ?> data) {
+ private static boolean isVisibleContainer(final NormalizedNode data) {
return data instanceof MapEntryNode || data instanceof ContainerNode || data instanceof AugmentationNode;
}
- private static boolean isNotAddressable(final NormalizedNode<?, ?> normalizedNode) {
+ private static boolean isNotAddressable(final NormalizedNode normalizedNode) {
return normalizedNode instanceof LeafNode
|| normalizedNode instanceof AnyxmlNode
|| normalizedNode instanceof LeafSetNode
return new DefaultDOMRpcResult(codec.toNormalizedNodeRpcData((DataContainer) inputData));
}
- return new DefaultDOMRpcResult((NormalizedNode<?, ?>) null);
+ return new DefaultDOMRpcResult((NormalizedNode) null);
}
return new DefaultDOMRpcResult(input.getErrors());
}
return MoreObjects.toStringHelper(this).add("identifier", identifier).add("domData", domData).toString();
}
- private T deserialize(final Optional<NormalizedNode<?, ?>> dataAfter) {
+ private T deserialize(final Optional<NormalizedNode> dataAfter) {
return dataAfter.map(codec::deserialize).orElse(null);
}
}
import static java.util.Objects.requireNonNull;
-import java.util.Optional;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.binding.dom.codec.spi.AbstractBindingLazyContainerNode;
import org.opendaylight.yangtools.yang.binding.DataObject;
}
@Override
- public Optional<DataContainerChild<? extends PathArgument, ?>> getChild(final PathArgument child) {
+ public DataContainerChild childByArg(final PathArgument child) {
// Use pre-cached value of routing field and do not run full serialization if we are accessing it.
- return contextRef.getIdentifier().equals(child) ? Optional.of(contextRef) : super.getChild(child);
+ return contextRef.getIdentifier().equals(child) ? contextRef : super.childByArg(child);
}
}
}
private ListenableFuture<RpcResult<?>> transformFuture(final ListenableFuture<? extends DOMRpcResult> domFuture,
final BindingNormalizedNodeSerializer resultCodec) {
return Futures.transform(domFuture, input -> {
- final NormalizedNode<?, ?> domData = input.getResult();
+ final NormalizedNode domData = input.getResult();
final DataObject bindingResult;
if (domData != null) {
bindingResult = resultCodec.fromNormalizedNodeRpcData(outputPath, (ContainerNode) domData);
@NonNullByDefault
@SuppressModernizer
final class DefaultQueryResult<T extends DataObject>
- implements QueryResult<T>, Function<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>, QueryResult.Item<T>> {
+ implements QueryResult<T>, Function<Entry<YangInstanceIdentifier, NormalizedNode>, QueryResult.Item<T>> {
private static final VarHandle ITEM_CODEC;
static {
}
@Override
- public Item<T> apply(final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> domItem) {
+ public Item<T> apply(final Entry<YangInstanceIdentifier, NormalizedNode> domItem) {
return new DefaultQueryResultItem<>(this, domItem);
}
- T createObject(final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> domItem) {
+ T createObject(final Entry<YangInstanceIdentifier, NormalizedNode> domItem) {
final @Nullable BindingDataObjectCodecTreeNode<T> local =
(BindingDataObjectCodecTreeNode<T>) ITEM_CODEC.getAcquire(this);
return (local != null ? local : loadItemCodec(domItem.getKey())).deserialize(domItem.getValue());
}
}
- private final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> domItem;
+ private final Entry<YangInstanceIdentifier, NormalizedNode> domItem;
private final DefaultQueryResult<T> result;
@SuppressWarnings("unused")
private volatile @Nullable T object = null;
DefaultQueryResultItem(final DefaultQueryResult<T> result,
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> domItem) {
+ final Entry<YangInstanceIdentifier, NormalizedNode> domItem) {
this.result = requireNonNull(result);
this.domItem = requireNonNull(domItem);
}
@NonNullByDefault
final class DefaultQueryResultSpliterator<T extends DataObject> implements Spliterator<QueryResult.Item<T>> {
- private final Spliterator<? extends Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> domSpliterator;
+ private final Spliterator<? extends Entry<YangInstanceIdentifier, NormalizedNode>> domSpliterator;
private final DefaultQueryResult<T> result;
DefaultQueryResultSpliterator(final DefaultQueryResult<T> result,
- final Spliterator<? extends Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> domSpliterator) {
+ final Spliterator<? extends Entry<YangInstanceIdentifier, NormalizedNode>> domSpliterator) {
this.result = requireNonNull(result);
this.domSpliterator = requireNonNull(domSpliterator);
}
@Override
public @Nullable Spliterator<Item<T>> trySplit() {
- final Spliterator<? extends Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> split =
- domSpliterator.trySplit();
+ final Spliterator<? extends Entry<YangInstanceIdentifier, NormalizedNode>> split = domSpliterator.trySplit();
return split == null ? null : new DefaultQueryResultSpliterator<>(result, split);
}
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
@Beta
public final class SimpleQueryExecutor implements QueryExecutor {
- private final NormalizedNode<?, ?> root;
+ private final NormalizedNode root;
- public SimpleQueryExecutor(final NormalizedNode<?, ?> root) {
+ public SimpleQueryExecutor(final NormalizedNode root) {
this.root = requireNonNull(root);
}
@SuppressWarnings("unchecked")
final BindingDataObjectCodecTreeNode<T> dataCodec = (BindingDataObjectCodecTreeNode<T>)
codec.getSubtreeCodec(InstanceIdentifier.create(data.implementedInterface()));
- rootBuilder.withChild((DataContainerChild<?, ?>) verifyNotNull(dataCodec).serialize(data));
+ rootBuilder.withChild((DataContainerChild) verifyNotNull(dataCodec).serialize(data));
return this;
}
import com.google.common.collect.ImmutableMap;
import java.lang.reflect.Method;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.bi.ba.rpcservice.rev140701.OpendaylightTestRpcServiceService;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
public class BindingDOMRpcImplementationAdapterTest {
public void basicTest() throws Exception {
final BindingDOMCodecServices registry = mock(BindingDOMCodecServices.class);
final Method testMethod = this.getClass().getDeclaredMethod("testMethod");
- final QName rpcType = QName.create(QNameModule.create(new URI("tst")), "test");
+ final QName rpcType = QName.create(QNameModule.create(XMLNamespace.of("tst")), "test");
final BindingDOMRpcImplementationAdapter adapter = new BindingDOMRpcImplementationAdapter(
new ConstantAdapterContext(registry), OpendaylightTestRpcServiceService.class,
ImmutableMap.of(rpcType, testMethod), mock(OpendaylightTestRpcServiceService.class));
import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.SetMultimap;
import java.lang.reflect.Method;
-import java.net.URI;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.util.AbstractSchemaContext;
+import org.opendaylight.yangtools.yang.model.spi.AbstractSchemaContext;
public class BindingNormalizedCodecTest extends AbstractSchemaAwareTest {
}
@Override
- protected SetMultimap<URI, Module> getNamespaceToModules() {
+ protected SetMultimap<XMLNamespace, Module> getNamespaceToModules() {
return ImmutableSetMultimap.of();
}
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
public class BindingStructuralTypeTest {
-
@Test
public void basicTest() throws Exception {
- final NormalizedNode<?, ?> normalizedNode = mock(NormalizedNode.class);
+ final NormalizedNode normalizedNode = mock(NormalizedNode.class);
final Optional<?> optional = Optional.of(normalizedNode);
final DataTreeCandidateNode dataTreeCandidateNode = mock(DataTreeCandidateNode.class);
doReturn(optional).when(dataTreeCandidateNode).getDataAfter();
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
@Test
public void fromNormalizedNodeTest() throws Exception {
final EffectiveModelContext schemaCtx = YangParserTestUtils.parseYangResource("/test.yang");
- final NormalizedNode<?, ?> data = prepareData(schemaCtx, Uint16.valueOf(42));
+ final NormalizedNode data = prepareData(schemaCtx, Uint16.valueOf(42));
final Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode = fromNormalizedNode(data, schemaCtx);
final DataObject value = fromNormalizedNode.getValue();
@Test
public void fromNormalizedNodeWithAnotherInputDataTest() throws Exception {
final EffectiveModelContext schemaCtx = YangParserTestUtils.parseYangResource("/test.yang");
- final NormalizedNode<?, ?> data = prepareData(schemaCtx, "42");
+ final NormalizedNode data = prepareData(schemaCtx, "42");
final Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode = fromNormalizedNode(data, schemaCtx);
final DataObject value = fromNormalizedNode.getValue();
assertThat(ex.getCause(), instanceOf(IllegalArgumentException.class));
}
- private static NormalizedNode<?, ?> prepareData(final EffectiveModelContext schemaCtx, final Object value) {
- final DataSchemaNode dataChildByName =
- schemaCtx.getDataChildByName(QName.create("urn:test", "2017-01-01", "cont"));
- final DataSchemaNode leaf = ((ContainerSchemaNode) dataChildByName)
- .getDataChildByName(QName.create("urn:test", "2017-01-01", "vlan-id"));
-
- final DataContainerChild<?, ?> child = Builders.leafBuilder((LeafSchemaNode) leaf).withValue(value).build();
- final NormalizedNode<?, ?> data =
- Builders.containerBuilder((ContainerSchemaNode) dataChildByName).withChild(child).build();
- return data;
+ private static ContainerNode prepareData(final EffectiveModelContext schemaCtx, final Object value) {
+ return Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(QName.create("urn:test", "2017-01-01", "cont")))
+ .withChild(Builders.leafBuilder()
+ .withNodeIdentifier(new NodeIdentifier(QName.create("urn:test", "2017-01-01", "vlan-id")))
+ .withValue(value).build())
+ .build();
}
- private static Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final NormalizedNode<?, ?> data,
+ private static Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final NormalizedNode data,
final EffectiveModelContext schemaCtx) {
final CurrentAdapterSerializer codec = new CurrentAdapterSerializer(new BindingCodecContext(
new DefaultBindingRuntimeContext(new DefaultBindingRuntimeGenerator().generateTypeMapping(schemaCtx),
}
@Override
- public ListenableFuture<? extends YangTextSchemaSource> getSource(SourceIdentifier sourceIdentifier) {
+ public ListenableFuture<? extends YangTextSchemaSource> getSource(final SourceIdentifier sourceIdentifier) {
throw new UnsupportedOperationException();
}
@Override
@SuppressWarnings("unchecked")
- public <T> Class<T> loadClass(String fullyQualifiedName) throws ClassNotFoundException {
+ public <T> Class<T> loadClass(final String fullyQualifiedName) throws ClassNotFoundException {
return (Class<T>) Class.forName(fullyQualifiedName);
}
}
import static org.junit.Assert.assertNotNull;
import com.google.common.collect.ImmutableSet;
-import java.net.URI;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
public class FutureSchemaTest {
-
@Test
- public void basicTest() throws Exception {
+ public void basicTest() {
final FutureSchema futureSchema = FutureSchema.create(0, TimeUnit.MICROSECONDS, true);
assertNotNull(futureSchema);
- assertFalse(futureSchema.waitForSchema(QNameModule.create(new URI("test"))));
+ assertFalse(futureSchema.waitForSchema(QNameModule.create(XMLNamespace.of("test"))));
assertFalse(futureSchema.waitForSchema(ImmutableSet.of()));
assertEquals(0, futureSchema.getDuration());
assertEquals(TimeUnit.MICROSECONDS, futureSchema.getUnit());
package org.opendaylight.mdsal.binding.dom.adapter;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.util.concurrent.MoreExecutors;
-import java.util.Optional;
import org.junit.Test;
import org.opendaylight.mdsal.binding.dom.adapter.test.util.BindingBrokerTestFactory;
import org.opendaylight.mdsal.binding.dom.adapter.test.util.BindingTestContext;
final BindingNormalizedNodeSerializer codec = mock(BindingNormalizedNodeSerializer.class);
final ContainerNode containerNode = mock(ContainerNode.class);
doReturn(containerNode).when(codec).toNormalizedNodeRpcData(any());
- doReturn(Optional.empty()).when(containerNode).getChild(any());
+ doReturn(null).when(containerNode).childByArg(any());
final BindingBrokerTestFactory bindingBrokerTestFactory = new BindingBrokerTestFactory();
bindingBrokerTestFactory.setExecutor(MoreExecutors.newDirectExecutorService());
(LazySerializedContainerNode) LazySerializedContainerNode.withContextRef(rpcName, dataObject, leafNode,
codec);
assertNotNull(lazySerializedContainerNode);
- assertEquals(leafNode, lazySerializedContainerNode.getChild(leafNode.getIdentifier()).get());
- assertFalse(lazySerializedContainerNode.getChild(mock(PathArgument.class)).isPresent());
+ assertEquals(leafNode, lazySerializedContainerNode.childByArg(leafNode.getIdentifier()));
+ assertNull(lazySerializedContainerNode.childByArg(mock(PathArgument.class)));
- assertTrue(lazySerializedContainerNode.getValue().isEmpty());
- assertEquals(lazySerializedContainerNode.getIdentifier().getNodeType(),
- lazySerializedContainerNode.getNodeType());
+ assertTrue(lazySerializedContainerNode.body().isEmpty());
assertEquals(rpcName, lazySerializedContainerNode.getIdentifier().getNodeType());
assertEquals(dataObject, lazySerializedContainerNode.getDataObject());
}
import static org.mockito.Mockito.mock;
import com.google.common.collect.ImmutableMap;
-import java.net.URI;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
public class LocalNameRpcServiceInvokerTest {
private static RpcServiceInvoker rpcServiceInvoker;
- private static final QNameModule Q_NAME_MODULE = QNameModule.create(URI.create("testURI"),
+ private static final QNameModule Q_NAME_MODULE = QNameModule.create(XMLNamespace.of("testURI"),
Revision.of("2017-10-26"));
private static final RpcService RPC_SERVICE = mock(RpcService.class);
import com.google.common.collect.ImmutableMap;
import java.lang.reflect.Method;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
public class RpcServiceInvokerTest {
final Method method = this.getClass().getDeclaredMethod("testMethod");
method.setAccessible(true);
assertNotNull(RpcServiceInvoker.from(ImmutableMap.of(
- QName.create(QNameModule.create(URI.create("testURI"), Revision.of("2017-10-26")),"test"), method,
- QName.create(QNameModule.create(URI.create("testURI2"), Revision.of("2017-10-26")),"test"), method)));
+ QName.create(QNameModule.create(XMLNamespace.of("testURI"), Revision.of("2017-10-26")),"test"), method,
+ QName.create(QNameModule.create(XMLNamespace.of("testURI2"), Revision.of("2017-10-26")),"test"), method)));
assertNotNull(RpcServiceInvoker.from(ImmutableMap.of(
- QName.create(QNameModule.create(URI.create("testURI"), Revision.of("2017-10-26")), "test"), method)));
+ QName.create(QNameModule.create(XMLNamespace.of("testURI"), Revision.of("2017-10-26")), "test"), method)));
}
@Test(expected = IllegalArgumentException.class)
* @param data Normalized Node representation of data
* @return Binding representation of data
*/
- @NonNull T deserialize(@NonNull NormalizedNode<?, ?> data);
+ @NonNull T deserialize(@NonNull NormalizedNode data);
/**
* Converts from Binding to Normalized Node representation of data.
* @param data Binding representation of data
* @return Normalized Node representation of data
*/
- @NonNull NormalizedNode<?, ?> serialize(@NonNull T data);
+ @NonNull NormalizedNode serialize(@NonNull T data);
}
* @return NormalizedNode representation
* @throws IllegalArgumentException If supplied Instance Identifier is not valid.
*/
- <T extends DataObject> @NonNull Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
+ <T extends DataObject> @NonNull Entry<YangInstanceIdentifier, NormalizedNode> toNormalizedNode(
InstanceIdentifier<T> path, T data);
/**
* @return DOM Instance Identifier
*/
@Nullable Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(@NonNull YangInstanceIdentifier path,
- NormalizedNode<?, ?> data);
+ NormalizedNode data);
/**
* Translates supplied NormalizedNode Notification into Binding data.
@Beta
@Component(immediate = true,
service = {
- BindingDOMCodecServices.class,
- BindingNormalizedNodeWriterFactory.class,
- BindingNormalizedNodeSerializer.class,
- BindingCodecTree.class
+ BindingDOMCodecServices.class,
+ BindingNormalizedNodeWriterFactory.class,
+ BindingNormalizedNodeSerializer.class,
+ BindingCodecTree.class
})
public final class GlobalBindingDOMCodecServices extends ForwardingBindingDOMCodecServices {
private static final Logger LOG = LoggerFactory.getLogger(GlobalBindingDOMCodecServices.class);
import com.google.common.annotations.Beta;
import com.google.common.collect.ForwardingObject;
import java.util.Collection;
-import java.util.Optional;
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingLazyContainerNode;
+import org.opendaylight.yangtools.concepts.PrettyTree;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
}
@Override
- public final QName getNodeType() {
- return identifier.getNodeType();
+ public final ContainerNode getDelegate() {
+ return delegate();
}
@Override
- public final ContainerNode getDelegate() {
- return delegate();
+ public Collection<DataContainerChild> body() {
+ return delegate().body();
}
@Override
- public Collection<DataContainerChild<? extends PathArgument, ?>> getValue() {
- return delegate().getValue();
+ public DataContainerChild childByArg(final PathArgument child) {
+ return delegate().childByArg(child);
}
@Override
- public Optional<DataContainerChild<? extends PathArgument, ?>> getChild(final PathArgument child) {
- return delegate().getChild(child);
+ public PrettyTree prettyTree() {
+ // Do not touch delegate() until we really need to
+ return new PrettyTree() {
+ @Override
+ public void appendTo(final StringBuilder sb, final int depth) {
+ delegate().prettyTree().appendTo(sb, depth);
+ }
+ };
}
@Override
}
@Override
- public <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?,?>> toNormalizedNode(
+ public <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode> toNormalizedNode(
final InstanceIdentifier<T> path, final T data) {
return delegate().toNormalizedNode(path, data);
}
@Override
public Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data) {
+ final NormalizedNode data) {
return delegate().fromNormalizedNode(path, data);
}
* @param <C> Root codec context type
*/
abstract class AbstractBindingNormalizedNodeCache<T extends BindingObject, C extends NodeCodecContext>
- extends CacheLoader<T, NormalizedNode<?, ?>> {
- private final LoadingCache<T, NormalizedNode<?, ?>> cache = CacheBuilder.newBuilder().weakValues().build(this);
+ extends CacheLoader<T, NormalizedNode> {
+ private final LoadingCache<T, NormalizedNode> cache = CacheBuilder.newBuilder().weakValues().build(this);
private final @NonNull C rootContext;
* @param obj Binding object to be deserialized
* @return NormalizedNode representation of binding object.
*/
- final NormalizedNode<?, ?> get(final @NonNull T obj) {
+ final NormalizedNode get(final @NonNull T obj) {
return cache.getUnchecked(obj);
}
}
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
/**
* A base class for {@link DataObject}s which are also {@link Augmentable}, backed by {@link DataObjectCodecContext}.
private volatile ImmutableMap<Class<? extends Augmentation<T>>, Augmentation<T>> cachedAugmentations;
protected AugmentableCodecDataObject(final DataObjectCodecContext<T, ?> context,
- final NormalizedNodeContainer<?, ?, ?> data) {
+ final DistinctNodeContainer<?, ?> data) {
super(context, data);
}
// the augmentation the user is requesting -- otherwise a strict receiver would end up with a cryptic
// ClassCastException.
if (augmentationType.isAssignableFrom(augCtx.getBindingClass())) {
- final Optional<NormalizedNode<?, ?>> augData = codecData().getChild(augCtx.getDomPathArgument());
- if (augData.isPresent()) {
- return (A) augCtx.deserialize(augData.get());
+ final NormalizedNode augData = codecData().childByArg(augCtx.getDomPathArgument());
+ if (augData != null) {
+ return (A) augCtx.deserialize(augData);
}
}
}
}
@Override
- public D deserialize(final NormalizedNode<?, ?> normalizedNode) {
+ public D deserialize(final NormalizedNode normalizedNode) {
Preconditions.checkArgument(normalizedNode instanceof AugmentationNode);
return createBindingProxy((AugmentationNode)normalizedNode);
}
@Override
- protected Object deserializeObject(final NormalizedNode<?, ?> normalizedNode) {
+ protected Object deserializeObject(final NormalizedNode normalizedNode) {
return deserialize(normalizedNode);
}
}
\ No newline at end of file
}
@Override
- public <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?,?>> toNormalizedNode(
+ public <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode> toNormalizedNode(
final InstanceIdentifier<T> path, final T data) {
final NormalizedNodeResult result = new NormalizedNodeResult();
// We create DOM stream writer which produces normalized nodes
@Override
public Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data) {
+ final NormalizedNode data) {
if (notBindingRepresentable(data)) {
return null;
}
}
- private static boolean notBindingRepresentable(final NormalizedNode<?, ?> data) {
+ private static boolean notBindingRepresentable(final NormalizedNode data) {
// ValueNode covers LeafNode and LeafSetEntryNode
return data instanceof ValueNode
|| data instanceof MapNode || data instanceof UnkeyedListNode
}
@Override
- public D deserialize(final NormalizedNode<?, ?> data) {
+ public D deserialize(final NormalizedNode data) {
return context.deserialize(data);
}
@Override
- public NormalizedNode<?, ?> serialize(final D data) {
+ public NormalizedNode serialize(final D data) {
// Serialize data using stream writer with child cache enable or using the cache if it is available
final AbstractBindingNormalizedNodeCache<D, ?> cache = getCachingSerializer(context);
return cache == null ? CachingNormalizedNodeSerializer.serializeUsingStreamWriter(this, context, data)
return delegate;
}
- NormalizedNode<?, ?> build() {
+ NormalizedNode build() {
return domResult.getResult();
}
* streaming of data when non-null result is returned.
*/
@Override
- public NormalizedNode<?, ?> serialize(final DataObject input) {
+ public NormalizedNode serialize(final DataObject input) {
final AbstractBindingNormalizedNodeCache<DataObject, ?> cachingSerializer = getCacheSerializer(
input.implementedInterface());
if (cachingSerializer != null) {
- final NormalizedNode<?, ?> domData = cachingSerializer.get(input);
+ final NormalizedNode domData = cachingSerializer.get(input);
domWriter.addChild(domData);
return domData;
}
* @param data Data to be serialized
* @return Normalized Node representation of data.
*/
- static NormalizedNode<?, ?> serializeUsingStreamWriter(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
+ static NormalizedNode serializeUsingStreamWriter(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
final DataContainerCodecContext<?, ?> subtreeRoot, final DataObject data) {
final CachingNormalizedNodeSerializer writer = new CachingNormalizedNodeSerializer(cacheHolder, subtreeRoot);
try {
}
@Override
- public D deserialize(final NormalizedNode<?, ?> data) {
+ public D deserialize(final NormalizedNode data) {
checkState(data instanceof ChoiceNode, "Unexpected data %s", data);
return createBindingProxy((ChoiceNode) data);
}
@Override
- protected Object deserializeObject(final NormalizedNode<?, ?> normalizedNode) {
+ protected Object deserializeObject(final NormalizedNode normalizedNode) {
return deserialize(normalizedNode);
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.SchemaUtils;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
+import org.opendaylight.yangtools.yang.data.util.NormalizedNodeSchemaUtils;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
// Updates collection of YANG instance identifier to case
for (final DataSchemaNode cazeChild : cazeDef.getSchema().getChildNodes()) {
if (cazeChild.isAugmenting()) {
- final AugmentationSchemaNode augment = SchemaUtils.findCorrespondingAugment(cazeDef.getSchema(),
- cazeChild);
+ final AugmentationSchemaNode augment =
+ NormalizedNodeSchemaUtils.findCorrespondingAugment(cazeDef.getSchema(), cazeChild);
if (augment != null) {
byYangCaseChildBuilder.put(DataSchemaContextNode.augmentationIdentifierFrom(augment),
cazeDef);
@SuppressWarnings("unchecked")
@Override
- public D deserialize(final NormalizedNode<?, ?> data) {
+ public D deserialize(final NormalizedNode data) {
checkArgument(data instanceof ChoiceNode);
final ChoiceNode casted = (ChoiceNode) data;
- final NormalizedNode<?, ?> first = Iterables.getFirst(casted.getValue(), null);
+ final NormalizedNode first = Iterables.getFirst(casted.body(), null);
if (first == null) {
// FIXME: this needs to be sorted out
}
@Override
- protected Object deserializeObject(final NormalizedNode<?, ?> normalizedNode) {
+ protected Object deserializeObject(final NormalizedNode normalizedNode) {
return deserialize(normalizedNode);
}
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
-import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
/**
* A base class for {@link DataObject}s backed by {@link DataObjectCodecContext}. While this class is public, it not
private final @NonNull DataObjectCodecContext<T, ?> context;
@SuppressWarnings("rawtypes")
- private final @NonNull NormalizedNodeContainer data;
+ private final @NonNull DistinctNodeContainer data;
// Accessed via a VarHandle
@SuppressWarnings("unused")
// FIXME: consider using a primitive int-based cache (with 0 being uninit)
private volatile Integer cachedHashcode;
- protected CodecDataObject(final DataObjectCodecContext<T, ?> context, final NormalizedNodeContainer<?, ?, ?> data) {
+ protected CodecDataObject(final DataObjectCodecContext<T, ?> context, final DistinctNodeContainer<?, ?> data) {
this.data = requireNonNull(data, "Data must not be null");
this.context = requireNonNull(context, "Context must not be null");
}
}
@SuppressWarnings("rawtypes")
- final @NonNull NormalizedNodeContainer codecData() {
+ final @NonNull DistinctNodeContainer codecData() {
return data;
}
// Helper split out of codecMember to aid its inlining
private Object loadMember(final VarHandle handle, final NodeCodecContext childCtx) {
@SuppressWarnings("unchecked")
- final Optional<NormalizedNode<?, ?>> child = data.getChild(childCtx.getDomPathArgument());
+ final NormalizedNode child = data.childByArg(childCtx.getDomPathArgument());
// We do not want to use Optional.map() here because we do not want to invoke defaultObject() when we have
// normal value because defaultObject() may end up throwing an exception intentionally.
- final Object obj = child.isPresent() ? childCtx.deserializeObject(child.get()) : childCtx.defaultObject();
+ final Object obj = child != null ? childCtx.deserializeObject(child) : childCtx.defaultObject();
final Object witness = handle.compareAndExchangeRelease(this, null, maskNull(obj));
return witness == null ? obj : unmaskNull(witness);
}
// Helper split out of hashCode() to aid its inlining
private int loadHashCode() {
final int result = codecHashCode();
- final Object witness = CACHED_HASH_CODE.compareAndExchangeRelease(this, null, Integer.valueOf(result));
+ final Object witness = CACHED_HASH_CODE.compareAndExchangeRelease(this, null, result);
return witness == null ? result : (Integer) witness;
}
* private static final VarHandle getBar$$$V;
* private volatile Object getBar;
*
- * public Foo$$$codecImpl(NormalizedNodeContainer data) {
+ * public Foo$$$codecImpl(DistinctNodeContainer data) {
* super(data);
* }
*
}
@Override
- public D deserialize(final NormalizedNode<?, ?> data) {
+ public D deserialize(final NormalizedNode data) {
checkState(data instanceof ContainerNode, "Unexpected data %s", data);
return createBindingProxy((ContainerNode) data);
}
@Override
- protected Object deserializeObject(final NormalizedNode<?, ?> normalizedNode) {
+ protected Object deserializeObject(final NormalizedNode normalizedNode) {
return deserialize(normalizedNode);
}
}
}
@Override
- public NormalizedNode<?, ?> serialize(final D data) {
+ public NormalizedNode serialize(final D data) {
final NormalizedNodeResult result = new NormalizedNodeResult();
// We create DOM stream writer which produces normalized nodes
final NormalizedNodeStreamWriter domWriter = ImmutableNormalizedNodeStreamWriter.from(result);
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return ChildAddressabilitySummary.UNADDRESSABLE;
}
- static DataContainerCodecPrototype<SchemaContext> rootPrototype(final CodecContextFactory factory) {
- final SchemaContext schema = factory.getRuntimeContext().getEffectiveModelContext();
+ static DataContainerCodecPrototype<EffectiveModelContext> rootPrototype(final CodecContextFactory factory) {
+ final EffectiveModelContext schema = factory.getRuntimeContext().getEffectiveModelContext();
final NodeIdentifier arg = NodeIdentifier.create(schema.getQName());
return new DataContainerCodecPrototype<>(DataRoot.class, arg, schema, factory);
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
-import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
extends DataContainerCodecContext<D, T> {
private static final Logger LOG = LoggerFactory.getLogger(DataObjectCodecContext.class);
private static final MethodType CONSTRUCTOR_TYPE = MethodType.methodType(void.class,
- DataObjectCodecContext.class, NormalizedNodeContainer.class);
+ DataObjectCodecContext.class, DistinctNodeContainer.class);
private static final MethodType DATAOBJECT_TYPE = MethodType.methodType(DataObject.class,
- DataObjectCodecContext.class, NormalizedNodeContainer.class);
+ DataObjectCodecContext.class, DistinctNodeContainer.class);
private static final VarHandle MISMATCHED_AUGMENTED;
static {
// Check if it is:
// - exactly same schema node, or
// - instantiated node was added via uses statement and is instantiation of same grouping
- if (origDef.equals(sameName) || origDef.equals(SchemaNodeUtils.getRootOriginalIfPossible(sameName))) {
+ if (origDef.equals(sameName) || origDef.equals(getRootOriginalIfPossible(sameName))) {
childSchema = sameName;
} else {
// Node has same name, but clearly is different
final QName instantiedName = origDef.getQName().bindTo(namespace());
final DataSchemaNode potential = getSchema().dataChildByName(instantiedName);
// We check if it is really instantiated from same definition as class was derived
- if (potential != null && origDef.equals(SchemaNodeUtils.getRootOriginalIfPossible(potential))) {
+ if (potential != null && origDef.equals(getRootOriginalIfPossible(potential))) {
childSchema = potential;
} else {
childSchema = null;
return DataContainerCodecPrototype.from(createBindingArg(childClass, nonNullChild), nonNullChild, factory());
}
+ private static SchemaNode getRootOriginalIfPossible(final SchemaNode data) {
+ Optional<SchemaNode> previous = Optional.empty();
+ Optional<SchemaNode> next = getOriginalIfPossible(data);
+ while (next.isPresent()) {
+ previous = next;
+ next = getOriginalIfPossible(next.get());
+ }
+ return previous.orElse(null);
+ }
+
+ private static Optional<SchemaNode> getOriginalIfPossible(final SchemaNode node) {
+ if (node instanceof DerivableSchemaNode) {
+ @SuppressWarnings("unchecked")
+ final Optional<SchemaNode> ret = (Optional<SchemaNode>) ((DerivableSchemaNode) node).getOriginal();
+ return ret;
+ }
+ return Optional.empty();
+ }
+
@SuppressWarnings("unchecked")
Item<?> createBindingArg(final Class<?> childClass, final DataSchemaNode childSchema) {
return Item.of((Class<? extends DataObject>) childClass);
}
@SuppressWarnings("checkstyle:illegalCatch")
- protected final @NonNull D createBindingProxy(final NormalizedNodeContainer<?, ?, ?> node) {
+ protected final @NonNull D createBindingProxy(final DistinctNodeContainer<?, ?> node) {
try {
return (D) proxyConstructor.invokeExact(this, node);
} catch (final Throwable e) {
@SuppressWarnings("unchecked")
Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAllAugmentationsFrom(
- final NormalizedNodeContainer<?, PathArgument, NormalizedNode<?, ?>> data) {
+ final DistinctNodeContainer<PathArgument, NormalizedNode> data) {
@SuppressWarnings("rawtypes")
final Map map = new HashMap<>();
- for (final NormalizedNode<?, ?> childValue : data.getValue()) {
+ for (final NormalizedNode childValue : data.body()) {
if (childValue instanceof AugmentationNode) {
final AugmentationNode augDomNode = (AugmentationNode) childValue;
final DataContainerCodecPrototype<?> codecProto = augmentationByYang.get(augDomNode.getIdentifier());
}
}
for (final DataContainerCodecPrototype<?> value : augmentationByStream.values()) {
- final Optional<NormalizedNode<?, ?>> augData = data.getChild(value.getYangArg());
- if (augData.isPresent()) {
- map.put(value.getBindingClass(), value.get().deserializeObject(augData.get()));
+ final NormalizedNode augData = data.childByArg(value.getYangArg());
+ if (augData != null) {
+ map.put(value.getBindingClass(), value.get().deserializeObject(augData));
}
}
return map;
}
@Override
- public NormalizedNode<?, ?> load(final DataObject key) {
+ public NormalizedNode load(final DataObject key) {
return CachingNormalizedNodeSerializer.serializeUsingStreamWriter(cacheHolder, rootContext(), key);
}
}
* @param <T> Object model type
*/
final class ForeignOpaqueData<T> extends AbstractOpaqueData<T> {
- private final ForeignDataNode<?, T> domData;
+ private final ForeignDataNode<T> domData;
- ForeignOpaqueData(final ForeignDataNode<?, T> domData) {
+ ForeignOpaqueData(final ForeignDataNode<T> domData) {
this.domData = requireNonNull(domData);
}
@Override
public Class<T> getObjectModel() {
- return domData.getValueObjectModel();
+ return domData.bodyObjectModel();
}
@Override
public T getData() {
- return domData.getValue();
+ return domData.body();
}
- ForeignDataNode<?, T> domData() {
+ ForeignDataNode<T> domData() {
return domData;
}
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final Object[] objects;
private LazyBindingList(final ListNodeCodecContext<E> codec,
- final Collection<? extends NormalizedNodeContainer<?, ?, ?>> entries) {
+ final Collection<? extends NormalizedNodeContainer<?>> entries) {
this.codec = requireNonNull(codec);
objects = entries.toArray();
}
static <E extends DataObject> @NonNull List<E> create(final ListNodeCodecContext<E> codec, final int size,
- final Collection<? extends NormalizedNodeContainer<?, ?, ?>> entries) {
+ final Collection<? extends DistinctNodeContainer<?, ?>> entries) {
if (size == 1) {
// Do not bother with lazy instantiation in case of a singleton
return List.of(codec.createBindingProxy(entries.iterator().next()));
}
private static <E extends DataObject> @NonNull List<E> eagerList(final ListNodeCodecContext<E> codec,
- final int size, final Collection<? extends NormalizedNodeContainer<?, ?, ?>> entries) {
+ final int size, final Collection<? extends DistinctNodeContainer<?, ?>> entries) {
@SuppressWarnings("unchecked")
final E[] objs = (E[]) new DataObject[size];
int offset = 0;
- for (NormalizedNodeContainer<?, ?, ?> node : entries) {
+ for (DistinctNodeContainer<?, ?> node : entries) {
objs[offset++] = codec.createBindingProxy(node);
}
verify(offset == objs.length);
//
// We could do a Class.isInstance() check here, but since the implementation is not marked as final (yet) we
// would be at the mercy of CHA being able to prove this invariant.
- return obj.getClass() == codec.generatedClass() ? (E) obj : load(index, (NormalizedNodeContainer<?, ?, ?>) obj);
+ return obj.getClass() == codec.generatedClass() ? (E) obj : load(index, (DistinctNodeContainer<?, ?>) obj);
}
- private @NonNull E load(final int index, final NormalizedNodeContainer<?, ?, ?> node) {
+ private @NonNull E load(final int index, final DistinctNodeContainer<?, ?> node) {
final E ret = codec.createBindingProxy(node);
final Object witness;
return (witness = OBJ_AA.compareAndExchangeRelease(objects, index, node, ret)) == node ? ret : (E) witness;
final Unordered<K, V> codec, final MapNode mapNode, final int size) {
if (size == 1) {
// Do not bother with lazy instantiation in case of a singleton
- final V entry = codec.createBindingProxy(mapNode.getValue().iterator().next());
+ final V entry = codec.createBindingProxy(mapNode.body().iterator().next());
return Map.of(entry.key(), entry);
}
return size > LAZY_CUTOFF ? new LazyBindingMap<>(codec, mapNode) : eagerMap(codec, mapNode, size);
private static <K extends Identifier<V>, V extends DataObject & Identifiable<K>> @NonNull Map<K, V> eagerMap(
final Unordered<K, V> codec, final MapNode mapNode, final int size) {
final Builder<K, V> builder = ImmutableMap.builderWithExpectedSize(size);
- for (MapEntryNode node : mapNode.getValue()) {
+ for (MapEntryNode node : mapNode.body()) {
final V entry = codec.createBindingProxy(node);
builder.put(entry.key(), entry);
}
Optional<V> lookupValue(final @NonNull Object key) {
final NodeIdentifierWithPredicates childId = codec.serialize((Identifier<?>) key);
- return mapNode.getChild(childId).map(codec::createBindingProxy);
+ return mapNode.findChildByArg(childId).map(codec::createBindingProxy);
}
@NonNull MapNode mapNode() {
Values(final LazyBindingMap<K, V> map) {
this.map = requireNonNull(map);
- objects = map.mapNode().getValue().toArray();
+ objects = map.mapNode().body().toArray();
}
@Override
Values(final LazyBindingMapLookupState<K, V> state) {
this.state = requireNonNull(state);
- objects = map().mapNode().getValue().toArray();
+ objects = map().mapNode().body().toArray();
}
@Override
final Object[] local = objects;
// When we have null objects it means we have everyone in state.objects
return local == null ? Iterators.unmodifiableIterator(state.objects.keySet().iterator())
- : Iterators.transform(new ValuesIter<>(this, local), value -> value.key());
+ : Iterators.transform(new ValuesIter<>(this, local), value -> value.key());
}
LazyBindingMap<K, V> map() {
}
@Override
- public T deserialize(final NormalizedNode<?, ?> data) {
+ public T deserialize(final NormalizedNode data) {
return bindingClass.cast(deserializeObject(data));
}
@Override
- public NormalizedNode<?, ?> serialize(final T data) {
+ public NormalizedNode serialize(final T data) {
return ImmutableNodes.leafNode(getDomPathArgument(), getValueCodec().serialize(data));
}
}
}
@Override
- protected Object deserializeObject(final NormalizedNode<?, ?> normalizedNode) {
- return normalizedNode != null ? getValueCodec().deserialize(normalizedNode.getValue()) : null;
+ protected Object deserializeObject(final NormalizedNode normalizedNode) {
+ return normalizedNode != null ? getValueCodec().deserialize(normalizedNode.body()) : null;
}
private static Object createDefaultObject(final LeafSchemaNode schema,
}
@Override
- protected Object deserializeObject(final NormalizedNode<?, ?> normalizedNode) {
+ protected Object deserializeObject(final NormalizedNode normalizedNode) {
if (normalizedNode instanceof LeafSetNode<?>) {
@SuppressWarnings("unchecked")
- final Collection<LeafSetEntryNode<Object>> domValues = ((LeafSetNode<Object>) normalizedNode).getValue();
+ final Collection<LeafSetEntryNode<Object>> domValues = ((LeafSetNode<Object>) normalizedNode).body();
final IllegalArgumentCodec<Object, Object> codec = getValueCodec();
final Builder<Object> builder = ImmutableList.builderWithExpectedSize(domValues.size());
for (final LeafSetEntryNode<Object> valueNode : domValues) {
- builder.add(codec.deserialize(valueNode.getValue()));
+ builder.add(codec.deserialize(valueNode.body()));
}
return builder.build();
}
}
@Override
- public D deserialize(final NormalizedNode<?, ?> node) {
+ public D deserialize(final NormalizedNode node) {
if (node instanceof MapEntryNode) {
return createBindingProxy((MapEntryNode) node);
} else if (node instanceof UnkeyedListEntryNode) {
}
@Override
- protected Object deserializeObject(final NormalizedNode<?, ?> node) {
+ protected Object deserializeObject(final NormalizedNode node) {
if (node instanceof MapNode) {
return fromMap((MapNode) node);
} else if (node instanceof MapEntryNode) {
}
@NonNull Object fromMap(final MapNode map, final int size) {
- return LazyBindingList.create(this, size, map.getValue());
+ return LazyBindingList.create(this, size, map.body());
}
private Object fromMap(final MapNode map) {
private List<D> fromUnkeyedList(final UnkeyedListNode node) {
final int size;
// This should never happen, but we do need to ensure users never see an empty List
- return (size = node.getSize()) == 0 ? null : LazyBindingList.create(this, size, node.getValue());
+ return (size = node.size()) == 0 ? null : LazyBindingList.create(this, size, node.body());
}
}
return null;
}
- protected abstract Object deserializeObject(NormalizedNode<?, ?> normalizedNode);
+ protected abstract Object deserializeObject(NormalizedNode normalizedNode);
}
}
@Override
- public D deserialize(final NormalizedNode<?, ?> data) {
+ public D deserialize(final NormalizedNode data) {
return delegate.deserialize(data);
}
@Override
- public NormalizedNode<?, ?> serialize(final D data) {
+ public NormalizedNode serialize(final D data) {
return delegate.serialize(data);
}
super(result);
}
- void addChild(final NormalizedNode<?, ?> child) {
+ void addChild(final NormalizedNode child) {
this.writeChild(child);
}
}
import org.opendaylight.yangtools.yang.binding.EventInstantAware;
import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
final class NotificationCodecContext<D extends DataObject & Notification>
}
private static final Generic BB_DOCC = TypeDefinition.Sort.describe(DataObjectCodecContext.class);
- private static final Generic BB_NNC = TypeDefinition.Sort.describe(NormalizedNodeContainer.class);
+ private static final Generic BB_DNC = TypeDefinition.Sort.describe(DistinctNodeContainer.class);
private static final Generic BB_I = TypeDefinition.Sort.describe(Instant.class);
private static final MethodType CONSTRUCTOR_TYPE = MethodType.methodType(void.class, DataObjectCodecContext.class,
- NormalizedNodeContainer.class, Instant.class);
+ DistinctNodeContainer.class, Instant.class);
private static final MethodType NOTIFICATION_TYPE = MethodType.methodType(Notification.class,
NotificationCodecContext.class, ContainerNode.class, Instant.class);
private static final String INSTANT_FIELD = "instant";
.name(fqcn)
.defineField(INSTANT_FIELD, BB_I, Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC)
.defineConstructor(Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC)
- .withParameters(BB_DOCC, BB_NNC, BB_I)
+ .withParameters(BB_DOCC, BB_DNC, BB_I)
.intercept(ConstructorImplementation.INSTANCE)
.defineMethod(EVENT_INSTANT_NAME, EVENT_INSTANT_RETTYPE, Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC)
.intercept(EventInstantImplementation.INSTANCE)
}
@Override
- public D deserialize(final NormalizedNode<?, ?> data) {
+ public D deserialize(final NormalizedNode data) {
checkState(data instanceof ContainerNode, "Unexpected data %s", data);
return createBindingProxy((ContainerNode) data);
}
}
@Override
- protected Object deserializeObject(final NormalizedNode<?, ?> normalizedNode) {
+ protected Object deserializeObject(final NormalizedNode normalizedNode) {
return deserialize(normalizedNode);
}
try {
LOAD_CTOR_ARGS = MethodVariableAccess.allArgumentsOf(new MethodDescription.ForLoadedConstructor(
AugmentableCodecDataObject.class.getDeclaredConstructor(DataObjectCodecContext.class,
- NormalizedNodeContainer.class)));
+ DistinctNodeContainer.class)));
} catch (NoSuchMethodException e) {
throw new ExceptionInInitializerError(e);
}
}
@Override
- ForeignDataNode<?, ?> serializedData(final OpaqueData<?> opaqueData) {
+ ForeignDataNode<?> serializedData(final OpaqueData<?> opaqueData) {
final Class<?> model = opaqueData.getObjectModel();
verify(DOMSource.class.isAssignableFrom(model), "Cannot just yet support object model %s", model);
return Builders.anyXmlBuilder().withNodeIdentifier(getDomPathArgument())
}
@Override
- T deserialize(final ForeignDataNode<?, ?> foreignData) {
+ T deserialize(final ForeignDataNode<?> foreignData) {
// Streaming cannot support anything but DOMSource-based AnyxmlNodes.
verify(foreignData instanceof DOMSourceAnyxmlNode, "Variable node %s not supported yet", foreignData);
return super.deserialize(foreignData);
@Override
protected Object deserializeImpl(final Object input) {
checkArgument(input instanceof NormalizedNode, "Unexpected input %s", input);
- return OpaqueNodeCodecContext.this.deserializeObject((NormalizedNode<?, ?>) input);
+ return OpaqueNodeCodecContext.this.deserializeObject((NormalizedNode) input);
}
};
}
@Override
- public final T deserialize(final NormalizedNode<?, ?> data) {
+ public final T deserialize(final NormalizedNode data) {
checkArgument(data instanceof ForeignDataNode, "Unexpected value %s", data);
- return deserialize((ForeignDataNode<?, ?>) data);
+ return deserialize((ForeignDataNode<?>) data);
}
- T deserialize(final ForeignDataNode<?, ?> foreignData) {
+ T deserialize(final ForeignDataNode<?> foreignData) {
return bindingClass.cast(createBindingProxy(new ForeignOpaqueData<>(foreignData)));
}
@Override
- public final ForeignDataNode<?, ?> serialize(final T data) {
+ public final ForeignDataNode<?> serialize(final T data) {
final OpaqueData<?> opaqueData = data.getValue();
return opaqueData instanceof ForeignOpaqueData ? ((ForeignOpaqueData<?>) opaqueData).domData()
: serializedData(opaqueData);
}
@Override
- protected final @NonNull Object deserializeObject(final NormalizedNode<?, ?> normalizedNode) {
+ protected final @NonNull Object deserializeObject(final NormalizedNode normalizedNode) {
return deserialize(normalizedNode);
}
return valueCodec;
}
- abstract @NonNull ForeignDataNode<?, ?> serializedData(OpaqueData<?> opaqueData);
+ abstract @NonNull ForeignDataNode<?> serializedData(OpaqueData<?> opaqueData);
@SuppressWarnings("checkstyle:illegalCatch")
private OpaqueObject<?> createBindingProxy(final OpaqueData<?> data) {
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
import com.google.common.base.Throwables;
import com.google.common.base.Verify;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.UncheckedExecutionException;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
+import java.util.Iterator;
import java.util.List;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.util.ClassLoaderUtils;
import org.opendaylight.yangtools.yang.model.api.ContainerLike;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
-import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
-import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
-final class SchemaRootCodecContext<D extends DataObject> extends DataContainerCodecContext<D,SchemaContext> {
+final class SchemaRootCodecContext<D extends DataObject> extends DataContainerCodecContext<D, EffectiveModelContext> {
private final LoadingCache<Class<? extends DataObject>, DataContainerCodecContext<?, ?>> childrenByClass =
CacheBuilder.newBuilder().build(new CacheLoader<>() {
CacheBuilder.newBuilder().build(new CacheLoader<>() {
@Override
public RpcInputCodec<?> load(final Absolute key) {
- final ContainerLike schema = SchemaContextUtil.getRpcDataSchema(getSchema(), key.asSchemaPath());
+ final ContainerLike schema = getRpcDataSchema(getSchema(), key);
@SuppressWarnings("unchecked")
final Class<? extends DataContainer> cls = (Class<? extends DataContainer>)
factory().getRuntimeContext().getClassForSchema(schema);
CacheBuilder.newBuilder().build(new CacheLoader<>() {
@Override
public NotificationCodecContext<?> load(final Absolute key) {
- final NotificationDefinition schema = SchemaContextUtil.getNotificationSchema(getSchema(),
- // FIXME: do not convert here!
- key.asSchemaPath());
+ final SchemaTreeEffectiveStatement<?> stmt = getSchema().findSchemaTreeNode(key)
+ .orElseThrow(() -> new IllegalArgumentException("Cannot find statement at " + key));
+ checkArgument(stmt instanceof NotificationDefinition, "Statement %s is not a notification", stmt);
+
@SuppressWarnings("unchecked")
final Class<? extends Notification> clz = (Class<? extends Notification>)
- factory().getRuntimeContext().getClassForSchema(schema);
+ factory().getRuntimeContext().getClassForSchema((NotificationDefinition) stmt);
return getNotification(clz);
}
});
- private SchemaRootCodecContext(final DataContainerCodecPrototype<SchemaContext> dataPrototype) {
+ private SchemaRootCodecContext(final DataContainerCodecPrototype<EffectiveModelContext> dataPrototype) {
super(dataPrototype);
}
* @return A new root node
*/
static SchemaRootCodecContext<?> create(final CodecContextFactory factory) {
- final DataContainerCodecPrototype<SchemaContext> prototype = DataContainerCodecPrototype.rootPrototype(factory);
- return new SchemaRootCodecContext<>(prototype);
+ return new SchemaRootCodecContext<>(DataContainerCodecPrototype.rootPrototype(factory));
}
-
@SuppressWarnings("unchecked")
@Override
public <C extends DataObject> DataContainerCodecContext<C, ?> streamChild(final Class<C> childClass) {
}
@Override
- public D deserialize(final NormalizedNode<?, ?> normalizedNode) {
+ public D deserialize(final NormalizedNode normalizedNode) {
throw new UnsupportedOperationException("Could not create Binding data representation for root");
}
* FIXME: Rework this to have more precise logic regarding Binding Specification.
*/
if (key.getSimpleName().equals(BindingMapping.getClassName(potentialQName) + className)) {
- final ContainerLike schema = SchemaNodeUtils.getRpcDataSchema(potential, qname);
+ final ContainerLike schema = getRpcDataSchema(potential, qname);
checkArgument(schema != null, "Schema for %s does not define input / output.", potential.getQName());
return (ContainerNodeCodecContext<?>) DataContainerCodecPrototype.from(key, schema, factory()).get();
}
throw new IllegalArgumentException("Supplied class " + key + " is not valid RPC class.");
}
+ /**
+ * Returns RPC input or output schema based on supplied QName.
+ *
+ * @param rpc RPC Definition
+ * @param qname input or output QName with namespace same as RPC
+ * @return input or output schema. Returns null if RPC does not have input/output specified.
+ */
+ private static @Nullable ContainerLike getRpcDataSchema(final @NonNull RpcDefinition rpc,
+ final @NonNull QName qname) {
+ requireNonNull(rpc, "Rpc Schema must not be null");
+ switch (requireNonNull(qname, "QName must not be null").getLocalName()) {
+ case "input":
+ return rpc.getInput();
+ case "output":
+ return rpc.getOutput();
+ default:
+ throw new IllegalArgumentException("Supplied qname " + qname
+ + " does not represent rpc input or output.");
+ }
+ }
+
+ /**
+ * Returns RPC Input or Output Data container from RPC definition.
+ *
+ * @param schema SchemaContext in which lookup should be performed.
+ * @param path Schema path of RPC input/output data container
+ * @return Notification schema or null, if notification is not present in schema context.
+ */
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
+ private static @Nullable ContainerLike getRpcDataSchema(final @NonNull EffectiveModelContext schema,
+ final @NonNull Absolute path) {
+ requireNonNull(schema, "Schema context must not be null.");
+ requireNonNull(path, "Schema path must not be null.");
+ final Iterator<QName> it = path.getNodeIdentifiers().iterator();
+ checkArgument(it.hasNext(), "Rpc must have QName.");
+ final QName rpcName = it.next();
+ checkArgument(it.hasNext(), "input or output must be part of path.");
+ final QName inOrOut = it.next();
+ for (final RpcDefinition potential : schema.getOperations()) {
+ if (rpcName.equals(potential.getQName())) {
+ return getRpcDataSchema(potential, inOrOut);
+ }
+ }
+ return null;
+ }
+
NotificationCodecContext<?> createNotificationDataContext(final Class<?> notificationType) {
checkArgument(Notification.class.isAssignableFrom(notificationType));
checkArgument(notificationType.isInterface(), "Supplied class must be interface.");
}
@Override
- protected Object deserializeObject(final NormalizedNode<?, ?> normalizedNode) {
+ protected Object deserializeObject(final NormalizedNode normalizedNode) {
throw new UnsupportedOperationException("Unable to deserialize root");
}
}
@Override
- public NormalizedNode<?, ?> load(final TypeObject key) {
+ public NormalizedNode load(final TypeObject key) {
return rootContext().serialize(key);
}
}
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
+import static com.google.common.base.Verify.verify;
+
import com.google.common.collect.ImmutableSet;
import java.lang.reflect.Method;
-import java.util.LinkedHashSet;
-import java.util.Set;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
import java.util.concurrent.Callable;
-import org.opendaylight.mdsal.binding.generator.util.BaseYangTypesProvider;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.runtime.api.RuntimeGeneratedUnion;
import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.concepts.IllegalArgumentCodec;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.PathExpression;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
final class UnionTypeCodec extends ReflectionBasedCodec {
private final ImmutableSet<UnionValueOptionContext> typeCodecs;
- private UnionTypeCodec(final Class<?> unionCls,final Set<UnionValueOptionContext> codecs) {
+ private UnionTypeCodec(final Class<?> unionCls,final List<UnionValueOptionContext> codecs) {
super(unionCls);
typeCodecs = ImmutableSet.copyOf(codecs);
}
static Callable<UnionTypeCodec> loader(final Class<?> unionCls, final UnionTypeDefinition unionType,
- final BindingCodecContext bindingCodecContext) {
+ final BindingCodecContext bindingCodecContext) {
return () -> {
- final Set<UnionValueOptionContext> values = new LinkedHashSet<>();
+ final GeneratedType contextType = bindingCodecContext.getRuntimeContext().getTypeWithSchema(unionCls)
+ .getKey();
+ verify(contextType instanceof RuntimeGeneratedUnion, "Unexpected runtime type %s", contextType);
+ final RuntimeGeneratedUnion contextUnion = (RuntimeGeneratedUnion) contextType;
+
+ final List<TypeDefinition<?>> unionTypes = unionType.getTypes();
+ final List<String> unionProperties = contextUnion.typePropertyNames();
+ verify(unionTypes.size() == unionProperties.size(), "Mismatched union types %s and properties %s",
+ unionTypes, unionProperties);
+
+ final List<UnionValueOptionContext> values = new ArrayList<>(unionTypes.size());
+ final Iterator<String> it = unionProperties.iterator();
for (final TypeDefinition<?> subtype : unionType.getTypes()) {
- if (subtype instanceof LeafrefTypeDefinition) {
- addLeafrefValueCodec(unionCls, unionType, bindingCodecContext, values, subtype);
- } else {
- final Method valueGetter = unionCls.getMethod(BindingMapping.GETTER_PREFIX
- + BindingMapping.getClassName(subtype.getQName()));
- final Class<?> valueType = valueGetter.getReturnType();
- final IllegalArgumentCodec<Object, Object> valueCodec =
- bindingCodecContext.getCodec(valueType, subtype);
+ final String getterName = BindingMapping.GETTER_PREFIX + BindingMapping.toFirstUpper(it.next());
+ final Method valueGetter = unionCls.getMethod(getterName);
+ final Class<?> valueType = valueGetter.getReturnType();
+ final IllegalArgumentCodec<Object, Object> codec = bindingCodecContext.getCodec(valueType, subtype);
- values.add(new UnionValueOptionContext(unionCls, valueType, valueGetter, valueCodec));
- }
+ values.add(new UnionValueOptionContext(unionCls, valueType, valueGetter, codec));
}
return new UnionTypeCodec(unionCls, values);
};
}
- /**
- * Prepare codec for type from leaf's return type of leafref.
- *
- * @param unionCls
- * - union class
- * @param unionType
- * - union type
- * @param bindingCodecContext
- * - binding codec context
- * @param values
- * - union values
- * @param subtype
- * - subtype of union
- * @throws NoSuchMethodException when the getter method is not found
- */
- private static void addLeafrefValueCodec(final Class<?> unionCls, final UnionTypeDefinition unionType,
- final BindingCodecContext bindingCodecContext, final Set<UnionValueOptionContext> values,
- final TypeDefinition<?> subtype) throws NoSuchMethodException {
- final EffectiveModelContext schemaContext = bindingCodecContext.getRuntimeContext().getEffectiveModelContext();
- final Module module = schemaContext.findModule(subtype.getQName().getModule()).get();
- final PathExpression xpath = ((LeafrefTypeDefinition) subtype).getPathStatement();
- // find schema node in schema context by xpath of leafref
- final SchemaNode dataNode;
- if (xpath.isAbsolute()) {
- dataNode = SchemaContextUtil.findDataSchemaNode(schemaContext, module, xpath);
- } else {
- dataNode = SchemaContextUtil.findDataSchemaNodeForRelativeXPath(schemaContext, module, unionType, xpath);
- }
- final String className = BindingMapping.getClassName(unionCls.getSimpleName());
- final LeafSchemaNode typeNode = (LeafSchemaNode) dataNode;
-
- // prepare name of type form return type of referenced leaf
- final String typeName = BindingMapping.getClassName(BaseYangTypesProvider.INSTANCE
- .javaTypeForSchemaDefinitionType(typeNode.getType(), typeNode).getName());
-
- // get method via reflection from generated code according to
- // get_TypeName_Value method
- final Method valueGetterParent = unionCls.getMethod(
- BindingMapping.GETTER_PREFIX + BindingMapping.getUnionLeafrefMemberName(className, typeName));
- final Class<?> returnType = valueGetterParent.getReturnType();
-
- // prepare codec of union subtype according to return type of referenced
- // leaf
- final IllegalArgumentCodec<Object, Object> valueCodec = bindingCodecContext.getCodec(returnType, subtype);
- values.add(new UnionValueOptionContext(unionCls, returnType, valueGetterParent, valueCodec));
- }
-
@Override
public Object deserialize(final Object input) {
for (final UnionValueOptionContext member : typeCodecs) {
@SuppressWarnings("unchecked")
protected <T extends DataObject> T thereAndBackAgain(final InstanceIdentifier<T> path, final T data) {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> there = codecContext.toNormalizedNode(path, data);
+ final Entry<YangInstanceIdentifier, NormalizedNode> there = codecContext.toNormalizedNode(path, data);
final Entry<InstanceIdentifier<?>, DataObject> backAgain = codecContext.fromNormalizedNode(there.getKey(),
there.getValue());
assertEquals(path, backAgain.getKey());
@Test
public void testAnydataFromBinding() {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode> entry = codecContext.toNormalizedNode(
InstanceIdentifier.create(Cont.class), new ContBuilder().setContAny(new FakeCont()).build());
assertEquals(YangInstanceIdentifier.create(CONT_NODE_ID), entry.getKey());
assertEquals(cont, entry.getValue());
@Test
public void testAnyxmlFromBinding() {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode> entry = codecContext.toNormalizedNode(
InstanceIdentifier.create(Cont.class), new ContBuilder().setContAny(new FakeCont()).build());
assertEquals(YangInstanceIdentifier.create(CONT_NODE_ID), entry.getKey());
assertEquals(cont, entry.getValue());
.withKey(TOP_FOO_KEY)
.addAugmentation(new TreeComplexUsesAugmentBuilder(createComplexData()).build())
.build();
- final NormalizedNode<?, ?> domTreeEntry = codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST, baTree).getValue();
- final NormalizedNode<?, ?> domRpcEntry = codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST, baRpc).getValue();
+ final NormalizedNode domTreeEntry = codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST, baTree).getValue();
+ final NormalizedNode domRpcEntry = codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST, baRpc).getValue();
assertEquals(domTreeEntry, domRpcEntry);
}
.addAugmentation(new TreeComplexUsesAugmentBuilder(createComplexData()).build())
.build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode> entry = codecContext.toNormalizedNode(
BA_TOP_LEVEL_LIST, manuallyConstructed);
final TopLevelList deserialized = (TopLevelList) codecContext.fromNormalizedNode(entry.getKey(),
entry.getValue()).getValue();
}
private BinaryList process(final BinaryList binaryList) {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode> entry = codecContext.toNormalizedNode(
instanceIdentifier, binaryList);
return (BinaryList) codecContext.fromNormalizedNode(entry.getKey(), entry.getValue()).getValue();
}
final BindingDataObjectCodecTreeNode<Module4Main> subtreeCodec = codecContext.getSubtreeCodec(
InstanceIdentifier.create(Module4Main.class));
- final NormalizedNode<?, ?> serialized = subtreeCodec.serialize(module4Main);
- final NormalizedNode<?, ?> manualSerialized = subtreeCodec.serialize(manualModule4Main);
- final NormalizedNode<?, ?> containerManualSerialized = subtreeCodec.serialize(contManualModule4Main);
+ final NormalizedNode serialized = subtreeCodec.serialize(module4Main);
+ final NormalizedNode manualSerialized = subtreeCodec.serialize(manualModule4Main);
+ final NormalizedNode containerManualSerialized = subtreeCodec.serialize(contManualModule4Main);
assertNotNull(serialized);
assertNotNull(manualSerialized);
assertNotNull(containerManualSerialized);
final BindingDataObjectCodecTreeNode<BooleanContainer> subtreeCodec = codecContext.getSubtreeCodec(
InstanceIdentifier.create(BooleanContainer.class));
- final NormalizedNode<?, ?> serializedInt = subtreeCodec.serialize(booleanContainerInt);
+ final NormalizedNode serializedInt = subtreeCodec.serialize(booleanContainerInt);
assertNotNull(serializedInt);
- final NormalizedNode<?, ?> serialized = subtreeCodec.serialize(booleanContainer);
+ final NormalizedNode serialized = subtreeCodec.serialize(booleanContainer);
assertNotNull(serialized);
}
}
@Test
public void testListCache() {
final BindingNormalizedNodeCachingCodec<Top> cachingCodec = createCachingCodec(TopLevelList.class);
- final NormalizedNode<?, ?> first = cachingCodec.serialize(TOP_TWO_LIST_DATA);
- final NormalizedNode<?, ?> second = cachingCodec.serialize(TOP_TWO_LIST_DATA);
+ final NormalizedNode first = cachingCodec.serialize(TOP_TWO_LIST_DATA);
+ final NormalizedNode second = cachingCodec.serialize(TOP_TWO_LIST_DATA);
assertNotSame(first, second);
assertEquals(first, second);
verifyListItemSame(first, second);
- final NormalizedNode<?, ?> third = cachingCodec.serialize(TOP_THREE_LIST_DATA);
+ final NormalizedNode third = cachingCodec.serialize(TOP_THREE_LIST_DATA);
verifyListItemSame(first, third);
verifyListItemSame(second, third);
}
@Test
public void testTopAndListCache() {
final BindingNormalizedNodeCachingCodec<Top> cachingCodec = createCachingCodec(Top.class, TopLevelList.class);
- final NormalizedNode<?, ?> first = cachingCodec.serialize(TOP_TWO_LIST_DATA);
- final NormalizedNode<?, ?> second = cachingCodec.serialize(TOP_TWO_LIST_DATA);
+ final NormalizedNode first = cachingCodec.serialize(TOP_TWO_LIST_DATA);
+ final NormalizedNode second = cachingCodec.serialize(TOP_TWO_LIST_DATA);
assertEquals(first, second);
assertSame(first, second);
- final NormalizedNode<?, ?> third = cachingCodec.serialize(TOP_THREE_LIST_DATA);
+ final NormalizedNode third = cachingCodec.serialize(TOP_THREE_LIST_DATA);
verifyListItemSame(first, third);
}
assertNotSame(CONT_DATA.getCaching().getValue(), CONT2_DATA.getCaching().getValue());
final BindingNormalizedNodeCachingCodec<Cont> cachingCodec = createContCachingCodec(Cont.class, MyType.class);
- final NormalizedNode<?, ?> first = cachingCodec.serialize(CONT_DATA);
- final NormalizedNode<?, ?> second = cachingCodec.serialize(CONT2_DATA);
+ final NormalizedNode first = cachingCodec.serialize(CONT_DATA);
+ final NormalizedNode second = cachingCodec.serialize(CONT2_DATA);
assertNotEquals(first, second);
verifyLeafItemSame(first, second);
assertNull(input.getTopLevelList());
assertEquals(ImmutableMap.of(), input.nonnullTopLevelList());
- final NormalizedNode<?, ?> dom = cachingCodec.serialize(input);
+ final NormalizedNode dom = cachingCodec.serialize(input);
final Top output = cachingCodec.deserialize(dom);
assertTrue(input.equals(output));
assertTrue(output.equals(input));
return contNode.createCachingCodec(ImmutableSet.copyOf(classes));
}
- private static void verifyListItemSame(final NormalizedNode<?, ?> firstTop, final NormalizedNode<?, ?> secondTop) {
- final Collection<MapEntryNode> initialNodes = getListItems(firstTop).getValue();
+ private static void verifyListItemSame(final NormalizedNode firstTop, final NormalizedNode secondTop) {
+ final Collection<MapEntryNode> initialNodes = getListItems(firstTop).body();
final MapNode secondMap = getListItems(secondTop);
for (final MapEntryNode initial : initialNodes) {
- final MapEntryNode second = secondMap.getChild(initial.getIdentifier()).get();
+ final MapEntryNode second = secondMap.childByArg(initial.getIdentifier());
assertEquals(initial, second);
assertSame(initial, second);
}
}
- private static MapNode getListItems(final NormalizedNode<?, ?> top) {
- return (MapNode) ((DataContainerNode<?>) top).getChild(TOP_LEVEL_LIST_ARG).get();
+ private static MapNode getListItems(final NormalizedNode top) {
+ return (MapNode) ((DataContainerNode) top).findChildByArg(TOP_LEVEL_LIST_ARG).get();
}
- private static void verifyLeafItemSame(final NormalizedNode<?, ?> firstCont,
- final NormalizedNode<?, ?> secondCont) {
- final DataContainerChild<?, ?> first = ((DataContainerNode<?>) firstCont).getChild(LEAF_ARG).get();
+ private static void verifyLeafItemSame(final NormalizedNode firstCont, final NormalizedNode secondCont) {
+ final DataContainerChild first = ((DataContainerNode) firstCont).childByArg(LEAF_ARG);
assertTrue(first instanceof LeafNode);
- final DataContainerChild<?, ?> second = ((DataContainerNode<?>) secondCont).getChild(LEAF_ARG).get();
+ final DataContainerChild second = ((DataContainerNode) secondCont).childByArg(LEAF_ARG);
assertTrue(second instanceof LeafNode);
// The leaf nodes are transient, but the values should be the same
assertEquals(first, second);
- assertSame(first.getValue(), second.getValue());
+ assertSame(first.body(), second.body());
}
}
.withKey(CHOICE_FOO_KEY)
.setChoiceInChoiceList(new ComplexViaUsesBuilder(createComplexData()).build())
.build();
- final NormalizedNode<?, ?> domTreeEntry = codecContext.toNormalizedNode(BA_CHOICE_LIST, baTree).getValue();
- final NormalizedNode<?, ?> domRpcEntry = codecContext.toNormalizedNode(BA_CHOICE_LIST, baRpc).getValue();
+ final NormalizedNode domTreeEntry = codecContext.toNormalizedNode(BA_CHOICE_LIST, baTree).getValue();
+ final NormalizedNode domRpcEntry = codecContext.toNormalizedNode(BA_CHOICE_LIST, baRpc).getValue();
assertEquals(domTreeEntry, domRpcEntry);
}
.withKey(TOP_FOO_KEY)
.setChoiceInList(new EmptyLeafBuilder().setEmptyType(Empty.getInstance()).build())
.build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> dom = codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST,
+ final Entry<YangInstanceIdentifier, NormalizedNode> dom = codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST,
withEmptyCase);
final Entry<InstanceIdentifier<?>, DataObject> readed = codecContext.fromNormalizedNode(dom.getKey(),
dom.getValue());
@Test
public void testFromBinding() {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> domDef = codecContext.toNormalizedNode(DEF_IID, DEF);
+ final Entry<YangInstanceIdentifier, NormalizedNode> domDef = codecContext.toNormalizedNode(DEF_IID, DEF);
Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(domDef.getKey(),
domDef.getValue());
assertEquals(DEF_IID, entry.getKey());
final Def codecDef = (Def) entry.getValue();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> domUse = codecContext.toNormalizedNode(USE_IID, USE);
+ final Entry<YangInstanceIdentifier, NormalizedNode> domUse = codecContext.toNormalizedNode(USE_IID, USE);
entry = codecContext.fromNormalizedNode(domUse.getKey(), domUse.getValue());
assertEquals(USE_IID, entry.getKey());
final Use codecUse = (Use) entry.getValue();
.setSchemaUnawareUnion(new Int32StringUnion("foo"))
.setSchemaUnawareUnionRef(new Int32StringUnion(10))
.build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> dom = codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST,
+ final Entry<YangInstanceIdentifier, NormalizedNode> dom = codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST,
binding);
final Entry<InstanceIdentifier<?>, DataObject> readed = codecContext.fromNormalizedNode(dom.getKey(),
dom.getValue());
final InstanceIdentifier<Cont> BA_II_CONT = InstanceIdentifier.builder(Cont.class).build();
final Ref refVal = new Ref("myvalue");
final Cont data = new ContBuilder().setRef(refVal).build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedNode =
+ final Entry<YangInstanceIdentifier, NormalizedNode> normalizedNode =
this.codecContext.toNormalizedNode(BA_II_CONT, data);
assertNotNull(normalizedNode);
final InstanceIdentifier<ContInt32> BA_II_CONT = InstanceIdentifier.builder(ContInt32.class).build();
final RefUnionInt32 refVal = new RefUnionInt32(Uint32.valueOf(5));
final ContInt32 data = new ContInt32Builder().setRefUnionInt32(refVal).build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedNode =
+ final Entry<YangInstanceIdentifier, NormalizedNode> normalizedNode =
this.codecContext.toNormalizedNode(BA_II_CONT, data);
assertNotNull(normalizedNode);
@Mock
private BindingNormalizedNodeCodec<DataObject> codec;
@Mock
- private NormalizedNode<?, ?> node;
+ private NormalizedNode node;
@Mock
private DataObject object;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeLeafOnlyAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeLeafOnlyAugmentBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.AugmentChoice1;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.augment.choice1.Case1Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.augment.choice1.case1.augment.choice2.Case11Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.augment.choice1.case1.augment.choice2.case11.Case11ChoiceCaseContainerBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.choice.augment1.AugmentChoice1;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.choice.augment1.augment.choice1.Case1Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.choice.augment2.augment.choice2.Case11Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.top.choice.augment2.augment.choice2.case11.Case11ChoiceCaseContainerBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.ChoiceContainer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.ChoiceContainerBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAugmentationNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableChoiceNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedLeafSetNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedMapNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUserLeafSetNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUserMapNodeBuilder;
public class NormalizedNodeSerializeDeserializeTest extends AbstractBindingCodecTest {
@Test
public void containerToNormalized() {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode> entry = codecContext.toNormalizedNode(
InstanceIdentifier.create(Top.class), top());
final ContainerNode topNormalized = getEmptyTop();
assertEquals(topNormalized, entry.getValue());
@Test
public void listWithKeysToNormalized() {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode> entry = codecContext.toNormalizedNode(
BA_TOP_LEVEL_LIST, topLevelList(TOP_LEVEL_LIST_FOO_KEY));
final MapEntryNode topLevelListNormalized = ImmutableMapEntryNodeBuilder.create()
.withNodeIdentifier(NodeIdentifierWithPredicates.of(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME,
@Test
public void leafOnlyAugmentationToNormalized() {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode> entry = codecContext.toNormalizedNode(
BA_TREE_LEAF_ONLY, new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build());
final Set<QName> augmentationChildren = new HashSet<>();
augmentationChildren.add(SIMPLE_VALUE_QNAME);
topLevelLeafList.add("foo");
Top top = new TopBuilder().setTopLevelOrderedLeafList(topLevelLeafList).build();
- Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ Entry<YangInstanceIdentifier, NormalizedNode> entry = codecContext.toNormalizedNode(
InstanceIdentifier.create(Top.class), top);
ContainerNode containerNode = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
- .withChild(ImmutableOrderedLeafSetNodeBuilder.create()
+ .withChild(ImmutableUserLeafSetNodeBuilder.create()
.withNodeIdentifier(new NodeIdentifier(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME))
.withChild(
ImmutableLeafSetEntryNodeBuilder.create()
topLevelLeafList.add("foo");
final Top top = new TopBuilder().setTopLevelLeafList(topLevelLeafList).build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode> entry = codecContext.toNormalizedNode(
InstanceIdentifier.create(Top.class), top);
final ContainerNode containerNode = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
public void orderedLeafListFromNormalized() {
ContainerNode topWithLeafList = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
- .withChild(ImmutableOrderedLeafSetNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(
+ .withChild(ImmutableUserLeafSetNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(
TOP_LEVEL_ORDERED_LEAF_LIST_QNAME))
.withChild(ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
new NodeWithValue<>(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME, "foo")).withValue("foo").build())
public void choiceToNormalized() {
final ChoiceContainer choiceContainerBA = new ChoiceContainerBuilder().setIdentifier(new ExtendedBuilder()
.setExtendedId(new ExtendedIdBuilder().setId("identifier_value").build()).build()).build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode> entry = codecContext.toNormalizedNode(
InstanceIdentifier.create(ChoiceContainer.class), choiceContainerBA);
final ContainerNode choiceContainer = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new NodeIdentifier(CHOICE_CONTAINER_QNAME))
nestedLists.add(new NestedListBuilder().withKey(new NestedListKey("bar")).build());
final TopLevelList topLevelList = new TopLevelListBuilder().withKey(TOP_LEVEL_LIST_FOO_KEY).setNestedList(
nestedLists).build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(ii,
+ final Entry<YangInstanceIdentifier, NormalizedNode> entry = codecContext.toNormalizedNode(ii,
topLevelList);
final MapEntryNode foo = mapEntryBuilder().withNodeIdentifier(NodeIdentifierWithPredicates.of(
TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
.withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
- .withChild(ImmutableOrderedMapNodeBuilder.create()
+ .withChild(ImmutableUserMapNodeBuilder.create()
.withNodeIdentifier(new NodeIdentifier(NESTED_LIST_QNAME))
.withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "foo"))
.withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "bar")).build()).build();
final MapEntryNode foo = mapEntryBuilder().withNodeIdentifier(NodeIdentifierWithPredicates.of(
TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
.withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
- .withChild(ImmutableOrderedMapNodeBuilder.create()
+ .withChild(ImmutableUserMapNodeBuilder.create()
.withNodeIdentifier(new NodeIdentifier(NESTED_LIST_QNAME))
.withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "foo"))
.withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "bar")).build()).build();
tBuilder.addAugmentation(tca1Builder.build());
final Top top = tBuilder.build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> biResult = codecContext.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode> biResult = codecContext.toNormalizedNode(
InstanceIdentifier.create(Top.class), top);
- final NormalizedNode<?, ?> topNormalized =
- containerBuilder().withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
+ final NormalizedNode topNormalized = containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
.withChild(augmentationBuilder().withNodeIdentifier(aug1Id)
.withChild(choiceBuilder().withNodeIdentifier(augmentChoice1Id)
.withChild(augmentationBuilder().withNodeIdentifier(aug2Id)
public void specifiedBooleanLeafTest() {
final BooleanCont booleanCont = new BooleanContBuilder().setIsFoo(true).build();
- final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> res = codecContext
+ final Map.Entry<YangInstanceIdentifier, NormalizedNode> res = codecContext
.toNormalizedNode(BOOLEAN_CONT_II, booleanCont);
final BooleanCont booleanContBinding = (BooleanCont)codecContext
public void specifiedCommonLeafTest() {
final BarCont barCont = new BarContBuilder().setLeaf2("foo").build();
- final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> res = codecContext
+ final Map.Entry<YangInstanceIdentifier, NormalizedNode> res = codecContext
.toNormalizedNode(BAR_CONT_II, barCont);
final BarCont booleanContBinding = (BarCont)codecContext
final List<String> testList = ImmutableList.of("test");
final BarCont barCont = new BarContBuilder().setLeafList1(testList).build();
- final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> res = codecContext
+ final Map.Entry<YangInstanceIdentifier, NormalizedNode> res = codecContext
.toNormalizedNode(BAR_CONT_II, barCont);
final BarCont barContAfterConverting = (BarCont)codecContext
.setAction2(new PolicyLoggingFlag(false))
.setAction3(true)
.build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> dom =
+ final Entry<YangInstanceIdentifier, NormalizedNode> dom =
codecContext.toNormalizedNode(BA_DEFAULT_POLICY, binding);
final Entry<InstanceIdentifier<?>, DataObject> readed =
codecContext.fromNormalizedNode(dom.getKey(),dom.getValue());
.setEmptyLeaf2(new TypedefEmpty(Empty.getInstance()))
.setEmptyLeaf3(Empty.getInstance())
.build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> dom =
+ final Entry<YangInstanceIdentifier, NormalizedNode> dom =
codecContext.toNormalizedNode(BA_TEST_CONT, binding);
final Entry<InstanceIdentifier<?>, DataObject> readed =
codecContext.fromNormalizedNode(dom.getKey(),dom.getValue());
public void unionTest() {
TopLevel topLevel = TopLevelBuilder.getDefaultInstance(TEST_STRING);
Wrapper wrapper = new WrapperBuilder().setWrap(topLevel).build();
- NormalizedNode<?, ?> topLevelEntry = codecContext.toNormalizedNode(InstanceIdentifier.create(Wrapper.class),
+ NormalizedNode topLevelEntry = codecContext.toNormalizedNode(InstanceIdentifier.create(Wrapper.class),
wrapper).getValue();
ContainerNode containerNode = ImmutableContainerNodeBuilder.create()
public void bug5446Test() {
IpAddressBinary ipAddress = IpAddressBinaryBuilder.getDefaultInstance("fwAAAQ==");
Root root = new RootBuilder().setIpAddress(ipAddress).build();
- NormalizedNode<?, ?> rootNode = codecContext.toNormalizedNode(InstanceIdentifier.create(Root.class), root)
+ NormalizedNode rootNode = codecContext.toNormalizedNode(InstanceIdentifier.create(Root.class), root)
.getValue();
Entry<InstanceIdentifier<?>, DataObject> rootEntry = codecContext.fromNormalizedNode(
- YangInstanceIdentifier.of(rootNode.getNodeType()), rootNode);
+ YangInstanceIdentifier.of(rootNode.getIdentifier().getNodeType()), rootNode);
DataObject rootObj = rootEntry.getValue();
assertTrue(rootObj instanceof Root);
private DataObject createValueNode(final String valueString) {
UnionType unionType = UnionTypeBuilder.getDefaultInstance(valueString);
UnionNode unionNode = new UnionNodeBuilder().setValue(unionType).build();
- NormalizedNode<?, ?> normalizedUnionNode = codecContext
+ NormalizedNode normalizedUnionNode = codecContext
.toNormalizedNode(InstanceIdentifier.builder(UnionNode.class).build(), unionNode)
.getValue();
Entry<InstanceIdentifier<?>, DataObject> unionNodeEntry = codecContext.fromNormalizedNode(
- YangInstanceIdentifier.of(normalizedUnionNode.getNodeType()), normalizedUnionNode);
+ YangInstanceIdentifier.of(normalizedUnionNode.getIdentifier().getNodeType()), normalizedUnionNode);
DataObject unionNodeObj = unionNodeEntry.getValue();
assertTrue(unionNodeObj instanceof UnionNode);
return unionNodeObj;
+++ /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.mdsal.binding.generator.spi;
-
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-
-//FIXME not implemented anywhere
-public interface TypeProviderFactory {
-
- TypeProvider providerFor(SourceIdentifier module);
-}
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>odlext-model-api</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-generator-api</artifactId>
import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeGenerator;
module org.opendaylight.mdsal.binding.generator.impl {
- // FIXME: 8.0.0: do not export this package (move public stuff to .di)
+ // FIXME: 8.0.0: rename to mdsal.binding.generator.ri, keep implementation hidden in ri.impl
exports org.opendaylight.mdsal.binding.generator.impl;
exports org.opendaylight.mdsal.binding.yang.types;
requires transitive org.opendaylight.mdsal.binding.generator.api;
requires transitive org.opendaylight.mdsal.binding.generator.util;
requires transitive org.opendaylight.mdsal.binding.runtime.api;
+ requires com.google.common;
requires org.opendaylight.mdsal.binding.spec.util;
+ requires org.opendaylight.yangtools.concepts;
+ requires org.opendaylight.yangtools.yang.common;
requires org.opendaylight.yangtools.yang.model.api;
+ requires org.opendaylight.yangtools.yang.model.spi;
+ requires org.opendaylight.yangtools.yang.model.ri;
requires org.opendaylight.yangtools.yang.model.util;
+ requires org.opendaylight.yangtools.odlext.model.api;
requires org.opendaylight.yangtools.util;
requires org.slf4j;
+++ /dev/null
-/*
- * Copyright (c) 2018 Pantheon Technologies, s.r.o. 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.mdsal.binding.generator.impl;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.base.Verify.verifyNotNull;
-import static java.util.Objects.requireNonNull;
-import static org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil.computeDefaultSUID;
-import static org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil.packageNameForAugmentedGeneratedType;
-import static org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil.packageNameForGeneratedType;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.BASE_IDENTITY;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.DATA_OBJECT;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.DATA_ROOT;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.NOTIFICATION;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.NOTIFICATION_LISTENER;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.QNAME;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.ROUTING_CONTEXT;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.RPC_INPUT;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.RPC_OUTPUT;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.RPC_SERVICE;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.action;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.augmentable;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.augmentation;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.childOf;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.choiceIn;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.identifiable;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.identifier;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.instanceNotification;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.keyedListAction;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.keyedListNotification;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.opaqueObject;
-import static org.opendaylight.mdsal.binding.model.util.BindingTypes.rpcResult;
-import static org.opendaylight.mdsal.binding.model.util.Types.STRING;
-import static org.opendaylight.mdsal.binding.model.util.Types.classType;
-import static org.opendaylight.mdsal.binding.model.util.Types.listTypeFor;
-import static org.opendaylight.mdsal.binding.model.util.Types.listTypeWildcard;
-import static org.opendaylight.mdsal.binding.model.util.Types.listenableFutureTypeFor;
-import static org.opendaylight.mdsal.binding.model.util.Types.mapTypeFor;
-import static org.opendaylight.mdsal.binding.model.util.Types.objectType;
-import static org.opendaylight.mdsal.binding.model.util.Types.primitiveBooleanType;
-import static org.opendaylight.mdsal.binding.model.util.Types.primitiveIntType;
-import static org.opendaylight.mdsal.binding.model.util.Types.primitiveVoidType;
-import static org.opendaylight.mdsal.binding.model.util.Types.wildcardTypeFor;
-import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode;
-import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findNodeInSchemaContext;
-import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
-
-import com.google.common.base.Splitter;
-import com.google.common.collect.Iterables;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.util.AbstractMap.SimpleImmutableEntry;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.mdsal.binding.model.api.AccessModifier;
-import org.opendaylight.mdsal.binding.model.api.AnnotationType;
-import org.opendaylight.mdsal.binding.model.api.Constant;
-import org.opendaylight.mdsal.binding.model.api.DefaultType;
-import org.opendaylight.mdsal.binding.model.api.Enumeration;
-import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
-import org.opendaylight.mdsal.binding.model.api.GeneratedType;
-import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
-import org.opendaylight.mdsal.binding.model.api.MethodSignature;
-import org.opendaylight.mdsal.binding.model.api.MethodSignature.ValueMechanics;
-import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
-import org.opendaylight.mdsal.binding.model.api.Restrictions;
-import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotableTypeBuilder;
-import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
-import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
-import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
-import org.opendaylight.mdsal.binding.model.api.type.builder.TypeMemberBuilder;
-import org.opendaylight.mdsal.binding.model.util.BaseYangTypes;
-import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil;
-import org.opendaylight.mdsal.binding.model.util.TypeConstants;
-import org.opendaylight.mdsal.binding.model.util.generated.type.builder.GeneratedPropertyBuilderImpl;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
-import org.opendaylight.mdsal.binding.yang.types.AbstractTypeProvider;
-import org.opendaylight.mdsal.binding.yang.types.CompatUtils;
-import org.opendaylight.mdsal.binding.yang.types.GroupingDefinitionDependencySort;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
-import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ContainerLike;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
-import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.InputSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleImport;
-import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
-import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
-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.LeafrefTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.ModuleDependencySort;
-import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-abstract class AbstractTypeGenerator {
- private enum InheritedGetter {
- /**
- * There is no matching method present.
- */
- NOT_PRESENT,
- /**
- * There is a matching method and its return type is resolved.
- */
- RESOLVED,
- /**
- * There is a matching method and its return type is unresolved -- i.e. in case of a leafref pointing to outside
- * of its parent grouping.
- */
- UNRESOLVED;
-
- /**
- * We are using {@code @Override} annotation to indicate specialization, hence we can differentiate between
- * resolved and unresolved methods based on them.
- *
- * @param annotations Method annotations
- * @return Either {@link #RESOLVED} or {@link #UNRESOLVED}.
- */
- static InheritedGetter fromAnnotations(final List<AnnotationType> annotations) {
- for (AnnotationType annotation : annotations) {
- if (OVERRIDE_ANNOTATION.equals(annotation.getIdentifier())) {
- return InheritedGetter.RESOLVED;
- }
- }
- return InheritedGetter.UNRESOLVED;
- }
- }
-
- private static final Logger LOG = LoggerFactory.getLogger(AbstractTypeGenerator.class);
- private static final Splitter COLON_SPLITTER = Splitter.on(':');
- private static final JavaTypeName DEPRECATED_ANNOTATION = JavaTypeName.create(Deprecated.class);
- private static final JavaTypeName OVERRIDE_ANNOTATION = JavaTypeName.create(Override.class);
- private static final JavaTypeName CHECK_RETURN_VALUE_ANNOTATION =
- // Do not refer to annotation class, as it may not be available at runtime
- JavaTypeName.create("edu.umd.cs.findbugs.annotations", "CheckReturnValue");
- private static final Type LIST_STRING_TYPE = listTypeFor(BaseYangTypes.STRING_TYPE);
-
- /**
- * Comparator based on augment target path.
- */
- private static final Comparator<AugmentationSchemaNode> AUGMENT_COMP = (o1, o2) -> {
- final Iterator<QName> thisIt = o1.getTargetPath().getNodeIdentifiers().iterator();
- final Iterator<QName> otherIt = o2.getTargetPath().getNodeIdentifiers().iterator();
-
- while (thisIt.hasNext()) {
- if (!otherIt.hasNext()) {
- return 1;
- }
-
- final int comp = thisIt.next().compareTo(otherIt.next());
- if (comp != 0) {
- return comp;
- }
- }
-
- return otherIt.hasNext() ? -1 : 0;
- };
-
- /**
- * Constant with the concrete name of identifier.
- */
- private static final String AUGMENT_IDENTIFIER_NAME = "augment-identifier";
-
- /**
- * Constant with the concrete name of namespace.
- */
- private static final String YANG_EXT_NAMESPACE = "urn:opendaylight:yang:extension:yang-ext";
-
- private final Map<QNameModule, ModuleContext> genCtx = new HashMap<>();
-
- /**
- * Outer key represents the package name. Outer value represents map of all builders in the same package. Inner key
- * represents the schema node name (in JAVA class/interface name format). Inner value represents instance of builder
- * for schema node specified in key part.
- */
- private final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
-
- /**
- * Provide methods for converting YANG types to JAVA types.
- */
- private final AbstractTypeProvider typeProvider;
-
- /**
- * Holds reference to schema context to resolve data of augmented element when creating augmentation builder.
- */
- private final @NonNull EffectiveModelContext schemaContext;
-
- /**
- * Holds renamed elements.
- */
- private final Map<SchemaNode, JavaTypeName> renames;
-
- AbstractTypeGenerator(final EffectiveModelContext context, final AbstractTypeProvider typeProvider,
- final Map<SchemaNode, JavaTypeName> renames) {
- this.schemaContext = requireNonNull(context);
- this.typeProvider = requireNonNull(typeProvider);
- this.renames = requireNonNull(renames);
-
- final List<Module> contextModules = ModuleDependencySort.sort(schemaContext.getModules());
- final List<ModuleContext> contexts = new ArrayList<>(contextModules.size());
- for (final Module contextModule : contextModules) {
- contexts.add(moduleToGenTypes(contextModule));
- }
-
- contexts.forEach(this::allAugmentsToGenTypes);
- }
-
- final @NonNull EffectiveModelContext schemaContext() {
- return schemaContext;
- }
-
- final Collection<ModuleContext> moduleContexts() {
- return genCtx.values();
- }
-
- final ModuleContext moduleContext(final QNameModule module) {
- return requireNonNull(genCtx.get(module), () -> "Module context not found for module " + module);
- }
-
- final AbstractTypeProvider typeProvider() {
- return typeProvider;
- }
-
- abstract void addCodegenInformation(GeneratedTypeBuilderBase<?> genType, Module module);
-
- abstract void addCodegenInformation(GeneratedTypeBuilderBase<?> genType, Module module, SchemaNode node);
-
- abstract void addCodegenInformation(GeneratedTypeBuilder interfaceBuilder, Module module, String description,
- Collection<? extends SchemaNode> nodes);
-
- abstract void addComment(TypeMemberBuilder<?> genType, DocumentedNode node);
-
- abstract void addRpcMethodComment(TypeMemberBuilder<?> genType, RpcDefinition node);
-
- private ModuleContext moduleToGenTypes(final Module module) {
- final ModuleContext context = new ModuleContext(module);
- genCtx.put(module.getQNameModule(), context);
- allTypeDefinitionsToGenTypes(context);
- groupingsToGenTypes(context, module.getGroupings());
- allIdentitiesToGenTypes(context);
-
- if (!module.getChildNodes().isEmpty()) {
- final GeneratedTypeBuilder moduleType = moduleToDataType(context);
- context.addModuleNode(moduleType);
- resolveDataSchemaNodes(context, moduleType, moduleType, module.getChildNodes(), false);
- }
-
- // Resolve RPCs and notifications only after we have created instantiated tree
- rpcMethodsToGenType(context);
- notificationsToGenType(context);
- return context;
- }
-
- /**
- * Converts all extended type definitions of module to the list of
- * <code>Type</code> objects.
- *
- * @param module
- * module from which is obtained set of type definitions
- * @throws IllegalArgumentException
- * <ul>
- * <li>if module is null</li>
- * <li>if name of module is null</li>
- * </ul>
- * @throws IllegalStateException
- * if set of type definitions from module is null
- */
- private void allTypeDefinitionsToGenTypes(final ModuleContext context) {
- final Module module = context.module();
- checkArgument(module.getName() != null, "Module name cannot be NULL.");
-
- for (final TypeDefinition<?> typedef : SchemaNodeUtils.getAllTypeDefinitions(module)) {
- if (typedef != null) {
- final GeneratedType type = typeProvider.generatedTypeForExtendedDefinitionType(typedef, typedef);
- if (type != null) {
- context.addTypedefType(typedef, type);
- context.addTypeToSchema(type,typedef);
- }
- }
- }
- }
-
- private GeneratedTypeBuilder processDataSchemaNode(final ModuleContext context, final Type baseInterface,
- final DataSchemaNode node, final boolean inGrouping) {
- if (node.isAugmenting() || node.isAddedByUses()) {
- return null;
- }
- final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, node, baseInterface);
- addConcreteInterfaceMethods(genType);
- annotateDeprecatedIfNecessary(node, genType);
-
- final Module module = context.module();
- genType.setModuleName(module.getName());
- addCodegenInformation(genType, module, node);
- genType.setSchemaPath(node.getPath());
- if (node instanceof DataNodeContainer) {
- context.addChildNodeType(node, genType);
- groupingsToGenTypes(context, ((DataNodeContainer) node).getGroupings());
- processUsesAugments((DataNodeContainer) node, context, inGrouping);
- }
- return genType;
- }
-
- private Type containerToGenType(final ModuleContext context, final GeneratedTypeBuilder parent,
- final Type baseInterface, final ContainerSchemaNode node, final boolean inGrouping) {
- final GeneratedTypeBuilder genType = processDataSchemaNode(context, baseInterface, node, inGrouping);
- if (genType != null) {
- constructGetter(parent, genType, node);
- resolveDataSchemaNodes(context, genType, genType, node.getChildNodes(), inGrouping);
- actionsToGenType(context, genType, node, null, inGrouping);
- notificationsToGenType(context, genType, node, null, inGrouping);
- }
- return genType;
- }
-
- private GeneratedTypeBuilder listToGenType(final ModuleContext context, final GeneratedTypeBuilder parent,
- final Type baseInterface, final ListSchemaNode node, final boolean inGrouping) {
- final GeneratedTypeBuilder genType = processDataSchemaNode(context, baseInterface, node, inGrouping);
- if (genType != null) {
- final List<String> listKeys = listKeys(node);
- final GeneratedTOBuilder keyTypeBuilder;
- if (!listKeys.isEmpty()) {
- keyTypeBuilder = typeProvider.newGeneratedTOBuilder(JavaTypeName.create(
- packageNameForGeneratedType(context.modulePackageName(), node.getPath()),
- BindingMapping.getClassName(node.getQName().getLocalName() + "Key")))
- .addImplementsType(identifier(genType));
- genType.addImplementsType(identifiable(keyTypeBuilder));
- } else {
- keyTypeBuilder = null;
- }
-
- // Decide whether to generate a List or a Map
- final ParameterizedType listType;
- if (keyTypeBuilder != null && !node.isUserOrdered()) {
- listType = mapTypeFor(keyTypeBuilder, genType);
- } else {
- listType = listTypeFor(genType);
- }
-
- constructGetter(parent, listType, node).setMechanics(ValueMechanics.NULLIFY_EMPTY);
- constructNonnull(parent, listType, node);
-
- actionsToGenType(context, genType, node, keyTypeBuilder, inGrouping);
- notificationsToGenType(context, genType, node, keyTypeBuilder, inGrouping);
-
- for (final DataSchemaNode schemaNode : node.getChildNodes()) {
- if (!schemaNode.isAugmenting()) {
- addSchemaNodeToListBuilders(context, schemaNode, genType, keyTypeBuilder, listKeys, inGrouping);
- }
- }
-
- // serialVersionUID
- if (keyTypeBuilder != null) {
- final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID");
- prop.setValue(Long.toString(computeDefaultSUID(keyTypeBuilder)));
- keyTypeBuilder.setSUID(prop);
- }
-
- typeBuildersToGenTypes(context, genType, keyTypeBuilder);
- }
- return genType;
- }
-
- private void processUsesAugments(final DataNodeContainer node, final ModuleContext context,
- final boolean inGrouping) {
- for (final UsesNode usesNode : node.getUses()) {
- for (final AugmentationSchemaNode augment : usesNode.getAugmentations()) {
- usesAugmentationToGenTypes(context, augment, usesNode, node, inGrouping);
- processUsesAugments(augment, context, inGrouping);
- }
- }
- }
-
- /**
- * Converts all <b>augmentation</b> of the module to the list
- * <code>Type</code> objects.
- *
- * @param module
- * module from which is obtained list of all augmentation objects
- * to iterate over them
- * @throws IllegalArgumentException
- * <ul>
- * <li>if the module is null</li>
- * <li>if the name of module is null</li>
- * </ul>
- * @throws IllegalStateException
- * if set of augmentations from module is null
- */
- private void allAugmentsToGenTypes(final ModuleContext context) {
- final Module module = context.module();
- checkArgument(module != null, "Module reference cannot be NULL.");
- checkArgument(module.getName() != null, "Module name cannot be NULL.");
- checkState(module.getAugmentations() != null, "Augmentations Set cannot be NULL.");
-
- for (final AugmentationSchemaNode augment : resolveAugmentations(module)) {
- augmentationToGenTypes(context, augment);
- }
- }
-
- /**
- * Returns list of <code>AugmentationSchema</code> objects. The objects are
- * sorted according to the length of their target path from the shortest to
- * the longest.
- *
- * @param module
- * module from which is obtained list of all augmentation objects
- * @return list of sorted <code>AugmentationSchema</code> objects obtained
- * from <code>module</code>
- * @throws IllegalArgumentException
- * if module is null
- * @throws IllegalStateException
- * if set of module augmentations is null
- */
- private static List<AugmentationSchemaNode> resolveAugmentations(final Module module) {
- checkArgument(module != null, "Module reference cannot be NULL.");
- checkState(module.getAugmentations() != null, "Augmentations Set cannot be NULL.");
-
- final List<AugmentationSchemaNode> sortedAugmentations = new ArrayList<>(module.getAugmentations());
- sortedAugmentations.sort(AUGMENT_COMP);
-
- return sortedAugmentations;
- }
-
- /**
- * Create GeneratedTypeBuilder object from module argument.
- *
- * @param module
- * Module object from which builder will be created
- * @return <code>GeneratedTypeBuilder</code> which is internal
- * representation of the module
- * @throws IllegalArgumentException
- * if module is null
- */
- private GeneratedTypeBuilder moduleToDataType(final ModuleContext context) {
- final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(context, BindingMapping.DATA_ROOT_SUFFIX);
- final Module module = context.module();
- addImplementedInterfaceFromUses(module, moduleDataTypeBuilder);
- moduleDataTypeBuilder.addImplementsType(DATA_ROOT);
- // if we have more than 2 top level uses statements we need to define getImplementedInterface() on the
- // top level DataRoot object
- if (module.getUses().size() > 1) {
- narrowImplementedInterface(moduleDataTypeBuilder);
- }
-
- addCodegenInformation(moduleDataTypeBuilder, module);
- return moduleDataTypeBuilder;
- }
-
- private <T extends DataNodeContainer & ActionNodeContainer> void actionsToGenType(final ModuleContext context,
- final Type parent, final T parentSchema, final Type keyType, final boolean inGrouping) {
- for (final ActionDefinition action : parentSchema.getActions()) {
- if (action.isAugmenting()) {
- continue;
- }
-
- final GeneratedType input;
- final GeneratedType output;
- if (action.isAddedByUses()) {
- final ActionDefinition orig = findOrigAction(parentSchema, action).get();
- // Original definition may live in a different module, make sure we account for that
- final ModuleContext origContext = moduleContext(
- orig.getPath().getPathFromRoot().iterator().next().getModule());
- input = context.addAliasType(origContext, orig.getInput(), action.getInput());
- output = context.addAliasType(origContext, orig.getOutput(), action.getOutput());
- } else {
- input = actionContainer(context, RPC_INPUT, action.getInput(), inGrouping);
- output = actionContainer(context, RPC_OUTPUT, action.getOutput(), inGrouping);
- }
-
- if (!(parentSchema instanceof GroupingDefinition)) {
- // Parent is a non-grouping, hence we need to establish an Action instance, which can be completely
- // identified by an InstanceIdentifier. We do not generate Actions for groupings as they are inexact,
- // and do not capture an actual instantiation.
- final QName qname = action.getQName();
- final GeneratedTypeBuilder builder = typeProvider.newGeneratedTypeBuilder(JavaTypeName.create(
- packageNameForGeneratedType(context.modulePackageName(), action.getPath()),
- BindingMapping.getClassName(qname)));
- qnameConstant(builder, context.moduleInfoType(), qname.getLocalName());
-
- annotateDeprecatedIfNecessary(action, builder);
- builder.addImplementsType(keyType != null ? keyedListAction(parent, keyType, input, output)
- : action(parent, input, output));
-
- addCodegenInformation(builder, context.module(), action);
- context.addChildNodeType(action, builder);
- }
- }
- }
-
- private Optional<ActionDefinition> findOrigAction(final DataNodeContainer parent, final ActionDefinition action) {
- final QName qname = action.getQName();
- for (UsesNode uses : parent.getUses()) {
- final GroupingDefinition grp = uses.getSourceGrouping();
- // Target grouping may reside in a different module, hence we need to rebind the QName to match grouping's
- // namespace
- final Optional<ActionDefinition> found = grp.findAction(qname.bindTo(grp.getQName().getModule()));
- if (found.isPresent()) {
- final ActionDefinition result = found.get();
- return result.isAddedByUses() ? findOrigAction(grp, result) : found;
- }
- }
-
- return Optional.empty();
- }
-
- private GeneratedType actionContainer(final ModuleContext context, final Type baseInterface,
- final ContainerLike schema, final boolean inGrouping) {
- final GeneratedTypeBuilder genType = processDataSchemaNode(context, baseInterface, schema, inGrouping);
- resolveDataSchemaNodes(context, genType, genType, schema.getChildNodes(), inGrouping);
- return genType.build();
- }
-
- /**
- * Converts all <b>RPCs</b> input and output substatements of the module
- * to the list of <code>Type</code> objects. In addition are to containers
- * and lists which belong to input or output also part of returning list.
- *
- * @param module
- * module from which is obtained set of all rpc objects to
- * iterate over them
- * @throws IllegalArgumentException
- * <ul>
- * <li>if the module is null</li>
- * <li>if the name of module is null</li>
- * </ul>
- * @throws IllegalStateException
- * if set of rpcs from module is null
- */
- private void rpcMethodsToGenType(final ModuleContext context) {
- final Module module = context.module();
- checkArgument(module.getName() != null, "Module name cannot be NULL.");
- final Collection<? extends RpcDefinition> rpcDefinitions = module.getRpcs();
- checkState(rpcDefinitions != null, "Set of rpcs from module " + module.getName() + " cannot be NULL.");
- if (rpcDefinitions.isEmpty()) {
- return;
- }
-
- final GeneratedTypeBuilder interfaceBuilder = moduleTypeBuilder(context, BindingMapping.RPC_SERVICE_SUFFIX);
- interfaceBuilder.addImplementsType(RPC_SERVICE);
-
- addCodegenInformation(interfaceBuilder, module, "RPCs", rpcDefinitions);
-
- for (final RpcDefinition rpc : rpcDefinitions) {
- if (rpc != null) {
- final String rpcName = BindingMapping.getClassName(rpc.getQName());
- final String rpcMethodName = BindingMapping.getRpcMethodName(rpc.getQName());
- final MethodSignatureBuilder method = interfaceBuilder.addMethod(rpcMethodName);
-
- // Do not refer to annotation class, as it may not be available at runtime
- method.addAnnotation(CHECK_RETURN_VALUE_ANNOTATION);
- addRpcMethodComment(method, rpc);
- method.addParameter(
- createRpcContainer(context, rpcName, rpc, verifyNotNull(rpc.getInput()), RPC_INPUT), "input");
- method.setReturnType(listenableFutureTypeFor(
- rpcResult(createRpcContainer(context, rpcName, rpc, verifyNotNull(rpc.getOutput()), RPC_OUTPUT))));
- }
- }
-
- context.addTopLevelNodeType(interfaceBuilder);
- }
-
- private Type createRpcContainer(final ModuleContext context, final String rpcName, final RpcDefinition rpc,
- final ContainerLike schema, final Type type) {
- processUsesAugments(schema, context, false);
- final GeneratedTypeBuilder outType = addRawInterfaceDefinition(context,
- JavaTypeName.create(context.modulePackageName(), rpcName + BindingMapping.getClassName(schema.getQName())),
- schema);
- addImplementedInterfaceFromUses(schema, outType);
- outType.addImplementsType(type);
- outType.addImplementsType(augmentable(outType));
- addConcreteInterfaceMethods(outType);
- annotateDeprecatedIfNecessary(rpc, outType);
- resolveDataSchemaNodes(context, outType, outType, schema.getChildNodes(), false);
- context.addChildNodeType(schema, outType);
- return outType.build();
- }
-
- /**
- * Converts all <b>notifications</b> of the module to the list of
- * <code>Type</code> objects. In addition are to this list added containers
- * and lists which are part of this notification.
- *
- * @param module
- * module from which is obtained set of all notification objects
- * to iterate over them
- * @throws IllegalArgumentException
- * <ul>
- * <li>if the module equals null</li>
- * <li>if the name of module equals null</li>
- * </ul>
- * @throws IllegalStateException
- * if set of notifications from module is null
- */
- private void notificationsToGenType(final ModuleContext context) {
- final Module module = context.module();
- checkArgument(module.getName() != null, "Module name cannot be NULL.");
- final Collection<? extends NotificationDefinition> notifications = module.getNotifications();
- if (notifications.isEmpty()) {
- return;
- }
-
- final GeneratedTypeBuilder listenerInterface = moduleTypeBuilder(context,
- BindingMapping.NOTIFICATION_LISTENER_SUFFIX);
- listenerInterface.addImplementsType(NOTIFICATION_LISTENER);
-
- for (final NotificationDefinition notification : notifications) {
- if (notification != null) {
- processUsesAugments(notification, context, false);
-
- final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition(
- context.modulePackageName(), notification, DATA_OBJECT, context);
- addConcreteInterfaceMethods(notificationInterface);
- annotateDeprecatedIfNecessary(notification, notificationInterface);
- notificationInterface.addImplementsType(NOTIFICATION);
- context.addChildNodeType(notification, notificationInterface);
-
- // Notification object
- resolveDataSchemaNodes(context, notificationInterface, notificationInterface,
- notification.getChildNodes(), false);
-
- final MethodSignatureBuilder notificationMethod =
- listenerInterface.addMethod("on" + notificationInterface.getName())
- .setAccessModifier(AccessModifier.PUBLIC).addParameter(notificationInterface, "notification")
- .setReturnType(primitiveVoidType());
-
- annotateDeprecatedIfNecessary(notification, notificationMethod);
- if (notification.getStatus().equals(Status.OBSOLETE)) {
- notificationMethod.setDefault(true);
- }
- addComment(notificationMethod, notification);
- }
- }
-
- addCodegenInformation(listenerInterface, module, "notifications", notifications);
- context.addTopLevelNodeType(listenerInterface);
- }
-
- private <T extends DataNodeContainer & NotificationNodeContainer> void notificationsToGenType(
- final ModuleContext context, final Type parent, final T parentSchema, final Type keyType,
- final boolean inGrouping) {
- final Collection<? extends NotificationDefinition> notifications = parentSchema.getNotifications();
- if (notifications.isEmpty()) {
- return;
- }
-
- for (NotificationDefinition notif : notifications) {
- if (notif.isAugmenting()) {
- continue;
- }
- if (parentSchema instanceof GroupingDefinition) {
- // Notifications cannot be really established, as they lack instantiation context, which would be
- // completely described by an InstanceIdentifier -- hence we cannot create a binding class
- continue;
- }
-
- processUsesAugments(notif, context, false);
-
- final GeneratedTypeBuilder notifInterface = addDefaultInterfaceDefinition(
- packageNameForGeneratedType(context.modulePackageName(), notif.getPath()), notif, DATA_OBJECT, context);
- addConcreteInterfaceMethods(notifInterface);
- annotateDeprecatedIfNecessary(notif, notifInterface);
-
- notifInterface.addImplementsType(keyType != null ? keyedListNotification(notifInterface, parent, keyType)
- : instanceNotification(notifInterface, parent));
- context.addChildNodeType(notif, notifInterface);
-
- // Notification object
- resolveDataSchemaNodes(context, notifInterface, notifInterface, notif.getChildNodes(), false);
- }
- }
-
- /**
- * Converts all <b>identities</b> of the module to the list of
- * <code>Type</code> objects.
- *
- * @param module
- * module from which is obtained set of all identity objects to
- * iterate over them
- * @param schemaContext
- * schema context only used as input parameter for method
- * {@link BindingGeneratorImpl#identityToGenType}
- *
- */
- private void allIdentitiesToGenTypes(final ModuleContext context) {
- final Collection<? extends IdentitySchemaNode> schemaIdentities = context.module().getIdentities();
-
- if (schemaIdentities != null && !schemaIdentities.isEmpty()) {
- for (final IdentitySchemaNode identity : schemaIdentities) {
- identityToGenType(context, identity);
- }
- }
- }
-
- /**
- * Converts the <b>identity</b> object to GeneratedType. Firstly it is
- * created transport object builder. If identity contains base identity then
- * reference to base identity is added to superior identity as its extend.
- * If identity doesn't contain base identity then only reference to abstract
- * class {@link org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode
- * BaseIdentity} is added
- *
- * @param module
- * current module
- * @param basePackageName
- * string contains the module package name
- * @param identity
- * IdentitySchemaNode which contains data about identity
- */
- private void identityToGenType(final ModuleContext context,final IdentitySchemaNode identity) {
- if (identity == null) {
- return;
- }
-
- JavaTypeName name = renames.get(identity);
- if (name == null) {
- name = JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), identity.getPath()),
- BindingMapping.getClassName(identity.getQName()));
- }
-
- final GeneratedTypeBuilder newType = typeProvider.newGeneratedTypeBuilder(name);
- final Collection<? extends IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
- if (!baseIdentities.isEmpty()) {
- for (IdentitySchemaNode baseIdentity : baseIdentities) {
- JavaTypeName base = renames.get(baseIdentity);
- if (base == null) {
- final QName qname = baseIdentity.getQName();
- base = JavaTypeName.create(BindingMapping.getRootPackageName(qname.getModule()),
- BindingMapping.getClassName(qname));
- }
-
- final GeneratedTransferObject gto = typeProvider.newGeneratedTOBuilder(base).build();
- newType.addImplementsType(gto);
- }
- } else {
- newType.addImplementsType(BASE_IDENTITY);
- }
-
- final Module module = context.module();
- addCodegenInformation(newType, module, identity);
- newType.setModuleName(module.getName());
- newType.setSchemaPath(identity.getPath());
-
- qnameConstant(newType, context.moduleInfoType(), identity.getQName().getLocalName());
-
- context.addIdentityType(identity, newType);
- }
-
- private static Constant qnameConstant(final GeneratedTypeBuilderBase<?> toBuilder,
- final JavaTypeName yangModuleInfo, final String localName) {
- return toBuilder.addConstant(QNAME, BindingMapping.QNAME_STATIC_FIELD_NAME,
- new SimpleImmutableEntry<>(yangModuleInfo, localName));
- }
-
- /**
- * Converts all <b>groupings</b> of the module to the list of
- * <code>Type</code> objects. Firstly are groupings sorted according mutual
- * dependencies. At least dependent (independent) groupings are in the list
- * saved at first positions. For every grouping the record is added to map
- * {@link ModuleContext#groupings allGroupings}
- *
- * @param module
- * current module
- * @param groupings
- * collection of groupings from which types will be generated
- *
- */
- private void groupingsToGenTypes(final ModuleContext context,
- final Collection<? extends GroupingDefinition> groupings) {
- for (final GroupingDefinition grouping : GroupingDefinitionDependencySort.sort(groupings)) {
- // Converts individual grouping to GeneratedType. Firstly generated type builder is created and every child
- // node of grouping is resolved to the method.
- final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, grouping);
- narrowImplementedInterface(genType);
- annotateDeprecatedIfNecessary(grouping, genType);
- context.addGroupingType(grouping, genType);
- resolveDataSchemaNodes(context, genType, genType, grouping.getChildNodes(), true);
- groupingsToGenTypes(context, grouping.getGroupings());
- processUsesAugments(grouping, context, true);
- actionsToGenType(context, genType, grouping, null, true);
- notificationsToGenType(context, genType, grouping, null, true);
- }
- }
-
- /**
- * Adds enumeration builder created from <code>enumTypeDef</code> to <code>typeBuilder</code>. Each
- * <code>enumTypeDef</code> item is added to builder with its name and value.
- *
- * @param enumTypeDef EnumTypeDefinition contains enum data
- * @param enumName string contains name which will be assigned to enumeration builder
- * @param typeBuilder GeneratedTypeBuilder to which will be enum builder assigned
- * @param module Module in which type should be generated
- * @return enumeration builder which contains data from <code>enumTypeDef</code>
- */
- private Enumeration resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final QName enumName,
- final GeneratedTypeBuilder typeBuilder, final ModuleContext context) {
- final EnumBuilder enumBuilder = typeProvider.newEnumerationBuilder(typeBuilder.getIdentifier()
- .createEnclosed(BindingMapping.getClassName(enumName), "$"));
- typeProvider.addEnumDescription(enumBuilder, enumTypeDef);
- enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
- final Enumeration ret = enumBuilder.toInstance();
- typeBuilder.addEnumeration(ret);
-
- context.addTypeToSchema(ret, enumTypeDef);
- context.addInnerTypedefType(enumTypeDef.getPath(), ret);
- return ret;
- }
-
- /**
- * Generates type builder for <code>module</code>.
- *
- * @param module Module which is source of package name for generated type builder
- * @param postfix string which is added to the module class name representation as suffix
- * @return instance of GeneratedTypeBuilder which represents <code>module</code>.
- * @throws IllegalArgumentException if <code>module</code> is null
- */
- private GeneratedTypeBuilder moduleTypeBuilder(final ModuleContext context, final String postfix) {
- final Module module = context.module();
- final String moduleName = BindingMapping.getClassName(module.getName()) + postfix;
- final GeneratedTypeBuilder moduleBuilder = typeProvider.newGeneratedTypeBuilder(
- JavaTypeName.create(context.modulePackageName(), moduleName));
-
- moduleBuilder.setModuleName(moduleName);
- addCodegenInformation(moduleBuilder, module);
- return moduleBuilder;
- }
-
- /**
- * Converts <code>augSchema</code> to list of <code>Type</code> which contains generated type for augmentation.
- * In addition there are also generated types for all containers, list and choices which are child of
- * <code>augSchema</code> node or a generated types for cases are added if augmented node is choice.
- *
- * @param augmentPackageName string with the name of the package to which the augmentation belongs
- * @param augSchema AugmentationSchema which is contains data about augmentation (target path, childs...)
- * @param module current module
- * @throws IllegalArgumentException
- * <ul>
- * <li>if <code>augmentPackageName</code> equals null</li>
- * <li>if <code>augSchema</code> equals null</li>
- * </ul>
- * @throws IllegalStateException
- * if augment target path is null
- */
- private void augmentationToGenTypes(final ModuleContext context, final AugmentationSchemaNode augSchema) {
- checkArgument(augSchema != null, "Augmentation Schema cannot be NULL.");
- checkState(augSchema.getTargetPath() != null,
- "Augmentation Schema does not contain Target Path (Target Path is NULL).");
-
- processUsesAugments(augSchema, context, false);
- final SchemaNodeIdentifier targetPath = augSchema.getTargetPath();
- SchemaNode targetSchemaNode = null;
-
- // 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);
- }
- if (targetSchemaNode == null) {
- throw new IllegalStateException("Failed to find target node from grouping in augmentation " + augSchema
- + " in module " + context.module().getName());
- }
- }
- if (targetSchemaNode == null) {
- throw new IllegalArgumentException("augment target not found: " + targetPath);
- }
-
- if (targetSchemaNode instanceof ChoiceSchemaNode) {
- final GeneratedTypeBuilder builder = findChildNodeByPath(targetSchemaNode.getPath());
- checkState(builder != null, "Choice target type not generated for %s", targetSchemaNode);
- generateTypesFromAugmentedChoiceCases(context, builder.build(), (ChoiceSchemaNode) targetSchemaNode,
- augSchema.getChildNodes(), null, false);
- return;
- }
-
- final JavaTypeName targetName;
- if (targetSchemaNode instanceof CaseSchemaNode) {
- final GeneratedTypeBuilder builder = findCaseByPath(targetSchemaNode.getPath());
- checkState(builder != null, "Case target type not generated for %s", targetSchemaNode);
- targetName = builder.getIdentifier();
- } else {
- final GeneratedTypeBuilder builder = findChildNodeByPath(targetSchemaNode.getPath());
- if (builder == null) {
- targetName = findAliasByPath(targetSchemaNode.getPath());
- checkState(targetName != null, "Target type not yet generated: %s", targetSchemaNode);
- } else {
- targetName = builder.getIdentifier();
- }
- }
-
- addRawAugmentGenTypeDefinition(context, DefaultType.of(targetName), augSchema, false);
- }
-
- private void usesAugmentationToGenTypes(final ModuleContext context, final AugmentationSchemaNode augSchema,
- final UsesNode usesNode, final DataNodeContainer usesNodeParent, final boolean inGrouping) {
- checkArgument(augSchema != null, "Augmentation Schema cannot be NULL.");
- checkState(augSchema.getTargetPath() != null,
- "Augmentation Schema does not contain Target Path (Target Path is NULL).");
-
- processUsesAugments(augSchema, context, inGrouping);
- final SchemaNodeIdentifier targetPath = augSchema.getTargetPath();
- final SchemaNode targetSchemaNode = findOriginalTargetFromGrouping(targetPath, usesNode);
- if (targetSchemaNode == null) {
- throw new IllegalArgumentException("augment target not found: " + targetPath);
- }
-
- GeneratedTypeBuilder targetTypeBuilder = findChildNodeByPath(targetSchemaNode.getPath());
- if (targetTypeBuilder == null) {
- targetTypeBuilder = findCaseByPath(targetSchemaNode.getPath());
- }
- if (targetTypeBuilder == null) {
- throw new NullPointerException("Target type not yet generated: " + targetSchemaNode);
- }
-
- if (!(targetSchemaNode instanceof ChoiceSchemaNode)) {
- if (usesNodeParent instanceof SchemaNode) {
- addRawAugmentGenTypeDefinition(context,
- packageNameForAugmentedGeneratedType(context.modulePackageName(),
- ((SchemaNode) usesNodeParent).getPath()),
- targetTypeBuilder.build(), augSchema, inGrouping);
- } else {
- addRawAugmentGenTypeDefinition(context, targetTypeBuilder.build(), augSchema, inGrouping);
- }
- } else {
- generateTypesFromAugmentedChoiceCases(context, targetTypeBuilder.build(),
- (ChoiceSchemaNode) targetSchemaNode, augSchema.getChildNodes(), usesNodeParent, inGrouping);
- }
- }
-
- /**
- * Convenient method to find node added by uses statement.
- *
- * @param targetPath node path
- * @param parentUsesNode parent of uses node
- * @return node from its original location in grouping
- */
- private static DataSchemaNode findOriginalTargetFromGrouping(final SchemaNodeIdentifier targetPath,
- final UsesNode parentUsesNode) {
- SchemaNode result = parentUsesNode.getSourceGrouping();
- for (final QName node : targetPath.getNodeIdentifiers()) {
- // FIXME: this dispatch is rather ugly, we probably want to refactor it a bit
- if (result instanceof DataNodeContainer) {
- final QName resultNode = node.bindTo(result.getQName().getModule());
-
- SchemaNode found = ((DataNodeContainer) result).dataChildByName(resultNode);
- if (found == null) {
- if (result instanceof ActionNodeContainer) {
- found = ((ActionNodeContainer) result).findAction(resultNode).orElse(null);
- }
- if (found == null && result instanceof NotificationNodeContainer) {
- found = ((NotificationNodeContainer) result).findNotification(resultNode).orElse(null);
- }
- }
- result = found;
- } else if (result instanceof ChoiceSchemaNode) {
- result = findNamedCase((ChoiceSchemaNode) result, node.getLocalName());
- } else if (result instanceof ActionDefinition) {
- final ActionDefinition action = (ActionDefinition) result;
- final QName resultNode = node.bindTo(result.getQName().getModule());
-
- final InputSchemaNode input = action.getInput();
- final OutputSchemaNode output = action.getOutput();
- if (resultNode.equals(input.getQName())) {
- result = input;
- } else if (resultNode.equals(output.getQName())) {
- result = output;
- } else {
- result = null;
- }
- } else if (result != null) {
- throw new IllegalStateException("Cannot handle " + result);
- }
- }
- if (result == null) {
- return null;
- }
-
- if (result instanceof DerivableSchemaNode) {
- DerivableSchemaNode castedResult = (DerivableSchemaNode) result;
- Optional<? extends SchemaNode> originalNode = castedResult.getOriginal();
- if (castedResult.isAddedByUses() && originalNode.isPresent()) {
- result = originalNode.get();
- }
- }
-
- if (result instanceof DataSchemaNode) {
- DataSchemaNode resultDataSchemaNode = (DataSchemaNode) result;
- if (resultDataSchemaNode.isAddedByUses()) {
- // The original node is required, but we have only the copy of
- // the original node.
- // Maybe this indicates a bug in Yang parser.
- throw new IllegalStateException("Failed to generate code for augment in " + parentUsesNode);
- }
-
- return resultDataSchemaNode;
- }
-
- throw new IllegalStateException(
- "Target node of uses-augment statement must be DataSchemaNode. Failed to generate code for augment in "
- + parentUsesNode);
- }
-
- /**
- * Returns a generated type builder for an augmentation. The name of the type builder is equal to the name
- * of augmented node with serial number as suffix.
- *
- * @param context current module
- * @param augmentPackageName string with contains the package name to which the augment belongs
- * @param basePackageName string with the package name to which the augmented node belongs
- * @param targetTypeRef target type
- * @param augSchema augmentation schema which contains data about the child nodes and uses of augment
- * @return generated type builder for augment
- */
- private GeneratedTypeBuilder addRawAugmentGenTypeDefinition(final ModuleContext context,
- final String augmentPackageName, final Type targetTypeRef,
- final AugmentationSchemaNode augSchema, final boolean inGrouping) {
- Map<String, GeneratedTypeBuilder> augmentBuilders =
- genTypeBuilders.computeIfAbsent(augmentPackageName, k -> new HashMap<>());
- final String augIdentifier = getAugmentIdentifier(augSchema.getUnknownSchemaNodes());
-
- String augTypeName;
- if (augIdentifier != null) {
- augTypeName = BindingMapping.getClassName(augIdentifier);
- } else {
- augTypeName = augGenTypeName(augmentBuilders, targetTypeRef.getName());
- }
-
- final GeneratedTypeBuilder augTypeBuilder = typeProvider.newGeneratedTypeBuilder(
- JavaTypeName.create(augmentPackageName, augTypeName));
-
- augTypeBuilder.addImplementsType(augmentation(targetTypeRef));
- addConcreteInterfaceMethods(augTypeBuilder);
-
- annotateDeprecatedIfNecessary(augSchema, augTypeBuilder);
- addImplementedInterfaceFromUses(augSchema, augTypeBuilder);
-
- augSchemaNodeToMethods(context, augTypeBuilder, augSchema.getChildNodes(), inGrouping);
- actionsToGenType(context, augTypeBuilder, augSchema, null, inGrouping);
- notificationsToGenType(context, augTypeBuilder, augSchema, null, inGrouping);
-
- augmentBuilders.put(augTypeName, augTypeBuilder);
-
- if (!augSchema.getChildNodes().isEmpty()) {
- context.addTypeToAugmentation(augTypeBuilder, augSchema);
- }
-
- context.addAugmentType(augTypeBuilder);
- return augTypeBuilder;
- }
-
- private GeneratedTypeBuilder addRawAugmentGenTypeDefinition(final ModuleContext context, final Type targetTypeRef,
- final AugmentationSchemaNode augSchema, final boolean inGrouping) {
- return addRawAugmentGenTypeDefinition(context, context.modulePackageName(), targetTypeRef, augSchema,
- inGrouping);
- }
-
- private static String getAugmentIdentifier(final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- for (final UnknownSchemaNode unknownSchemaNode : unknownSchemaNodes) {
- final QName nodeType = unknownSchemaNode.getNodeType();
- if (AUGMENT_IDENTIFIER_NAME.equals(nodeType.getLocalName())
- && YANG_EXT_NAMESPACE.equals(nodeType.getNamespace().toString())) {
- return unknownSchemaNode.getNodeParameter();
- }
- }
- return null;
- }
-
- /**
- * Returns first unique name for the augment generated type builder. The generated type builder name for augment
- * consists from name of augmented node and serial number of its augmentation.
- *
- * @param builders map of builders which were created in the package to which the augmentation belongs
- * @param genTypeName string with name of augmented node
- * @return string with unique name for augmentation builder
- */
- private static String augGenTypeName(final Map<String, GeneratedTypeBuilder> builders, final String genTypeName) {
- int index = 1;
- if (builders != null) {
- while (builders.containsKey(genTypeName + index)) {
- index = index + 1;
- }
- }
- return genTypeName + index;
- }
-
- /**
- * Adds the methods to <code>typeBuilder</code> which represent subnodes of node for which <code>typeBuilder</code>
- * was created. The subnodes aren't mapped to the methods if they are part of grouping or augment (in this case are
- * already part of them).
- *
- * @param module current module
- * @param parent generated type builder which represents any node. The subnodes of this node are added
- * to the <code>typeBuilder</code> as methods. The subnode can be of type leaf, leaf-list, list,
- * container, choice.
- * @param childOf parent type
- * @param schemaNodes set of data schema nodes which are the children of the node for which
- * <code>typeBuilder</code> was created
- * @return generated type builder which is the same builder as input parameter. The getter methods (representing
- * child nodes) could be added to it.
- */
- private GeneratedTypeBuilder resolveDataSchemaNodes(final ModuleContext context, final GeneratedTypeBuilder parent,
- final @Nullable Type childOf, final Iterable<? extends DataSchemaNode> schemaNodes,
- final boolean inGrouping) {
- if (schemaNodes != null && parent != null) {
- final Type baseInterface = childOf == null ? DATA_OBJECT : childOf(childOf);
- for (final DataSchemaNode schemaNode : schemaNodes) {
- if (!schemaNode.isAugmenting()) {
- addSchemaNodeToBuilderAsMethod(context, schemaNode, parent, baseInterface, inGrouping);
- }
- }
- }
- return parent;
- }
-
- private void addSchemaNodeToBuilderAsMethod(final ModuleContext context, final DataSchemaNode schemaNode,
- final GeneratedTypeBuilder parent, final Type baseInterface, final boolean inGrouping) {
- if (!schemaNode.isAddedByUses()) {
- addUnambiguousNodeToBuilderAsMethod(context, schemaNode, parent, baseInterface, inGrouping);
- } else if (needGroupingMethodOverride(schemaNode, parent)) {
- addLeafrefNodeToBuilderAsMethod(context, (TypedDataSchemaNode) schemaNode, parent, inGrouping);
- }
- }
-
- /**
- * Determine whether a particular node, added from a grouping, needs to be reflected as a method. This method
- * performs a check for {@link TypedDataSchemaNode} and defers to
- * {@link #needGroupingMethodOverride(TypedDataSchemaNode, GeneratedTypeBuilder)}.
- *
- * @param parent {@code GeneratedType} where method should be defined
- * @param child node from which method should be defined
- * @return True if an override method is needed
- */
- private static boolean needGroupingMethodOverride(final DataSchemaNode child, final GeneratedTypeBuilder parent) {
- return child instanceof TypedDataSchemaNode && needGroupingMethodOverride((TypedDataSchemaNode) child, parent);
- }
-
- /**
- * Determine whether a particular {@link TypedDataSchemaNode}, added from a grouping, needs to be reflected as a
- * method.
- *
- * <p>
- * This check would be super easy were it not for relative leafrefs in groupings. These can legally point outside of
- * the grouping -- which means we cannot inherently cannot determine their type, as they are polymorphic.
- *
- * @param parent {@code GeneratedType} where method should be defined
- * @param child node from which method should be defined
- * @return True if an override method is needed
- */
- private static boolean needGroupingMethodOverride(final TypedDataSchemaNode child,
- final GeneratedTypeBuilder parent) {
- // This is a child added through uses and it is is data-bearing, i.e. leaf or leaf-list. Under normal
- // circumstances we would not bother, but if the target type is a leafref we have more checks to do.
- return isRelativeLeafref(child.getType()) && needMethodDefinition(child.getQName().getLocalName(), parent);
- }
-
- private static boolean needMethodDefinition(final String localName, final GeneratedTypeBuilder parent) {
- for (Type implementsType : parent.getImplementsTypes()) {
- if (implementsType instanceof GeneratedType) {
- final InheritedGetter precision = findInheritedGetter(localName, (GeneratedType) implementsType);
- switch (precision) {
- case RESOLVED:
- return false;
- case UNRESOLVED:
- return true;
- default:
- // No-op
- }
- }
- }
- throw new IllegalStateException(localName + " should be present in " + parent
- + " or in one of its ancestors as a getter");
- }
-
- private static InheritedGetter findInheritedGetter(final String localName, final GeneratedType impl) {
- return findInheritedGetter(impl, BindingMapping.getGetterMethodName(localName));
- }
-
- private static InheritedGetter findInheritedGetter(final GeneratedType type, final String getter) {
- for (MethodSignature method : type.getMethodDefinitions()) {
- if (getter.equals(method.getName())) {
- return InheritedGetter.fromAnnotations(method.getAnnotations());
- }
- }
-
- // Try to find the method in other interfaces we implement
- for (Type implementsType : type.getImplements()) {
- if (implementsType instanceof GeneratedType) {
- final InheritedGetter found = findInheritedGetter((GeneratedType) implementsType, getter);
- if (found != InheritedGetter.NOT_PRESENT) {
- return found;
- }
- }
- }
- return InheritedGetter.NOT_PRESENT;
- }
-
- private static boolean isRelativeLeafref(final TypeDefinition<? extends TypeDefinition<?>> type) {
- return type instanceof LeafrefTypeDefinition && !((LeafrefTypeDefinition) type).getPathStatement().isAbsolute();
- }
-
- /**
- * Adds the methods to <code>typeBuilder</code> what represents subnodes of node for which <code>typeBuilder</code>
- * was created.
- *
- * @param module current module
- * @param typeBuilder generated type builder which represents any node. The subnodes of this node are added
- * to the <code>typeBuilder</code> as methods. The subnode can be of type leaf, leaf-list, list,
- * container, choice.
- * @param childOf parent type
- * @param schemaNodes set of data schema nodes which are the children of the node for which <code>typeBuilder</code>
- * was created
- * @return generated type builder which is the same object as the input parameter <code>typeBuilder</code>.
- * The getter method could be added to it.
- */
- private GeneratedTypeBuilder augSchemaNodeToMethods(final ModuleContext context,
- final GeneratedTypeBuilder typeBuilder, final Iterable<? extends DataSchemaNode> schemaNodes,
- final boolean inGrouping) {
- if (schemaNodes != null && typeBuilder != null) {
- final Type baseInterface = childOf(typeBuilder);
- for (final DataSchemaNode schemaNode : schemaNodes) {
- if (!schemaNode.isAugmenting()) {
- addSchemaNodeToBuilderAsMethod(context, schemaNode, typeBuilder, baseInterface, inGrouping);
- }
- }
- }
- return typeBuilder;
- }
-
- /**
- * Adds to {@code typeBuilder} a method which is derived from {@code schemaNode}.
- *
- * @param node data schema node which is added to <code>typeBuilder</code> as a method
- * @param typeBuilder generated type builder to which is <code>schemaNode</code> added as a method.
- * @param childOf parent type
- * @param module current module
- */
- private void addLeafrefNodeToBuilderAsMethod(final ModuleContext context, final TypedDataSchemaNode node,
- final GeneratedTypeBuilder typeBuilder, final boolean inGrouping) {
- if (node != null && typeBuilder != null) {
- if (node instanceof LeafSchemaNode) {
- resolveLeafLeafrefNodeAsMethod(typeBuilder, (LeafSchemaNode) node, context, inGrouping);
- } else if (node instanceof LeafListSchemaNode) {
- resolveLeafListLeafrefNode(typeBuilder, (LeafListSchemaNode) node, context, inGrouping);
- } else {
- logUnableToAddNodeAsMethod(node, typeBuilder);
- }
- }
- }
-
- private void addUnambiguousNodeToBuilderAsMethod(final ModuleContext context, final DataSchemaNode node,
- final GeneratedTypeBuilder typeBuilder, final Type baseInterface, final boolean inGrouping) {
- if (node instanceof LeafSchemaNode) {
- resolveUnambiguousLeafNodeAsMethod(typeBuilder, (LeafSchemaNode) node, context, inGrouping);
- } else if (node instanceof LeafListSchemaNode) {
- resolveUnambiguousLeafListNode(typeBuilder, (LeafListSchemaNode) node, context, inGrouping);
- } else if (node instanceof ContainerSchemaNode) {
- containerToGenType(context, typeBuilder, baseInterface, (ContainerSchemaNode) node, inGrouping);
- } else if (node instanceof ListSchemaNode) {
- listToGenType(context, typeBuilder, baseInterface, (ListSchemaNode) node, inGrouping);
- } else if (node instanceof ChoiceSchemaNode) {
- choiceToGeneratedType(context, typeBuilder, (ChoiceSchemaNode) node, inGrouping);
- } else if (node instanceof AnyxmlSchemaNode || node instanceof AnydataSchemaNode) {
- opaqueToGeneratedType(context, typeBuilder, node);
- } else {
- logUnableToAddNodeAsMethod(node, typeBuilder);
- }
- }
-
- private static void logUnableToAddNodeAsMethod(final DataSchemaNode node, final GeneratedTypeBuilder typeBuilder) {
- LOG.debug("Unable to add schema node {} as method in {}: unsupported type of node.", node.getClass(),
- typeBuilder.getFullyQualifiedName());
- }
-
- /**
- * Converts <code>choiceNode</code> to the list of generated types for choice and its cases. The package names
- * for choice and for its cases are created as concatenation of the module package (<code>basePackageName</code>)
- * and names of all parents node.
- *
- * @param context current module
- * @param basePackageName string with the module package name
- * @param parent parent type
- * @param choiceNode choice node which is mapped to generated type. Also child nodes - cases are mapped to generated
- * types.
- * @throws IllegalArgumentException
- * <ul>
- * <li>if <code>basePackageName</code> is null</li>
- * <li>if <code>choiceNode</code> is null</li>
- * </ul>
- */
- private void choiceToGeneratedType(final ModuleContext context, final GeneratedTypeBuilder parent,
- final ChoiceSchemaNode choiceNode, final boolean inGrouping) {
- if (!choiceNode.isAddedByUses()) {
- final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(context,
- JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), choiceNode.getPath()),
- BindingMapping.getClassName(choiceNode.getQName())), choiceNode);
- choiceTypeBuilder.addImplementsType(choiceIn(parent));
- annotateDeprecatedIfNecessary(choiceNode, choiceTypeBuilder);
- context.addChildNodeType(choiceNode, choiceTypeBuilder);
-
- final GeneratedType choiceType = choiceTypeBuilder.build();
- generateTypesFromChoiceCases(context, choiceType, choiceNode, inGrouping);
-
- constructGetter(parent, choiceType, choiceNode);
- }
- }
-
- private void opaqueToGeneratedType(final ModuleContext context, final GeneratedTypeBuilder parent,
- final DataSchemaNode anyNode) {
- if (!anyNode.isAddedByUses()) {
- final GeneratedTypeBuilder anyxmlTypeBuilder = addRawInterfaceDefinition(context,
- JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), anyNode.getPath()),
- BindingMapping.getClassName(anyNode.getQName())), anyNode);
- anyxmlTypeBuilder.addImplementsType(opaqueObject(anyxmlTypeBuilder)).addImplementsType(childOf(parent));
- defaultImplementedInterace(anyxmlTypeBuilder);
- annotateDeprecatedIfNecessary(anyNode, anyxmlTypeBuilder);
- context.addChildNodeType(anyNode, anyxmlTypeBuilder);
-
- constructGetter(parent, anyxmlTypeBuilder.build(), anyNode);
- }
- }
-
- /**
- * Converts <code>caseNodes</code> set to list of corresponding generated types. For every <i>case</i> which is not
- * added through augment or <i>uses</i> is created generated type builder. The package names for the builder is
- * created as concatenation of the module package and names of all parents nodes of the concrete <i>case</i>. There
- * is also relation "<i>implements type</i>" between every case builder and <i>choice</i> type
- *
- * @param context current module context
- * @param refChoiceType type which represents superior <i>case</i>
- * @param choiceNode choice case node which is mapped to generated type
- * @throws IllegalArgumentException
- * <ul>
- * <li>if <code>refChoiceType</code> equals null</li>
- * <li>if <code>caseNodes</code> equals null</li>
- * </ul>
- */
- private void generateTypesFromChoiceCases(final ModuleContext context, final Type refChoiceType,
- final ChoiceSchemaNode choiceNode, final boolean inGrouping) {
- checkArgument(refChoiceType != null, "Referenced Choice Type cannot be NULL.");
- checkArgument(choiceNode != null, "ChoiceNode cannot be NULL.");
-
- for (final CaseSchemaNode caseNode : choiceNode.getCases()) {
- if (caseNode != null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {
- final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode);
- caseTypeBuilder.addImplementsType(refChoiceType);
- addConcreteInterfaceMethods(caseTypeBuilder);
- annotateDeprecatedIfNecessary(caseNode, caseTypeBuilder);
- context.addCaseType(caseNode.getPath(), caseTypeBuilder);
- context.addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
- final Iterable<? extends DataSchemaNode> caseChildNodes = caseNode.getChildNodes();
- if (caseChildNodes != null) {
- final SchemaPath choiceNodeParentPath = choiceNode.getPath().getParent();
-
- if (!Iterables.isEmpty(choiceNodeParentPath.getPathFromRoot())) {
- SchemaNode parent = findDataSchemaNode(schemaContext, choiceNodeParentPath);
-
- if (parent instanceof AugmentationSchemaNode) {
- final AugmentationSchemaNode augSchema = (AugmentationSchemaNode) parent;
- 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) {
- targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal()
- .orElse(null);
- }
- if (targetSchemaNode == null) {
- throw new IllegalStateException(
- "Failed to find target node from grouping for augmentation " + augSchema
- + " in module " + context.module().getName());
- }
- }
- parent = targetSchemaNode;
- }
-
- checkState(parent != null, "Could not find Choice node parent %s", choiceNodeParentPath);
- Type childOfType = findChildNodeByPath(parent.getPath());
- if (childOfType == null) {
- childOfType = findGroupingByPath(parent.getPath());
- }
- resolveDataSchemaNodes(context, caseTypeBuilder, childOfType, caseChildNodes, inGrouping);
- } else {
- resolveDataSchemaNodes(context, caseTypeBuilder, moduleToDataType(context), caseChildNodes,
- inGrouping);
- }
- }
- }
- processUsesAugments(caseNode, context, inGrouping);
- }
- }
-
- /**
- * Generates list of generated types for all the cases of a choice which are added to the choice through
- * the augment.
- *
- * @param module current module
- * @param basePackageName string contains name of package to which augment belongs. If an augmented choice is
- * from an other package (pcg1) than an augmenting choice (pcg2) then case's
- * of the augmenting choice will belong to pcg2.
- * @param targetType Type which represents target choice
- * @param targetNode node which represents target choice
- * @param augmentedNodes set of choice case nodes for which is checked if are/are not added to choice through
- * augmentation
- * @throws IllegalArgumentException
- * <ul>
- * <li>if <code>basePackageName</code> is null</li>
- * <li>if <code>targetType</code> is null</li>
- * <li>if <code>augmentedNodes</code> is null</li>
- * </ul>
- */
- // FIXME: nullness rules need to untangled in this method
- @SuppressFBWarnings("NP_NULL_ON_SOME_PATH")
- private void generateTypesFromAugmentedChoiceCases(final ModuleContext context,
- final Type targetType, final ChoiceSchemaNode targetNode,
- final Iterable<? extends DataSchemaNode> augmentedNodes,
- final DataNodeContainer usesNodeParent, final boolean inGrouping) {
- checkArgument(targetType != null, "Referenced Choice Type cannot be NULL.");
- checkArgument(augmentedNodes != null, "Set of Choice Case Nodes cannot be NULL.");
-
- for (final DataSchemaNode caseNode : augmentedNodes) {
- if (caseNode != null) {
- final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode);
- caseTypeBuilder.addImplementsType(targetType);
- addConcreteInterfaceMethods(caseTypeBuilder);
-
- CaseSchemaNode node = null;
- final String caseLocalName = caseNode.getQName().getLocalName();
- if (caseNode instanceof CaseSchemaNode) {
- node = (CaseSchemaNode) caseNode;
- } else if (findNamedCase(targetNode, caseLocalName) == null) {
- final String targetNodeLocalName = targetNode.getQName().getLocalName();
- for (DataSchemaNode dataSchemaNode : usesNodeParent.getChildNodes()) {
- if (dataSchemaNode instanceof ChoiceSchemaNode
- && targetNodeLocalName.equals(dataSchemaNode.getQName().getLocalName())) {
- node = findNamedCase((ChoiceSchemaNode) dataSchemaNode, caseLocalName);
- break;
- }
- }
- } else {
- node = findNamedCase(targetNode, caseLocalName);
- }
- final Iterable<? extends DataSchemaNode> childNodes = node.getChildNodes();
- if (childNodes != null) {
- resolveDataSchemaNodes(context, caseTypeBuilder, findChildOfType(targetNode), childNodes,
- inGrouping);
- }
- context.addCaseType(caseNode.getPath(), caseTypeBuilder);
- context.addChoiceToCaseMapping(targetType, caseTypeBuilder, node);
- }
- }
- }
-
- private GeneratedTypeBuilder findChildOfType(final ChoiceSchemaNode targetNode) {
- final SchemaPath nodePath = targetNode.getPath();
- final SchemaPath parentSp = nodePath.getParent();
- if (parentSp.getParent() == null) {
- return moduleContext(nodePath.getLastComponent().getModule()).getModuleNode();
- }
-
- final SchemaNode parent = findDataSchemaNode(schemaContext, parentSp);
- GeneratedTypeBuilder childOfType = null;
- if (parent instanceof CaseSchemaNode) {
- childOfType = findCaseByPath(parent.getPath());
- } else if (parent instanceof DataSchemaNode || parent instanceof NotificationDefinition) {
- childOfType = findChildNodeByPath(parent.getPath());
- } else if (parent instanceof GroupingDefinition) {
- childOfType = findGroupingByPath(parent.getPath());
- }
-
- if (childOfType == null) {
- throw new IllegalArgumentException("Failed to find parent type of choice " + targetNode);
- }
-
- return childOfType;
- }
-
- private static CaseSchemaNode findNamedCase(final ChoiceSchemaNode choice, final String caseName) {
- final List<? extends CaseSchemaNode> cases = choice.findCaseNodes(caseName);
- return cases.isEmpty() ? null : cases.get(0);
- }
-
- private static boolean isInnerType(final LeafSchemaNode leaf, final TypeDefinition<?> type) {
- // New parser with encapsulated type
- if (leaf.getPath().equals(type.getPath())) {
- return true;
- }
-
- // Embedded type definition with new parser. Also takes care of the old parser with bits
- if (leaf.getPath().equals(type.getPath().getParent())) {
- return true;
- }
-
- return false;
- }
-
- private void addPatternConstant(final GeneratedTypeBuilder typeBuilder, final String leafName,
- final List<PatternConstraint> patternConstraints) {
- if (!patternConstraints.isEmpty()) {
- final StringBuilder field = new StringBuilder().append(TypeConstants.PATTERN_CONSTANT_NAME).append("_")
- .append(BindingMapping.getPropertyName(leafName));
- typeBuilder.addConstant(LIST_STRING_TYPE, field.toString(),
- typeProvider.resolveRegExpressions(patternConstraints));
- }
- }
-
- private Type resolveLeafLeafrefNodeAsMethod(final GeneratedTypeBuilder typeBuilder, final LeafSchemaNode leaf,
- final ModuleContext context, final boolean inGrouping) {
- final Module parentModule = findParentModule(schemaContext, leaf);
- final Type returnType = resolveReturnType(typeBuilder, leaf, context, parentModule, inGrouping);
- if (returnType != null && isTypeSpecified(returnType)) {
- processContextRefExtension(leaf, constructOverrideGetter(typeBuilder, returnType, leaf), parentModule);
- }
- return returnType;
- }
-
- /**
- * Converts {@code leafList} to the getter method which is added to {@code typeBuilder}.
- *
- * @param context module in which type was defined
- * @param typeBuilder generated type builder to which is added getter method as {@code leafList} mapping
- * @param leafList leaf-list schema node which is mapped as getter method which is added to {@code typeBuilder}
- */
- private void resolveLeafListNodeAsMethod(final GeneratedTypeBuilder typeBuilder, final LeafListSchemaNode leafList,
- final ModuleContext context, final boolean inGrouping) {
- if (!leafList.isAddedByUses()) {
- resolveUnambiguousLeafListNode(typeBuilder, leafList, context, inGrouping);
- } else if (needGroupingMethodOverride(leafList, typeBuilder)) {
- resolveLeafListLeafrefNode(typeBuilder, leafList, context, inGrouping);
- }
- }
-
- private Type resolveUnambiguousLeafNodeAsMethod(final GeneratedTypeBuilder typeBuilder, final LeafSchemaNode leaf,
- final ModuleContext context, final boolean inGrouping) {
- final Module parentModule = findParentModule(schemaContext, leaf);
- final Type returnType = resolveReturnType(typeBuilder, leaf, context, parentModule, inGrouping);
- if (returnType != null) {
- processContextRefExtension(leaf, constructGetter(typeBuilder, returnType, leaf), parentModule);
- }
- return returnType;
- }
-
- private Type resolveReturnType(final GeneratedTypeBuilder typeBuilder, final LeafSchemaNode leaf,
- final ModuleContext context, final Module parentModule, final boolean inGrouping) {
- Type returnType = null;
-
- final TypeDefinition<?> typeDef = CompatUtils.compatType(leaf);
- if (isInnerType(leaf, typeDef)) {
- if (typeDef instanceof EnumTypeDefinition) {
- final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
- returnType = resolveInnerEnumFromTypeDefinition(enumTypeDef, leaf.getQName(), typeBuilder, context);
- typeProvider.putReferencedType(leaf.getPath(), returnType);
- } else if (typeDef instanceof UnionTypeDefinition) {
- final UnionTypeDefinition unionDef = (UnionTypeDefinition)typeDef;
- returnType = addTOToTypeBuilder(unionDef, typeBuilder, leaf, parentModule);
- // Store the inner type within the union so that we can find the reference for it
- context.addInnerTypedefType(typeDef.getPath(), returnType);
- } else if (typeDef instanceof BitsTypeDefinition) {
- returnType = addTOToTypeBuilder((BitsTypeDefinition) typeDef, typeBuilder, leaf, parentModule);
- } else {
- // It is constrained version of already declared type (inner declared type exists, only for special
- // cases (Enum, Union, Bits), which were already checked.
- // In order to get proper class we need to look up closest derived type and apply restrictions from leaf
- // type
- final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
- final TypeDefinition<?> baseOrDeclaredType = getBaseOrDeclaredType(typeDef);
- // we need to try to lookup an already generated type in case the leafref is targetting a generated type
- if (baseOrDeclaredType instanceof LeafrefTypeDefinition) {
- final SchemaNode leafrefTarget =
- typeProvider.getTargetForLeafref((LeafrefTypeDefinition) baseOrDeclaredType, leaf);
- if (leafrefTarget instanceof TypedDataSchemaNode) {
- returnType = context.getInnerType(((TypedDataSchemaNode) leafrefTarget).getType().getPath());
- }
- }
- if (returnType == null) {
- returnType = typeProvider.javaTypeForSchemaDefinitionType(baseOrDeclaredType, leaf,
- restrictions, inGrouping);
- }
-
- addPatternConstant(typeBuilder, leaf.getQName().getLocalName(), restrictions.getPatternConstraints());
- }
- } else {
- final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
- returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions, inGrouping);
- addPatternConstant(typeBuilder, leaf.getQName().getLocalName(), restrictions.getPatternConstraints());
- }
-
- if (returnType == null) {
- return null;
- }
-
- if (typeDef instanceof EnumTypeDefinition) {
- typeProvider.putReferencedType(leaf.getPath(), returnType);
- }
-
- return returnType;
- }
-
- private static boolean isTypeSpecified(final Type type) {
- return !type.equals(objectType());
- }
-
- private static TypeDefinition<?> getBaseOrDeclaredType(final TypeDefinition<?> typeDef) {
- // Returns DerivedType in case of new parser.
- final TypeDefinition<?> baseType = typeDef.getBaseType();
- return baseType != null && baseType.getBaseType() != null ? baseType : typeDef;
- }
-
- private void processContextRefExtension(final LeafSchemaNode leaf, final MethodSignatureBuilder getter,
- final Module module) {
- for (final UnknownSchemaNode node : leaf.getUnknownSchemaNodes()) {
- final QName nodeType = node.getNodeType();
- if ("context-reference".equals(nodeType.getLocalName())) {
- final String nodeParam = node.getNodeParameter();
- IdentitySchemaNode identity = null;
- String basePackageName = null;
- final Iterable<String> splittedElement = COLON_SPLITTER.split(nodeParam);
- final Iterator<String> iterator = splittedElement.iterator();
- final int length = Iterables.size(splittedElement);
- if (length == 1) {
- identity = findIdentityByName(module.getIdentities(), iterator.next());
- basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
- } else if (length == 2) {
- final String prefix = iterator.next();
- final Module dependentModule = findModuleFromImports(module.getImports(), prefix);
- if (dependentModule == null) {
- throw new IllegalArgumentException("Failed to process context-reference: unknown prefix "
- + prefix);
- }
- identity = findIdentityByName(dependentModule.getIdentities(), iterator.next());
- basePackageName = BindingMapping.getRootPackageName(dependentModule.getQNameModule());
- } else {
- throw new IllegalArgumentException("Failed to process context-reference: unknown identity "
- + nodeParam);
- }
- if (identity == null) {
- throw new IllegalArgumentException("Failed to process context-reference: unknown identity "
- + nodeParam);
- }
-
- final AnnotationTypeBuilder rc = getter.addAnnotation(ROUTING_CONTEXT);
- final String packageName = packageNameForGeneratedType(basePackageName, identity.getPath());
- final String genTypeName = BindingMapping.getClassName(identity.getQName().getLocalName());
- rc.addParameter("value", packageName + "." + genTypeName + ".class");
- }
- }
- }
-
- private static IdentitySchemaNode findIdentityByName(final Collection<? extends IdentitySchemaNode> identities,
- final String name) {
- for (final IdentitySchemaNode id : identities) {
- if (id.getQName().getLocalName().equals(name)) {
- return id;
- }
- }
- return null;
- }
-
- private Module findModuleFromImports(final Collection<? extends ModuleImport> imports, final String prefix) {
- for (final ModuleImport imp : imports) {
- if (imp.getPrefix().equals(prefix)) {
- return schemaContext.findModule(imp.getModuleName(), imp.getRevision()).orElse(null);
- }
- }
- return null;
- }
-
- private boolean resolveLeafSchemaNodeAsProperty(final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
- final boolean isReadOnly) {
- if (leaf != null && toBuilder != null) {
- Type returnType;
- final TypeDefinition<?> typeDef = CompatUtils.compatType(leaf);
- if (typeDef instanceof UnionTypeDefinition) {
- // GeneratedType for this type definition should have be already created
- final ModuleContext mc = moduleContext(typeDef.getQName().getModule());
- returnType = mc.getTypedefs().get(typeDef.getPath());
- if (returnType == null) {
- // This may still be an inner type, try to find it
- returnType = mc.getInnerType(typeDef.getPath());
- }
- } else if (typeDef instanceof EnumTypeDefinition && typeDef.getBaseType() == null) {
- // Annonymous enumeration (already generated, since it is inherited via uses).
- LeafSchemaNode originalLeaf = (LeafSchemaNode) SchemaNodeUtils.getRootOriginalIfPossible(leaf);
- QName qname = originalLeaf.getQName();
- returnType = moduleContext(qname.getModule()).getInnerType(originalLeaf.getType().getPath());
- } else {
- returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);
- }
- return resolveLeafSchemaNodeAsProperty(toBuilder, leaf, returnType, isReadOnly);
- }
- return false;
- }
-
- /**
- * Converts <code>leaf</code> schema node to property of generated TO builder.
- *
- * @param toBuilder generated TO builder to which is <code>leaf</code> added as property
- * @param leaf leaf schema node which is added to <code>toBuilder</code> as property
- * @param returnType property type
- * @param isReadOnly boolean value which says if leaf property is|isn't read only
- * @return boolean value
- * <ul>
- * <li>false - if <code>leaf</code>, <code>toBuilder</code> or leaf
- * name equals null or if leaf is added by <i>uses</i>.</li>
- * <li>true - other cases</li>
- * </ul>
- */
- private boolean resolveLeafSchemaNodeAsProperty(final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
- final Type returnType, final boolean isReadOnly) {
- if (returnType == null) {
- return false;
- }
- final String leafName = leaf.getQName().getLocalName();
- final GeneratedPropertyBuilder propBuilder = toBuilder.addProperty(BindingMapping.getPropertyName(leafName));
- propBuilder.setReadOnly(isReadOnly);
- propBuilder.setReturnType(returnType);
- addComment(propBuilder, leaf);
-
- toBuilder.addEqualsIdentity(propBuilder);
- toBuilder.addHashIdentity(propBuilder);
- toBuilder.addToStringProperty(propBuilder);
- return true;
- }
-
- private void resolveLeafListLeafrefNode(final GeneratedTypeBuilder typeBuilder, final LeafListSchemaNode node,
- final ModuleContext context, final boolean inGrouping) {
- final Type returnType = resolveLeafListItemsType(typeBuilder, node, context, inGrouping,
- findParentModule(schemaContext, node));
- if (isTypeSpecified(returnType)) {
- constructOverrideGetter(typeBuilder, listTypeFor(returnType), node);
- }
- }
-
- /**
- * Converts <code>node</code> leaf list schema node to getter method of <code>typeBuilder</code>.
- *
- * @param context module
- * @param typeBuilder generated type builder to which is <code>node</code> added as getter method
- * @param node leaf list schema node which is added to <code>typeBuilder</code> as getter method
- */
- private Type resolveUnambiguousLeafListNode(final GeneratedTypeBuilder typeBuilder, final LeafListSchemaNode node,
- final ModuleContext context, final boolean inGrouping) {
- final Module parentModule = findParentModule(schemaContext, node);
- final Type listItemsType = resolveLeafListItemsType(typeBuilder, node, context, inGrouping, parentModule);
- final Type returnType;
- if (listItemsType.equals(objectType())) {
- returnType = listTypeWildcard();
- } else {
- returnType = listTypeFor(listItemsType);
- }
-
- constructGetter(typeBuilder, returnType, node);
-
- return returnType;
- }
-
- private Type resolveLeafListItemsType(final GeneratedTypeBuilder typeBuilder, final LeafListSchemaNode node,
- final ModuleContext context, final boolean inGrouping, final Module parentModule) {
- final Type returnType;
- final TypeDefinition<? extends TypeDefinition<?>> typeDef = node.getType();
- if (typeDef.getBaseType() == null) {
- if (typeDef instanceof EnumTypeDefinition) {
- final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
- returnType = resolveInnerEnumFromTypeDefinition(enumTypeDef, node.getQName(), typeBuilder, context);
- typeProvider.putReferencedType(node.getPath(), returnType);
- } else if (typeDef instanceof UnionTypeDefinition) {
- final UnionTypeDefinition unionDef = (UnionTypeDefinition) typeDef;
- returnType = addTOToTypeBuilder(unionDef, typeBuilder, node, parentModule);
- } else if (typeDef instanceof BitsTypeDefinition) {
- returnType = addTOToTypeBuilder((BitsTypeDefinition) typeDef, typeBuilder, node, parentModule);
- } else {
- final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
- returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions, inGrouping);
- addPatternConstant(typeBuilder, node.getQName().getLocalName(), restrictions.getPatternConstraints());
- }
- } else {
- final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
- returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions, inGrouping);
- addPatternConstant(typeBuilder, node.getQName().getLocalName(), restrictions.getPatternConstraints());
- }
- return returnType;
- }
-
- private Type createReturnTypeForUnion(final GeneratedTOBuilder genTOBuilder, final UnionTypeDefinition typeDef,
- final GeneratedTypeBuilder typeBuilder, final Module parentModule) {
- final GeneratedTOBuilder returnTypeBuilder = typeProvider.newGeneratedTOBuilder(genTOBuilder.getIdentifier());
- returnTypeBuilder.setIsUnion(true);
- addCodegenInformation(returnTypeBuilder, parentModule, typeDef);
- returnTypeBuilder.setSchemaPath(typeDef.getPath());
- returnTypeBuilder.setModuleName(parentModule.getName());
- final GeneratedTransferObject returnType = returnTypeBuilder.build();
-
- genTOBuilder.setTypedef(true);
- genTOBuilder.setIsUnion(true);
- AbstractTypeProvider.addUnitsToGenTO(genTOBuilder, typeDef.getUnits().orElse(null));
-
- createUnionBuilder(genTOBuilder, typeBuilder, returnType, parentModule);
- return returnType;
- }
-
- private void createUnionBuilder(final GeneratedTOBuilder genTOBuilder, final GeneratedTypeBuilder typeBuilder,
- final GeneratedTransferObject returnType, final Module parentModule) {
- // Append enclosing path hierarchy without dots
- final StringBuilder sb = new StringBuilder();
- genTOBuilder.getIdentifier().localNameComponents().forEach(sb::append);
- final GeneratedTOBuilder unionBuilder = typeProvider.newGeneratedTOBuilder(
- JavaTypeName.create(typeBuilder.getPackageName(), sb.append("Builder").toString()));
- unionBuilder.setIsUnionBuilder(true);
-
- final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
- method.setReturnType(returnType);
- method.addParameter(STRING, "defaultValue");
- method.setAccessModifier(AccessModifier.PUBLIC);
- method.setStatic(true);
-
- final GeneratedTransferObject unionBuilderType = unionBuilder.build();
- typeProvider.getAdditionalTypes().computeIfAbsent(parentModule, key -> new HashSet<>()).add(unionBuilderType);
- }
-
- private GeneratedTypeBuilder addDefaultInterfaceDefinition(final ModuleContext context,
- final SchemaNode schemaNode) {
- return addDefaultInterfaceDefinition(context, schemaNode, DATA_OBJECT);
- }
-
- private GeneratedTypeBuilder addDefaultInterfaceDefinition(final ModuleContext context,
- final SchemaNode schemaNode, final Type baseInterface) {
- final String packageName = packageNameForGeneratedType(context.modulePackageName(), schemaNode.getPath());
- return addDefaultInterfaceDefinition(packageName, schemaNode, baseInterface, context);
- }
-
- /**
- * Instantiates generated type builder with <code>packageName</code> and <code>schemaNode</code>. The new builder
- * always implements {@link org.opendaylight.yangtools.yang.binding.DataObject DataObject}.<br>
- * If <code>schemaNode</code> is instance of GroupingDefinition it also implements
- * {@link org.opendaylight.yangtools.yang.binding.Augmentable Augmentable}.<br>
- * If <code>schemaNode</code> is instance of
- * {@link org.opendaylight.yangtools.yang.model.api.DataNodeContainer DataNodeContainer} it can also implement nodes
- * which are specified in <i>uses</i>.
- *
- * @param packageName string with the name of the package to which <code>schemaNode</code> belongs.
- * @param schemaNode schema node for which is created generated type builder
- * @param parent parent type (can be null)
- * @return generated type builder <code>schemaNode</code>
- */
- private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
- final Type baseInterface, final ModuleContext context) {
- JavaTypeName name = renames.get(schemaNode);
- if (name == null) {
- name = JavaTypeName.create(packageName, BindingMapping.getClassName(schemaNode.getQName()));
- }
-
- final GeneratedTypeBuilder it = addRawInterfaceDefinition(context, name, schemaNode);
- it.addImplementsType(baseInterface);
- if (!(schemaNode instanceof GroupingDefinition)) {
- it.addImplementsType(augmentable(it));
- }
- if (schemaNode instanceof DataNodeContainer) {
- final DataNodeContainer containerSchema = (DataNodeContainer) schemaNode;
- groupingsToGenTypes(context, containerSchema.getGroupings());
- addImplementedInterfaceFromUses(containerSchema, it);
- }
-
- return it;
- }
-
- /**
- * Returns reference to generated type builder for specified <code>schemaNode</code> with <code>packageName</code>.
- * Firstly the generated type builder is searched in {@link BindingGeneratorImpl#genTypeBuilders genTypeBuilders}.
- * If it is not found it is created and added to <code>genTypeBuilders</code>.
- *
- * @param packageName string with the package name to which returning generated type builder belongs
- * @param schemaNode schema node which provide data about the schema node name
- * @param prefix return type name prefix
- * @return generated type builder for <code>schemaNode</code>
- * @throws IllegalArgumentException
- * <ul>
- * <li>if <code>schemaNode</code> is null</li>
- * <li>if <code>packageName</code> is null</li>
- * <li>if QName of schema node is null</li>
- * <li>if schemaNode name is null</li>
- * </ul>
- */
- private GeneratedTypeBuilder addRawInterfaceDefinition(final ModuleContext context, final JavaTypeName identifier,
- final SchemaNode schemaNode) {
- checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
- checkArgument(schemaNode.getQName() != null, "QName for Data Schema Node cannot be NULL.");
- final String schemaNodeName = schemaNode.getQName().getLocalName();
- checkArgument(schemaNodeName != null, "Local Name of QName for Data Schema Node cannot be NULL.");
-
- // FIXME: Validation of name conflict
- final GeneratedTypeBuilder newType = typeProvider.newGeneratedTypeBuilder(identifier);
- qnameConstant(newType, context.moduleInfoType(), schemaNode.getQName().getLocalName());
-
- final Module module = context.module();
- addCodegenInformation(newType, module, schemaNode);
- newType.setSchemaPath(schemaNode.getPath());
- newType.setModuleName(module.getName());
-
- final String packageName = identifier.packageName();
- final String simpleName = identifier.simpleName();
- if (!genTypeBuilders.containsKey(packageName)) {
- final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
- builders.put(simpleName, newType);
- genTypeBuilders.put(packageName, builders);
- } else {
- final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);
- if (!builders.containsKey(simpleName)) {
- builders.put(simpleName, newType);
- }
- }
- return newType;
- }
-
- /**
- * Created a method signature builder as part of <code>interfaceBuilder</code>. The method signature builder is
- * created for the getter method of <code>schemaNodeName</code>. Also <code>comment</code>
- * and <code>returnType</code> information are added to the builder.
- *
- * @param interfaceBuilder generated type builder for which the getter method should be created
- * @param returnType type which represents the return type of the getter method
- * @param schemaNodeName string with schema node name. The name will be the part of the getter method name.
- * @param comment string with comment for the getter method
- * @param status status from yang file, for deprecated annotation
- * @return method signature builder which represents the getter method of <code>interfaceBuilder</code>
- */
- private MethodSignatureBuilder constructGetter(final GeneratedTypeBuilder interfaceBuilder, final Type returnType,
- final SchemaNode node) {
- final MethodSignatureBuilder getMethod = interfaceBuilder.addMethod(
- BindingMapping.getGetterMethodName(node.getQName().getLocalName()));
- getMethod.setReturnType(returnType);
-
- annotateDeprecatedIfNecessary(node, getMethod);
- addComment(getMethod, node);
-
- return getMethod;
- }
-
- private MethodSignatureBuilder constructOverrideGetter(final GeneratedTypeBuilder interfaceBuilder,
- final Type returnType, final SchemaNode node) {
- final MethodSignatureBuilder getter = constructGetter(interfaceBuilder, returnType, node);
- getter.addAnnotation(OVERRIDE_ANNOTATION);
- return getter;
- }
-
- private static void constructNonnull(final GeneratedTypeBuilder interfaceBuilder, final Type returnType,
- final ListSchemaNode node) {
- final MethodSignatureBuilder getMethod = interfaceBuilder.addMethod(
- BindingMapping.getNonnullMethodName(node.getQName().getLocalName()));
- getMethod.setReturnType(returnType).setDefault(true);
- annotateDeprecatedIfNecessary(node, getMethod);
- }
-
- /**
- * Adds <code>schemaNode</code> to <code>typeBuilder</code> as getter method or to <code>genTOBuilder</code>
- * as a property.
- *
- * @param basePackageName string contains the module package name
- * @param schemaNode data schema node which should be added as getter method to <code>typeBuilder</code>
- * or as a property to <code>genTOBuilder</code> if is part of the list key
- * @param typeBuilder generated type builder for the list schema node
- * @param genTOBuilder generated TO builder for the list keys
- * @param listKeys list of string which contains names of the list keys
- * @param module current module
- * @throws IllegalArgumentException
- * <ul>
- * <li>if <code>schemaNode</code> equals null</li>
- * <li>if <code>typeBuilder</code> equals null</li>
- * </ul>
- */
- private void addSchemaNodeToListBuilders(final ModuleContext context, final DataSchemaNode schemaNode,
- final GeneratedTypeBuilder typeBuilder, final GeneratedTOBuilder genTOBuilder,
- final List<String> listKeys, final boolean inGrouping) {
- checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
- checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
-
- if (schemaNode instanceof LeafSchemaNode) {
- final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode;
- final String leafName = leaf.getQName().getLocalName();
- final Type type;
- if (!schemaNode.isAddedByUses()) {
- type = resolveUnambiguousLeafNodeAsMethod(typeBuilder, leaf, context, inGrouping);
- } else if (needGroupingMethodOverride(leaf, typeBuilder)) {
- type = resolveLeafLeafrefNodeAsMethod(typeBuilder, leaf, context, inGrouping);
- } else {
- type = null;
- }
-
- if (listKeys.contains(leafName)) {
- if (type == null) {
- resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true);
- } else {
- resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, type, true);
- }
- }
- } else if (schemaNode instanceof LeafListSchemaNode) {
- resolveLeafListNodeAsMethod(typeBuilder, (LeafListSchemaNode) schemaNode, context, inGrouping);
- } else if (!schemaNode.isAddedByUses()) {
- if (schemaNode instanceof ContainerSchemaNode) {
- containerToGenType(context, typeBuilder, childOf(typeBuilder), (ContainerSchemaNode) schemaNode,
- inGrouping);
- } else if (schemaNode instanceof ChoiceSchemaNode) {
- choiceToGeneratedType(context, typeBuilder, (ChoiceSchemaNode) schemaNode, inGrouping);
- } else if (schemaNode instanceof ListSchemaNode) {
- listToGenType(context, typeBuilder, childOf(typeBuilder), (ListSchemaNode) schemaNode, inGrouping);
- } else if (schemaNode instanceof AnyxmlSchemaNode || schemaNode instanceof AnydataSchemaNode) {
- opaqueToGeneratedType(context, typeBuilder, schemaNode);
- }
- }
- }
-
- private static void typeBuildersToGenTypes(final ModuleContext context, final GeneratedTypeBuilder typeBuilder,
- final GeneratedTOBuilder genTOBuilder) {
- checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
-
- if (genTOBuilder != null) {
- final GeneratedTransferObject genTO = genTOBuilder.build();
- // Add Identifiable.getKey() for items
- typeBuilder.addMethod(BindingMapping.IDENTIFIABLE_KEY_NAME).setReturnType(genTO)
- .addAnnotation(OVERRIDE_ANNOTATION);
- context.addGeneratedTOBuilder(genTOBuilder);
- }
- }
-
- /**
- * Selects the names of the list keys from <code>list</code> and returns them as the list of the strings.
- *
- * @param list of string with names of the list keys
- * @return list of string which represents names of the list keys. If the <code>list</code> contains no keys then
- * an empty list is returned.
- */
- private static List<String> listKeys(final ListSchemaNode list) {
- final List<QName> keyDefinition = list.getKeyDefinition();
- switch (keyDefinition.size()) {
- case 0:
- return Collections.emptyList();
- case 1:
- return Collections.singletonList(keyDefinition.get(0).getLocalName());
- default:
- final List<String> listKeys = new ArrayList<>(keyDefinition.size());
- for (final QName keyDef : keyDefinition) {
- listKeys.add(keyDef.getLocalName());
- }
- return listKeys;
- }
- }
-
- /**
- * Builds a GeneratedTOBuilder for a UnionType {@link UnionTypeDefinition}. If more then one generated TO builder
- * is created for enclosing then all of the generated TO builders are added to <code>typeBuilder</code> as
- * enclosing transfer objects.
- *
- * @param typeDef type definition which can be of type <code>UnionType</code> or <code>BitsTypeDefinition</code>
- * @param typeBuilder generated type builder to which is added generated TO created from <code>typeDef</code>
- * @param leaf string with name for generated TO builder
- * @param parentModule parent module
- * @return generated TO builder for <code>typeDef</code>
- */
- private Type addTOToTypeBuilder(final UnionTypeDefinition typeDef,
- final GeneratedTypeBuilder typeBuilder, final DataSchemaNode leaf, final Module parentModule) {
- final List<GeneratedTOBuilder> types = typeProvider.provideGeneratedTOBuildersForUnionTypeDef(
- allocateNestedType(typeBuilder.getIdentifier(), leaf.getQName()), typeDef, leaf);
-
- checkState(!types.isEmpty(), "No GeneratedTOBuilder objects generated from union %s", typeDef);
- final List<GeneratedTOBuilder> genTOBuilders = new ArrayList<>(types);
- final GeneratedTOBuilder resultTOBuilder = types.remove(0);
- genTOBuilders.forEach(builder -> typeBuilder.addEnclosingTransferObject(builder.build()));
-
- for (GeneratedTOBuilder builder : types) {
- final GeneratedTransferObject type = builder.build();
- resultTOBuilder.addEnclosingTransferObject(type);
- if (builder.isUnion()) {
- createUnionBuilder(builder, typeBuilder, type, parentModule);
- }
- }
-
- return createReturnTypeForUnion(resultTOBuilder, typeDef, typeBuilder, parentModule);
- }
-
- /**
- * Builds generated TO builders for <code>typeDef</code> of type {@link BitsTypeDefinition} which are also added
- * to <code>typeBuilder</code> as enclosing transfer object. If more then one generated TO builder is created
- * for enclosing then all of the generated TO builders are added to <code>typeBuilder</code> as enclosing transfer
- * objects.
- *
- * @param typeDef type definition which can be of type <code>UnionType</code> or <code>BitsTypeDefinition</code>
- * @param typeBuilder generated type builder to which is added generated TO created from <code>typeDef</code>
- * @param leaf string with name for generated TO builder
- * @param parentModule parent module
- * @return generated TO builder for <code>typeDef</code>
- */
- private GeneratedTransferObject addTOToTypeBuilder(final BitsTypeDefinition typeDef,
- final GeneratedTypeBuilder typeBuilder, final DataSchemaNode leaf, final Module parentModule) {
- final GeneratedTransferObject genTO = typeProvider.provideGeneratedTOBuilderForBitsTypeDefinition(
- allocateNestedType(typeBuilder.getIdentifier(), leaf.getQName()), typeDef, parentModule.getName())
- .build();
- typeBuilder.addEnclosingTransferObject(genTO);
- return genTO;
- }
-
- /**
- * Adds the implemented types to type builder. The method passes through the list of <i>uses</i> in
- * {@code dataNodeContainer}. For every <i>use</i> is obtained corresponding generated type
- * from {@link ModuleContext#groupings allGroupings} which is added as <i>implements type</i>
- * to <code>builder</code>
- *
- * @param dataNodeContainer element which contains the list of used YANG groupings
- * @param builder builder to which are added implemented types according to <code>dataNodeContainer</code>
- * @return generated type builder with all implemented types
- */
- private GeneratedTypeBuilder addImplementedInterfaceFromUses(final DataNodeContainer dataNodeContainer,
- final GeneratedTypeBuilder builder) {
- for (final UsesNode usesNode : dataNodeContainer.getUses()) {
- final GeneratedTypeBuilder genType = findGrouping(usesNode.getSourceGrouping());
- if (genType == null) {
- throw new IllegalStateException("Grouping " + usesNode.getSourceGrouping().getQName()
- + " is not resolved for " + builder.getFullyQualifiedName());
- }
-
- builder.addImplementsType(genType.build());
- }
- return builder;
- }
-
- private JavaTypeName findAliasByPath(final SchemaPath path) {
- for (final ModuleContext ctx : genCtx.values()) {
- final JavaTypeName result = ctx.getAlias(path);
- if (result != null) {
- return result;
- }
- }
- return null;
- }
-
- private GeneratedTypeBuilder findChildNodeByPath(final SchemaPath path) {
- for (final ModuleContext ctx : genCtx.values()) {
- final GeneratedTypeBuilder result = ctx.getChildNode(path);
- if (result != null) {
- return result;
- }
- }
- 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);
- if (result != null) {
- return result;
- }
- }
- return null;
- }
-
- private GeneratedTypeBuilder findCaseByPath(final SchemaPath path) {
- for (final ModuleContext ctx : genCtx.values()) {
- final GeneratedTypeBuilder result = ctx.getCase(path);
- if (result != null) {
- return result;
- }
- }
- return null;
- }
-
- private static JavaTypeName allocateNestedType(final JavaTypeName parent, final QName child) {
- // Single '$' suffix cannot come from user, this mirrors AbstractGeneratedTypeBuilder.addEnumeration()
- return parent.createEnclosed(BindingMapping.getClassName(child), "$");
- }
-
- private static void annotateDeprecatedIfNecessary(final WithStatus node, final AnnotableTypeBuilder builder) {
- switch (node.getStatus()) {
- case DEPRECATED:
- // FIXME: we really want to use a pre-made annotation
- builder.addAnnotation(DEPRECATED_ANNOTATION);
- break;
- case OBSOLETE:
- builder.addAnnotation(DEPRECATED_ANNOTATION).addParameter("forRemoval", "true");
- break;
- case CURRENT:
- // No-op
- break;
- default:
- throw new IllegalStateException("Unhandled status in " + node);
- }
- }
-
- private static void addConcreteInterfaceMethods(final GeneratedTypeBuilder typeBuilder) {
- defaultImplementedInterace(typeBuilder);
-
- typeBuilder.addMethod(BindingMapping.BINDING_HASHCODE_NAME)
- .setAccessModifier(AccessModifier.PUBLIC)
- .setStatic(true)
- .setReturnType(primitiveIntType());
- typeBuilder.addMethod(BindingMapping.BINDING_EQUALS_NAME)
- .setAccessModifier(AccessModifier.PUBLIC)
- .setStatic(true)
- .setReturnType(primitiveBooleanType());
- typeBuilder.addMethod(BindingMapping.BINDING_TO_STRING_NAME)
- .setAccessModifier(AccessModifier.PUBLIC)
- .setStatic(true)
- .setReturnType(STRING);
- }
-
- private static void narrowImplementedInterface(final GeneratedTypeBuilder typeBuilder) {
- defineImplementedInterfaceMethod(typeBuilder, wildcardTypeFor(typeBuilder.getIdentifier()));
- }
-
- private static void defaultImplementedInterace(final GeneratedTypeBuilder typeBuilder) {
- defineImplementedInterfaceMethod(typeBuilder, DefaultType.of(typeBuilder)).setDefault(true);
- }
-
- private static MethodSignatureBuilder defineImplementedInterfaceMethod(final GeneratedTypeBuilder typeBuilder,
- final Type classType) {
- final MethodSignatureBuilder ret = typeBuilder
- .addMethod(BindingMapping.DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME)
- .setAccessModifier(AccessModifier.PUBLIC)
- .setReturnType(classType(classType));
- ret.addAnnotation(OVERRIDE_ANNOTATION);
- return ret;
- }
-}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl;
+
+import static com.google.common.base.Verify.verify;
+
+import com.google.common.base.Stopwatch;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.AbstractExplicitGenerator;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.Generator;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.GeneratorReactor;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.ModuleGenerator;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.TypeBuilderFactory;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeTypes;
+import org.opendaylight.yangtools.concepts.Mutable;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.AugmentEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+final class BindingRuntimeTypesFactory implements Mutable {
+ private static final Logger LOG = LoggerFactory.getLogger(BindingRuntimeTypesFactory.class);
+
+ private final Map<Type, AugmentationSchemaNode> augmentationToSchema = new HashMap<>();
+ private final Map<Type, WithStatus> typeToSchema = new HashMap<>();
+ private final Map<QName, Type> identities = new HashMap<>();
+
+ // Note: we are keying through WithStatus, but these nodes compare on semantics, so equivalent schema nodes
+ // can result in two distinct types. We certainly need to keep them separate.
+ private final Map<WithStatus, Type> schemaToType = new IdentityHashMap<>();
+
+ private BindingRuntimeTypesFactory() {
+ // Hidden on purpose
+ }
+
+ static @NonNull BindingRuntimeTypes createTypes(final @NonNull EffectiveModelContext context) {
+ final Collection<ModuleGenerator> moduleGens = new GeneratorReactor(context)
+ .execute(TypeBuilderFactory.runtime())
+ .values();
+
+ final Stopwatch sw = Stopwatch.createStarted();
+ final BindingRuntimeTypesFactory factory = new BindingRuntimeTypesFactory();
+ factory.indexTypes(moduleGens);
+ LOG.debug("Indexed {} generators in {}", moduleGens.size(), sw);
+
+ return new BindingRuntimeTypes(context, factory.augmentationToSchema, factory.typeToSchema,
+ factory.schemaToType, factory.identities);
+ }
+
+ private void indexTypes(final Iterable<? extends Generator> generators) {
+ for (Generator gen : generators) {
+ gen.generatedType().ifPresent(type -> indexType(gen, type));
+ indexTypes(gen);
+ }
+ }
+
+ private void indexType(final @NonNull Generator generator, final @NonNull GeneratedType type) {
+ if (generator instanceof AbstractExplicitGenerator) {
+ final EffectiveStatement<?, ?> stmt = ((AbstractExplicitGenerator<?>) generator).statement();
+ if (stmt instanceof IdentityEffectiveStatement) {
+ identities.put(((IdentityEffectiveStatement) stmt).argument(), type);
+ } else if (stmt instanceof AugmentEffectiveStatement) {
+ verify(stmt instanceof AugmentationSchemaNode, "Unexpected statement %s", stmt);
+ augmentationToSchema.put(type, (AugmentationSchemaNode) stmt);
+ }
+
+ final WithStatus schema;
+ if (stmt instanceof TypedDataSchemaNode) {
+ schema = ((TypedDataSchemaNode) stmt).getType();
+ } else if (stmt instanceof TypedefEffectiveStatement) {
+ schema = ((TypedefEffectiveStatement) stmt).getTypeDefinition();
+ } else if (stmt instanceof WithStatus) {
+ schema = (WithStatus) stmt;
+ } else {
+ return;
+ }
+
+ typeToSchema.put(type, schema);
+ schemaToType.put(schema, type);
+ }
+ }
+}
+++ /dev/null
-/*
- * Copyright (c) 2014 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.mdsal.binding.generator.impl;
-
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
-
-// FIXME: 8.0.0: hide this class
-public final class CodecTypeUtils {
- private CodecTypeUtils() {
- throw new UnsupportedOperationException("Utility class should not be instantiated");
- }
-
- @SuppressWarnings({"unchecked","rawtypes"})
- public static IdentifiableItem<?, ?> newIdentifiableItem(final Class<?> type, final Object key) {
- return IdentifiableItem.of((Class)type, (Identifier)key);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2018 Pantheon Technologies, s.r.o. 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.mdsal.binding.generator.impl;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import org.opendaylight.mdsal.binding.model.api.GeneratedType;
-import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
-import org.opendaylight.mdsal.binding.model.api.TypeMemberComment;
-import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
-import org.opendaylight.mdsal.binding.model.api.type.builder.TypeMemberBuilder;
-import org.opendaylight.mdsal.binding.model.util.TypeComments;
-import org.opendaylight.mdsal.binding.yang.types.CodegenTypeProvider;
-import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-
-final class CodegenTypeGenerator extends AbstractTypeGenerator {
- CodegenTypeGenerator(final EffectiveModelContext context, final Map<SchemaNode, JavaTypeName> renames) {
- super(context, new CodegenTypeProvider(context, renames), renames);
- }
-
- List<GeneratedType> toTypes(final Collection<? extends Module> modules) {
- final List<GeneratedType> filteredGenTypes = new ArrayList<>();
- for (final Module m : modules) {
- filteredGenTypes.addAll(moduleContext(m.getQNameModule()).getGeneratedTypes());
- final Set<GeneratedType> additionalTypes = typeProvider().getAdditionalTypes().get(m);
- if (additionalTypes != null) {
- filteredGenTypes.addAll(additionalTypes);
- }
- }
- return filteredGenTypes;
- }
-
- @Override
- void addCodegenInformation(final GeneratedTypeBuilderBase<?> genType, final Module module,
- final SchemaNode node) {
- YangSourceDefinition.of(module, node).ifPresent(genType::setYangSourceDefinition);
- TypeComments.description(node).ifPresent(genType::addComment);
- node.getDescription().ifPresent(genType::setDescription);
- node.getReference().ifPresent(genType::setReference);
- }
-
- @Override
- void addCodegenInformation(final GeneratedTypeBuilderBase<?> genType, final Module module) {
- YangSourceDefinition.of(module).ifPresent(genType::setYangSourceDefinition);
- TypeComments.description(module).ifPresent(genType::addComment);
- module.getDescription().ifPresent(genType::setDescription);
- module.getReference().ifPresent(genType::setReference);
- }
-
- @Override
- void addCodegenInformation(final GeneratedTypeBuilder interfaceBuilder, final Module module,
- final String description, final Collection<? extends SchemaNode> nodes) {
- interfaceBuilder.addComment(TypeComments.javadoc("Interface for implementing the following YANG " + description
- + " defined in module <b>" + module.getName() + "</b>").get());
- YangSourceDefinition.of(module, nodes).ifPresent(interfaceBuilder::setYangSourceDefinition);
- }
-
- @Override
- void addComment(final TypeMemberBuilder<?> genType, final DocumentedNode node) {
- node.getDescription().map(TypeMemberComment::referenceOf).ifPresent(genType::setComment);
- }
-
- @Override
- void addRpcMethodComment(final TypeMemberBuilder<?> genType, final RpcDefinition node) {
- final String rpcName = node.getQName().getLocalName();
- genType.setComment(new TypeMemberComment(
- "Invoke {@code " + rpcName + "} RPC.",
- node.getDescription().orElse(null),
- "@param input of {@code " + rpcName + "}\n"
- + "@return output of {@code " + rpcName + '}'));
- }
-}
*/
package org.opendaylight.mdsal.binding.generator.impl;
-import static com.google.common.base.Preconditions.checkArgument;
-
import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
+import java.util.ArrayList;
import java.util.Collection;
-import java.util.IdentityHashMap;
import java.util.List;
-import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.kohsuke.MetaInfServices;
import org.opendaylight.mdsal.binding.generator.api.BindingGenerator;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.Generator;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.GeneratorReactor;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.ModuleGenerator;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.TypeBuilderFactory;
+import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
-import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
/**
* Default implementation of {@link BindingGenerator}.
}
/**
- * Resolves generated types from <code>context</code> schema nodes only for modules specified
- * in <code>modules</code>. Generated types are created for modules, groupings, types, containers, lists, choices,
- * augments, rpcs, notification, identities.
+ * Resolves generated types from {@code context} schema nodes only for modules specified in {@code modules}.
+ * Generated types are created for modules, groupings, types, containers, lists, choices, augments, rpcs,
+ * notification, identities and actions.
*
* @param context schema context which contains data about all schema nodes saved in modules
* @param modules set of modules for which schema nodes should be generated types
- * @return list of types (usually <code>GeneratedType</code> or
- * <code>GeneratedTransferObject</code>) which:
+ * @return list of types (usually a {@link GeneratedType} or an {@link GeneratedTransferObject}), which:
* <ul>
- * <li>are generated from <code>context</code> schema nodes and</li>
- * <li>are also part of some of the module in <code>modules</code>
- * set.</li>
+ * <li>are generated from {@code context} schema nodes and</li>
+ * <li>are also part of some of the module in {@code modules} set.</li>
* </ul>
- * @throws IllegalArgumentException
- * <ul>
- * <li>if arg <code>context</code> is null or</li>
- * <li>if arg <code>modules</code> is null</li>
- * </ul>
- * @throws IllegalStateException
- * if <code>context</code> contain no modules
+ * @throws NullPointerException if any argument is {@code null}, or if {@code modules} contains a {@code null}
+ * element
*/
@VisibleForTesting
static @NonNull List<GeneratedType> generateFor(final EffectiveModelContext context,
final Collection<? extends Module> modules) {
- GeneratorUtils.checkContext(context);
- checkArgument(modules != null, "Set of Modules cannot be NULL.");
+ final Set<ModuleEffectiveStatement> filter = modules.stream().map(Module::asEffectiveStatement)
+ .collect(Collectors.toUnmodifiableSet());
- final Map<SchemaNode, JavaTypeName> renames = new IdentityHashMap<>();
- for (;;) {
- try {
- return new CodegenTypeGenerator(context, renames).toTypes(modules);
- } catch (RenameMappingException e) {
- GeneratorUtils.rename(renames, e);
+ final List<GeneratedType> result = new ArrayList<>();
+ for (ModuleGenerator gen : new GeneratorReactor(context).execute(TypeBuilderFactory.codegen()).values()) {
+ if (filter.contains(gen.statement())) {
+ addTypes(result, gen);
}
}
+
+ return result;
+ }
+
+ private static void addTypes(final List<GeneratedType> result, final Generator gen) {
+ gen.generatedType()
+ .filter(type -> type.getIdentifier().immediatelyEnclosingClass().isEmpty())
+ .ifPresent(result::add);
+ result.addAll(gen.auxiliaryGeneratedTypes());
+ for (Generator child : gen) {
+ addTypes(result, child);
+ }
}
}
package org.opendaylight.mdsal.binding.generator.impl;
import com.google.common.annotations.Beta;
-import java.util.IdentityHashMap;
-import java.util.Map;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.kohsuke.MetaInfServices;
-import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeGenerator;
import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeTypes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
@Override
public BindingRuntimeTypes generateTypeMapping(final EffectiveModelContext context) {
- GeneratorUtils.checkContext(context);
-
- final Map<SchemaNode, JavaTypeName> renames = new IdentityHashMap<>();
- for (;;) {
- try {
- return new RuntimeTypeGenerator(context, renames).toTypeMapping();
- } catch (RenameMappingException e) {
- GeneratorUtils.rename(renames, e);
- }
- }
+ return BindingRuntimeTypesFactory.createTypes(context);
}
@Activate
+++ /dev/null
-/*
- * 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.mdsal.binding.generator.impl;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkState;
-
-import java.util.Map;
-import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-final class GeneratorUtils {
- private static final Logger LOG = LoggerFactory.getLogger(GeneratorUtils.class);
-
- private GeneratorUtils() {
-
- }
-
- static void checkContext(final SchemaContext context) {
- checkArgument(context != null, "Schema Context reference cannot be NULL.");
- checkState(context.getModules() != null, "Schema Context does not contain defined modules.");
- }
-
- static void rename(final Map<SchemaNode, JavaTypeName> renames, final RenameMappingException ex) {
- final JavaTypeName name = ex.getName();
- final SchemaNode def = ex.getDefinition();
- final JavaTypeName existing = renames.get(def);
- if (existing != null) {
- throw new IllegalStateException("Attempted to relocate " + def + " to " + name + ", already remapped to "
- + existing, ex);
- }
-
- final String suffix;
- if (def instanceof IdentitySchemaNode) {
- suffix = "$I";
- } else if (def instanceof GroupingDefinition) {
- suffix = "$G";
- } else if (def instanceof TypeDefinition) {
- suffix = "$T";
- } else {
- throw new IllegalStateException("Unhandled remapping of " + def + " at " + name, ex);
- }
-
- final JavaTypeName newName = name.createSibling(name.simpleName() + suffix);
- renames.put(def, newName);
- LOG.debug("Restarting code generation after remapping {} to {}", name, newName);
- }
-
-}
+++ /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.mdsal.binding.generator.impl;
-
-import static com.google.common.base.Preconditions.checkState;
-import static java.util.Objects.requireNonNull;
-
-import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Multimap;
-import com.google.common.collect.Multimaps;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.mdsal.binding.model.api.GeneratedType;
-import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
-import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
-import org.opendaylight.yangtools.concepts.Mutable;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ContainerLike;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
-import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Utility class for building up Binding mapping information. This class is NOT thread-safe.
- */
-// FIXME: 8.0.0: hide this class
-public final class ModuleContext implements Mutable {
- private static final Logger LOG = LoggerFactory.getLogger(ModuleContext.class);
-
- private final BiMap<Type, AugmentationSchemaNode> typeToAugmentation = HashBiMap.create();
- private final Map<SchemaPath, GeneratedTypeBuilder> childNodes = new HashMap<>();
- private final Map<SchemaPath, GeneratedTypeBuilder> groupings = new HashMap<>();
- private final BiMap<Type, CaseSchemaNode> caseTypeToSchema = HashBiMap.create();
- private final Map<SchemaPath, GeneratedTypeBuilder> cases = new HashMap<>();
- private final Map<QName, GeneratedTypeBuilder> identities = new HashMap<>();
- private final List<GeneratedTypeBuilder> augmentations = new ArrayList<>();
- private final Multimap<Type, Type> choiceToCases = HashMultimap.create();
- private final Set<GeneratedTypeBuilder> topLevelNodes = new HashSet<>();
- private final Map<SchemaPath, JavaTypeName> aliases = new HashMap<>();
- private final Map<Type, WithStatus> typeToSchema = new HashMap<>();
- private final List<GeneratedTOBuilder> genTOs = new ArrayList<>();
- private final Map<SchemaPath, Type> innerTypes = new HashMap<>();
- private final Map<SchemaPath, GeneratedType> typedefs = new HashMap<>();
- private final Module module;
-
- // Conflict mapping
- private final Map<JavaTypeName, SchemaNode> nameMapping = new HashMap<>();
-
- private GeneratedTypeBuilder moduleNode;
- private JavaTypeName moduleInfoType;
- private String modulePackageName;
-
- ModuleContext(final Module module) {
- this.module = requireNonNull(module);
- }
-
- Module module() {
- return module;
- }
-
- @NonNull String modulePackageName() {
- String ret = modulePackageName;
- if (ret == null) {
- modulePackageName = ret = BindingMapping.getRootPackageName(module.getQNameModule());
- }
- return ret;
- }
-
- @NonNull JavaTypeName moduleInfoType() {
- JavaTypeName ret = moduleInfoType;
- if (ret == null) {
- moduleInfoType = ret = JavaTypeName.create(modulePackageName(), BindingMapping.MODULE_INFO_CLASS_NAME);
- }
- return ret;
- }
-
- List<GeneratedType> getGeneratedTypes() {
- List<GeneratedType> result = new ArrayList<>();
-
- if (moduleNode != null) {
- result.add(moduleNode.build());
- }
-
- for (GeneratedTOBuilder b : genTOs) {
- result.add(b.build());
- }
- for (GeneratedType b : typedefs.values()) {
- if (b != null) {
- result.add(b);
- }
- }
- for (GeneratedTypeBuilder b : childNodes.values()) {
- result.add(b.build());
- }
- for (GeneratedTypeBuilder b : groupings.values()) {
- result.add(b.build());
- }
- for (GeneratedTypeBuilder b : cases.values()) {
- result.add(b.build());
- }
- for (GeneratedTypeBuilder b : identities.values()) {
- result.add(b.build());
- }
- for (GeneratedTypeBuilder b : topLevelNodes) {
- result.add(b.build());
- }
- for (GeneratedTypeBuilder b : augmentations) {
- result.add(b.build());
- }
- return result;
- }
-
- public Multimap<Type, Type> getChoiceToCases() {
- return Multimaps.unmodifiableMultimap(choiceToCases);
- }
-
- public GeneratedTypeBuilder getModuleNode() {
- return moduleNode;
- }
-
- public GeneratedTypeBuilder getChildNode(final SchemaPath path) {
- return childNodes.get(path);
- }
-
- public GeneratedTypeBuilder getGrouping(final SchemaPath path) {
- return groupings.get(path);
- }
-
- public GeneratedTypeBuilder getCase(final SchemaPath path) {
- return cases.get(path);
- }
-
- public void addModuleNode(final GeneratedTypeBuilder newModuleNode) {
- this.moduleNode = newModuleNode;
- }
-
- public void addGeneratedTOBuilder(final GeneratedTOBuilder builder) {
- genTOs.add(builder);
- }
-
- @NonNull GeneratedType addAliasType(final ModuleContext sourceContext, final ContainerLike source,
- final ContainerLike alias) {
- final GeneratedTypeBuilder builder = sourceContext.getChildNode(source.getPath());
- checkState(builder != null, "Could not find builder for %s", source);
-
- final JavaTypeName id = builder.getIdentifier();
- final SchemaPath path = alias.getPath();
- final JavaTypeName prev = aliases.putIfAbsent(path, id);
- checkState(prev == null, "Type aliasing conflict on %s: %s vs %s", path, prev, id);
-
- return builder.build();
- }
-
- @Nullable JavaTypeName getAlias(final SchemaPath path) {
- return aliases.get(path);
- }
-
- public void addChildNodeType(final SchemaNode def, final GeneratedTypeBuilder builder) {
- checkNamingConflict(def, builder.getIdentifier());
- childNodes.put(def.getPath(), builder);
- typeToSchema.put(builder, def);
- }
-
- public void addGroupingType(final GroupingDefinition def, final GeneratedTypeBuilder builder) {
- checkNamingConflict(def, builder.getIdentifier());
- groupings.put(def.getPath(), builder);
- }
-
- public void addTypedefType(final TypeDefinition<?> def, final GeneratedType type) {
- final JavaTypeName name = type.getIdentifier();
- final SchemaNode existingDef = nameMapping.putIfAbsent(name, def);
- if (existingDef != null) {
- if (!(existingDef instanceof TypeDefinition)) {
- throw resolveNamingConfict(existingDef, def, name);
- }
-
- // This seems to be fine
- LOG.debug("GeneratedType conflict between {} and {} on {}", def, existingDef, name);
- }
-
- typedefs.put(def.getPath(), type);
- }
-
- public void addCaseType(final SchemaPath path, final GeneratedTypeBuilder builder) {
- cases.put(path, builder);
- }
-
- public void addIdentityType(final IdentitySchemaNode def, final GeneratedTypeBuilder builder) {
- checkNamingConflict(def, builder.getIdentifier());
- identities.put(def.getQName(), builder);
- }
-
- public void addTopLevelNodeType(final GeneratedTypeBuilder builder) {
- topLevelNodes.add(builder);
- }
-
- public void addAugmentType(final GeneratedTypeBuilder builder) {
- augmentations.add(builder);
- }
-
- public Map<SchemaPath, GeneratedType> getTypedefs() {
- return typedefs;
- }
-
- public Map<SchemaPath, GeneratedTypeBuilder> getChildNodes() {
- return Collections.unmodifiableMap(childNodes);
- }
-
- public Map<SchemaPath, GeneratedTypeBuilder> getGroupings() {
- return Collections.unmodifiableMap(groupings);
- }
-
- public Map<SchemaPath, GeneratedTypeBuilder> getCases() {
- return Collections.unmodifiableMap(cases);
- }
-
- public Map<QName, GeneratedTypeBuilder> getIdentities() {
- return Collections.unmodifiableMap(identities);
- }
-
- public Set<GeneratedTypeBuilder> getTopLevelNodes() {
- return Collections.unmodifiableSet(topLevelNodes);
- }
-
- public List<GeneratedTypeBuilder> getAugmentations() {
- return Collections.unmodifiableList(augmentations);
- }
-
- public BiMap<Type, AugmentationSchemaNode> getTypeToAugmentation() {
- return Maps.unmodifiableBiMap(typeToAugmentation);
- }
-
- public void addTypeToAugmentation(final GeneratedTypeBuilder builder, final AugmentationSchemaNode schema) {
- typeToAugmentation.put(builder, schema);
- typeToSchema.put(builder, schema);
- }
-
- public void addChoiceToCaseMapping(final Type choiceType, final Type caseType, final CaseSchemaNode schema) {
- choiceToCases.put(choiceType, caseType);
- caseTypeToSchema.put(caseType, schema);
- typeToSchema.put(caseType, schema);
- }
-
- public BiMap<Type, CaseSchemaNode> getCaseTypeToSchemas() {
- return Maps.unmodifiableBiMap(caseTypeToSchema);
- }
-
- /**
- * Returns mapping of type to its schema. Valid values are only instances of {@link DataSchemaNode}
- * or {@link AugmentationSchemaNode}.
- *
- * @return Mapping from type to corresponding schema
- */
- public Map<Type, WithStatus> getTypeToSchema() {
- return Collections.unmodifiableMap(typeToSchema);
- }
-
- protected void addTypeToSchema(final Type type, final TypeDefinition<?> typedef) {
- typeToSchema.put(type, typedef);
- }
-
- /**
- * Adds mapping between schema path and an inner type.
- */
- void addInnerTypedefType(final SchemaPath path, final Type type) {
- innerTypes.put(path, type);
- }
-
- public Type getInnerType(final SchemaPath path) {
- return innerTypes.get(path);
- }
-
- private void checkNamingConflict(final SchemaNode def, final JavaTypeName name) {
- final SchemaNode existingDef = nameMapping.putIfAbsent(name, def);
- if (existingDef != null) {
- if (def.equals(existingDef)) {
- if (LOG.isDebugEnabled()) {
- // TODO: this should not really be happening
- LOG.debug("Duplicate definition on {} as {}", name, def, new Throwable());
- }
- } else {
- throw resolveNamingConfict(existingDef, def, name);
- }
- }
- }
-
- private static IllegalStateException resolveNamingConfict(final SchemaNode existing, final SchemaNode incoming,
- final JavaTypeName name) {
- if (existing instanceof IdentitySchemaNode) {
- if (incoming instanceof GroupingDefinition || incoming instanceof TypeDefinition
- || incoming instanceof DataSchemaNode || incoming instanceof NotificationDefinition
- || incoming instanceof OperationDefinition) {
- return new RenameMappingException(name, existing);
- }
- } else if (existing instanceof GroupingDefinition) {
- if (incoming instanceof IdentitySchemaNode) {
- return new RenameMappingException(name, incoming);
- }
- if (incoming instanceof TypeDefinition || incoming instanceof DataSchemaNode
- || incoming instanceof NotificationDefinition || incoming instanceof OperationDefinition) {
- return new RenameMappingException(name, existing);
- }
- } else if (existing instanceof TypeDefinition) {
- if (incoming instanceof GroupingDefinition || incoming instanceof IdentitySchemaNode) {
- return new RenameMappingException(name, incoming);
- }
- if (incoming instanceof DataSchemaNode || incoming instanceof NotificationDefinition
- || incoming instanceof OperationDefinition) {
- return new RenameMappingException(name, existing);
- }
- } else {
- if (incoming instanceof GroupingDefinition || incoming instanceof IdentitySchemaNode
- || incoming instanceof TypeDefinition) {
- return new RenameMappingException(name, incoming);
- }
- }
-
- return new IllegalStateException(String.format("Unhandled GeneratedType conflict between %s and %s on %s",
- incoming, existing, name));
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2018 Pantheon Technologies, 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,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.mdsal.binding.generator.impl;
-
-import static java.util.Objects.requireNonNull;
-
-import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-
-/**
- * Exception thrown from ModuleContext when it detects a Java namespace clash between generated classes. This can occur
- * because we are mapping multiple YANG namespaces to a single Java class namespace.
- *
- * <p>
- * While handling this case via an exception (and related mechanics) is a bit slow, it works with minimal disturbance
- * of existing logic. The situation should not be very common and hence it should provide an acceptable performance
- * envelope.
- *
- * @author Robert Varga
- */
-@NonNullByDefault
-final class RenameMappingException extends IllegalStateException {
- private static final long serialVersionUID = 1L;
-
- private final JavaTypeName name;
- private final transient SchemaNode definition;
-
- RenameMappingException(final JavaTypeName name, final SchemaNode definition) {
- super("Remap " + name + " occupant " + definition);
- this.name = requireNonNull(name);
- this.definition = requireNonNull(definition);
- }
-
- JavaTypeName getName() {
- return name;
- }
-
- SchemaNode getDefinition() {
- return definition;
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2018 Pantheon Technologies, s.r.o. 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.mdsal.binding.generator.impl;
-
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.IdentityHashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
-import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
-import org.opendaylight.mdsal.binding.model.api.type.builder.TypeMemberBuilder;
-import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeTypes;
-import org.opendaylight.mdsal.binding.yang.types.RuntimeTypeProvider;
-import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
-import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-
-final class RuntimeTypeGenerator extends AbstractTypeGenerator {
- RuntimeTypeGenerator(final EffectiveModelContext context, final Map<SchemaNode, JavaTypeName> renames) {
- super(context, new RuntimeTypeProvider(context, renames), renames);
- }
-
- @NonNull BindingRuntimeTypes toTypeMapping() {
- final Map<Type, AugmentationSchemaNode> augmentationToSchema = new HashMap<>();
- final Map<Type, WithStatus> typeToSchema = new HashMap<>();
- final Multimap<Type, Type> choiceToCases = HashMultimap.create();
- final Map<QName, Type> identities = new HashMap<>();
-
- // Note: we are keying through WithStatus, but these nodes compare on semantics, so equivalent schema nodes
- // can result in two distinct types. We certainly need to keep them separate.
- final Map<WithStatus, Type> schemaToType = new IdentityHashMap<>();
-
- /*
- * Fun parts are here. ModuleContext maps have Builders in them, we want plain types. We may encounter each
- * builder multiple times, hence we keep a builder->instance cache.
- */
- final Map<Type, Type> builderToType = new IdentityHashMap<>();
-
- for (final ModuleContext ctx : moduleContexts()) {
- for (Entry<Type, AugmentationSchemaNode> e : ctx.getTypeToAugmentation().entrySet()) {
- augmentationToSchema.put(builtType(builderToType, e.getKey()), e.getValue());
- }
- for (Entry<Type, WithStatus> e : ctx.getTypeToSchema().entrySet()) {
- final Type type = builtType(builderToType, e.getKey());
- typeToSchema.put(type, e.getValue());
- schemaToType.put(e.getValue(), type);
- }
- for (Entry<Type, Type> e : ctx.getChoiceToCases().entries()) {
- choiceToCases.put(builtType(builderToType, e.getKey()), builtType(builderToType, e.getValue()));
- }
- for (Entry<QName, GeneratedTypeBuilder> e : ctx.getIdentities().entrySet()) {
- identities.put(e.getKey(), builtType(builderToType, e.getValue()));
- }
- }
-
- return new BindingRuntimeTypes(schemaContext(), augmentationToSchema, typeToSchema, schemaToType, choiceToCases,
- identities);
- }
-
- private static Type builtType(final Map<Type, Type> knownTypes, final Type type) {
- if (type instanceof Builder) {
- final Type existing = knownTypes.get(type);
- if (existing != null) {
- return existing;
- }
-
- final Type built = (Type) ((Builder<?>)type).build();
- knownTypes.put(type, built);
- return built;
- }
- return type;
- }
-
- @Override
- void addCodegenInformation(final GeneratedTypeBuilderBase<?> genType, final Module module) {
- // No-op
- }
-
- @Override
- void addCodegenInformation(final GeneratedTypeBuilderBase<?> genType, final Module module, final SchemaNode node) {
- // No-op
- }
-
- @Override
- void addCodegenInformation(final GeneratedTypeBuilder interfaceBuilder, final Module module, final String string,
- final Collection<? extends SchemaNode> nodes) {
- // No-op
- }
-
- @Override
- void addComment(final TypeMemberBuilder<?> genType, final DocumentedNode node) {
- // No-op
- }
-
- @Override
- void addRpcMethodComment(final TypeMemberBuilder<?> genType, final RpcDefinition node) {
- // No-op
- }
-}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static com.google.common.base.Verify.verify;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import java.util.Comparator;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierEffectiveStatement;
+import org.opendaylight.yangtools.yang.common.AbstractQName;
+import org.opendaylight.yangtools.yang.model.api.stmt.AugmentEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * A generator corresponding to a {@code augment} statement. This class is further specialized for the two distinct uses
+ * an augment is used.
+ */
+abstract class AbstractAugmentGenerator extends AbstractCompositeGenerator<AugmentEffectiveStatement> {
+ /**
+ * Comparator comparing target path length. This is useful for quickly determining order the order in which two
+ * (or more) {@link AbstractAugmentGenerator}s need to be evaluated. This is necessary when augments are layered on
+ * top of each other:
+ *
+ * <p>
+ * <pre>
+ * <code>
+ * container foo;
+ *
+ * augment /foo/bar {
+ * container baz;
+ * }
+ *
+ * augment /foo {
+ * container bar;
+ * }
+ * </code>
+ * </pre>
+ *
+ * <p>
+ * Evaluating these in the order of increasing argument component count solves this without having to perform a full
+ * analysis.
+ */
+ static final Comparator<? super AbstractAugmentGenerator> COMPARATOR =
+ Comparator.comparingInt(augment -> augment.statement().argument().getNodeIdentifiers().size());
+
+ private AbstractCompositeGenerator<?> targetGen;
+
+ AbstractAugmentGenerator(final AugmentEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ @Override
+ final void pushToInference(final SchemaInferenceStack dataTree) {
+ dataTree.enterSchemaTree(statement().argument());
+ }
+
+ @Override
+ final AbstractQName localName() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ ClassPlacement classPlacement() {
+ // if the target is a choice we are NOT creating an explicit augmentation, but we still need a phantom to
+ // reserve the appropriate package name
+ final AbstractCompositeGenerator<?> target = targetGenerator();
+ return target instanceof ChoiceGenerator ? ClassPlacement.PHANTOM : super.classPlacement();
+ }
+
+ @Override
+ final Member createMember(final CollisionDomain domain) {
+ final AbstractQName explicitIdentifier = statement()
+ .findFirstEffectiveSubstatementArgument(AugmentIdentifierEffectiveStatement.class).orElse(null);
+ if (explicitIdentifier != null) {
+ return domain.addPrimary(new CamelCaseNamingStrategy(StatementNamespace.DEFAULT, explicitIdentifier));
+ }
+
+ final AbstractCompositeGenerator<?> target = targetGenerator();
+ final AbstractQName ref = target.localName();
+ int offset = 1;
+ for (Generator gen : getParent()) {
+ if (gen == this) {
+ break;
+ }
+ if (gen instanceof AbstractAugmentGenerator
+ && ref.equals(((AbstractAugmentGenerator) gen).targetGenerator().localName())) {
+ offset++;
+ }
+ }
+
+ return domain.addSecondary(target.getMember(), String.valueOf(offset), statement().argument());
+ }
+
+ @Override
+ final GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+
+ builder.addImplementsType(BindingTypes.augmentation(targetGenerator().getGeneratedType(builderFactory)));
+ addUsesInterfaces(builder, builderFactory);
+ addConcreteInterfaceMethods(builder);
+
+ addGetterMethods(builder, builderFactory);
+ annotateDeprecatedIfNecessary(builder);
+
+ return builder.build();
+ }
+
+ @Override
+ final void addAsGetterMethod(final GeneratedTypeBuilderBase<?> builder, final TypeBuilderFactory builderFactory) {
+ // Augments are never added as getters, as they are handled via Augmentable mechanics
+ }
+
+ final void setTargetGenerator(final AbstractExplicitGenerator<?> target) {
+ verify(target instanceof AbstractCompositeGenerator, "Unexpected target %s", target);
+ targetGen = (AbstractCompositeGenerator<?>) target;
+ targetGen.addAugment(this);
+ }
+
+ final @NonNull AbstractCompositeGenerator<?> targetGenerator() {
+ final AbstractCompositeGenerator<?> existing = targetGen;
+ if (existing != null) {
+ return existing.getOriginal();
+ }
+
+ loadTargetGenerator();
+ return verifyNotNull(targetGen, "No target for %s", this).getOriginal();
+ }
+
+ abstract void loadTargetGenerator();
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static com.google.common.base.Verify.verify;
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.mdsal.binding.model.api.Enumeration;
+import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.AddedByUsesAware;
+import org.opendaylight.yangtools.yang.model.api.CopyableNode;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ActionEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.AnydataEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.AugmentEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ContainerEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.GroupingEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.LeafEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.LeafListEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ListEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.NotificationEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RpcEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.UsesEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.ri.type.TypeBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A composite generator. Composite generators may contain additional children, which end up being mapped into
+ * the naming hierarchy 'under' the composite generator. To support this use case, each composite has a Java package
+ * name assigned.
+ */
+abstract class AbstractCompositeGenerator<T extends EffectiveStatement<?, ?>> extends AbstractExplicitGenerator<T> {
+ private static final Logger LOG = LoggerFactory.getLogger(AbstractCompositeGenerator.class);
+
+ private final @NonNull CollisionDomain domain = new CollisionDomain();
+ private final List<Generator> children;
+
+ private List<AbstractAugmentGenerator> augments = List.of();
+ private List<GroupingGenerator> groupings;
+
+ AbstractCompositeGenerator(final T statement) {
+ super(statement);
+ children = createChildren(statement);
+ }
+
+ AbstractCompositeGenerator(final T statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ children = createChildren(statement);
+ }
+
+ @Override
+ public final Iterator<Generator> iterator() {
+ return children.iterator();
+ }
+
+ @Override
+ final boolean isEmpty() {
+ return children.isEmpty();
+ }
+
+ @Override
+ final @Nullable Generator findGenerator(final EffectiveStatement<?, ?> stmt) {
+ for (Generator gen : children) {
+ if (gen instanceof AbstractExplicitGenerator && ((AbstractExplicitGenerator<?>) gen).statement() == stmt) {
+ return gen;
+ }
+ }
+ return null;
+ }
+
+ final @NonNull CollisionDomain domain() {
+ return domain;
+ }
+
+ final void linkUsesDependencies(final GeneratorContext context) {
+ // We are establishing two linkages here:
+ // - we are resolving 'uses' statements to their corresponding 'grouping' definitions
+ // - we propagate those groupings as anchors to any augment statements
+ final List<GroupingGenerator> tmp = new ArrayList<>();
+ for (EffectiveStatement<?, ?> stmt : statement().effectiveSubstatements()) {
+ if (stmt instanceof UsesEffectiveStatement) {
+ final UsesEffectiveStatement uses = (UsesEffectiveStatement) stmt;
+ final GroupingGenerator grouping = context.resolveTreeScoped(GroupingGenerator.class, uses.argument());
+ tmp.add(grouping);
+
+ for (Generator gen : this) {
+ if (gen instanceof UsesAugmentGenerator) {
+ ((UsesAugmentGenerator) gen).linkGroupingDependency(uses, grouping);
+ }
+ }
+ }
+ }
+ groupings = List.copyOf(tmp);
+ }
+
+ final void addAugment(final AbstractAugmentGenerator augment) {
+ if (augments.isEmpty()) {
+ augments = new ArrayList<>(2);
+ }
+ augments.add(requireNonNull(augment));
+ }
+
+ @Override
+ final AbstractCompositeGenerator<?> getOriginal() {
+ return (AbstractCompositeGenerator<?>) super.getOriginal();
+ }
+
+ final @NonNull AbstractExplicitGenerator<?> getOriginalChild(final QName childQName) {
+ // First try groupings/augments ...
+ final AbstractExplicitGenerator<?> found = findInferredGenerator(childQName);
+ if (found != null) {
+ return found;
+ }
+
+ // ... no luck, we really need to start looking at our origin
+ final AbstractExplicitGenerator<?> prev = verifyNotNull(previous(),
+ "Failed to find %s in scope of %s", childQName, this);
+
+ final QName prevQName = childQName.bindTo(prev.getQName().getModule());
+ return verifyNotNull(prev.findSchemaTreeGenerator(prevQName),
+ "Failed to find child %s (proxy for %s) in %s", prevQName, childQName, prev).getOriginal();
+ }
+
+ @Override
+ final @Nullable AbstractExplicitGenerator<?> findSchemaTreeGenerator(final QName qname) {
+ final AbstractExplicitGenerator<?> found = super.findSchemaTreeGenerator(qname);
+ return found != null ? found : findInferredGenerator(qname);
+ }
+
+ private @Nullable AbstractExplicitGenerator<?> findInferredGenerator(final QName qname) {
+ // First search our local groupings ...
+ for (GroupingGenerator grouping : groupings) {
+ final AbstractExplicitGenerator<?> gen = grouping.findSchemaTreeGenerator(
+ qname.bindTo(grouping.statement().argument().getModule()));
+ if (gen != null) {
+ return gen;
+ }
+ }
+ // ... next try local augments, which may have groupings themselves
+ for (AbstractAugmentGenerator augment : augments) {
+ final AbstractExplicitGenerator<?> gen = augment.findSchemaTreeGenerator(qname);
+ if (gen != null) {
+ return gen;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Update the specified builder to implement interfaces generated for the {@code grouping} statements this generator
+ * is using.
+ *
+ * @param builder Target builder
+ * @param builderFactory factory for creating {@link TypeBuilder}s
+ * @return The number of groupings this type uses.
+ */
+ final int addUsesInterfaces(final GeneratedTypeBuilder builder, final TypeBuilderFactory builderFactory) {
+ for (GroupingGenerator grp : groupings) {
+ builder.addImplementsType(grp.getGeneratedType(builderFactory));
+ }
+ return groupings.size();
+ }
+
+ static final void addAugmentable(final GeneratedTypeBuilder builder) {
+ builder.addImplementsType(BindingTypes.augmentable(builder));
+ }
+
+ final void addGetterMethods(final GeneratedTypeBuilder builder, final TypeBuilderFactory builderFactory) {
+ for (Generator child : this) {
+ // Only process explicit generators here
+ if (child instanceof AbstractExplicitGenerator) {
+ ((AbstractExplicitGenerator<?>) child).addAsGetterMethod(builder, builderFactory);
+ }
+
+ final GeneratedType enclosedType = child.enclosedType(builderFactory);
+ if (enclosedType instanceof GeneratedTransferObject) {
+ builder.addEnclosingTransferObject((GeneratedTransferObject) enclosedType);
+ } else if (enclosedType instanceof Enumeration) {
+ builder.addEnumeration((Enumeration) enclosedType);
+ } else {
+ verify(enclosedType == null, "Unhandled enclosed type %s in %s", enclosedType, child);
+ }
+ }
+ }
+
+ private List<Generator> createChildren(final EffectiveStatement<?, ?> statement) {
+ final List<Generator> tmp = new ArrayList<>();
+ final List<AbstractAugmentGenerator> tmpAug = new ArrayList<>();
+
+ for (EffectiveStatement<?, ?> stmt : statement.effectiveSubstatements()) {
+ if (stmt instanceof ActionEffectiveStatement) {
+ if (!isAugmenting(stmt)) {
+ tmp.add(new ActionGenerator((ActionEffectiveStatement) stmt, this));
+ }
+ } else if (stmt instanceof AnydataEffectiveStatement) {
+ if (!isAugmenting(stmt)) {
+ tmp.add(new OpaqueObjectGenerator<>((AnydataEffectiveStatement) stmt, this));
+ }
+ } else if (stmt instanceof AnyxmlEffectiveStatement) {
+ if (!isAugmenting(stmt)) {
+ tmp.add(new OpaqueObjectGenerator<>((AnyxmlEffectiveStatement) stmt, this));
+ }
+ } else if (stmt instanceof CaseEffectiveStatement) {
+ tmp.add(new CaseGenerator((CaseEffectiveStatement) stmt, this));
+ } else if (stmt instanceof ChoiceEffectiveStatement) {
+ // FIXME: use isOriginalDeclaration() ?
+ if (!isAddedByUses(stmt)) {
+ tmp.add(new ChoiceGenerator((ChoiceEffectiveStatement) stmt, this));
+ }
+ } else if (stmt instanceof ContainerEffectiveStatement) {
+ if (isOriginalDeclaration(stmt)) {
+ tmp.add(new ContainerGenerator((ContainerEffectiveStatement) stmt, this));
+ }
+ } else if (stmt instanceof GroupingEffectiveStatement) {
+ tmp.add(new GroupingGenerator((GroupingEffectiveStatement) stmt, this));
+ } else if (stmt instanceof IdentityEffectiveStatement) {
+ tmp.add(new IdentityGenerator((IdentityEffectiveStatement) stmt, this));
+ } else if (stmt instanceof InputEffectiveStatement) {
+ // FIXME: do not generate legacy RPC layout
+ tmp.add(this instanceof RpcGenerator ? new RpcContainerGenerator((InputEffectiveStatement) stmt, this)
+ : new OperationContainerGenerator((InputEffectiveStatement) stmt, this));
+ } else if (stmt instanceof LeafEffectiveStatement) {
+ if (!isAugmenting(stmt)) {
+ tmp.add(new LeafGenerator((LeafEffectiveStatement) stmt, this));
+ }
+ } else if (stmt instanceof LeafListEffectiveStatement) {
+ if (!isAugmenting(stmt)) {
+ tmp.add(new LeafListGenerator((LeafListEffectiveStatement) stmt, this));
+ }
+ } else if (stmt instanceof ListEffectiveStatement) {
+ if (isOriginalDeclaration(stmt)) {
+ final ListGenerator listGen = new ListGenerator((ListEffectiveStatement) stmt, this);
+ tmp.add(listGen);
+
+ final KeyGenerator keyGen = listGen.keyGenerator();
+ if (keyGen != null) {
+ tmp.add(keyGen);
+ }
+ }
+ } else if (stmt instanceof NotificationEffectiveStatement) {
+ if (!isAugmenting(stmt)) {
+ tmp.add(new NotificationGenerator((NotificationEffectiveStatement) stmt, this));
+ }
+ } else if (stmt instanceof OutputEffectiveStatement) {
+ // FIXME: do not generate legacy RPC layout
+ tmp.add(this instanceof RpcGenerator ? new RpcContainerGenerator((OutputEffectiveStatement) stmt, this)
+ : new OperationContainerGenerator((OutputEffectiveStatement) stmt, this));
+ } else if (stmt instanceof RpcEffectiveStatement) {
+ tmp.add(new RpcGenerator((RpcEffectiveStatement) stmt, this));
+ } else if (stmt instanceof TypedefEffectiveStatement) {
+ tmp.add(new TypedefGenerator((TypedefEffectiveStatement) stmt, this));
+ } else if (stmt instanceof AugmentEffectiveStatement) {
+ if (this instanceof ModuleGenerator) {
+ tmpAug.add(new ModuleAugmentGenerator((AugmentEffectiveStatement) stmt, this));
+ }
+ } else if (stmt instanceof UsesEffectiveStatement) {
+ final UsesEffectiveStatement uses = (UsesEffectiveStatement) stmt;
+ for (EffectiveStatement<?, ?> usesSub : uses.effectiveSubstatements()) {
+ if (usesSub instanceof AugmentEffectiveStatement) {
+ tmpAug.add(new UsesAugmentGenerator((AugmentEffectiveStatement) usesSub, this, uses));
+ }
+ }
+ } else {
+ LOG.trace("Ignoring statement {}", stmt);
+ continue;
+ }
+ }
+
+ // Sort augments and add them last. This ensures child iteration order always reflects potential
+ // interdependencies, hence we do not need to worry about them.
+ tmpAug.sort(AbstractAugmentGenerator.COMPARATOR);
+ tmp.addAll(tmpAug);
+
+ // Compatibility FooService and FooListener interfaces, only generated for modules.
+ if (this instanceof ModuleGenerator) {
+ final ModuleGenerator moduleGen = (ModuleGenerator) this;
+
+ final List<NotificationGenerator> notifs = tmp.stream()
+ .filter(NotificationGenerator.class::isInstance)
+ .map(NotificationGenerator.class::cast)
+ .collect(Collectors.toUnmodifiableList());
+ if (!notifs.isEmpty()) {
+ tmp.add(new NotificationServiceGenerator(moduleGen, notifs));
+ }
+
+ final List<RpcGenerator> rpcs = tmp.stream()
+ .filter(RpcGenerator.class::isInstance)
+ .map(RpcGenerator.class::cast)
+ .collect(Collectors.toUnmodifiableList());
+ if (!rpcs.isEmpty()) {
+ tmp.add(new RpcServiceGenerator(moduleGen, rpcs));
+ }
+ }
+
+ return List.copyOf(tmp);
+ }
+
+ // Utility equivalent of (!isAddedByUses(stmt) && !isAugmenting(stmt)). Takes advantage of relationship between
+ // CopyableNode and AddedByUsesAware
+ private static boolean isOriginalDeclaration(final EffectiveStatement<?, ?> stmt) {
+ if (stmt instanceof AddedByUsesAware) {
+ if (((AddedByUsesAware) stmt).isAddedByUses()
+ || stmt instanceof CopyableNode && ((CopyableNode) stmt).isAugmenting()) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private static boolean isAddedByUses(final EffectiveStatement<?, ?> stmt) {
+ return stmt instanceof AddedByUsesAware && ((AddedByUsesAware) stmt).isAddedByUses();
+ }
+
+ private static boolean isAugmenting(final EffectiveStatement<?, ?> stmt) {
+ return stmt instanceof CopyableNode && ((CopyableNode) stmt).isAugmenting();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+
+/**
+ * A simple {@link Generator} which (potentially) has dependencies on other generators.
+ */
+abstract class AbstractDependentGenerator<T extends EffectiveStatement<?, ?>> extends AbstractExplicitGenerator<T> {
+ AbstractDependentGenerator(final T statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ /**
+ * Discover and link this generator's dependencies.
+ *
+ * @param context GeneratorContext of this generator
+ */
+ abstract void linkDependencies(GeneratorContext context);
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static com.google.common.base.Verify.verify;
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.base.MoreObjects.ToStringHelper;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotableTypeBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.common.AbstractQName;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.model.api.AddedByUsesAware;
+import org.opendaylight.yangtools.yang.model.api.CopyableNode;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * An explicit {@link Generator}, associated with a particular {@link EffectiveStatement}.
+ */
+public abstract class AbstractExplicitGenerator<T extends EffectiveStatement<?, ?>> extends Generator
+ implements CopyableNode {
+ private static final Logger LOG = LoggerFactory.getLogger(AbstractExplicitGenerator.class);
+
+ private final @NonNull T statement;
+
+ // FIXME: this, along with AbstractTypeObjectGenerator's (and TypedefGenerator's) fields should be better-controlled
+ // with explicit sequencing guards. It it currently stands, we are expending two (or more) additional fields
+ // to express downstream linking. If we had the concept of resolution step (an enum), we could just get by
+ // with a simple queue of Step/Callback pairs, which would trigger as needed. For an example see how
+ // AbstractTypeObjectGenerator manages baseGen/inferred fields.
+ private AbstractExplicitGenerator<?> prev;
+
+ AbstractExplicitGenerator(final T statement) {
+ this.statement = requireNonNull(statement);
+ }
+
+ AbstractExplicitGenerator(final T statement, final AbstractCompositeGenerator<?> parent) {
+ super(parent);
+ this.statement = requireNonNull(statement);
+ }
+
+ /**
+ * Return the {@link EffectiveStatement} associated with this generator.
+ *
+ * @return An EffectiveStatement
+ */
+ public final @NonNull T statement() {
+ return statement;
+ }
+
+ @Override
+ public final boolean isAddedByUses() {
+ return statement instanceof AddedByUsesAware && ((AddedByUsesAware) statement).isAddedByUses();
+ }
+
+ @Override
+ public final boolean isAugmenting() {
+ return statement instanceof CopyableNode && ((CopyableNode) statement).isAugmenting();
+ }
+
+ final void linkOriginalGenerator(final GeneratorContext context) {
+ if (isAddedByUses() || isAugmenting()) {
+ LOG.trace("Linking {}", this);
+ prev = getParent().getOriginalChild(getQName());
+ LOG.trace("Linked {} to {}", this, prev);
+ }
+ }
+
+ final @Nullable AbstractExplicitGenerator<?> previous() {
+ return prev;
+ }
+
+ @NonNull AbstractExplicitGenerator<?> getOriginal() {
+ return prev == null ? this : prev.getOriginal();
+ }
+
+ @Nullable AbstractExplicitGenerator<?> findSchemaTreeGenerator(final QName qname) {
+ for (Generator child : this) {
+ if (child instanceof AbstractExplicitGenerator) {
+ final AbstractExplicitGenerator<?> gen = (AbstractExplicitGenerator<?>) child;
+ final EffectiveStatement<?, ?> stmt = gen.statement();
+ if (stmt instanceof SchemaTreeEffectiveStatement && qname.equals(stmt.argument())) {
+ return gen;
+ }
+ }
+ }
+ return null;
+ }
+
+ final @NonNull AbstractExplicitGenerator<?> resolveSchemaNode(final @NonNull SchemaNodeIdentifier path,
+ final @Nullable QNameModule targetModule) {
+ AbstractExplicitGenerator<?> current = this;
+ QNameModule currentModule = targetModule;
+
+ for (QName next : path.getNodeIdentifiers()) {
+ final QName qname = currentModule == null ? next : next.bindTo(currentModule);
+ current = verifyNotNull(current.findSchemaTreeGenerator(qname),
+ "Failed to find %s as %s in %s", next, qname, current);
+
+ final QNameModule foundNamespace = current.getQName().getModule();
+ if (!foundNamespace.equals(qname.getModule())) {
+ // We have located a different QName than the one we were looking for. We need to make sure we adjust
+ // all subsequent QNames to this new namespace
+ currentModule = foundNamespace;
+ }
+ }
+
+ return current;
+ }
+
+ final @NonNull QName getQName() {
+ final Object arg = statement.argument();
+ verify(arg instanceof QName, "Unexpected argument %s", arg);
+ return (QName) arg;
+ }
+
+ @NonNull AbstractQName localName() {
+ // FIXME: this should be done in a nicer way
+ final Object argument = statement.argument();
+ verify(argument instanceof AbstractQName, "Illegal argument %s", argument);
+ return (AbstractQName) argument;
+ }
+
+ @Override
+ ClassPlacement classPlacement() {
+ // We process nodes introduced through augment or uses separately
+ // FIXME: this is not quite right!
+ return isAddedByUses() || isAugmenting() ? ClassPlacement.NONE : ClassPlacement.TOP_LEVEL;
+ }
+
+ @Override
+ Member createMember(final CollisionDomain domain) {
+ return domain.addPrimary(new CamelCaseNamingStrategy(namespace(), localName()));
+ }
+
+ void addAsGetterMethod(final @NonNull GeneratedTypeBuilderBase<?> builder,
+ final @NonNull TypeBuilderFactory builderFactory) {
+ if (isAugmenting()) {
+ // Do not process augmented nodes: they will be taken care of in their home augmentation
+ return;
+ }
+ if (isAddedByUses()) {
+ // If this generator has been added by a uses node, it is already taken care of by the corresponding
+ // grouping. There is one exception to this rule: 'type leafref' can use a relative path to point
+ // outside of its home grouping. In this case we need to examine the instantiation until we succeed in
+ // resolving the reference.
+ addAsGetterMethodOverride(builder, builderFactory);
+ return;
+ }
+
+ constructGetter(builder, methodReturnType(builderFactory));
+ }
+
+ MethodSignatureBuilder constructGetter(final GeneratedTypeBuilderBase<?> builder, final Type returnType) {
+ final MethodSignatureBuilder getMethod = builder
+ .addMethod(BindingMapping.getGetterMethodName(localName().getLocalName()))
+ .setReturnType(returnType);
+
+ annotateDeprecatedIfNecessary(getMethod);
+// addComment(getMethod, node);
+
+ return getMethod;
+ }
+
+ void addAsGetterMethodOverride(final @NonNull GeneratedTypeBuilderBase<?> builder,
+ final @NonNull TypeBuilderFactory builderFactory) {
+ // No-op for most cases
+ }
+
+ @NonNull Type methodReturnType(final @NonNull TypeBuilderFactory builderFactory) {
+ return getGeneratedType(builderFactory);
+ }
+
+ final void annotateDeprecatedIfNecessary(final AnnotableTypeBuilder builder) {
+ annotateDeprecatedIfNecessary(statement, builder);
+ }
+
+ @Override
+ ToStringHelper addToStringAttributes(final ToStringHelper helper) {
+ helper.add("argument", statement.argument());
+
+ if (isAddedByUses()) {
+ helper.addValue("addedByUses");
+ }
+ if (isAugmenting()) {
+ helper.addValue("augmenting");
+ }
+ return helper;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * An implicit {@link Generator}, not associated with any particular statement.
+ */
+abstract class AbstractImplicitGenerator extends Generator {
+ AbstractImplicitGenerator(final ModuleGenerator parent) {
+ super(parent);
+ }
+
+ @Override
+ final void pushToInference(final SchemaInferenceStack inferenceStack) {
+ // No-op
+ }
+
+ @Override
+ final ClassPlacement classPlacement() {
+ return ClassPlacement.TOP_LEVEL;
+ }
+
+ @Override
+ final Member createMember(final CollisionDomain domain) {
+ return domain.addSecondary(((ModuleGenerator) getParent()).getPrefixMember(), classSuffix());
+ }
+
+ abstract @NonNull String classSuffix();
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static com.google.common.base.Verify.verify;
+
+import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.yangtools.odlext.model.api.ContextReferenceEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.TypeAware;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Common base class for {@link LeafGenerator} and {@link LeafListGenerator}.
+ */
+abstract class AbstractTypeAwareGenerator<T extends DataTreeEffectiveStatement<?>>
+ extends AbstractTypeObjectGenerator<T> {
+ private static final Logger LOG = LoggerFactory.getLogger(AbstractTypeAwareGenerator.class);
+
+ private IdentityGenerator contextType;
+
+ AbstractTypeAwareGenerator(final T statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ verify(statement instanceof TypeAware, "Unexpected statement %s", statement);
+ }
+
+ @Override
+ final void pushToInference(final SchemaInferenceStack dataTree) {
+ dataTree.enterDataTree(statement().getIdentifier());
+ }
+
+ @Override
+ final void bindDerivedGenerators(final TypeReference reference) {
+ // No-op
+ }
+
+ @Override
+ final void bindTypeDefinition(final GeneratorContext context) {
+ super.bindTypeDefinition(context);
+ contextType = statement().findFirstEffectiveSubstatementArgument(ContextReferenceEffectiveStatement.class)
+ .map(context::resolveIdentity)
+ .orElse(null);
+ }
+
+ @Override
+ final TypeDefinition<?> extractTypeDefinition() {
+ return ((TypedDataSchemaNode) statement()).getType();
+ }
+
+ @Override
+ final JavaTypeName createTypeName() {
+ // FIXME: we should be be assigning a non-conflict name here
+ return getParent().typeName().createEnclosed(assignedName(), "$");
+ }
+
+ @Override
+ final GeneratedTransferObject createDerivedType(final TypeBuilderFactory builderFactory,
+ final GeneratedTransferObject baseType) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ final MethodSignatureBuilder constructGetter(final GeneratedTypeBuilderBase<?> builder, final Type returnType) {
+ final MethodSignatureBuilder ret = super.constructGetter(builder, returnType);
+
+ if (contextType != null) {
+ ret.addAnnotation(BindingTypes.ROUTING_CONTEXT)
+ .addParameter("value", contextType.typeName().toString() + ".class");
+ }
+
+ return ret;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static com.google.common.base.Verify.verify;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.TypeReference.ResolvedLeafref;
+import org.opendaylight.mdsal.binding.model.api.AccessModifier;
+import org.opendaylight.mdsal.binding.model.api.ConcreteType;
+import org.opendaylight.mdsal.binding.model.api.Enumeration;
+import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
+import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.model.api.Restrictions;
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
+import org.opendaylight.mdsal.binding.model.util.BaseYangTypes;
+import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.mdsal.binding.model.util.TypeConstants;
+import org.opendaylight.mdsal.binding.model.util.Types;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.AbstractEnumerationBuilder;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.GeneratedPropertyBuilderImpl;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.yang.binding.RegexPatterns;
+import org.opendaylight.yangtools.yang.binding.TypeObject;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.YangConstants;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.BaseEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.LengthEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PathEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PatternExpression;
+import org.opendaylight.yangtools.yang.model.api.stmt.RangeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
+import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
+import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
+import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
+import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.TypeDefinitions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Common base class for {@link TypedefGenerator} and {@link AbstractTypeAwareGenerator}. This encompasses three
+ * different statements with two different semantics:
+ * <ul>
+ * <li>{@link TypedefGenerator}s always result in a generated {@link TypeObject}, even if the semantics is exactly
+ * the same as its base type. This aligns with {@code typedef} defining a new type.<li>
+ * <li>{@link LeafGenerator}s and {@link LeafListGenerator}s, on the other hand, do not generate a {@link TypeObject}
+ * unless absolutely necassary. This aligns with {@code leaf} and {@code leaf-list} being mapped onto a property
+ * of its parent type.<li>
+ * </ul>
+ *
+ * <p>
+ * To throw a bit of confusion into the mix, there are three exceptions to those rules:
+ * <ul>
+ * <li>
+ * {@code identityref} definitions never result in a type definition being emitted. The reason for this has to do
+ * with identity type mapping as well as history of our codebase.
+ *
+ * <p>
+ * The problem at hand is inconsistency between the fact that identity is mapped to a {@link Class}, which is also
+ * returned from leaves which specify it like this:
+ * <pre>
+ * <code>
+ * identity iden;
+ *
+ * container foo {
+ * leaf foo {
+ * type identityref {
+ * base iden;
+ * }
+ * }
+ * }
+ * </code>
+ * </pre>
+ * which results in fine-looking
+ * <pre>
+ * <code>
+ * interface Foo {
+ * Class<? extends Iden> getFoo();
+ * }
+ * </code>
+ * </pre>
+ *
+ * <p>
+ * This gets more dicey if we decide to extend the previous snippet to also include:
+ * <pre>
+ * <code>
+ * typedef bar-ref {
+ * type identityref {
+ * base iden;
+ * }
+ * }
+ *
+ * container bar {
+ * leaf bar {
+ * type bar-ref;
+ * }
+ * }
+ * </code>
+ * </pre>
+ *
+ * <p>
+ * Now we have competing requirements: {@code typedef} would like us to use encapsulation to capture the defined
+ * type, while {@code getBar()} wants us to retain shape with getFoo(), as it should not matter how the
+ * {@code identityref} was formed. We need to pick between:
+ * <ol>
+ * <li>
+ * <pre>
+ * <code>
+ * public class BarRef extends ScalarTypeObject<Class<? extends Iden>> {
+ * Class<? extends Iden> getValue() {
+ * // ...
+ * }
+ * }
+ *
+ * interface Bar {
+ * BarRef getBar();
+ * }
+ * </code>
+ * </pre>
+ * </li>
+ * <li>
+ * <pre>
+ * <code>
+ * interface Bar {
+ * Class<? extends Iden> getBar();
+ * }
+ * </code>
+ * </pre>
+ * </li>
+ * </ol>
+ *
+ * <p>
+ * Here the second option is more user-friendly, as the type system works along the lines of <b>reference</b>
+ * semantics, treating and {@code Bar.getBar()} and {@code Foo.getFoo()} as equivalent. The first option would
+ * force users to go through explicit encapsulation, for no added benefit as the {@code typedef} cannot possibly add
+ * anything useful to the actual type semantics.
+ * </li>
+ * <li>
+ * {@code leafref} definitions never result in a type definition being emitted. The reasons for this are similar to
+ * {@code identityref}, but have an additional twist: a {@leafref} can target a relative path, which may only be
+ * resolved at a particular instantiation.
+ *
+ * Take the example of the following model:
+ * <pre>
+ * <code>
+ * grouping grp {
+ * typedef ref {
+ * type leafref {
+ * path ../xyzzy;
+ * }
+ * }
+ *
+ * leaf foo {
+ * type ref;
+ * }
+ * }
+ *
+ * container bar {
+ uses grp;
+ *
+ * leaf xyzzy {
+ * type string;
+ * }
+ * }
+ *
+ * container baz {
+ * uses grp;
+ *
+ * leaf xyzzy {
+ * type int32;
+ * }
+ * }
+ * </code>
+ * </pre>
+ *
+ * The {@code typedef ref} points to outside of the grouping, and hence the type of {@code leaf foo} is polymorphic:
+ * the definition in {@code grouping grp} needs to use {@code Object}, whereas the instantiations in
+ * {@code container bar} and {@code container baz} need to use {@code String} and {@link Integer} respectively.
+ * Expressing the resulting interface contracts requires return type specialization and run-time checks. An
+ * intermediate class generated for the typedef would end up being a hindrance without any benefit.
+ * <li>
+ * <li>
+ * {@code enumeration} definitions never result in a derived type. This is because these are mapped to Java
+ * {@code enum}, which does not allow subclassing.
+ * <li>
+ * </ul>
+ *
+ * <p>
+ * At the end of the day, the mechanic translation rules are giving way to correctly mapping the semantics -- which in
+ * both of the exception cases boil down to tracking type indirection. Intermediate constructs involved in tracking
+ * type indirection in YANG constructs is therefore explicitly excluded from the generated Java code, but the Binding
+ * Specification still takes them into account when determining types as outlined above.
+ */
+abstract class AbstractTypeObjectGenerator<T extends EffectiveStatement<?, ?>> extends AbstractDependentGenerator<T> {
+ private static final class UnionDependencies implements Immutable {
+ private final Map<EffectiveStatement<?, ?>, TypeReference> identityTypes = new HashMap<>();
+ private final Map<EffectiveStatement<?, ?>, TypeReference> leafTypes = new HashMap<>();
+ private final Map<QName, TypedefGenerator> baseTypes = new HashMap<>();
+
+ UnionDependencies(final TypeEffectiveStatement<?> type, final GeneratorContext context) {
+ resolveUnionDependencies(context, type);
+ }
+
+ private void resolveUnionDependencies(final GeneratorContext context, final TypeEffectiveStatement<?> union) {
+ for (EffectiveStatement<?, ?> stmt : union.effectiveSubstatements()) {
+ if (stmt instanceof TypeEffectiveStatement) {
+ final TypeEffectiveStatement<?> type = (TypeEffectiveStatement<?>) stmt;
+ final QName typeName = type.argument();
+ if (TypeDefinitions.IDENTITYREF.equals(typeName)) {
+ if (!identityTypes.containsKey(stmt)) {
+ identityTypes.put(stmt, TypeReference.identityRef(
+ type.streamEffectiveSubstatements(BaseEffectiveStatement.class)
+ .map(BaseEffectiveStatement::argument)
+ .map(context::resolveIdentity)
+ .collect(Collectors.toUnmodifiableList())));
+ }
+ } else if (TypeDefinitions.LEAFREF.equals(typeName)) {
+ if (!leafTypes.containsKey(stmt)) {
+ leafTypes.put(stmt, TypeReference.leafRef(context.resolveLeafref(
+ type.findFirstEffectiveSubstatementArgument(PathEffectiveStatement.class)
+ .orElseThrow())));
+ }
+ } else if (TypeDefinitions.UNION.equals(typeName)) {
+ resolveUnionDependencies(context, type);
+ } else if (!isBuiltinName(typeName) && !baseTypes.containsKey(typeName)) {
+ baseTypes.put(typeName, context.resolveTypedef(typeName));
+ }
+ }
+ }
+ }
+ }
+
+ private static final Logger LOG = LoggerFactory.getLogger(AbstractTypeObjectGenerator.class);
+ static final ImmutableMap<QName, Type> SIMPLE_TYPES = ImmutableMap.<QName, Type>builder()
+ .put(TypeDefinitions.BINARY, BaseYangTypes.BINARY_TYPE)
+ .put(TypeDefinitions.BOOLEAN, BaseYangTypes.BOOLEAN_TYPE)
+ .put(TypeDefinitions.DECIMAL64, BaseYangTypes.DECIMAL64_TYPE)
+ .put(TypeDefinitions.EMPTY, BaseYangTypes.EMPTY_TYPE)
+ .put(TypeDefinitions.INSTANCE_IDENTIFIER, BaseYangTypes.INSTANCE_IDENTIFIER)
+ .put(TypeDefinitions.INT8, BaseYangTypes.INT8_TYPE)
+ .put(TypeDefinitions.INT16, BaseYangTypes.INT16_TYPE)
+ .put(TypeDefinitions.INT32, BaseYangTypes.INT32_TYPE)
+ .put(TypeDefinitions.INT64, BaseYangTypes.INT64_TYPE)
+ .put(TypeDefinitions.STRING, BaseYangTypes.STRING_TYPE)
+ .put(TypeDefinitions.UINT8, BaseYangTypes.UINT8_TYPE)
+ .put(TypeDefinitions.UINT16, BaseYangTypes.UINT16_TYPE)
+ .put(TypeDefinitions.UINT32, BaseYangTypes.UINT32_TYPE)
+ .put(TypeDefinitions.UINT64, BaseYangTypes.UINT64_TYPE)
+ .build();
+
+ private final TypeEffectiveStatement<?> type;
+
+ /**
+ * The generator corresponding to our YANG base type. It produces the superclass of our encapsulated type. If it is
+ * {@code null}, this generator is the root of the hierarchy.
+ */
+ private TypedefGenerator baseGen;
+ private TypeReference refType;
+ private List<GeneratedType> auxiliaryGeneratedTypes = List.of();
+ private UnionDependencies unionDependencies;
+ private List<AbstractTypeObjectGenerator<?>> inferred = List.of();
+
+ AbstractTypeObjectGenerator(final T statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ type = statement().findFirstEffectiveSubstatement(TypeEffectiveStatement.class).orElseThrow();
+ }
+
+ @Override
+ public final List<GeneratedType> auxiliaryGeneratedTypes() {
+ return auxiliaryGeneratedTypes;
+ }
+
+ @Override
+ final void linkDependencies(final GeneratorContext context) {
+ verify(inferred != null, "Duplicate linking of %s", this);
+
+ final QName typeName = type.argument();
+ if (isBuiltinName(typeName)) {
+ verify(inferred.isEmpty(), "Unexpected non-empty downstreams in %s", this);
+ inferred = null;
+ return;
+ }
+
+ final AbstractExplicitGenerator<?> prev = previous();
+ if (prev != null) {
+ verify(prev instanceof AbstractTypeObjectGenerator, "Unexpected previous %s", prev);
+ ((AbstractTypeObjectGenerator<?>) prev).linkInferred(this);
+ } else {
+ linkBaseGen(context.resolveTypedef(typeName));
+ }
+ }
+
+ private void linkInferred(final AbstractTypeObjectGenerator<?> downstream) {
+ if (inferred == null) {
+ downstream.linkBaseGen(verifyNotNull(baseGen, "Mismatch on linking between %s and %s", this, downstream));
+ return;
+ }
+
+ if (inferred.isEmpty()) {
+ inferred = new ArrayList<>(2);
+ }
+ inferred.add(downstream);
+ }
+
+ private void linkBaseGen(final TypedefGenerator upstreamBaseGen) {
+ verify(baseGen == null, "Attempted to replace base %s with %s in %s", baseGen, upstreamBaseGen, this);
+ final List<AbstractTypeObjectGenerator<?>> downstreams = verifyNotNull(inferred,
+ "Duplicated linking of %s", this);
+ baseGen = verifyNotNull(upstreamBaseGen);
+ baseGen.addDerivedGenerator(this);
+ inferred = null;
+
+ for (AbstractTypeObjectGenerator<?> downstream : downstreams) {
+ downstream.linkBaseGen(upstreamBaseGen);
+ }
+ }
+
+ void bindTypeDefinition(final GeneratorContext context) {
+ if (baseGen != null) {
+ // We have registered with baseGen, it will push the type to us
+ return;
+ }
+
+ final QName arg = type.argument();
+ if (TypeDefinitions.IDENTITYREF.equals(arg)) {
+ refType = TypeReference.identityRef(type.streamEffectiveSubstatements(BaseEffectiveStatement.class)
+ .map(BaseEffectiveStatement::argument)
+ .map(context::resolveIdentity)
+ .collect(Collectors.toUnmodifiableList()));
+ } else if (TypeDefinitions.LEAFREF.equals(arg)) {
+ refType = TypeReference.leafRef(context.resolveLeafref(
+ type.findFirstEffectiveSubstatementArgument(PathEffectiveStatement.class).orElseThrow()));
+ } else if (TypeDefinitions.UNION.equals(arg)) {
+ unionDependencies = new UnionDependencies(type, context);
+ LOG.trace("Resolved union {} to dependencies {}", type, unionDependencies);
+ }
+
+ LOG.trace("Resolved base {} to generator {}", type, refType);
+ bindDerivedGenerators(refType);
+ }
+
+ final void bindTypeDefinition(final @Nullable TypeReference reference) {
+ refType = reference;
+ LOG.trace("Resolved derived {} to generator {}", type, refType);
+ }
+
+ private static boolean isBuiltinName(final QName typeName) {
+ return YangConstants.RFC6020_YANG_MODULE.equals(typeName.getModule());
+ }
+
+ abstract void bindDerivedGenerators(@Nullable TypeReference reference);
+
+ @Override
+ final ClassPlacement classPlacement() {
+ if (refType != null) {
+ // Reference types never create a new type
+ return ClassPlacement.NONE;
+ }
+ if (isDerivedEnumeration()) {
+ // Types derived from an enumeration never create a new type, as that would have to be a subclass of an enum
+ // and since enums are final, that can never happen.
+ return ClassPlacement.NONE;
+ }
+ return classPlacementImpl();
+ }
+
+ @NonNull ClassPlacement classPlacementImpl() {
+ // TODO: make this a lot more accurate by comparing the effective delta between the base type and the effective
+ // restricted type. We should not be generating a type for constructs like:
+ //
+ // leaf foo {
+ // type uint8 { range 0..255; }
+ // }
+ //
+ // or
+ //
+ // typedef foo {
+ // type uint8 { range 0..100; }
+ // }
+ //
+ // leaf foo {
+ // type foo { range 0..100; }
+ // }
+ //
+ // Which is relatively easy to do for integral types, but is way more problematic for 'pattern'
+ // restrictions. Nevertheless we can define the mapping in a way which can be implemented with relative
+ // ease.
+ return baseGen != null || SIMPLE_TYPES.containsKey(type.argument()) || isAddedByUses() || isAugmenting()
+ ? ClassPlacement.NONE : ClassPlacement.MEMBER;
+ }
+
+ @Override
+ final GeneratedType getGeneratedType(final TypeBuilderFactory builderFactory) {
+ // For derived enumerations defer to base type
+ return isDerivedEnumeration() ? baseGen.getGeneratedType(builderFactory)
+ : super.getGeneratedType(builderFactory);
+ }
+
+ final boolean isEnumeration() {
+ return baseGen != null ? baseGen.isEnumeration() : TypeDefinitions.ENUMERATION.equals(type.argument());
+ }
+
+ final boolean isDerivedEnumeration() {
+ return baseGen != null && baseGen.isEnumeration();
+ }
+
+ @Override
+ Type methodReturnType(final TypeBuilderFactory builderFactory) {
+ return methodReturnElementType(builderFactory);
+ }
+
+ final @NonNull Type methodReturnElementType(final @NonNull TypeBuilderFactory builderFactory) {
+ final GeneratedType generatedType = tryGeneratedType(builderFactory);
+ if (generatedType != null) {
+ // We have generated a type here, so return it. This covers 'bits', 'enumeration' and 'union'.
+ return generatedType;
+ }
+
+ if (refType != null) {
+ // This is a reference type of some kind. Defer to its judgement as to what the return type is.
+ return refType.methodReturnType(builderFactory);
+ }
+
+ final AbstractExplicitGenerator<?> prev = previous();
+ if (prev != null) {
+ // We have been added through augment/uses, defer to the original definition
+ return prev.methodReturnType(builderFactory);
+ }
+
+ final Type baseType;
+ if (baseGen == null) {
+ final QName qname = type.argument();
+ baseType = verifyNotNull(SIMPLE_TYPES.get(qname), "Cannot resolve type %s in %s", qname, this);
+ } else {
+ // We are derived from a base generator. Defer to its type for return.
+ baseType = baseGen.getGeneratedType(builderFactory);
+ }
+
+ return restrictType(baseType, computeRestrictions(), builderFactory);
+ }
+
+ private static @NonNull Type restrictType(final @NonNull Type baseType, final Restrictions restrictions,
+ final TypeBuilderFactory builderFactory) {
+ if (restrictions == null || restrictions.isEmpty()) {
+ // No additional restrictions, return base type
+ return baseType;
+ }
+
+ if (!(baseType instanceof GeneratedTransferObject)) {
+ // This is a simple Java type, just wrap it with new restrictions
+ return Types.restrictedType(baseType, restrictions);
+ }
+
+ // Base type is a GTO, we need to re-adjust it with new restrictions
+ final GeneratedTransferObject gto = (GeneratedTransferObject) baseType;
+ final GeneratedTOBuilder builder = builderFactory.newGeneratedTOBuilder(gto.getIdentifier());
+ final GeneratedTransferObject parent = gto.getSuperType();
+ if (parent != null) {
+ builder.setExtendsType(parent);
+ }
+ builder.setRestrictions(restrictions);
+ for (GeneratedProperty gp : gto.getProperties()) {
+ builder.addProperty(gp.getName())
+ .setValue(gp.getValue())
+ .setReadOnly(gp.isReadOnly())
+ .setAccessModifier(gp.getAccessModifier())
+ .setReturnType(gp.getReturnType())
+ .setFinal(gp.isFinal())
+ .setStatic(gp.isStatic());
+ }
+ return builder.build();
+ }
+
+ @Override
+ final void addAsGetterMethodOverride(final GeneratedTypeBuilderBase<?> builder,
+ final TypeBuilderFactory builderFactory) {
+ if (!(refType instanceof ResolvedLeafref)) {
+ // We are not dealing with a leafref or have nothing to add
+ return;
+ }
+
+ final AbstractTypeObjectGenerator<?> prev =
+ (AbstractTypeObjectGenerator<?>) verifyNotNull(previous(), "Missing previous link in %s", this);
+ if (prev.refType instanceof ResolvedLeafref) {
+ // We should be already inheriting the correct type
+ return;
+ }
+
+ // Note: this may we wrapped for leaf-list, hence we need to deal with that
+ final Type myType = methodReturnType(builderFactory);
+ LOG.trace("Override of {} to {}", this, myType);
+ final MethodSignatureBuilder getter = constructGetter(builder, myType);
+ getter.addAnnotation(OVERRIDE_ANNOTATION);
+ annotateDeprecatedIfNecessary(getter);
+ }
+
+ final @Nullable Restrictions computeRestrictions() {
+ final List<ValueRange> length = type.findFirstEffectiveSubstatementArgument(LengthEffectiveStatement.class)
+ .orElse(List.of());
+ final List<ValueRange> range = type.findFirstEffectiveSubstatementArgument(RangeEffectiveStatement.class)
+ .orElse(List.of());
+ final List<PatternExpression> patterns = type.streamEffectiveSubstatements(PatternEffectiveStatement.class)
+ .map(PatternEffectiveStatement::argument)
+ .collect(Collectors.toUnmodifiableList());
+
+ if (length.isEmpty() && range.isEmpty() && patterns.isEmpty()) {
+ return null;
+ }
+
+ return BindingGeneratorUtil.getRestrictions(extractTypeDefinition());
+ }
+
+ @Override
+ final GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ if (baseGen != null) {
+ final GeneratedType baseType = baseGen.getGeneratedType(builderFactory);
+ verify(baseType instanceof GeneratedTransferObject, "Unexpected base type %s", baseType);
+ return createDerivedType(builderFactory, (GeneratedTransferObject) baseType);
+ }
+
+ // FIXME: why do we need this boolean?
+ final boolean isTypedef = this instanceof TypedefGenerator;
+ final QName arg = type.argument();
+ if (TypeDefinitions.BITS.equals(arg)) {
+ return createBits(builderFactory, typeName(), currentModule(), extractTypeDefinition(), isTypedef);
+ } else if (TypeDefinitions.ENUMERATION.equals(arg)) {
+ return createEnumeration(builderFactory, typeName(), currentModule(),
+ (EnumTypeDefinition) extractTypeDefinition());
+ } else if (TypeDefinitions.UNION.equals(arg)) {
+ final List<GeneratedType> tmp = new ArrayList<>(1);
+ final GeneratedTransferObject ret = createUnion(tmp, builderFactory, statement(), unionDependencies,
+ typeName(), currentModule(), type, isTypedef, extractTypeDefinition());
+ auxiliaryGeneratedTypes = List.copyOf(tmp);
+ return ret;
+ } else {
+ return createSimple(builderFactory, typeName(), currentModule(),
+ verifyNotNull(SIMPLE_TYPES.get(arg), "Unhandled type %s", arg), extractTypeDefinition());
+ }
+ }
+
+ private static @NonNull GeneratedTransferObject createBits(final TypeBuilderFactory builderFactory,
+ final JavaTypeName typeName, final ModuleGenerator module, final TypeDefinition<?> typedef,
+ final boolean isTypedef) {
+ final GeneratedTOBuilder builder = builderFactory.newGeneratedTOBuilder(typeName);
+ builder.setTypedef(isTypedef);
+ builder.addImplementsType(BindingTypes.TYPE_OBJECT);
+ builder.setBaseType(typedef);
+
+ for (Bit bit : ((BitsTypeDefinition) typedef).getBits()) {
+ final String name = bit.getName();
+ GeneratedPropertyBuilder genPropertyBuilder = builder.addProperty(BindingMapping.getPropertyName(name));
+ genPropertyBuilder.setReadOnly(true);
+ genPropertyBuilder.setReturnType(BaseYangTypes.BOOLEAN_TYPE);
+
+ builder.addEqualsIdentity(genPropertyBuilder);
+ builder.addHashIdentity(genPropertyBuilder);
+ builder.addToStringProperty(genPropertyBuilder);
+ }
+
+ // builder.setSchemaPath(typedef.getPath());
+ builder.setModuleName(module.statement().argument().getLocalName());
+ addCodegenInformation(typedef, builder);
+ annotateDeprecatedIfNecessary(typedef, builder);
+ makeSerializable(builder);
+ return builder.build();
+ }
+
+ private static @NonNull Enumeration createEnumeration(final TypeBuilderFactory builderFactory,
+ final JavaTypeName typeName, final ModuleGenerator module, final EnumTypeDefinition typedef) {
+ // TODO units for typedef enum
+ final AbstractEnumerationBuilder builder = builderFactory.newEnumerationBuilder(typeName);
+
+ typedef.getDescription().map(BindingGeneratorUtil::encodeAngleBrackets)
+ .ifPresent(builder::setDescription);
+ typedef.getReference().ifPresent(builder::setReference);
+
+ builder.setModuleName(module.statement().argument().getLocalName());
+ builder.updateEnumPairsFromEnumTypeDef(typedef);
+ return builder.toInstance();
+ }
+
+ private static @NonNull GeneratedType createSimple(final TypeBuilderFactory builderFactory,
+ final JavaTypeName typeName, final ModuleGenerator module, final Type javaType,
+ final TypeDefinition<?> typedef) {
+ final String moduleName = module.statement().argument().getLocalName();
+ final GeneratedTOBuilder builder = builderFactory.newGeneratedTOBuilder(typeName);
+ builder.setTypedef(true);
+ builder.addImplementsType(BindingTypes.scalarTypeObject(javaType));
+
+ final GeneratedPropertyBuilder genPropBuilder = builder.addProperty(TypeConstants.VALUE_PROP);
+ genPropBuilder.setReturnType(javaType);
+ builder.addEqualsIdentity(genPropBuilder);
+ builder.addHashIdentity(genPropBuilder);
+ builder.addToStringProperty(genPropBuilder);
+
+ builder.setRestrictions(BindingGeneratorUtil.getRestrictions(typedef));
+
+// builder.setSchemaPath(typedef.getPath());
+ builder.setModuleName(moduleName);
+ addCodegenInformation(typedef, builder);
+
+ annotateDeprecatedIfNecessary(typedef, builder);
+
+ if (javaType instanceof ConcreteType && "String".equals(javaType.getName()) && typedef.getBaseType() != null) {
+ addStringRegExAsConstant(builder, resolveRegExpressions(typedef));
+ }
+ addUnits(builder, typedef);
+
+ makeSerializable(builder);
+ return builder.build();
+ }
+
+ private static @NonNull GeneratedTransferObject createUnion(final List<GeneratedType> auxiliaryGeneratedTypes,
+ final TypeBuilderFactory builderFactory, final EffectiveStatement<?, ?> definingStatement,
+ final UnionDependencies dependencies, final JavaTypeName typeName, final ModuleGenerator module,
+ final TypeEffectiveStatement<?> type, final boolean isTypedef, final TypeDefinition<?> typedef) {
+ final GeneratedUnionBuilder builder = builderFactory.newGeneratedUnionBuilder(typeName);
+ builder.addImplementsType(BindingTypes.TYPE_OBJECT);
+ builder.setIsUnion(true);
+
+// builder.setSchemaPath(typedef.getPath());
+ builder.setModuleName(module.statement().argument().getLocalName());
+ addCodegenInformation(definingStatement, builder);
+
+ annotateDeprecatedIfNecessary(definingStatement, builder);
+
+ // Pattern string is the key, XSD regex is the value. The reason for this choice is that the pattern carries
+ // also negation information and hence guarantees uniqueness.
+ final Map<String, String> expressions = new HashMap<>();
+
+ // Linear list of properties generated from subtypes. We need this information for runtime types, as it allows
+ // direct mapping of type to corresponding property -- without having to resort to re-resolving the leafrefs
+ // again.
+ final List<String> typeProperties = new ArrayList<>();
+
+ for (EffectiveStatement<?, ?> stmt : type.effectiveSubstatements()) {
+ if (stmt instanceof TypeEffectiveStatement) {
+ final TypeEffectiveStatement<?> subType = (TypeEffectiveStatement<?>) stmt;
+ final QName subName = subType.argument();
+ final String localName = subName.getLocalName();
+
+ String propSource = localName;
+ final Type generatedType;
+ if (TypeDefinitions.UNION.equals(subName)) {
+ final JavaTypeName subUnionName = typeName.createEnclosed(
+ provideAvailableNameForGenTOBuilder(typeName.simpleName()));
+ final GeneratedTransferObject subUnion = createUnion(auxiliaryGeneratedTypes, builderFactory,
+ definingStatement, dependencies, subUnionName, module, subType, isTypedef,
+ subType.getTypeDefinition());
+ builder.addEnclosingTransferObject(subUnion);
+ propSource = subUnionName.simpleName();
+ generatedType = subUnion;
+ } else if (TypeDefinitions.ENUMERATION.equals(subName)) {
+ final Enumeration subEnumeration = createEnumeration(builderFactory,
+ typeName.createEnclosed(BindingMapping.getClassName(localName), "$"), module,
+ (EnumTypeDefinition) subType.getTypeDefinition());
+ builder.addEnumeration(subEnumeration);
+ generatedType = subEnumeration;
+ } else if (TypeDefinitions.BITS.equals(subName)) {
+ final GeneratedTransferObject subBits = createBits(builderFactory,
+ typeName.createEnclosed(BindingMapping.getClassName(localName), "$"), module,
+ subType.getTypeDefinition(), isTypedef);
+ builder.addEnclosingTransferObject(subBits);
+ generatedType = subBits;
+ } else if (TypeDefinitions.IDENTITYREF.equals(subName)) {
+ generatedType = verifyNotNull(dependencies.identityTypes.get(stmt),
+ "Cannot resolve identityref %s in %s", stmt, definingStatement)
+ .methodReturnType(builderFactory);
+ } else if (TypeDefinitions.LEAFREF.equals(subName)) {
+ generatedType = verifyNotNull(dependencies.leafTypes.get(stmt),
+ "Cannot resolve leafref %s in %s", stmt, definingStatement)
+ .methodReturnType(builderFactory);
+ } else {
+ Type baseType = SIMPLE_TYPES.get(subName);
+ if (baseType == null) {
+ // This has to be a reference to a typedef, let's lookup it up and pick the its type
+ final AbstractTypeObjectGenerator<?> baseGen = verifyNotNull(
+ dependencies.baseTypes.get(subName), "Cannot resolve base type %s in %s", subName,
+ definingStatement);
+ baseType = baseGen.methodReturnType(builderFactory);
+
+ // FIXME: This is legacy behaviour for leafrefs:
+ if (baseGen.refType instanceof TypeReference.Leafref) {
+ // if there already is a compatible property, do not generate a new one
+ final Type search = baseType;
+
+ final String matching = builder.getProperties().stream()
+ .filter(prop -> search == ((GeneratedPropertyBuilderImpl) prop).getReturnType())
+ .findFirst()
+ .map(GeneratedPropertyBuilder::getName)
+ .orElse(null);
+ if (matching != null) {
+ typeProperties.add(matching);
+ continue;
+ }
+
+ // ... otherwise generate this weird property name
+ propSource = BindingMapping.getUnionLeafrefMemberName(builder.getName(),
+ baseType.getName());
+ }
+ }
+
+ generatedType = restrictType(baseType,
+ BindingGeneratorUtil.getRestrictions(type.getTypeDefinition()), builderFactory);
+ }
+
+ final String propName = BindingMapping.getPropertyName(propSource);
+ typeProperties.add(propName);
+
+ if (builder.containsProperty(propName)) {
+ /*
+ * FIXME: this is not okay, as we are ignoring multiple base types. For example in the case of:
+ *
+ * type union {
+ * type string {
+ * length 1..5;
+ * }
+ * type string {
+ * length 8..10;
+ * }
+ * }
+ *
+ * We are ending up losing the information about 8..10 being an alternative. This is also the case
+ * for leafrefs -- we are performing property compression as well (see above). While it is alluring
+ * to merge these into 'length 1..5|8..10', that may not be generally feasible.
+ *
+ * We should resort to a counter of conflicting names, i.e. the second string would be mapped to
+ * 'string1' or similar.
+ */
+ continue;
+ }
+
+ final GeneratedPropertyBuilder propBuilder = builder
+ .addProperty(propName)
+ .setReturnType(generatedType);
+
+ builder.addEqualsIdentity(propBuilder);
+ builder.addHashIdentity(propBuilder);
+ builder.addToStringProperty(propBuilder);
+ }
+ }
+
+ // Record property names if needed
+ builder.setTypePropertyNames(typeProperties);
+
+ addStringRegExAsConstant(builder, expressions);
+ addUnits(builder, typedef);
+
+ makeSerializable(builder);
+ final GeneratedTransferObject ret = builder.build();
+
+ // Define a corresponding union builder. Typedefs are always anchored at a Java package root,
+ // so we are placing the builder alongside the union.
+ final GeneratedTOBuilder unionBuilder = builderFactory.newGeneratedTOBuilder(unionBuilderName(typeName));
+ unionBuilder.setIsUnionBuilder(true);
+ unionBuilder.addMethod("getDefaultInstance")
+ .setAccessModifier(AccessModifier.PUBLIC)
+ .setStatic(true)
+ .setReturnType(ret)
+ .addParameter(Types.STRING, "defaultValue");
+ auxiliaryGeneratedTypes.add(unionBuilder.build());
+
+ return ret;
+ }
+
+ // FIXME: this can be a source of conflicts as we are not guarding against nesting
+ private static @NonNull JavaTypeName unionBuilderName(final JavaTypeName unionName) {
+ final StringBuilder sb = new StringBuilder();
+ for (String part : unionName.localNameComponents()) {
+ sb.append(part);
+ }
+ return JavaTypeName.create(unionName.packageName(), sb.append("Builder").toString());
+ }
+
+ // FIXME: we should not rely on TypeDefinition
+ abstract @NonNull TypeDefinition<?> extractTypeDefinition();
+
+ abstract @NonNull GeneratedTransferObject createDerivedType(@NonNull TypeBuilderFactory builderFactory,
+ @NonNull GeneratedTransferObject baseType);
+
+ /**
+ * Adds to the {@code genTOBuilder} the constant which contains regular expressions from the {@code expressions}.
+ *
+ * @param genTOBuilder generated TO builder to which are {@code regular expressions} added
+ * @param expressions list of string which represent regular expressions
+ */
+ static void addStringRegExAsConstant(final GeneratedTOBuilder genTOBuilder, final Map<String, String> expressions) {
+ if (!expressions.isEmpty()) {
+ genTOBuilder.addConstant(Types.listTypeFor(BaseYangTypes.STRING_TYPE), TypeConstants.PATTERN_CONSTANT_NAME,
+ ImmutableMap.copyOf(expressions));
+ }
+ }
+
+ /**
+ * Converts the pattern constraints from {@code typedef} to the list of the strings which represents these
+ * constraints.
+ *
+ * @param typedef extended type in which are the pattern constraints sought
+ * @return list of strings which represents the constraint patterns
+ * @throws IllegalArgumentException if <code>typedef</code> equals null
+ */
+ static Map<String, String> resolveRegExpressions(final TypeDefinition<?> typedef) {
+ return typedef instanceof StringTypeDefinition
+ // TODO: run diff against base ?
+ ? resolveRegExpressions(((StringTypeDefinition) typedef).getPatternConstraints())
+ : ImmutableMap.of();
+ }
+
+ /**
+ * Converts the pattern constraints to the list of the strings which represents these constraints.
+ *
+ * @param patternConstraints list of pattern constraints
+ * @return list of strings which represents the constraint patterns
+ */
+ private static Map<String, String> resolveRegExpressions(final List<PatternConstraint> patternConstraints) {
+ if (patternConstraints.isEmpty()) {
+ return ImmutableMap.of();
+ }
+
+ final Map<String, String> regExps = Maps.newHashMapWithExpectedSize(patternConstraints.size());
+ for (PatternConstraint patternConstraint : patternConstraints) {
+ String regEx = patternConstraint.getJavaPatternString();
+
+ // The pattern can be inverted
+ final Optional<ModifierKind> optModifier = patternConstraint.getModifier();
+ if (optModifier.isPresent()) {
+ regEx = applyModifier(optModifier.get(), regEx);
+ }
+
+ regExps.put(regEx, patternConstraint.getRegularExpressionString());
+ }
+
+ return regExps;
+ }
+
+ /**
+ * Returns string which contains the same value as <code>name</code> but integer suffix is incremented by one. If
+ * <code>name</code> contains no number suffix, a new suffix initialized at 1 is added. A suffix is actually
+ * composed of a '$' marker, which is safe, as no YANG identifier can contain '$', and a unsigned decimal integer.
+ *
+ * @param name string with name of augmented node
+ * @return string with the number suffix incremented by one (or 1 is added)
+ */
+ private static String provideAvailableNameForGenTOBuilder(final String name) {
+ final int dollar = name.indexOf('$');
+ if (dollar == -1) {
+ return name + "$1";
+ }
+
+ final int newSuffix = Integer.parseUnsignedInt(name.substring(dollar + 1)) + 1;
+ verify(newSuffix > 0, "Suffix counter overflow");
+ return name.substring(0, dollar + 1) + newSuffix;
+ }
+
+ private static String applyModifier(final ModifierKind modifier, final String pattern) {
+ switch (modifier) {
+ case INVERT_MATCH:
+ return RegexPatterns.negatePatternString(pattern);
+ default:
+ LOG.warn("Ignoring unhandled modifier {}", modifier);
+ return pattern;
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.model.api.DefaultType;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.yangtools.yang.model.api.stmt.ActionEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * Generator corresponding to a {@code action} statement.
+ */
+final class ActionGenerator extends AbstractCompositeGenerator<ActionEffectiveStatement> {
+ ActionGenerator(final ActionEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ @Override
+ void pushToInference(final SchemaInferenceStack dataTree) {
+ dataTree.enterSchemaTree(statement().getIdentifier());
+ }
+
+ @Override
+ ClassPlacement classPlacement() {
+ // We do not generate Actions for groupings as they are inexact, and do not capture an actual instantiation --
+ // therefore they do not have an InstanceIdentifier. We still need to allocate a package name for the purposes
+ // of generating shared classes for input/output
+ return getParent() instanceof GroupingGenerator ? ClassPlacement.PHANTOM : ClassPlacement.TOP_LEVEL;
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+ builder.addImplementsType(implementedType(builderFactory));
+
+ final ModuleGenerator module = currentModule();
+ module.addQNameConstant(builder, statement().argument().getLocalName());
+
+// addGetterMethods(builder, builderFactory);
+
+ annotateDeprecatedIfNecessary(builder);
+ if (builderFactory instanceof TypeBuilderFactory.Codegen) {
+ addCodegenInformation(module, statement(), builder);
+ }
+
+ return builder.build();
+ }
+
+ private @NonNull Type implementedType(final TypeBuilderFactory builderFactory) {
+ final GeneratedType input = getChild(this, InputEffectiveStatement.class).getOriginal()
+ .getGeneratedType(builderFactory);
+ final GeneratedType output = getChild(this, OutputEffectiveStatement.class).getOriginal()
+ .getGeneratedType(builderFactory);
+
+ final AbstractCompositeGenerator<?> parent = getParent();
+ if (parent instanceof ListGenerator) {
+ final KeyGenerator keyGen = ((ListGenerator) parent).keyGenerator();
+ if (keyGen != null) {
+ return BindingTypes.keyedListAction(DefaultType.of(parent.typeName()),
+ keyGen.getGeneratedType(builderFactory), input, output);
+ }
+ }
+
+ return BindingTypes.action(DefaultType.of(parent.typeName()), input, output);
+ }
+
+ @Override
+ void addAsGetterMethod(final GeneratedTypeBuilderBase<?> builder, final TypeBuilderFactory builderFactory) {
+ // actions are a separate concept
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.base.MoreObjects.ToStringHelper;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.opendaylight.yangtools.yang.common.AbstractQName;
+
+@NonNullByDefault
+final class CamelCaseNamingStrategy extends ClassNamingStrategy {
+ private final StatementNamespace namespace;
+ private final AbstractQName nodeIdentifier;
+
+ CamelCaseNamingStrategy(final StatementNamespace namespace, final AbstractQName nodeIdentifier) {
+ this.namespace = requireNonNull(namespace);
+ this.nodeIdentifier = requireNonNull(nodeIdentifier);
+ }
+
+ @Override
+ AbstractQName nodeIdentifier() {
+ return nodeIdentifier;
+ }
+
+ StatementNamespace namespace() {
+ return namespace;
+ }
+
+ @Override
+ @NonNull ClassNamingStrategy fallback() {
+ return new CamelCaseWithNamespaceNamingStrategy(this);
+ }
+
+ @Override
+ ToStringHelper addToStringAttributes(final ToStringHelper helper) {
+ return helper.add("localName", nodeIdentifier.getLocalName()).add("namespace", namespace);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.base.MoreObjects.ToStringHelper;
+import org.opendaylight.yangtools.yang.common.AbstractQName;
+
+final class CamelCaseWithNamespaceNamingStrategy extends ClassNamingStrategy {
+ private final CamelCaseNamingStrategy delegate;
+
+ CamelCaseWithNamespaceNamingStrategy(final CamelCaseNamingStrategy delegate) {
+ this.delegate = requireNonNull(delegate);
+ }
+
+ @Override
+ AbstractQName nodeIdentifier() {
+ return delegate.nodeIdentifier();
+ }
+
+ @Override
+ String simpleClassName() {
+ return delegate.namespace().appendSuffix(delegate.simpleClassName());
+ }
+
+ @Override
+ ClassNamingStrategy fallback() {
+ // FIXME: MDSAL-503: add a BijectiveNamingStrategy
+ // The algorithm needs to essentially fall back to using escape-based translation scheme, where each
+ // localName results in a unique name, while not conflicting with any possible preferredName. The exact
+ // mechanics for that are TBD. A requirement for that mapping is that it must not rely on definition
+ // order.
+ //
+ // But there is another possible step: since we are assigning 14 different statements into the default
+ // namespace (which did not add a suffix), we can try to assign a statement-derived suffix. To make
+ // things easier, we use two-characters: AC, AD, AU, AX, CA, CH, CO, IP, LE, LI, LL, NO, OP, RP.
+ return null;
+ }
+
+ @Override
+ ToStringHelper addToStringAttributes(final ToStringHelper helper) {
+ return helper.add("delegate", delegate);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static com.google.common.base.Verify.verify;
+
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * Generator corresponding to a {@code case} statement.
+ */
+final class CaseGenerator extends AbstractCompositeGenerator<CaseEffectiveStatement> {
+ CaseGenerator(final CaseEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ @Override
+ void pushToInference(final SchemaInferenceStack dataTree) {
+ // No-op
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+ builder.addImplementsType(BindingTypes.DATA_OBJECT);
+
+ // We also are implementing target choice's type. This is tricky, as we need to cover two distinct cases:
+ // - being a child of a choice (i.e. normal definition)
+ // - being a child of an augment (i.e. augmented into a choice)
+ final AbstractCompositeGenerator<?> parent = getParent();
+ final ChoiceGenerator choice;
+ if (parent instanceof AbstractAugmentGenerator) {
+ final AbstractCompositeGenerator<?> target = ((AbstractAugmentGenerator) parent).targetGenerator();
+ verify(target instanceof ChoiceGenerator, "Unexpected parent augment %s target %s", parent, target);
+ choice = (ChoiceGenerator) target;
+ } else {
+ verify(parent instanceof ChoiceGenerator, "Unexpected parent %s", parent);
+ choice = (ChoiceGenerator) parent;
+ }
+
+ // Most generators have a parent->child dependency due to parent methods' return types and therefore children
+ // must not request parent's type. That is not true for choice->case relationship and hence we do not need to
+ // go through DefaultType here.
+ builder.addImplementsType(choice.getGeneratedType(builderFactory));
+ addAugmentable(builder);
+ addUsesInterfaces(builder, builderFactory);
+ addConcreteInterfaceMethods(builder);
+
+ final ModuleGenerator module = currentModule();
+ module.addQNameConstant(builder, localName().getLocalName());
+
+ addGetterMethods(builder, builderFactory);
+
+ annotateDeprecatedIfNecessary(builder);
+ if (builderFactory instanceof TypeBuilderFactory.Codegen) {
+ addCodegenInformation(module, statement(), builder);
+ }
+ builder.setModuleName(module.statement().argument().getLocalName());
+
+ return builder.build();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.opendaylight.mdsal.binding.model.api.DefaultType;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * Generator corresponding to a {@code choice} statement.
+ */
+final class ChoiceGenerator extends AbstractCompositeGenerator<ChoiceEffectiveStatement> {
+ ChoiceGenerator(final ChoiceEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ @Override
+ void pushToInference(final SchemaInferenceStack dataTree) {
+ // No-op
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+ builder.addImplementsType(BindingTypes.choiceIn(DefaultType.of(getParent().typeName())));
+
+ final ModuleGenerator module = currentModule();
+ module.addQNameConstant(builder, localName().getLocalName());
+
+ annotateDeprecatedIfNecessary(builder);
+ if (builderFactory instanceof TypeBuilderFactory.Codegen) {
+ addCodegenInformation(module, statement(), builder);
+ }
+// newType.setSchemaPath(schemaNode.getPath());
+ builder.setModuleName(module.statement().argument().getLocalName());
+
+
+ return builder.build();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.MoreObjects.ToStringHelper;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.yang.common.AbstractQName;
+
+/**
+ * Enumeration of known strategies for translating a YANG node identifier into a Java package name segment or a Java
+ * simple class name.
+ */
+abstract class ClassNamingStrategy implements Immutable {
+ /**
+ * Return the YANG node identifier backing this naming strategy. Only the {@link AbstractQName#getLocalName()} part
+ * of the identifier is significant.
+ *
+ * @return YANG node identifier.
+ */
+ abstract @NonNull AbstractQName nodeIdentifier();
+
+ /**
+ * Return the simple Java class name assigned by this naming strategy.
+ *
+ * @return Simple class name
+ */
+ @NonNull String simpleClassName() {
+ return BindingMapping.getClassName(nodeIdentifier().getLocalName());
+ }
+
+ /**
+ * Return the fallback naming strategy. The fallback is used if this strategy ends up being insufficient in
+ * assigning a unique name.
+ *
+ * @return Fallback strategy, {@code null} if there is no fallback.
+ */
+ abstract @Nullable ClassNamingStrategy fallback();
+
+ @Override
+ public final String toString() {
+ return addToStringAttributes(MoreObjects.toStringHelper(this)).toString();
+ }
+
+ abstract @NonNull ToStringHelper addToStringAttributes(@NonNull ToStringHelper helper);
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+
+/**
+ * Enumeration of possible placements for a particular type. This provides a tie-in between the {@link Generator} tree
+ * and the layout of resulting Java classes as dictated by {@link JavaTypeName} and {@link CollisionDomain}.
+ */
+enum ClassPlacement {
+ /**
+ * Generated class is a
+ * <a href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-7.html#jls-7.6">top level type declaration</a>.
+ */
+ TOP_LEVEL,
+ /**
+ * Generated class is a
+ * <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.5">member type declaration</a>.
+ */
+ MEMBER,
+ /**
+ * There is no class being generated, hence placement is irrelevant.
+ */
+ NONE,
+ /**
+ * There is no class being generated, just as with {@link #NONE}, but there is at least one {@link #TOP_LEVEL}
+ * generated class which derives its name from this {@link Generator} and is participating in the same
+ * {@link CollisionDomain}.
+ */
+ PHANTOM;
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.MoreObjects.ToStringHelper;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Multimap;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map.Entry;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.AbstractQName;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+
+final class CollisionDomain {
+ abstract class Member {
+ private String currentPackage;
+ private String currentClass;
+
+ final @NonNull String currentClass() {
+ if (currentClass == null) {
+ currentClass = computeCurrentClass();
+ }
+ return currentClass;
+ }
+
+ final @NonNull String currentPackage() {
+ if (currentPackage == null) {
+ currentPackage = computeCurrentPackage();
+ }
+ return currentPackage;
+ }
+
+ abstract String computeCurrentClass();
+
+ abstract String computeCurrentPackage();
+
+ boolean signalConflict() {
+ solved = false;
+ currentClass = null;
+ currentPackage = null;
+ return true;
+ }
+
+ @Override
+ public final String toString() {
+ return addToStringAttributes(MoreObjects.toStringHelper(this).omitNullValues()).toString();
+ }
+
+ ToStringHelper addToStringAttributes(final ToStringHelper helper) {
+ return helper.add("class", currentClass).add("package", currentPackage);
+ }
+ }
+
+ private class Primary extends Member {
+ private ClassNamingStrategy strategy;
+ private List<Secondary> secondaries = List.of();
+
+ Primary(final ClassNamingStrategy strategy) {
+ this.strategy = requireNonNull(strategy);
+ }
+
+ @Override
+ final String computeCurrentClass() {
+ return strategy.simpleClassName();
+ }
+
+ @Override
+ final String computeCurrentPackage() {
+ return packageString(strategy.nodeIdentifier());
+ }
+
+ final void addSecondary(final Secondary secondary) {
+ if (secondaries.isEmpty()) {
+ secondaries = new ArrayList<>();
+ }
+ secondaries.add(requireNonNull(secondary));
+ }
+
+ @Override
+ final boolean signalConflict() {
+ final ClassNamingStrategy newStrategy = strategy.fallback();
+ if (newStrategy == null) {
+ return false;
+ }
+
+ strategy = newStrategy;
+ super.signalConflict();
+ for (Secondary secondary : secondaries) {
+ secondary.primaryConflict();
+ }
+ return true;
+ }
+
+ @Override
+ final ToStringHelper addToStringAttributes(final ToStringHelper helper) {
+ return super.addToStringAttributes(helper.add("strategy", strategy));
+ }
+ }
+
+ private final class Prefix extends Primary {
+ Prefix(final ClassNamingStrategy strategy) {
+ super(strategy);
+ }
+ }
+
+ private abstract class Secondary extends Member {
+ private final String classSuffix;
+ final Primary classPrimary;
+
+ Secondary(final Primary primary, final String classSuffix) {
+ this.classPrimary = requireNonNull(primary);
+ this.classSuffix = requireNonNull(classSuffix);
+ primary.addSecondary(this);
+ }
+
+ @Override
+ final String computeCurrentClass() {
+ return classPrimary.currentClass() + classSuffix;
+ }
+
+ @Override
+ final boolean signalConflict() {
+ return classPrimary.signalConflict();
+ }
+
+ final void primaryConflict() {
+ super.signalConflict();
+ }
+ }
+
+ private final class LeafSecondary extends Secondary {
+ LeafSecondary(final Primary classPrimary, final String classSuffix) {
+ super(classPrimary, classSuffix);
+ }
+
+ @Override
+ String computeCurrentPackage() {
+ // This should never happen
+ throw new UnsupportedOperationException();
+ }
+ }
+
+ private final class SuffixSecondary extends Secondary {
+ private final AbstractQName packageSuffix;
+
+ SuffixSecondary(final Primary primaryClass, final String classSuffix, final AbstractQName packageSuffix) {
+ super(primaryClass, classSuffix);
+ this.packageSuffix = requireNonNull(packageSuffix);
+ }
+
+ @Override
+ String computeCurrentPackage() {
+ return classPrimary.currentPackage() + '.' + packageString(packageSuffix);
+ }
+ }
+
+ private final class AugmentSecondary extends Secondary {
+ private final SchemaNodeIdentifier packageSuffix;
+
+ AugmentSecondary(final Primary primary, final String classSuffix, final SchemaNodeIdentifier packageSuffix) {
+ super(primary, classSuffix);
+ this.packageSuffix = requireNonNull(packageSuffix);
+ }
+
+ @Override
+ String computeCurrentPackage() {
+ final Iterator<QName> it = packageSuffix.getNodeIdentifiers().iterator();
+
+ final StringBuilder sb = new StringBuilder();
+ sb.append(packageString(it.next()));
+ while (it.hasNext()) {
+ sb.append('.').append(packageString(it.next()));
+ }
+ return sb.toString();
+ }
+ }
+
+ private List<Member> members = List.of();
+ private boolean solved;
+
+ @NonNull Member addPrefix(final ClassNamingStrategy strategy) {
+ // Note that contrary to the method name, we are not adding the result to members
+ return new Prefix(strategy);
+ }
+
+ @NonNull Member addPrimary(final ClassNamingStrategy strategy) {
+ return addMember(new Primary(strategy));
+ }
+
+ @NonNull Member addSecondary(final Member primary, final String classSuffix) {
+ return addMember(new LeafSecondary(castPrimary(primary), classSuffix));
+ }
+
+ @NonNull Member addSecondary(final Member primary, final String classSuffix, final AbstractQName packageSuffix) {
+ return addMember(new SuffixSecondary(castPrimary(primary), classSuffix, packageSuffix));
+ }
+
+ @NonNull Member addSecondary(final Member classPrimary, final String classSuffix,
+ final SchemaNodeIdentifier packageSuffix) {
+ return addMember(new AugmentSecondary(castPrimary(classPrimary), classSuffix, packageSuffix));
+ }
+
+ private static @NonNull Primary castPrimary(final Member primary) {
+ verify(primary instanceof Primary, "Unexpected primary %s", primary);
+ return (Primary) primary;
+ }
+
+ /*
+ * Naming child nodes is tricky.
+ *
+ * We map multiple YANG namespaces (see YangStatementNamespace) onto a single Java namespace
+ * (package/class names), hence we can have legal conflicts on same localName.
+ *
+ * Furthermore not all localNames are valid Java class/package identifiers, hence even non-equal localNames can
+ * conflict on their mapping.
+ *
+ * Final complication is that we allow user to control preferred name, or we generate one, and we try to come up
+ * with nice names like 'foo-bar' becoming FooBar and similar.
+ *
+ * In all cases we want to end up with cutest possible names while also never creating duplicates. For that we
+ * start with each child telling us their preferred name and we collect name->child mapping.
+ */
+ boolean findSolution() {
+ if (solved) {
+ // Already solved, nothing to do
+ return false;
+ }
+ if (members.size() < 2) {
+ // Zero or one member: no conflict possible
+ solved = true;
+ return false;
+ }
+
+ boolean result = false;
+ do {
+ // Construct mapping to discover any naming overlaps.
+ final Multimap<String, Member> toAssign = ArrayListMultimap.create();
+ for (Member member : members) {
+ toAssign.put(member.currentClass(), member);
+ }
+
+ // Deal with names which do not create a conflict. This is very simple and also very effective, we rarely
+ // run into conflicts.
+ final var it = toAssign.asMap().entrySet().iterator();
+ while (it.hasNext()) {
+ final Entry<String, Collection<Member>> entry = it.next();
+ final Collection<Member> assignees = entry.getValue();
+ if (assignees.size() == 1) {
+ it.remove();
+ }
+ }
+
+ // This looks counter-intuitive, but the idea is simple: the act of assigning a different strategy may end
+ // up creating conflicts where there were none -- including in this domain. Marking this bit allows us to
+ // react to such invalidation chains and retry the process.
+ solved = true;
+ if (!toAssign.isEmpty()) {
+ result = true;
+ // We still have some assignments we need to resolve -- which means we need to change their strategy.
+ for (Collection<Member> conflicting : toAssign.asMap().values()) {
+ int remaining = 0;
+ for (Member member : conflicting) {
+ if (!member.signalConflict()) {
+ remaining++;
+ }
+ }
+ checkState(remaining < 2, "Failed to resolve members %s", conflicting);
+ }
+ }
+ } while (!solved);
+
+ return result;
+ }
+
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
+ private @NonNull Member addMember(final @NonNull Member member) {
+ if (members.isEmpty()) {
+ members = new ArrayList<>();
+ }
+ members.add(member);
+ return member;
+ }
+
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
+ private static @NonNull String packageString(final AbstractQName component) {
+ // Replace dashes with dots, as dashes are not allowed in package names
+ return component.getLocalName().replace('-', '.');
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.yangtools.yang.model.api.stmt.ContainerEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * Generator corresponding to a {@code container} statement.
+ */
+final class ContainerGenerator extends AbstractCompositeGenerator<ContainerEffectiveStatement> {
+ ContainerGenerator(final ContainerEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ @Override
+ void pushToInference(final SchemaInferenceStack dataTree) {
+ dataTree.enterDataTree(statement().getIdentifier());
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+ addImplementsChildOf(builder);
+ addAugmentable(builder);
+ addUsesInterfaces(builder, builderFactory);
+ addConcreteInterfaceMethods(builder);
+
+ final ModuleGenerator module = currentModule();
+ module.addQNameConstant(builder, localName().getLocalName());
+
+ addGetterMethods(builder, builderFactory);
+
+ annotateDeprecatedIfNecessary(builder);
+ if (builderFactory instanceof TypeBuilderFactory.Codegen) {
+ addCodegenInformation(module, statement(), builder);
+ }
+ builder.setModuleName(module.statement().argument().getLocalName());
+// builder.setSchemaPath(node.getPath());
+
+ return builder.build();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import java.util.List;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
+
+interface GeneratedUnionBuilder extends GeneratedTOBuilder {
+
+ void setTypePropertyNames(List<String> propertyNames);
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+import static org.opendaylight.mdsal.binding.model.util.Types.STRING;
+import static org.opendaylight.mdsal.binding.model.util.Types.classType;
+import static org.opendaylight.mdsal.binding.model.util.Types.primitiveBooleanType;
+import static org.opendaylight.mdsal.binding.model.util.Types.primitiveIntType;
+import static org.opendaylight.mdsal.binding.model.util.Types.wildcardTypeFor;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.MoreObjects.ToStringHelper;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
+import org.opendaylight.mdsal.binding.model.api.AccessModifier;
+import org.opendaylight.mdsal.binding.model.api.DefaultType;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
+import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotableTypeBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
+import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.mdsal.binding.model.util.TypeComments;
+import org.opendaylight.mdsal.binding.model.util.Types;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.GeneratedPropertyBuilderImpl;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.DataContainer;
+import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
+import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.ri.type.TypeBuilder;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * A single node in generator tree. Each node will eventually resolve to a generated Java class. Each node also can have
+ * a number of children, which are generators corresponding to the YANG subtree of this node.
+ */
+public abstract class Generator implements Iterable<Generator> {
+ private static final JavaTypeName DEPRECATED_ANNOTATION = JavaTypeName.create(Deprecated.class);
+ static final JavaTypeName OVERRIDE_ANNOTATION = JavaTypeName.create(Override.class);
+
+ private final AbstractCompositeGenerator<?> parent;
+
+ private Optional<Member> member;
+ private GeneratorResult result;
+ private JavaTypeName typeName;
+ private String javaPackage;
+
+ Generator() {
+ this.parent = null;
+ }
+
+ Generator(final AbstractCompositeGenerator<?> parent) {
+ this.parent = requireNonNull(parent);
+ }
+
+ public final @NonNull Optional<GeneratedType> generatedType() {
+ return Optional.ofNullable(result.generatedType());
+ }
+
+ public @NonNull List<GeneratedType> auxiliaryGeneratedTypes() {
+ return List.of();
+ }
+
+ @Override
+ public Iterator<Generator> iterator() {
+ return Collections.emptyIterator();
+ }
+
+ /**
+ * Return the {@link AbstractCompositeGenerator} inside which this generator is defined. It is illegal to call this
+ * method on a {@link ModuleGenerator}.
+ *
+ * @return Parent generator
+ */
+ final @NonNull AbstractCompositeGenerator<?> getParent() {
+ return verifyNotNull(parent, "No parent for %s", this);
+ }
+
+ boolean isEmpty() {
+ return true;
+ }
+
+ @Nullable Generator findGenerator(final EffectiveStatement<?, ?> stmt) {
+ return null;
+ }
+
+ final @NonNull Generator getGenerator(final EffectiveStatement<?, ?> stmt) {
+ return verifyNotNull(findGenerator(stmt), "Cannot match statement %s in %s", stmt, this);
+ }
+
+ /**
+ * Return the namespace of this statement.
+ *
+ * @return Corresponding namespace
+ * @throws UnsupportedOperationException if this node does not have a corresponding namespace
+ */
+ @NonNull StatementNamespace namespace() {
+ return StatementNamespace.DEFAULT;
+ }
+
+ @NonNull ModuleGenerator currentModule() {
+ return getParent().currentModule();
+ }
+
+ /**
+ * Push this statement into a {@link SchemaInferenceStack} so that the stack contains a resolvable {@code data tree}
+ * hierarchy.
+ *
+ * @param inferenceStack Target inference stack
+ */
+ abstract void pushToInference(@NonNull SchemaInferenceStack inferenceStack);
+
+ abstract @NonNull ClassPlacement classPlacement();
+
+ final @NonNull Member getMember() {
+ return verifyNotNull(ensureMember(), "No member for %s", this);
+ }
+
+ final Member ensureMember() {
+ if (member == null) {
+ final ClassPlacement placement = classPlacement();
+ switch (placement) {
+ case NONE:
+ member = Optional.empty();
+ break;
+ case MEMBER:
+ case PHANTOM:
+ case TOP_LEVEL:
+ member = Optional.of(createMember(parentDomain()));
+ break;
+ default:
+ throw new IllegalStateException("Unhandled placement " + placement);
+ }
+ }
+ return member.orElse(null);
+ }
+
+ @NonNull CollisionDomain parentDomain() {
+ return getParent().domain();
+ }
+
+ abstract @NonNull Member createMember(@NonNull CollisionDomain domain);
+
+ /**
+ * Create the type associated with this builder. This method idempotent.
+ *
+ * @param builderFactory Factory for {@link TypeBuilder}s
+ * @throws NullPointerException if {@code builderFactory} is {@code null}
+ */
+ final void ensureType(final TypeBuilderFactory builderFactory) {
+ if (result != null) {
+ return;
+ }
+
+ final ClassPlacement placement = classPlacement();
+ switch (placement) {
+ case NONE:
+ case PHANTOM:
+ result = GeneratorResult.empty();
+ break;
+ case MEMBER:
+ result = GeneratorResult.member(createTypeImpl(requireNonNull(builderFactory)));
+ break;
+ case TOP_LEVEL:
+ result = GeneratorResult.toplevel(createTypeImpl(requireNonNull(builderFactory)));
+ break;
+ default:
+ throw new IllegalStateException("Unhandled placement " + placement);
+ }
+
+ for (Generator child : this) {
+ child.ensureType(builderFactory);
+ }
+ }
+
+ @NonNull GeneratedType getGeneratedType(final TypeBuilderFactory builderFactory) {
+ return verifyNotNull(tryGeneratedType(builderFactory), "No type generated for %s", this);
+ }
+
+ final @Nullable GeneratedType tryGeneratedType(final TypeBuilderFactory builderFactory) {
+ ensureType(builderFactory);
+ return result.generatedType();
+ }
+
+ final @Nullable GeneratedType enclosedType(final TypeBuilderFactory builderFactory) {
+ ensureType(builderFactory);
+ return result.enclosedType();
+ }
+
+ /**
+ * Create the type associated with this builder, as per {@link #ensureType(TypeBuilderFactory)} contract. This
+ * method is guaranteed to be called at most once.
+ *
+ * @param builderFactory Factory for {@link TypeBuilder}s
+ */
+ abstract @NonNull GeneratedType createTypeImpl(@NonNull TypeBuilderFactory builderFactory);
+
+ final @NonNull String assignedName() {
+ return getMember().currentClass();
+ }
+
+ final @NonNull String javaPackage() {
+ String local = javaPackage;
+ if (local == null) {
+ javaPackage = local = createJavaPackage();
+ }
+ return local;
+ }
+
+ @NonNull String createJavaPackage() {
+ final String parentPackage = getPackageParent().javaPackage();
+ final String myPackage = getMember().currentPackage();
+ return BindingMapping.normalizePackageName(parentPackage + '.' + myPackage);
+ }
+
+ final @NonNull JavaTypeName typeName() {
+ JavaTypeName local = typeName;
+ if (local == null) {
+ typeName = local = createTypeName();
+ }
+ return local;
+ }
+
+ @NonNull JavaTypeName createTypeName() {
+ return JavaTypeName.create(getPackageParent().javaPackage(), assignedName());
+ }
+
+ @NonNull AbstractCompositeGenerator<?> getPackageParent() {
+ return getParent();
+ }
+
+ @Override
+ public final String toString() {
+ return addToStringAttributes(MoreObjects.toStringHelper(this).omitNullValues()).toString();
+ }
+
+ ToStringHelper addToStringAttributes(final ToStringHelper helper) {
+ return helper;
+ }
+
+ final void addImplementsChildOf(final GeneratedTypeBuilder builder) {
+ AbstractCompositeGenerator<?> ancestor = getParent();
+ while (true) {
+ // choice/case hierarchy does not factor into 'ChildOf' hierarchy, hence we need to skip them
+ if (ancestor instanceof CaseGenerator || ancestor instanceof ChoiceGenerator) {
+ ancestor = ancestor.getParent();
+ continue;
+ }
+
+ // if we into a choice we need to follow the hierararchy of that choice
+ if (ancestor instanceof AbstractAugmentGenerator) {
+ final AbstractCompositeGenerator<?> target = ((AbstractAugmentGenerator) ancestor).targetGenerator();
+ if (target instanceof ChoiceGenerator) {
+ ancestor = target;
+ continue;
+ }
+ }
+
+ break;
+ }
+
+ builder.addImplementsType(BindingTypes.childOf(DefaultType.of(ancestor.typeName())));
+ }
+
+ /**
+ * Add common methods implemented in a generated type. This includes {@link DataContainer#implementedInterface()} as
+ * well has {@code bindingHashCode()}, {@code bindingEquals()} and {@code bindingToString()}.
+ *
+ * @param builder Target builder
+ */
+ static final void addConcreteInterfaceMethods(final GeneratedTypeBuilder builder) {
+ defaultImplementedInterace(builder);
+
+ builder.addMethod(BindingMapping.BINDING_HASHCODE_NAME)
+ .setAccessModifier(AccessModifier.PUBLIC)
+ .setStatic(true)
+ .setReturnType(primitiveIntType());
+ builder.addMethod(BindingMapping.BINDING_EQUALS_NAME)
+ .setAccessModifier(AccessModifier.PUBLIC)
+ .setStatic(true)
+ .setReturnType(primitiveBooleanType());
+ builder.addMethod(BindingMapping.BINDING_TO_STRING_NAME)
+ .setAccessModifier(AccessModifier.PUBLIC)
+ .setStatic(true)
+ .setReturnType(STRING);
+ }
+
+ static final void annotateDeprecatedIfNecessary(final EffectiveStatement<?, ?> stmt,
+ final AnnotableTypeBuilder builder) {
+ if (stmt instanceof WithStatus) {
+ annotateDeprecatedIfNecessary((WithStatus) stmt, builder);
+ }
+ }
+
+ static final void annotateDeprecatedIfNecessary(final WithStatus node, final AnnotableTypeBuilder builder) {
+ switch (node.getStatus()) {
+ case DEPRECATED:
+ // FIXME: we really want to use a pre-made annotation
+ builder.addAnnotation(DEPRECATED_ANNOTATION);
+ break;
+ case OBSOLETE:
+ builder.addAnnotation(DEPRECATED_ANNOTATION).addParameter("forRemoval", "true");
+ break;
+ case CURRENT:
+ // No-op
+ break;
+ default:
+ throw new IllegalStateException("Unhandled status in " + node);
+ }
+ }
+
+ static final void addCodegenInformation(final EffectiveStatement<?, ?> stmt,
+ final GeneratedTypeBuilderBase<?> builder) {
+ if (stmt instanceof DocumentedNode) {
+ addCodegenInformation((DocumentedNode) stmt, builder);
+ }
+ }
+
+ static final void addCodegenInformation(final DocumentedNode node, final GeneratedTypeBuilderBase<?> builder) {
+ node.getDescription().map(BindingGeneratorUtil::encodeAngleBrackets).ifPresent(builder::setDescription);
+ node.getReference().ifPresent(builder::setReference);
+ }
+
+ static final void addCodegenInformation(final ModuleGenerator module, final EffectiveStatement<?, ?> stmt,
+ final GeneratedTypeBuilderBase<?> builder) {
+ if (stmt instanceof DocumentedNode) {
+ final DocumentedNode node = (DocumentedNode) stmt;
+ TypeComments.description(node).ifPresent(builder::addComment);
+ node.getDescription().ifPresent(builder::setDescription);
+ node.getReference().ifPresent(builder::setReference);
+ }
+ if (stmt instanceof SchemaNode) {
+ YangSourceDefinition.of(module.statement(), (SchemaNode) stmt).ifPresent(builder::setYangSourceDefinition);
+ }
+ }
+
+ static final void addUnits(final GeneratedTOBuilder builder, final TypeDefinition<?> typedef) {
+ typedef.getUnits().ifPresent(units -> {
+ if (!units.isEmpty()) {
+ builder.addConstant(Types.STRING, "_UNITS", "\"" + units + "\"");
+ final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("UNITS");
+ prop.setReturnType(Types.STRING);
+ builder.addToStringProperty(prop);
+ }
+ });
+ }
+
+ /**
+ * Add {@link java.io.Serializable} to implemented interfaces of this TO. Also compute and add serialVersionUID
+ * property.
+ *
+ * @param builder transfer object which needs to be made serializable
+ */
+ static final void makeSerializable(final GeneratedTOBuilder builder) {
+ builder.addImplementsType(Types.serializableType());
+ addSerialVersionUID(builder);
+ }
+
+ static final void addSerialVersionUID(final GeneratedTOBuilder gto) {
+ final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID");
+ prop.setValue(Long.toString(BindingGeneratorUtil.computeDefaultSUID(gto)));
+ gto.setSUID(prop);
+ }
+
+ /**
+ * Add a {@link DataContainer#implementedInterface()} declaration with a narrower return type to specified builder.
+ *
+ * @param builder Target builder
+ */
+ static final void narrowImplementedInterface(final GeneratedTypeBuilder builder) {
+ defineImplementedInterfaceMethod(builder, wildcardTypeFor(builder.getIdentifier()));
+ }
+
+ /**
+ * Add a default implementation of {@link DataContainer#implementedInterface()} to specified builder.
+ *
+ * @param builder Target builder
+ */
+ static final void defaultImplementedInterace(final GeneratedTypeBuilder builder) {
+ defineImplementedInterfaceMethod(builder, DefaultType.of(builder)).setDefault(true);
+ }
+
+ static final <T extends EffectiveStatement<?, ?>> AbstractExplicitGenerator<T> getChild(final Generator parent,
+ final Class<T> type) {
+ for (Generator child : parent) {
+ if (child instanceof AbstractExplicitGenerator) {
+ @SuppressWarnings("unchecked")
+ final AbstractExplicitGenerator<T> explicit = (AbstractExplicitGenerator<T>)child;
+ if (type.isInstance(explicit.statement())) {
+ return explicit;
+ }
+ }
+ }
+ throw new IllegalStateException("Cannot find " + type + " in " + parent);
+ }
+
+ private static MethodSignatureBuilder defineImplementedInterfaceMethod(final GeneratedTypeBuilder typeBuilder,
+ final Type classType) {
+ final MethodSignatureBuilder ret = typeBuilder
+ .addMethod(BindingMapping.DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME)
+ .setAccessModifier(AccessModifier.PUBLIC)
+ .setReturnType(classType(classType));
+ ret.addAnnotation(OVERRIDE_ANNOTATION);
+ return ret;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import edu.umd.cs.findbugs.annotations.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.PathExpression;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+
+/**
+ * Abstract view on generation tree as viewed by a particular {@link Generator}.
+ */
+abstract class GeneratorContext {
+ /**
+ * Resolve generator for the type object pointed to by a {@code path} expression, or {@code null} it the if cannot
+ * the current generator is nested inside a {@code grouping} and the generator cannot be found.
+ *
+ * @param path A {@code path} expression
+ * @return Resolved generator, or {@code null} if legally not found
+ * @throws NullPointerException if {@code path} is {@code null}
+ * @throws IllegalStateException if this generator is not inside a {@code grouping} and the path cannot be resolved
+ */
+ abstract @Nullable AbstractTypeObjectGenerator<?> resolveLeafref(@NonNull PathExpression path);
+
+ /**
+ * Resolve a tree-scoped namespace reference. This covers {@code typedef} and {@code grouping} statements, as per
+ * bullets 5 and 6 of <a href="https://tools.ietf.org/html/rfc6020#section-6.2.1">RFC6020, section 6.2.1</a>.
+ *
+ * @param <E> {@link EffectiveStatement} type
+ * @param type EffectiveStatement class
+ * @param argument Statement argument
+ * @return Resolved {@link Generator}
+ * @throws NullPointerException if any argument is null
+ * @throws IllegalStateException if the generator cannot be found
+ */
+ abstract <E extends EffectiveStatement<QName, ?>, G extends AbstractExplicitGenerator<E>>
+ @NonNull G resolveTreeScoped(@NonNull Class<G> type, @NonNull QName argument);
+
+ abstract @NonNull AbstractExplicitGenerator<?> resolveSchemaNode(@NonNull SchemaNodeIdentifier path);
+
+ abstract @NonNull IdentityGenerator resolveIdentity(@NonNull QName name);
+
+ final @NonNull TypedefGenerator resolveTypedef(final @NonNull QName qname) {
+ return resolveTreeScoped(TypedefGenerator.class, qname);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static com.google.common.base.Verify.verify;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import com.google.common.base.Stopwatch;
+import com.google.common.collect.Maps;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.yangtools.concepts.Mutable;
+import org.opendaylight.yangtools.yang.binding.ChildOf;
+import org.opendaylight.yangtools.yang.binding.ChoiceIn;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.PathExpression;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.model.ri.type.TypeBuilder;
+import org.opendaylight.yangtools.yang.model.spi.ModuleDependencySort;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A multi-stage reactor for generating {@link GeneratedType} instances from an {@link EffectiveModelContext}.
+ *
+ * <p>
+ * The reason for multi-stage processing is that the problem ahead of us involves:
+ * <ul>
+ * <li>mapping {@code typedef} and restricted {@code type} statements onto Java classes</li>
+ * <li>mapping a number of schema tree nodes into Java interfaces with properties</li>
+ * <li>taking advantage of Java composition to provide {@code grouping} mobility</li>
+ * </ul>
+ */
+public final class GeneratorReactor extends GeneratorContext implements Mutable {
+ private enum State {
+ INITIALIZED,
+ EXECUTING,
+ FINISHED
+ }
+
+ private static final Logger LOG = LoggerFactory.getLogger(GeneratorReactor.class);
+
+ private final Deque<Iterable<? extends Generator>> stack = new ArrayDeque<>();
+ private final @NonNull Map<QNameModule, ModuleGenerator> generators;
+ private final @NonNull List<ModuleGenerator> children;
+ private final @NonNull SchemaInferenceStack inferenceStack;
+
+ private Map<?, AbstractTypeAwareGenerator<?>> leafGenerators;
+ private State state = State.INITIALIZED;
+
+ public GeneratorReactor(final EffectiveModelContext context) {
+ inferenceStack = SchemaInferenceStack.of(context);
+
+ // Construct modules and their subtrees. Dependency sort is very much needed here, as it establishes order of
+ // module evaluation, and that (along with the sort in AbstractCompositeGenerator) ensures we visit
+ // AugmentGenerators without having forward references.
+ // FIXME: migrate to new ModuleDependencySort when it is available, which streamline things here
+ children = ModuleDependencySort.sort(context.getModules()).stream()
+ .map(module -> {
+ verify(module instanceof ModuleEffectiveStatement, "Unexpected module %s", module);
+ return new ModuleGenerator((ModuleEffectiveStatement) module);
+ })
+ .collect(Collectors.toUnmodifiableList());
+ generators = Maps.uniqueIndex(children, gen -> gen.statement().localQNameModule());
+ }
+
+ /**
+ * Execute the reactor. Execution follows the following steps:
+ * <ol>
+ * <li>link the statement inheritance graph along {@code uses}/{@code grouping} statements</li>
+ * <li>link the {@code typedef} inheritance hierarchy by visiting all {@link TypedefGenerator}s and memoizing the
+ * {@code type} lookup</li>
+ * <li>link the {@code identity} inheritance hierarchy by visiting all {@link IdentityGenerator}s and memoizing
+ * the {@code base} lookup</li>
+ * <li>link the {@code type} statements and resolve type restriction hierarchy, determining the set of Java
+ classes required for Java equivalent of effective YANG type definitions</li>
+ * <li>bind {@code leafref} and {@code identityref} references to their Java class roots</li>
+ * <li>resolve {@link ChoiceIn}/{@link ChildOf} hierarchy</li>
+ * <li>assign Java package names and {@link JavaTypeName}s to all generated classes</li>
+ * <li>create {@link Type} instances</li>
+ * </ol>
+ *
+ * @param builderFactory factory for creating {@link TypeBuilder}s for resulting types
+ * @return Resolved generators
+ * @throws IllegalStateException if the reactor has failed execution
+ * @throws NullPointerException if {@code builderFactory} is {@code null}
+ */
+ public @NonNull Map<QNameModule, ModuleGenerator> execute(final TypeBuilderFactory builderFactory) {
+ switch (state) {
+ case INITIALIZED:
+ state = State.EXECUTING;
+ break;
+ case FINISHED:
+ return generators;
+ case EXECUTING:
+ throw new IllegalStateException("Cannot resume partial execution");
+ default:
+ throw new IllegalStateException("Unhandled state" + state);
+ }
+
+ // Step 1a: walk all composite generators and resolve 'uses' statements to the corresponding grouping node,
+ // establishing implied inheritance ...
+ linkUsesDependencies(children);
+
+ // Step 1b: ... and also link augments and their targets in a separate pass, as we need groupings fully resolved
+ // before we attempt augmentation lookups ...
+ for (ModuleGenerator module : children) {
+ for (Generator child : module) {
+ if (child instanceof ModuleAugmentGenerator) {
+ ((ModuleAugmentGenerator) child).linkAugmentationTarget(this);
+ }
+ }
+ }
+
+ // Step 1c: ... finally establish linkage along the reverse uses/augment axis. This is needed to route generated
+ // type manifestations (isAddedByUses/isAugmenting) to their type generation sites.
+ linkOriginalGenerator(children);
+
+ /*
+ * Step 2: link typedef statements, so that typedef's 'type' axis is fully established
+ * Step 3: link all identity statements, so that identity's 'base' axis is fully established
+ * Step 4: link all type statements, so that leafs and leaf-lists have restrictions established
+ *
+ * Since our implementation class hierarchy captures all four statements involved in a common superclass, we can
+ * perform this in a single pass.
+ */
+ final Stopwatch sw = Stopwatch.createStarted();
+ linkDependencies(children);
+
+ // Step five: resolve all 'type leafref' and 'type identityref' statements, so they point to their
+ // corresponding Java type representation.
+ bindTypeDefinition(children);
+
+ // Step six: walk all composite generators and link ChildOf/ChoiceIn relationships with parents. We have taken
+ // care of this step during tree construction, hence this now a no-op.
+
+ /*
+ * Step seven: assign java packages and JavaTypeNames
+ *
+ * This is a really tricky part, as we have large number of factors to consider:
+ * - we are mapping grouping, typedef, identity and schema tree namespaces into Fully Qualified Class Names,
+ * i.e. four namespaces into one
+ * - our source of class naming are YANG identifiers, which allow characters not allowed by Java
+ * - we generate class names as well as nested package hierarchy
+ * - we want to generate names which look like Java as much as possible
+ * - we need to always have an (arbitrarily-ugly) fail-safe name
+ *
+ * To deal with all that, we split this problem into multiple manageable chunks.
+ *
+ * The first chunk is here: we walk all generators and ask them to do two things:
+ * - instantiate their CollisionMembers and link them to appropriate CollisionDomains
+ * - return their collision domain
+ *
+ * Then we process we ask collision domains until all domains are resolved, driving the second chunk of the
+ * algorithm in CollisionDomain. Note that we may need to walk the domains multiple times, as the process of
+ * solving a domain may cause another domain's solution to be invalidated.
+ */
+ final List<CollisionDomain> domains = new ArrayList<>();
+ collectCollisionDomains(domains, children);
+ boolean haveUnresolved;
+ do {
+ haveUnresolved = false;
+ for (CollisionDomain domain : domains) {
+ if (domain.findSolution()) {
+ haveUnresolved = true;
+ }
+ }
+ } while (haveUnresolved);
+
+ // Step eight: generate actual Types
+ //
+ // We have now properly cross-linked all generators and have assigned their naming roots, so from this point
+ // it looks as though we are performing a simple recursive execution. In reality, though, the actual path taken
+ // through generators is dictated by us as well as generator linkage.
+ for (ModuleGenerator module : children) {
+ module.ensureType(builderFactory);
+ }
+
+ LOG.debug("Processed {} modules in {}", generators.size(), sw);
+ state = State.FINISHED;
+ return generators;
+ }
+
+ private void collectCollisionDomains(final List<CollisionDomain> result,
+ final Iterable<? extends Generator> parent) {
+ for (Generator gen : parent) {
+ gen.ensureMember();
+ collectCollisionDomains(result, gen);
+ if (gen instanceof AbstractCompositeGenerator) {
+ result.add(((AbstractCompositeGenerator<?>) gen).domain());
+ }
+ }
+ }
+
+ @Override
+ AbstractExplicitGenerator<?> resolveSchemaNode(final SchemaNodeIdentifier path) {
+ verify(path instanceof SchemaNodeIdentifier.Absolute, "Unexpected path %s", path);
+ return verifyNotNull(generators.get(path.firstNodeIdentifier().getModule()), "Cannot find module for %s", path)
+ .resolveSchemaNode(path, null);
+ }
+
+ @Override
+ <E extends EffectiveStatement<QName, ?>, G extends AbstractExplicitGenerator<E>> G resolveTreeScoped(
+ final Class<G> type, final QName argument) {
+ LOG.trace("Searching for tree-scoped argument {} at {}", argument, stack);
+
+ // Check if the requested QName matches current module, if it does search the stack
+ final Iterable<? extends Generator> last = stack.getLast();
+ verify(last instanceof ModuleGenerator, "Unexpected last stack item %s", last);
+
+ if (argument.getModule().equals(((ModuleGenerator) last).statement().localQNameModule())) {
+ for (Iterable<? extends Generator> ancestor : stack) {
+ for (Generator child : ancestor) {
+ if (type.isInstance(child)) {
+ final G cast = type.cast(child);
+ if (argument.equals(cast.statement().argument())) {
+ LOG.trace("Found matching {}", child);
+ return cast;
+ }
+ }
+ }
+ }
+ } else {
+ final ModuleGenerator module = generators.get(argument.getModule());
+ if (module != null) {
+ for (Generator child : module) {
+ if (type.isInstance(child)) {
+ final G cast = type.cast(child);
+ if (argument.equals(cast.statement().argument())) {
+ LOG.trace("Found matching {}", child);
+ return cast;
+ }
+ }
+ }
+ }
+ }
+
+ throw new IllegalStateException("Could not find " + type + " argument " + argument + " in " + stack);
+ }
+
+ @Override
+ IdentityGenerator resolveIdentity(final QName name) {
+ final ModuleGenerator module = generators.get(name.getModule());
+ if (module != null) {
+ for (Generator gen : module) {
+ if (gen instanceof IdentityGenerator) {
+ final IdentityGenerator idgen = (IdentityGenerator) gen;
+ if (name.equals(idgen.statement().argument())) {
+ return idgen;
+ }
+ }
+ }
+ }
+ throw new IllegalStateException("Failed to find identity " + name);
+ }
+
+ @Override
+ AbstractTypeObjectGenerator<?> resolveLeafref(final PathExpression path) {
+ LOG.trace("Resolving path {}", path);
+ verify(inferenceStack.isEmpty(), "Unexpected data tree state %s", inferenceStack);
+ try {
+ // Populate inferenceStack with a grouping + data tree equivalent of current stack's state.
+ final Iterator<Iterable<? extends Generator>> it = stack.descendingIterator();
+ // Skip first item, as it points to our children
+ verify(it.hasNext(), "Unexpected empty stack");
+ it.next();
+
+ while (it.hasNext()) {
+ final Iterable<? extends Generator> item = it.next();
+ verify(item instanceof Generator, "Unexpected stack item %s", item);
+ ((Generator) item).pushToInference(inferenceStack);
+ }
+
+ return inferenceStack.inGrouping() ? lenientResolveLeafref(path) : strictResolvePath(path);
+ } finally {
+ inferenceStack.clear();
+ }
+ }
+
+ private @NonNull AbstractTypeAwareGenerator<?> strictResolvePath(final @NonNull PathExpression path) {
+ final EffectiveStatement<?, ?> stmt;
+ try {
+ stmt = inferenceStack.resolvePathExpression(path);
+ } catch (IllegalArgumentException e) {
+ throw new IllegalArgumentException("Failed to find leafref target " + path, e);
+ }
+ return mapToGenerator(stmt);
+ }
+
+ private @Nullable AbstractTypeAwareGenerator<?> lenientResolveLeafref(final @NonNull PathExpression path) {
+ final EffectiveStatement<?, ?> stmt;
+ try {
+ stmt = inferenceStack.resolvePathExpression(path);
+ } catch (IllegalArgumentException e) {
+ LOG.debug("Ignoring unresolved path {}", path, e);
+ return null;
+ }
+ return mapToGenerator(stmt);
+ }
+
+ // Map a statement to the corresponding generator
+ private @NonNull AbstractTypeAwareGenerator<?> mapToGenerator(final EffectiveStatement<?, ?> stmt) {
+ if (leafGenerators == null) {
+ final Map<EffectiveStatement<?, ?>, AbstractTypeAwareGenerator<?>> map = new IdentityHashMap<>();
+ indexLeafGenerators(map, children);
+ leafGenerators = map;
+ }
+
+ AbstractTypeAwareGenerator<?> match = leafGenerators.get(stmt);
+ if (match == null && stmt instanceof DerivableSchemaNode) {
+ final SchemaNode orig = ((DerivableSchemaNode) stmt).getOriginal().orElse(null);
+ if (orig instanceof EffectiveStatement) {
+ match = leafGenerators.get(orig);
+ }
+ }
+
+ return verifyNotNull(match, "Cannot resolve generator for %s", stmt);
+ }
+
+ private static void indexLeafGenerators(final Map<EffectiveStatement<?, ?>, AbstractTypeAwareGenerator<?>> map,
+ final Iterable<? extends Generator> parent) {
+ for (Generator child : parent) {
+ if (child instanceof AbstractTypeAwareGenerator) {
+ final AbstractTypeAwareGenerator<?> value = (AbstractTypeAwareGenerator<?>) child;
+ final EffectiveStatement<?, ?> key = value.statement();
+ final AbstractTypeAwareGenerator<?> prev = map.putIfAbsent(key, value);
+ verify(prev == null, "Conflict on %s between %s and %s", key, prev, value);
+ }
+ indexLeafGenerators(map, child);
+ }
+ }
+
+ // Note: unlike other methods, this method pushes matching child to the stack
+ private void linkUsesDependencies(final Iterable<? extends Generator> parent) {
+ for (Generator child : parent) {
+ if (child instanceof AbstractCompositeGenerator) {
+ LOG.trace("Visiting composite {}", child);
+ final AbstractCompositeGenerator<?> composite = (AbstractCompositeGenerator<?>) child;
+ stack.push(composite);
+ composite.linkUsesDependencies(this);
+ linkUsesDependencies(composite);
+ stack.pop();
+ }
+ }
+ }
+
+ private void linkDependencies(final Iterable<? extends Generator> parent) {
+ for (Generator child : parent) {
+ if (child instanceof AbstractDependentGenerator) {
+ ((AbstractDependentGenerator<?>) child).linkDependencies(this);
+ } else if (child instanceof AbstractCompositeGenerator) {
+ stack.push(child);
+ linkDependencies(child);
+ stack.pop();
+ }
+ }
+ }
+
+ private void linkOriginalGenerator(final Iterable<? extends Generator> parent) {
+ for (Generator child : parent) {
+ if (child instanceof AbstractExplicitGenerator) {
+ ((AbstractExplicitGenerator<?>) child).linkOriginalGenerator(this);
+ }
+ if (child instanceof AbstractCompositeGenerator) {
+ stack.push(child);
+ linkOriginalGenerator(child);
+ stack.pop();
+ }
+ }
+ }
+
+ private void bindTypeDefinition(final Iterable<? extends Generator> parent) {
+ for (Generator child : parent) {
+ stack.push(child);
+ if (child instanceof AbstractTypeObjectGenerator) {
+ ((AbstractTypeObjectGenerator<?>) child).bindTypeDefinition(this);
+ } else if (child instanceof AbstractCompositeGenerator) {
+ bindTypeDefinition(child);
+ }
+ stack.pop();
+ }
+ }
+}
--- /dev/null
+/*
+ * 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static java.util.Objects.requireNonNull;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.yangtools.concepts.Immutable;
+
+class GeneratorResult implements Immutable {
+ private static final class Nested extends GeneratorResult {
+ Nested(final GeneratedType generatedType) {
+ super(generatedType);
+ }
+
+ @Override
+ GeneratedType enclosedType() {
+ return generatedType();
+ }
+ }
+
+ private static final @NonNull GeneratorResult EMPTY = new GeneratorResult();
+
+ private final @Nullable GeneratedType generatedType;
+
+ private GeneratorResult() {
+ this.generatedType = null;
+ }
+
+ private GeneratorResult(final GeneratedType generatedType) {
+ this.generatedType = requireNonNull(generatedType);
+ }
+
+ static @NonNull GeneratorResult empty() {
+ return EMPTY;
+ }
+
+ static @NonNull GeneratorResult member(final GeneratedType generatedType) {
+ return new Nested(generatedType);
+ }
+
+ static @NonNull GeneratorResult toplevel(final GeneratedType generatedType) {
+ return new GeneratorResult(generatedType);
+ }
+
+ final @Nullable GeneratedType generatedType() {
+ return generatedType;
+ }
+
+ @Nullable GeneratedType enclosedType() {
+ return null;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.yangtools.yang.model.api.stmt.GroupingEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * Generator corresponding to a {@code grouping} statement.
+ */
+final class GroupingGenerator extends AbstractCompositeGenerator<GroupingEffectiveStatement> {
+ GroupingGenerator(final GroupingEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ @Override
+ StatementNamespace namespace() {
+ return StatementNamespace.GROUPING;
+ }
+
+ @Override
+ void pushToInference(final SchemaInferenceStack dataTree) {
+ dataTree.enterGrouping(statement().argument());
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+ builder.addImplementsType(BindingTypes.DATA_OBJECT);
+ narrowImplementedInterface(builder);
+ addUsesInterfaces(builder, builderFactory);
+ addGetterMethods(builder, builderFactory);
+
+ final ModuleGenerator module = currentModule();
+ module.addQNameConstant(builder, statement().argument().getLocalName());
+
+ annotateDeprecatedIfNecessary(builder);
+ if (builderFactory instanceof TypeBuilderFactory.Codegen) {
+ addCodegenInformation(module, statement(), builder);
+ }
+
+ return builder.build();
+ }
+
+ @Override
+ void addAsGetterMethod(final GeneratedTypeBuilderBase<?> builder, final TypeBuilderFactory builderFactory) {
+ // groupings are a separate concept
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static org.opendaylight.mdsal.binding.model.util.BindingTypes.BASE_IDENTITY;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.yangtools.yang.model.api.stmt.BaseEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * Generator corresponding to a {@code identity} statement.
+ */
+final class IdentityGenerator extends AbstractDependentGenerator<IdentityEffectiveStatement> {
+ private List<IdentityGenerator> baseIdentities = null;
+
+ IdentityGenerator(final IdentityEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ @Override
+ StatementNamespace namespace() {
+ return StatementNamespace.IDENTITY;
+ }
+
+ @Override
+ void pushToInference(final SchemaInferenceStack dataTree) {
+ throw new UnsupportedOperationException("Cannot push " + statement() + " to data tree");
+ }
+
+ @Override
+ void linkDependencies(final GeneratorContext context) {
+ baseIdentities = statement().streamEffectiveSubstatements(BaseEffectiveStatement.class)
+ .map(BaseEffectiveStatement::argument)
+ .map(context::resolveIdentity)
+ .collect(Collectors.toUnmodifiableList());
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+ if (!baseIdentities.isEmpty()) {
+ for (IdentityGenerator baseIdentity : baseIdentities) {
+ builder.addImplementsType(baseIdentity.getGeneratedType(builderFactory));
+ }
+ } else {
+ builder.addImplementsType(BASE_IDENTITY);
+ }
+
+ final ModuleGenerator module = currentModule();
+ module.addQNameConstant(builder, localName().getLocalName());
+
+ addCodegenInformation(module, statement(), builder);
+ builder.setModuleName(module.statement().argument().getLocalName());
+// builder.setSchemaPath(identity.getPath());
+
+ return builder.build();
+ }
+
+ @Override
+ void addAsGetterMethod(final GeneratedTypeBuilderBase<?> builder, final TypeBuilderFactory builderFactory) {
+ // identities are a separate concept
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.Set;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
+import org.opendaylight.mdsal.binding.model.api.DefaultType;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+final class KeyGenerator extends AbstractExplicitGenerator<KeyEffectiveStatement> {
+ // FIXME: this should be a well-known constant
+ private static final String SUFFIX = "Key";
+
+ private final ListGenerator listGen;
+
+ KeyGenerator(final KeyEffectiveStatement statement, final AbstractCompositeGenerator<?> parent,
+ final ListGenerator listGen) {
+ super(statement, parent);
+ this.listGen = requireNonNull(listGen);
+ }
+
+ @Override
+ void pushToInference(final SchemaInferenceStack inferenceStack) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ Member createMember(final CollisionDomain domain) {
+ return domain.addSecondary(listGen.getMember(), SUFFIX);
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTOBuilder builder = builderFactory.newGeneratedTOBuilder(typeName());
+
+ builder.addImplementsType(BindingTypes.identifier(DefaultType.of(listGen.typeName())));
+
+ final Set<QName> leafNames = statement().argument();
+ for (Generator listChild : listGen) {
+ if (listChild instanceof LeafGenerator) {
+ final LeafGenerator leafGen = (LeafGenerator) listChild;
+ final QName qname = leafGen.statement().argument();
+ if (leafNames.contains(qname)) {
+ final GeneratedPropertyBuilder prop = builder
+ .addProperty(BindingMapping.getPropertyName(qname.getLocalName()))
+ .setReturnType(leafGen.methodReturnType(builderFactory))
+ .setReadOnly(true);
+
+// addComment(propBuilder, leaf);
+
+ builder.addEqualsIdentity(prop);
+ builder.addHashIdentity(prop);
+ builder.addToStringProperty(prop);
+ }
+ }
+ }
+
+ // serialVersionUID
+ addSerialVersionUID(builder);
+
+ return builder.build();
+ }
+
+ @Override
+ void addAsGetterMethod(final GeneratedTypeBuilderBase<?> builder, final TypeBuilderFactory builderFactory) {
+ // Keys are explicitly handled by their corresponding list
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.opendaylight.yangtools.yang.model.api.stmt.LeafEffectiveStatement;
+
+/**
+ * Generator corresponding to a {@code leaf} statement.
+ */
+final class LeafGenerator extends AbstractTypeAwareGenerator<LeafEffectiveStatement> {
+ LeafGenerator(final LeafEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.util.Types;
+import org.opendaylight.yangtools.yang.model.api.stmt.LeafListEffectiveStatement;
+
+/**
+ * Generator corresponding to a {@code leaf-list} statement.
+ */
+final class LeafListGenerator extends AbstractTypeAwareGenerator<LeafListEffectiveStatement> {
+ LeafListGenerator(final LeafListEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ @Override
+ Type methodReturnType(final TypeBuilderFactory builderFactory) {
+ // If we are a leafref and the reference cannot be resolved, we need to generate a list wildcard, not
+ // List<Object>, we will try to narrow the return type in subclasses.
+ final Type type = super.methodReturnType(builderFactory);
+ return Types.objectType().equals(type) ? Types.listTypeWildcard() : Types.listTypeFor(type);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static org.opendaylight.mdsal.binding.model.util.BindingTypes.identifiable;
+
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.MethodSignature.ValueMechanics;
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
+import org.opendaylight.mdsal.binding.model.util.Types;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.common.Ordering;
+import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ListEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * Generator corresponding to a {@code list} statement.
+ */
+final class ListGenerator extends AbstractCompositeGenerator<ListEffectiveStatement> {
+ private final @Nullable KeyGenerator keyGen;
+
+ ListGenerator(final ListEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ keyGen = statement.findFirstEffectiveSubstatement(KeyEffectiveStatement.class)
+ .map(key -> new KeyGenerator(key, parent, this))
+ .orElse(null);
+ }
+
+ @Nullable KeyGenerator keyGenerator() {
+ return keyGen;
+ }
+
+ @Override
+ void pushToInference(final SchemaInferenceStack dataTree) {
+ dataTree.enterDataTree(statement().getIdentifier());
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+ addImplementsChildOf(builder);
+ addAugmentable(builder);
+ addUsesInterfaces(builder, builderFactory);
+ addConcreteInterfaceMethods(builder);
+
+ final ModuleGenerator module = currentModule();
+ module.addQNameConstant(builder, localName().getLocalName());
+
+ if (keyGen != null) {
+ // Add yang.binding.Identifiable and its key() method
+ final GeneratedType keyType = keyGen.getGeneratedType(builderFactory);
+ builder.addImplementsType(identifiable(keyType));
+ builder.addMethod(BindingMapping.IDENTIFIABLE_KEY_NAME)
+ .setReturnType(keyType)
+ .addAnnotation(OVERRIDE_ANNOTATION);
+ }
+
+ addGetterMethods(builder, builderFactory);
+
+ annotateDeprecatedIfNecessary(builder);
+ if (builderFactory instanceof TypeBuilderFactory.Codegen) {
+ addCodegenInformation(module, statement(), builder);
+ }
+ builder.setModuleName(module.statement().argument().getLocalName());
+ // builder.setSchemaPath(node.getPath());
+
+ return builder.build();
+ }
+
+ @Override
+ Type methodReturnType(final TypeBuilderFactory builderFactory) {
+ final Type generatedType = super.methodReturnType(builderFactory);
+ // We are wrapping the generated type in either a List or a Map based on presence of the key
+ if (keyGen != null) {
+ final Ordering ordering = statement()
+ .findFirstEffectiveSubstatementArgument(OrderedByEffectiveStatement.class)
+ .orElse(Ordering.SYSTEM);
+ if (ordering == Ordering.SYSTEM) {
+ return Types.mapTypeFor(keyGen.getGeneratedType(builderFactory), generatedType);
+ }
+ }
+
+ return Types.listTypeFor(generatedType);
+ }
+
+ @Override
+ MethodSignatureBuilder constructGetter(final GeneratedTypeBuilderBase<?> builder, final Type returnType) {
+ final MethodSignatureBuilder ret = super.constructGetter(builder, returnType)
+ .setMechanics(ValueMechanics.NULLIFY_EMPTY);
+
+ final MethodSignatureBuilder nonnull = builder
+ .addMethod(BindingMapping.getNonnullMethodName(localName().getLocalName()))
+ .setReturnType(returnType)
+ .setDefault(true);
+ annotateDeprecatedIfNecessary(nonnull);
+
+ return ret;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.opendaylight.yangtools.yang.model.api.stmt.AugmentEffectiveStatement;
+
+/**
+ * Generator corresponding to a {@code augment} statement used as a child of a {@code module} statement.
+ */
+final class ModuleAugmentGenerator extends AbstractAugmentGenerator {
+ ModuleAugmentGenerator(final AugmentEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ @Override
+ void loadTargetGenerator() {
+ throw new UnsupportedOperationException();
+ }
+
+ void linkAugmentationTarget(final GeneratorContext context) {
+ // FIXME: we need two-step resolution here:
+
+// if (targetSchemaNode instanceof DataSchemaNode && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) {
+// if (targetSchemaNode instanceof DerivableSchemaNode) {
+// targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal().orElse(null);
+// }
+// if (targetSchemaNode == null) {
+// throw new IllegalStateException("Failed to find target node from grouping in augmentation " + augSchema
+// + " in module " + context.module().getName());
+// }
+// }
+
+ setTargetGenerator(context.resolveSchemaNode(statement().argument()));
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static com.google.common.base.Verify.verify;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import java.util.Map;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.mdsal.binding.model.util.TypeComments;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * Generator corresponding to a {@code module} statement. These generators are roots for generating types for a
+ * particular {@link QNameModule} as mapped into the root package.
+ */
+public final class ModuleGenerator extends AbstractCompositeGenerator<ModuleEffectiveStatement> {
+ private final @NonNull JavaTypeName yangModuleInfo;
+ private final @NonNull ClassPlacement placement;
+
+ /**
+ * Note that for sake of simplicity of lookup and child mapping, this instance serves as the root for all child
+ * generators, but mapping to {@link CollisionDomain}s and their {@link Member}s is rather weird. This generator
+ * actually produces one of <em>secondary</em> members, more precisely the {@link BindingMapping#DATA_ROOT_SUFFIX}
+ * one. Counter-intuitively the other secondary members live as children of this generator. To support this we have
+ * also have this field, which is actually the <em>primary</em> derived from the module's name.
+ */
+ private final Member prefixMember;
+
+ ModuleGenerator(final ModuleEffectiveStatement statement) {
+ super(statement);
+ yangModuleInfo = JavaTypeName.create(javaPackage(), BindingMapping.MODULE_INFO_CLASS_NAME);
+ placement = computePlacement();
+ prefixMember = placement != ClassPlacement.NONE || haveSecondary()
+ ? domain().addPrefix(new ModuleNamingStrategy(statement.argument())) : null;
+ }
+
+ private @NonNull ClassPlacement computePlacement() {
+ return statement().findFirstEffectiveSubstatement(DataTreeEffectiveStatement.class).isPresent()
+ || statement().findFirstEffectiveSubstatement(ChoiceEffectiveStatement.class).isPresent()
+ ? ClassPlacement.TOP_LEVEL : ClassPlacement.NONE;
+ }
+
+ private boolean haveSecondary() {
+ for (Generator child : this) {
+ if (child instanceof AbstractImplicitGenerator) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ ModuleGenerator currentModule() {
+ return this;
+ }
+
+ @Override
+ void pushToInference(final SchemaInferenceStack dataTree) {
+ // No-op
+ }
+
+ @Override
+ String createJavaPackage() {
+ return BindingMapping.getRootPackageName(statement().localQNameModule());
+ }
+
+ @Override
+ AbstractCompositeGenerator<?> getPackageParent() {
+ return this;
+ }
+
+ @Override
+ CollisionDomain parentDomain() {
+ return domain();
+ }
+
+ @Override
+ ClassPlacement classPlacement() {
+ return placement;
+ }
+
+ @Override
+ Member createMember(final CollisionDomain domain) {
+ return domain.addSecondary(prefixMember, BindingMapping.DATA_ROOT_SUFFIX);
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+ builder.setModuleName(statement().argument().getLocalName());
+ builder.addImplementsType(BindingTypes.DATA_ROOT);
+
+ final int usesCount = addUsesInterfaces(builder, builderFactory);
+ // if we have more than 2 top level uses statements we need to define getImplementedInterface() on the top-level
+ // DataRoot object
+ if (usesCount > 1) {
+ narrowImplementedInterface(builder);
+ }
+
+ addGetterMethods(builder, builderFactory);
+
+ if (builderFactory instanceof TypeBuilderFactory.Codegen) {
+ final ModuleEffectiveStatement stmt = statement();
+ verify(stmt instanceof Module, "Unexpected module %s", stmt);
+ final Module module = (Module) stmt;
+
+ YangSourceDefinition.of(module).ifPresent(builder::setYangSourceDefinition);
+ TypeComments.description(module).ifPresent(builder::addComment);
+ module.getDescription().ifPresent(builder::setDescription);
+ module.getReference().ifPresent(builder::setReference);
+ }
+
+ return builder.build();
+ }
+
+ @NonNull Member getPrefixMember() {
+ return verifyNotNull(prefixMember);
+ }
+
+ void addQNameConstant(final GeneratedTypeBuilderBase<?> builder, final String localName) {
+ builder.addConstant(BindingTypes.QNAME, BindingMapping.QNAME_STATIC_FIELD_NAME,
+ Map.entry(yangModuleInfo, localName));
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.base.MoreObjects.ToStringHelper;
+import org.opendaylight.yangtools.yang.common.AbstractQName;
+
+final class ModuleNamingStrategy extends ClassNamingStrategy {
+ private final AbstractQName name;
+
+ ModuleNamingStrategy(final AbstractQName name) {
+ this.name = requireNonNull(name);
+ }
+
+ @Override
+ AbstractQName nodeIdentifier() {
+ return name;
+ }
+
+ @Override
+ ClassNamingStrategy fallback() {
+ return null;
+ }
+
+ @Override
+ ToStringHelper addToStringAttributes(final ToStringHelper helper) {
+ return helper.add("localName", name.getLocalName());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.opendaylight.mdsal.binding.model.api.DefaultType;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.yangtools.yang.model.api.stmt.NotificationEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * Generator corresponding to a {@code notification} statement.
+ */
+final class NotificationGenerator extends AbstractCompositeGenerator<NotificationEffectiveStatement> {
+ NotificationGenerator(final NotificationEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ @Override
+ void pushToInference(final SchemaInferenceStack dataTree) {
+ dataTree.enterSchemaTree(statement().getIdentifier());
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+
+ builder.addImplementsType(BindingTypes.DATA_OBJECT);
+ builder.addImplementsType(notificationType(builder, builderFactory));
+
+ addAugmentable(builder);
+ addUsesInterfaces(builder, builderFactory);
+
+ addConcreteInterfaceMethods(builder);
+ addGetterMethods(builder, builderFactory);
+
+ final ModuleGenerator module = currentModule();
+ module.addQNameConstant(builder, localName().getLocalName());
+
+ addCodegenInformation(module, statement(), builder);
+ annotateDeprecatedIfNecessary(builder);
+
+ return builder.build();
+ }
+
+ @Override
+ void addAsGetterMethod(final GeneratedTypeBuilderBase<?> builder, final TypeBuilderFactory builderFactory) {
+ // Notifications are a distinct concept
+ }
+
+ private Type notificationType(final GeneratedTypeBuilder builder, final TypeBuilderFactory builderFactory) {
+ final AbstractCompositeGenerator<?> parent = getParent();
+ if (parent instanceof ModuleGenerator) {
+ return BindingTypes.NOTIFICATION;
+ }
+
+ final Type parentType = DefaultType.of(parent.typeName());
+ if (parent instanceof ListGenerator) {
+ final KeyGenerator keyGen = ((ListGenerator) parent).keyGenerator();
+ if (keyGen != null) {
+ return BindingTypes.keyedListNotification(builder, parentType, keyGen.getGeneratedType(builderFactory));
+ }
+ }
+ return BindingTypes.instanceNotification(builder, parentType);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
+
+import java.util.List;
+import org.opendaylight.mdsal.binding.model.api.AccessModifier;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.mdsal.binding.model.util.Types;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
+import org.opendaylight.yangtools.yang.model.api.Status;
+import org.opendaylight.yangtools.yang.model.api.stmt.NotificationEffectiveStatement;
+
+final class NotificationServiceGenerator extends AbstractImplicitGenerator {
+ private final List<NotificationGenerator> notifs;
+
+ NotificationServiceGenerator(final ModuleGenerator parent, final List<NotificationGenerator> notifs) {
+ super(parent);
+ this.notifs = requireNonNull(notifs);
+ }
+
+ @Override
+ String classSuffix() {
+ return BindingMapping.NOTIFICATION_LISTENER_SUFFIX;
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+ builder.addImplementsType(BindingTypes.NOTIFICATION_LISTENER);
+
+ for (NotificationGenerator gen : notifs) {
+ final MethodSignatureBuilder notificationMethod = builder.addMethod("on" + gen.assignedName())
+ .setAccessModifier(AccessModifier.PUBLIC)
+ .addParameter(gen.getGeneratedType(builderFactory), "notification")
+ .setReturnType(Types.primitiveVoidType());
+
+ final NotificationEffectiveStatement stmt = gen.statement();
+ verify(stmt instanceof WithStatus, "Unexpected statement %s", stmt);
+ final WithStatus withStatus = (WithStatus) stmt;
+
+ annotateDeprecatedIfNecessary(withStatus, notificationMethod);
+ if (withStatus.getStatus() == Status.OBSOLETE) {
+ notificationMethod.setDefault(true);
+ }
+
+ // FIXME: finish this up
+ // addComment(notificationMethod, notification);
+ }
+
+ return builder.build();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * Common generator for {@code anydata} and {@code anyxml}.
+ */
+final class OpaqueObjectGenerator<T extends DataTreeEffectiveStatement<?>> extends AbstractExplicitGenerator<T> {
+ OpaqueObjectGenerator(final T statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ @Override
+ void pushToInference(final SchemaInferenceStack dataTree) {
+ dataTree.enterDataTree(statement().getIdentifier());
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+ builder.addImplementsType(BindingTypes.opaqueObject(builder));
+ addImplementsChildOf(builder);
+ defaultImplementedInterace(builder);
+ annotateDeprecatedIfNecessary(builder);
+
+ final ModuleGenerator module = currentModule();
+ module.addQNameConstant(builder, localName().getLocalName());
+
+ addCodegenInformation(module, statement(), builder);
+ builder.setModuleName(module.statement().argument().getLocalName());
+// newType.setSchemaPath(schemaNode.getPath());
+
+ return builder.build();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.opendaylight.mdsal.binding.model.api.ConcreteType;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.util.Types;
+import org.opendaylight.yangtools.yang.binding.RpcInput;
+import org.opendaylight.yangtools.yang.binding.RpcOutput;
+import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * Generator corresponding to an {@code input} or an {@code output} statement.
+ */
+class OperationContainerGenerator extends AbstractCompositeGenerator<SchemaTreeEffectiveStatement<?>> {
+ private static final ConcreteType RPC_INPUT = Types.typeForClass(RpcInput.class);
+ private static final ConcreteType RPC_OUTPUT = Types.typeForClass(RpcOutput.class);
+
+ private final ConcreteType baseInterface;
+
+ OperationContainerGenerator(final InputEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ baseInterface = RPC_INPUT;
+ }
+
+ OperationContainerGenerator(final OutputEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ baseInterface = RPC_OUTPUT;
+ }
+
+ @Override
+ final void pushToInference(final SchemaInferenceStack dataTree) {
+ dataTree.enterSchemaTree(statement().getIdentifier());
+ }
+
+ @Override
+ final GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final AbstractCompositeGenerator<?> parent = getParent();
+ if (parent instanceof ActionGenerator && ((ActionGenerator) parent).isAddedByUses()) {
+ // final ActionDefinition orig = findOrigAction(parentSchema, action).get();
+ // // Original definition may live in a different module, make sure we account for that
+ // final ModuleContext origContext = moduleContext(
+ // orig.getPath().getPathFromRoot().iterator().next().getModule());
+ // input = context.addAliasType(origContext, orig.getInput(), action.getInput());
+ // output = context.addAliasType(origContext, orig.getOutput(), action.getOutput());
+
+ throw new UnsupportedOperationException("Lookup in original");
+ }
+
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+ builder.addImplementsType(baseInterface);
+ addAugmentable(builder);
+
+ addUsesInterfaces(builder, builderFactory);
+ addConcreteInterfaceMethods(builder);
+ addGetterMethods(builder, builderFactory);
+
+ final ModuleGenerator module = currentModule();
+ module.addQNameConstant(builder, localName().getLocalName());
+
+ annotateDeprecatedIfNecessary(builder);
+ if (builderFactory instanceof TypeBuilderFactory.Codegen) {
+ addCodegenInformation(module, statement(), builder);
+ }
+// builder.setSchemaPath(schemaNode.getPath());
+ builder.setModuleName(module.statement().argument().getLocalName());
+
+ return builder.build();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement;
+
+/**
+ * Specialization for legacy RPC services.
+ */
+final class RpcContainerGenerator extends OperationContainerGenerator {
+ private final @NonNull String suffix;
+
+ RpcContainerGenerator(final InputEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ suffix = BindingMapping.RPC_INPUT_SUFFIX;
+ }
+
+ RpcContainerGenerator(final OutputEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ suffix = BindingMapping.RPC_OUTPUT_SUFFIX;
+ }
+
+ @Override
+ CollisionDomain parentDomain() {
+ return getParent().parentDomain();
+ }
+
+ @Override
+ AbstractCompositeGenerator<?> getPackageParent() {
+ return getParent().getParent();
+ }
+
+ @Override
+ Member createMember(final CollisionDomain domain) {
+ return domain.addSecondary(getParent().ensureMember(), suffix, statement().argument());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.yangtools.yang.model.api.stmt.RpcEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * Generator corresponding to a {@code rpc} statement.
+ */
+final class RpcGenerator extends AbstractCompositeGenerator<RpcEffectiveStatement> {
+ RpcGenerator(final RpcEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ @Override
+ void pushToInference(final SchemaInferenceStack dataTree) {
+ dataTree.enterSchemaTree(statement().argument());
+ }
+
+ @Override
+ // FIXME: switch to the same thing we are using for 'action'
+ ClassPlacement classPlacement() {
+ return ClassPlacement.PHANTOM;
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ void addAsGetterMethod(final GeneratedTypeBuilderBase<?> builder, final TypeBuilderFactory builderFactory) {
+ // RPCs are a separate concept
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.List;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.model.api.TypeMemberComment;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.mdsal.binding.model.util.Types;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RpcEffectiveStatement;
+
+final class RpcServiceGenerator extends AbstractImplicitGenerator {
+ private static final JavaTypeName CHECK_RETURN_VALUE_ANNOTATION =
+ // Do not refer to annotation class, as it may not be available at runtime
+ JavaTypeName.create("edu.umd.cs.findbugs.annotations", "CheckReturnValue");
+
+ private final List<RpcGenerator> rpcs;
+
+ RpcServiceGenerator(final ModuleGenerator parent, final List<RpcGenerator> rpcs) {
+ super(parent);
+ this.rpcs = requireNonNull(rpcs);
+ }
+
+ @Override
+ String classSuffix() {
+ return BindingMapping.RPC_SERVICE_SUFFIX;
+ }
+
+ @Override
+ GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
+ final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+ builder.addImplementsType(BindingTypes.RPC_SERVICE);
+
+ for (RpcGenerator rpcGen : rpcs) {
+ final RpcEffectiveStatement rpc = rpcGen.statement();
+ final QName qname = rpc.argument();
+
+ // FIXME: this may still conflict in theory
+ final MethodSignatureBuilder method = builder.addMethod(BindingMapping.getRpcMethodName(qname));
+
+ method.addParameter(getChild(rpcGen, InputEffectiveStatement.class).getGeneratedType(builderFactory),
+ "input");
+ method.setReturnType(Types.listenableFutureTypeFor(BindingTypes.rpcResult(
+ getChild(rpcGen, OutputEffectiveStatement.class).getGeneratedType(builderFactory))));
+
+ // FIXME: this should not be part of runtime types
+ method.addAnnotation(CHECK_RETURN_VALUE_ANNOTATION);
+ final String rpcName = qname.getLocalName();
+ method.setComment(new TypeMemberComment("Invoke {@code " + rpcName + "} RPC.",
+ rpc.findFirstEffectiveSubstatementArgument(DescriptionEffectiveStatement.class).orElse(null),
+ "@param input of {@code " + rpcName + "}\n"
+ + "@return output of {@code " + rpcName + '}'));
+ }
+
+ // FIXME: activate this
+ // addCodegenInformation(interfaceBuilder, module, "RPCs", rpcDefinitions);
+
+ return builder.build();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+import org.eclipse.jdt.annotation.NonNull;
+
+/**
+ * <a href="https://tools.ietf.org/html/rfc6020#section-6.2.1">YANG statement namespaces</a> which we process.
+ */
+// FIXME: move this to 'BindingNamespace' in binding-spec-util
+enum StatementNamespace {
+ /**
+ * The namespace of all {@code identity} statements, bullet 4.
+ */
+ IDENTITY("$I"),
+ /**
+ * The namespace of all {@code typedef} statements, bullet 5.
+ */
+ TYPEDEF("$T"),
+ /**
+ * The namespace of all {@code grouping} statements, bullet 6.
+ */
+ GROUPING("$G"),
+ /**
+ * All other processed statements. Includes {@code augment}, and {@code schema tree} statements.
+ */
+ // FIXME: peel augment into "$A", which our own thing
+ // FIXME: add "$D" to disambiguate <module-name>Data
+ // FIXME: add "$L" to disambiguate <module-name>Listener
+ // FIXME: add "$S" to disambiguate <module-name>Service
+ DEFAULT("");
+
+ private final @NonNull String suffix;
+
+ StatementNamespace(final @NonNull String suffix) {
+ this.suffix = requireNonNull(suffix);
+ }
+
+ @NonNull String appendSuffix(final String str) {
+ return suffix.isEmpty() ? verifyNotNull(str) : str + suffix;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.annotations.Beta;
+import java.util.List;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.AbstractEnumerationBuilder;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenEnumerationBuilder;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTOBuilder;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.RuntimeEnumerationBuilder;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.RuntimeGeneratedTOBuilder;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.RuntimeGeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.runtime.api.RuntimeGeneratedUnion;
+import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.yang.model.ri.type.TypeBuilder;
+
+/**
+ * A factory component creating {@link TypeBuilder} instances.
+ */
+@Beta
+public abstract class TypeBuilderFactory implements Immutable {
+ static final class Codegen extends TypeBuilderFactory {
+ private static final @NonNull Codegen INSTANCE = new Codegen();
+
+ private Codegen() {
+ // Hidden on purpose
+ }
+
+ @Override
+ GeneratedTOBuilder newGeneratedTOBuilder(final JavaTypeName identifier) {
+ return new CodegenGeneratedTOBuilder(identifier);
+ }
+
+ @Override
+ GeneratedTypeBuilder newGeneratedTypeBuilder(final JavaTypeName identifier) {
+ return new CodegenGeneratedTypeBuilder(identifier);
+ }
+
+ @Override
+ AbstractEnumerationBuilder newEnumerationBuilder(final JavaTypeName identifier) {
+ return new CodegenEnumerationBuilder(identifier);
+ }
+
+ @Override
+ GeneratedUnionBuilder newGeneratedUnionBuilder(final JavaTypeName identifier) {
+ return new UnionBuilder(identifier);
+ }
+
+ private static final class UnionBuilder extends CodegenGeneratedTOBuilder implements GeneratedUnionBuilder {
+ UnionBuilder(final JavaTypeName identifier) {
+ super(identifier);
+ setIsUnion(true);
+ }
+
+ @Override
+ public void setTypePropertyNames(final List<String> propertyNames) {
+ // No-op, really
+ requireNonNull(propertyNames);
+ }
+ }
+ }
+
+ static final class Runtime extends TypeBuilderFactory {
+ private static final @NonNull Runtime INSTANCE = new Runtime();
+
+ private Runtime() {
+ // Hidden on purpose
+ }
+
+ @Override
+ GeneratedTOBuilder newGeneratedTOBuilder(final JavaTypeName identifier) {
+ return new RuntimeGeneratedTOBuilder(identifier);
+ }
+
+ @Override
+ GeneratedTypeBuilder newGeneratedTypeBuilder(final JavaTypeName identifier) {
+ return new RuntimeGeneratedTypeBuilder(identifier);
+ }
+
+ @Override
+ AbstractEnumerationBuilder newEnumerationBuilder(final JavaTypeName identifier) {
+ return new RuntimeEnumerationBuilder(identifier);
+ }
+
+ @Override
+ GeneratedUnionBuilder newGeneratedUnionBuilder(final JavaTypeName identifier) {
+ return new UnionBuilder(identifier);
+ }
+
+ private static final class UnionBuilder extends RuntimeGeneratedTOBuilder implements GeneratedUnionBuilder {
+ private List<String> typePropertyNames;
+
+ UnionBuilder(final JavaTypeName identifier) {
+ super(identifier);
+ setIsUnion(true);
+ }
+
+ @Override
+ public void setTypePropertyNames(final List<String> propertyNames) {
+ this.typePropertyNames = List.copyOf(propertyNames);
+ }
+
+ @Override
+ public GeneratedTransferObject build() {
+ return typePropertyNames == null || typePropertyNames.isEmpty()
+ ? super.build() : new UnionGTO(this, typePropertyNames);
+ }
+
+ private static final class UnionGTO extends GTO implements RuntimeGeneratedUnion {
+ private final @NonNull List<String> typePropertyNames;
+
+ UnionGTO(final RuntimeGeneratedTOBuilder builder, final List<String> typePropertyNames) {
+ super(builder);
+ this.typePropertyNames = requireNonNull(typePropertyNames);
+ }
+
+ @Override
+ public List<String> typePropertyNames() {
+ return typePropertyNames;
+ }
+ }
+ }
+ }
+
+ TypeBuilderFactory() {
+ // Hidden on purpose
+ }
+
+ public static @NonNull TypeBuilderFactory codegen() {
+ return Codegen.INSTANCE;
+ }
+
+ public static @NonNull TypeBuilderFactory runtime() {
+ return Runtime.INSTANCE;
+ }
+
+ abstract @NonNull AbstractEnumerationBuilder newEnumerationBuilder(JavaTypeName identifier);
+
+ abstract @NonNull GeneratedTOBuilder newGeneratedTOBuilder(JavaTypeName identifier);
+
+ abstract @NonNull GeneratedTypeBuilder newGeneratedTypeBuilder(JavaTypeName identifier);
+
+ abstract @NonNull GeneratedUnionBuilder newGeneratedUnionBuilder(JavaTypeName identifier);
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.util.Types;
+
+abstract class TypeReference {
+ private static final class Identityref extends TypeReference {
+ private final List<IdentityGenerator> referencedGenerators;
+
+ private ParameterizedType returnType;
+
+ Identityref(final List<IdentityGenerator> referencedGenerators) {
+ this.referencedGenerators = requireNonNull(referencedGenerators);
+ }
+
+ @Override
+ Type methodReturnType(final TypeBuilderFactory builderFactory) {
+ if (returnType == null) {
+ final List<GeneratedType> referencedTypes = referencedGenerators.stream()
+ .map(gen -> gen.getGeneratedType(builderFactory))
+ .collect(Collectors.toUnmodifiableList());
+ // FIXME: This deals only with RFC6020 semantics. In order to deal with full RFC7950 semantics, we need
+ // to analyze all the types and come up with the lowest-common denominator and use that as the
+ // return type. We also need to encode restrictions, so that builder generator ends up checking
+ // identities being passed -- because the identities may be completely unrelated, in which case
+ // we cannot generate type-safe code.
+ returnType = Types.classType(Types.wildcardTypeFor(referencedTypes.get(0).getIdentifier()));
+ }
+ return returnType;
+ }
+ }
+
+ // Note: this is exposed only for legacy naming handling
+ abstract static class Leafref extends TypeReference {
+ private Leafref() {
+ // Hidden on purpose
+ }
+ }
+
+ static final class ResolvedLeafref extends Leafref {
+ private final AbstractTypeObjectGenerator<?> referencedGenerator;
+
+ private ResolvedLeafref(final AbstractTypeObjectGenerator<?> referencedGenerator) {
+ this.referencedGenerator = requireNonNull(referencedGenerator);
+ }
+
+ @Override
+ Type methodReturnType(final TypeBuilderFactory builderFactory) {
+ return referencedGenerator.methodReturnElementType(builderFactory);
+ }
+ }
+
+ private static final class UnresolvedLeafref extends Leafref {
+ static final @NonNull UnresolvedLeafref INSTANCE = new UnresolvedLeafref();
+
+ private UnresolvedLeafref() {
+ // Hidden on purpose
+ }
+
+ @Override
+ Type methodReturnType(final TypeBuilderFactory builderFactory) {
+ return Types.objectType();
+ }
+ }
+
+ static @NonNull TypeReference leafRef(final @Nullable AbstractTypeObjectGenerator<?> referencedGenerator) {
+ return referencedGenerator == null ? UnresolvedLeafref.INSTANCE : new ResolvedLeafref(referencedGenerator);
+ }
+
+ static @NonNull TypeReference identityRef(final List<IdentityGenerator> referencedGenerators) {
+ return new Identityref(referencedGenerators);
+ }
+
+ abstract @NonNull Type methodReturnType(@NonNull TypeBuilderFactory builderFactory);
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
+
+/**
+ * Generator corresponding to a {@code typedef} statement.
+ */
+final class TypedefGenerator extends AbstractTypeObjectGenerator<TypedefEffectiveStatement> {
+ /**
+ * List of all generators for types directly derived from this typedef. We populate this list during initial type
+ * linking. It allows us to easily cascade inferences made by this typedef down the type derivation tree.
+ */
+ private List<AbstractTypeObjectGenerator<?>> derivedGenerators = null;
+
+ TypedefGenerator(final TypedefEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
+ super(statement, parent);
+ }
+
+ @Override
+ StatementNamespace namespace() {
+ return StatementNamespace.TYPEDEF;
+ }
+
+ @Override
+ void pushToInference(final SchemaInferenceStack dataTree) {
+ dataTree.enterTypedef(statement().argument());
+ }
+
+ void addDerivedGenerator(final AbstractTypeObjectGenerator<?> derivedGenerator) {
+ if (derivedGenerators == null) {
+ derivedGenerators = new ArrayList<>(4);
+ }
+ derivedGenerators.add(requireNonNull(derivedGenerator));
+ }
+
+ @Override
+ void bindDerivedGenerators(final TypeReference reference) {
+ // Trigger any derived resolvers ...
+ if (derivedGenerators != null) {
+ for (AbstractTypeObjectGenerator<?> derived : derivedGenerators) {
+ derived.bindTypeDefinition(reference);
+ }
+ }
+ // ... and make sure nobody can come in late
+ derivedGenerators = List.of();
+ }
+
+ @Override
+ ClassPlacement classPlacementImpl() {
+ return ClassPlacement.TOP_LEVEL;
+ }
+
+ @Override
+ TypeDefinition<?> extractTypeDefinition() {
+ return statement().getTypeDefinition();
+ }
+
+ @Override
+ GeneratedTransferObject createDerivedType(final TypeBuilderFactory builderFactory,
+ final GeneratedTransferObject baseType) {
+ final GeneratedTOBuilder builder = builderFactory.newGeneratedTOBuilder(typeName());
+ builder.setTypedef(true);
+ builder.setExtendsType(baseType);
+ builder.setIsUnion(baseType.isUnionType());
+ builder.setRestrictions(computeRestrictions());
+
+ final TypeDefinition<?> typedef = statement().getTypeDefinition();
+ annotateDeprecatedIfNecessary(typedef, builder);
+ addStringRegExAsConstant(builder, resolveRegExpressions(typedef));
+ addUnits(builder, typedef);
+
+ makeSerializable(builder);
+ return builder.build();
+ }
+
+ @Override
+ void addAsGetterMethod(final GeneratedTypeBuilderBase<?> builder, final TypeBuilderFactory builderFactory) {
+ // typedefs are a separate concept
+ }
+}
--- /dev/null
+/*
+ * 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl.reactor;
+
+import static com.google.common.base.Verify.verify;
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+import org.opendaylight.yangtools.yang.model.api.stmt.AugmentEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.model.api.stmt.UsesEffectiveStatement;
+
+/**
+ * Generator corresponding to a {@code augment} statement used as a child of a {@code uses} statement.
+ */
+final class UsesAugmentGenerator extends AbstractAugmentGenerator {
+ private final UsesEffectiveStatement uses;
+
+ private GroupingGenerator grouping;
+
+ UsesAugmentGenerator(final AugmentEffectiveStatement statement, final AbstractCompositeGenerator<?> parent,
+ final UsesEffectiveStatement uses) {
+ super(statement, parent);
+ this.uses = requireNonNull(uses);
+ }
+
+ void linkGroupingDependency(final UsesEffectiveStatement checkUses, final GroupingGenerator resolvedGrouping) {
+ if (uses.equals(checkUses)) {
+ verify(grouping == null, "Attempted to relink %s from %s to %s", this, grouping, resolvedGrouping);
+ this.grouping = requireNonNull(resolvedGrouping);
+ }
+ }
+
+ @Override
+ void loadTargetGenerator() {
+ final GroupingGenerator grp = verifyNotNull(grouping, "No grouping linked in %s", this);
+ final SchemaNodeIdentifier path = statement().argument();
+
+ /*
+ * Here we are going in the opposite direction of RFC7950, section 3.13:
+ *
+ * The effect of a "uses" reference to a grouping is that the nodes
+ * defined by the grouping are copied into the current schema tree and
+ * are then updated according to the "refine" and "augment" statements.
+ *
+ * Our argument is composed of QNames in the current schema tree's namespace, but the grouping may have been
+ * defined in a different module -- and therefore it knows those children under its namespace. Adjust the path
+ * we are searching if that happens to be the case.
+ */
+ setTargetGenerator(grp.resolveSchemaNode(path, grp.statement().argument().getModule()));
+ }
+}
import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.model.util.BindingTypes.TYPE_OBJECT;
-import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNodeForRelativeXPath;
-import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataTreeSchemaNode;
-import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
import com.google.common.annotations.Beta;
-import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableMap;
import java.util.Optional;
import java.util.Set;
import java.util.TreeMap;
-import java.util.regex.Pattern;
import org.opendaylight.mdsal.binding.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.generator.util.BaseYangTypesProvider;
import org.opendaylight.mdsal.binding.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.model.api.ConcreteType;
import org.opendaylight.mdsal.binding.model.api.Enumeration;
-import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.AbstractEnumerationBuilder;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.GeneratedPropertyBuilderImpl;
import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.PathExpression;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
-import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.ModuleDependencySort;
-import org.opendaylight.yangtools.yang.model.util.PathExpressionImpl;
-import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.opendaylight.yangtools.yang.model.spi.ModuleDependencySort;
@Beta
public abstract class AbstractTypeProvider implements TypeProvider {
- private static final Logger LOG = LoggerFactory.getLogger(AbstractTypeProvider.class);
- private static final Pattern GROUPS_PATTERN = Pattern.compile("\\[(.*?)\\]");
private static final JavaTypeName DEPRECATED_ANNOTATION = JavaTypeName.create(Deprecated.class);
/**
* @param renames renaming table
* @throws IllegalArgumentException if <code>schemaContext</code> equal null.
*/
- AbstractTypeProvider(final SchemaContext schemaContext, final Map<SchemaNode, JavaTypeName> renames) {
- Preconditions.checkArgument(schemaContext != null, "Schema Context cannot be null!");
- this.schemaContext = schemaContext;
+ AbstractTypeProvider(final EffectiveModelContext schemaContext, final Map<SchemaNode, JavaTypeName> renames) {
+ this.schemaContext = requireNonNull(schemaContext);
this.renames = requireNonNull(renames);
+
resolveTypeDefsFromContext();
}
@Override
public Type javaTypeForSchemaDefinitionType(final TypeDefinition<?> typeDefinition, final SchemaNode parentNode,
final Restrictions restrictions, final boolean lenientRelativeLeafrefs) {
- Preconditions.checkArgument(typeDefinition != null, "Type Definition cannot be NULL!");
- Preconditions.checkArgument(typeDefinition.getQName() != null,
- "Type Definition cannot have non specified QName (QName cannot be NULL!)");
- final String typedefName = typeDefinition.getQName().getLocalName();
- Preconditions.checkArgument(typedefName != null, "Type Definitions Local Name cannot be NULL!");
-
- // Deal with base types
- if (typeDefinition.getBaseType() == null) {
- // We have to deal with differing handling of decimal64. The old parser used a fixed Decimal64 type
- // and generated an enclosing ExtendedType to hold any range constraints. The new parser instantiates
- // a base type which holds these constraints.
- if (typeDefinition instanceof DecimalTypeDefinition) {
- final Type ret = BaseYangTypesProvider.INSTANCE.javaTypeForSchemaDefinitionType(typeDefinition,
- parentNode, restrictions, lenientRelativeLeafrefs);
- if (ret != null) {
- return ret;
- }
- }
-
- // Deal with leafrefs/identityrefs
- Type ret = javaTypeForLeafrefOrIdentityRef(typeDefinition, parentNode, lenientRelativeLeafrefs);
- if (ret != null) {
- return ret;
- }
-
- // FIXME: it looks as though we could be using the same codepath as above...
- ret = BaseYangTypes.javaTypeForYangType(typeDefinition.getQName().getLocalName());
- if (ret == null) {
- LOG.debug("Failed to resolve Java type for {}", typeDefinition);
- }
-
- return ret;
- }
-
- Type returnType = javaTypeForExtendedType(typeDefinition, lenientRelativeLeafrefs);
- if (restrictions != null && returnType instanceof GeneratedTransferObject) {
- final GeneratedTransferObject gto = (GeneratedTransferObject) returnType;
- final Module module = findParentModule(schemaContext, parentNode);
- final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
- final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName,
- typeDefinition.getPath());
- final String genTOName = BindingMapping.getClassName(typedefName);
- final String name = packageName + "." + genTOName;
- if (!returnType.getFullyQualifiedName().equals(name)) {
- returnType = shadedTOWithRestrictions(gto, restrictions);
- }
- }
- return returnType;
- }
-
- public SchemaNode getTargetForLeafref(final LeafrefTypeDefinition leafrefType, final SchemaNode parentNode) {
- final PathExpression xpath = leafrefType.getPathStatement();
- Preconditions.checkArgument(xpath != null, "The Path Statement for Leafref Type Definition cannot be NULL!");
-
- final Module module = findParentModule(schemaContext, parentNode);
- Preconditions.checkArgument(module != null, "Failed to find module for parent %s", parentNode);
-
- return xpath.isAbsolute() ? findDataTreeSchemaNode(schemaContext, module.getQNameModule(), xpath)
- : findDataSchemaNodeForRelativeXPath(schemaContext, module, parentNode, xpath);
- }
-
- private GeneratedTransferObject shadedTOWithRestrictions(final GeneratedTransferObject gto,
- final Restrictions restrictions) {
- final GeneratedTOBuilder gtob = newGeneratedTOBuilder(gto.getIdentifier());
- final GeneratedTransferObject parent = gto.getSuperType();
- if (parent != null) {
- gtob.setExtendsType(parent);
- }
- gtob.setRestrictions(restrictions);
- for (GeneratedProperty gp : gto.getProperties()) {
- final GeneratedPropertyBuilder gpb = gtob.addProperty(gp.getName());
- gpb.setValue(gp.getValue());
- gpb.setReadOnly(gp.isReadOnly());
- gpb.setAccessModifier(gp.getAccessModifier());
- gpb.setReturnType(gp.getReturnType());
- gpb.setFinal(gp.isFinal());
- gpb.setStatic(gp.isStatic());
- }
- return gtob.build();
- }
-
- private boolean isLeafRefSelfReference(final LeafrefTypeDefinition leafref, final SchemaNode parentNode) {
- /*
- * First check if the leafref is an augment. If that is the case, skip it as it will be checked once augments
- * are resolved.
- */
- DataNodeContainer current = null;
- DataSchemaNode dataChildByName;
- for (QName next : parentNode.getPath().getPathFromRoot()) {
- if (current == null) {
- dataChildByName = schemaContext.dataChildByName(next);
- } else {
- dataChildByName = current.dataChildByName(next);
- }
- if (dataChildByName == null) {
- return false;
- }
- if (dataChildByName.isAugmenting()) {
- return false;
- }
- if (dataChildByName instanceof DataNodeContainer) {
- current = (DataNodeContainer) dataChildByName;
- }
- }
-
- // Then try to look up the expression.
- final PathExpression leafRefXPath = leafref.getPathStatement();
- final Module parentModule = getParentModule(parentNode);
- final SchemaNode leafRefValueNode;
- if (leafRefXPath.isAbsolute()) {
- leafRefValueNode = SchemaContextUtil.findDataTreeSchemaNode(schemaContext, parentModule.getQNameModule(),
- leafRefXPath);
- } else {
- leafRefValueNode = SchemaContextUtil.findDataSchemaNodeForRelativeXPath(schemaContext, parentModule,
- parentNode, new PathExpressionImpl(
- GROUPS_PATTERN.matcher(leafRefXPath.getOriginalString()).replaceAll(""), false));
- }
-
- return leafRefValueNode != null && leafRefValueNode.equals(parentNode);
- }
-
- /**
- * Returns JAVA <code>Type</code> for instances of the type <code>LeafrefTypeDefinition</code> or
- * <code>IdentityrefTypeDefinition</code>.
- *
- * @param typeDefinition type definition which is converted to JAVA <code>Type</code>
- * @return JAVA <code>Type</code> instance for <code>typeDefinition</code>
- */
- private Type javaTypeForLeafrefOrIdentityRef(final TypeDefinition<?> typeDefinition, final SchemaNode parentNode,
- final boolean inGrouping) {
- if (typeDefinition instanceof LeafrefTypeDefinition) {
- final LeafrefTypeDefinition leafref = (LeafrefTypeDefinition) typeDefinition;
- Preconditions.checkArgument(!isLeafRefSelfReference(leafref, parentNode),
- "Leafref %s is referencing itself, incoming StackOverFlowError detected.", leafref);
- return provideTypeForLeafref(leafref, parentNode, inGrouping);
- } else if (typeDefinition instanceof IdentityrefTypeDefinition) {
- return provideTypeForIdentityref((IdentityrefTypeDefinition) typeDefinition);
- }
-
- return null;
- }
-
- /**
- * Returns JAVA <code>Type</code> for instances of the type <code>ExtendedType</code>.
- *
- * @param typeDefinition type definition which is converted to JAVA <code>Type</code>
- * @return JAVA <code>Type</code> instance for <code>typeDefinition</code>
- */
- private Type javaTypeForExtendedType(final TypeDefinition<?> typeDefinition, final boolean lenient) {
- final String typedefName = typeDefinition.getQName().getLocalName();
- final TypeDefinition<?> baseTypeDef = baseTypeDefForExtendedType(typeDefinition);
- Type returnType = javaTypeForLeafrefOrIdentityRef(baseTypeDef, typeDefinition, lenient);
- if (returnType == null) {
- if (baseTypeDef instanceof EnumTypeDefinition) {
- final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) baseTypeDef;
- returnType = provideTypeForEnum(enumTypeDef, typedefName, typeDefinition);
- } else {
- final Module module = findParentModule(schemaContext, typeDefinition);
- final Restrictions r = BindingGeneratorUtil.getRestrictions(typeDefinition);
- if (module != null) {
- final Map<Optional<Revision>, Map<String, GeneratedType>> modulesByDate = genTypeDefsContextMap.get(
- module.getName());
- final Map<String, GeneratedType> genTOs = modulesByDate.get(module.getRevision());
- if (genTOs != null) {
- returnType = genTOs.get(typedefName);
- }
- if (returnType == null) {
- returnType = BaseYangTypesProvider.INSTANCE.javaTypeForSchemaDefinitionType(baseTypeDef,
- typeDefinition, r, lenient);
- }
- }
- }
- }
- return returnType;
- }
-
- /**
- * Seeks for identity reference <code>idref</code> the JAVA <code>type</code>.
- *
- * <p>
- * <i>Example:<br />
- * If identy which is referenced via <code>idref</code> has name <b>Idn</b>
- * then returning type is <b>{@code Class<? extends Idn>}</b></i>
- *
- * @param idref identityref type definition for which JAVA <code>Type</code> is sought
- * @return JAVA <code>Type</code> of the identity which is referenced through <code>idref</code>
- */
- private Type provideTypeForIdentityref(final IdentityrefTypeDefinition idref) {
- final Collection<? extends IdentitySchemaNode> identities = idref.getIdentities();
- if (identities.size() > 1) {
- LOG.warn("Identity reference {} has multiple identities, using only the first one", idref);
- }
-
- final QName baseIdQName = identities.iterator().next().getQName();
- final Module module = schemaContext.findModule(baseIdQName.getModule()).orElse(null);
- IdentitySchemaNode identity = null;
- for (IdentitySchemaNode id : module.getIdentities()) {
- if (id.getQName().equals(baseIdQName)) {
- identity = id;
- }
- }
- Preconditions.checkArgument(identity != null, "Target identity '" + baseIdQName + "' do not exist");
-
- final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
- final JavaTypeName identifier = JavaTypeName.create(BindingGeneratorUtil.packageNameForGeneratedType(
- basePackageName, identity.getPath()), BindingMapping.getClassName(identity.getQName()));
- return Types.classType(Types.wildcardTypeFor(identifier));
+ throw new UnsupportedOperationException();
}
/**
return ret;
}
- /**
- * Converts <code>leafrefType</code> to JAVA <code>Type</code>. The path of <code>leafrefType</code> is followed
- * to find referenced node and its <code>Type</code> is returned.
- *
- * @param leafrefType leafref type definition for which is the type sought
- * @param parentNode parent node of the leaf being resolved
- * @param inGrouping true if we are resolving the type within a grouping.
- * @return JAVA <code>Type</code> of data schema node which is referenced in <code>leafrefType</code>
- * @throws IllegalArgumentException
- * <ul>
- * <li>if <code>leafrefType</code> equal null</li>
- * <li>if path statement of <code>leafrefType</code> equal null</li>
- * </ul>
- */
- @VisibleForTesting
- Type provideTypeForLeafref(final LeafrefTypeDefinition leafrefType, final SchemaNode parentNode,
- final boolean inGrouping) {
- Preconditions.checkArgument(leafrefType != null, "Leafref Type Definition reference cannot be NULL!");
-
- final PathExpression xpath = leafrefType.getPathStatement();
- Preconditions.checkArgument(xpath != null, "The Path Statement for Leafref Type Definition cannot be NULL!");
-
- final String strXPath = xpath.getOriginalString();
- if (strXPath.indexOf('[') != -1) {
- // XXX: why are we special-casing this?
- return Types.objectType();
- }
-
- final Module module = findParentModule(schemaContext, parentNode);
- Preconditions.checkArgument(module != null, "Failed to find module for parent %s", parentNode);
-
- final SchemaNode dataNode;
- if (xpath.isAbsolute()) {
- dataNode = findDataTreeSchemaNode(schemaContext, module.getQNameModule(), xpath);
- } else {
- dataNode = findDataSchemaNodeForRelativeXPath(schemaContext, module, parentNode, xpath);
- if (dataNode == null && inGrouping) {
- // Relative path within a grouping may end up being unresolvable because it may refer outside
- // the grouping, in which case it is polymorphic based on instantiation, for example:
- //
- // grouping foo {
- // leaf foo {
- // type leafref {
- // path "../../bar";
- // }
- // }
- // }
- //
- // container one {
- // leaf bar {
- // type string;
- // }
- // uses foo;
- // }
- //
- // container two {
- // leaf bar {
- // type uint16;
- // }
- // uses foo;
- // }
- LOG.debug("Leafref type {} not found in parent {}, assuming polymorphic object", leafrefType,
- parentNode);
- return Types.objectType();
- }
- }
- Preconditions.checkArgument(dataNode != null, "Failed to find leafref target: %s in module %s (%s)",
- strXPath, this.getParentModule(parentNode).getName(), parentNode.getQName().getModule());
-
- // FIXME: this block seems to be some weird magic hack. Analyze and refactor it.
- Type returnType = null;
- if (leafContainsEnumDefinition(dataNode)) {
- returnType = referencedTypes.get(dataNode.getPath());
- } else if (leafListContainsEnumDefinition(dataNode)) {
- returnType = Types.listTypeFor(referencedTypes.get(dataNode.getPath()));
- }
- if (returnType == null) {
- returnType = resolveTypeFromDataSchemaNode(dataNode, inGrouping);
- }
- Preconditions.checkArgument(returnType != null, "Failed to find leafref target: %s in module %s (%s)",
- strXPath, this.getParentModule(parentNode).getName(), parentNode.getQName().getModule(), this);
- return returnType;
- }
-
- /**
- * Checks if <code>dataNode</code> is <code>LeafSchemaNode</code> and if it so then checks if it is of type
- * <code>EnumTypeDefinition</code>.
- *
- * @param dataNode data schema node for which is checked if it is leaf and if it is of enum type
- * @return boolean value
- * <ul>
- * <li>true - if <code>dataNode</code> is leaf of type enumeration</li>
- * <li>false - other cases</li>
- * </ul>
- */
- private static boolean leafContainsEnumDefinition(final SchemaNode dataNode) {
- if (dataNode instanceof LeafSchemaNode) {
- final LeafSchemaNode leaf = (LeafSchemaNode) dataNode;
- return CompatUtils.compatType(leaf) instanceof EnumTypeDefinition;
- }
- return false;
- }
-
- /**
- * Checks if <code>dataNode</code> is <code>LeafListSchemaNode</code> and if it so then checks if it is of type
- * <code>EnumTypeDefinition</code>.
- *
- * @param dataNode data schema node for which is checked if it is leaflist and if it is of enum type
- * @return boolean value
- * <ul>
- * <li>true - if <code>dataNode</code> is leaflist of type
- * enumeration</li>
- * <li>false - other cases</li>
- * </ul>
- */
- private static boolean leafListContainsEnumDefinition(final SchemaNode dataNode) {
- if (dataNode instanceof LeafListSchemaNode) {
- final LeafListSchemaNode leafList = (LeafListSchemaNode) dataNode;
- return leafList.getType() instanceof EnumTypeDefinition;
- }
- return false;
- }
-
/**
* Converts <code>enumTypeDef</code> to {@link Enumeration enumeration}.
*
addEnumDescription(enumBuilder, enumTypeDef);
enumTypeDef.getReference().ifPresent(enumBuilder::setReference);
enumBuilder.setModuleName(module.getName());
- enumBuilder.setSchemaPath(enumTypeDef.getPath());
enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
return enumBuilder.toInstance();
}
return resolveRegExpressions(((StringTypeDefinition) typedef).getPatternConstraints());
}
- /**
- * Converts <code>dataNode</code> to JAVA <code>Type</code>.
- *
- * @param dataNode contains information about YANG type
- * @return JAVA <code>Type</code> representation of <code>dataNode</code>
- */
- private Type resolveTypeFromDataSchemaNode(final SchemaNode dataNode, final boolean inGrouping) {
- Type returnType = null;
- if (dataNode != null) {
- if (dataNode instanceof LeafSchemaNode) {
- final LeafSchemaNode leaf = (LeafSchemaNode) dataNode;
- final TypeDefinition<?> type = CompatUtils.compatType(leaf);
- returnType = javaTypeForSchemaDefinitionType(type, leaf, inGrouping);
- } else if (dataNode instanceof LeafListSchemaNode) {
- final LeafListSchemaNode leafList = (LeafListSchemaNode) dataNode;
- returnType = javaTypeForSchemaDefinitionType(leafList.getType(), leafList, inGrouping);
- }
- }
- return returnType;
- }
-
/**
* Passes through all modules and through all its type definitions and convert it to generated types.
*
}
}
- private Module getParentModule(final SchemaNode node) {
- final QName qname = node.getPath().getPathFromRoot().iterator().next();
- return schemaContext.findModule(qname.getModule()).orElse(null);
+ /**
+ * Returns parent Yang Module for specified Schema Context in which Schema
+ * Node is declared. If the Schema Node is not present in Schema Context the
+ * operation will return <code>null</code>.
+ *
+ * @param context Schema Context
+ * @param schemaNode Schema Node
+ * @return Yang Module for specified Schema Context and Schema Node, if Schema Node is NOT present, the method will
+ * return <code>null</code>
+ * @throws NullPointerException if any of the arguments is null
+ */
+ private static Module findParentModule(final SchemaContext context, final SchemaNode schemaNode) {
+ return context.findModule(schemaNode.getQName().getModule()).orElse(null);
}
}
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTypeBuilder;
import org.opendaylight.yangtools.yang.binding.RegexPatterns;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
* @param renames renaming table
* @throws IllegalArgumentException if <code>schemaContext</code> is null.
*/
- public CodegenTypeProvider(final SchemaContext schemaContext, final Map<SchemaNode, JavaTypeName> renames) {
+ public CodegenTypeProvider(final EffectiveModelContext schemaContext, final Map<SchemaNode, JavaTypeName> renames) {
super(schemaContext, renames);
}
@VisibleForTesting
- CodegenTypeProvider(final SchemaContext schemaContext) {
+ CodegenTypeProvider(final EffectiveModelContext schemaContext) {
this(schemaContext, ImmutableMap.of());
}
+++ /dev/null
-/*
- * Copyright (c) 2015 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.mdsal.binding.yang.types;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static java.util.Objects.requireNonNull;
-
-import java.util.List;
-import java.util.Optional;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
-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.InstanceIdentifierTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.LengthRestrictedTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
-
-/**
- * Compatibility utilities for dealing with differences between the old parser's ExtendedType-driven type
- * representation versus the representation provided by {@code yang-model-util} models.
- */
-public final class CompatUtils {
- private CompatUtils() {
- // Hidden on purpose
- }
-
- /**
- * This package's type hierarchy model generates a type which encapsulates the default value and units for leaves.
- * Java Binding specification is implemented in a way, where it needs to revert this process if the internal
- * declaration has not restricted the type further -- which is not something available via
- * {@link TypeDefinition#getBaseType()}.
- *
- * <p>
- * Here are the possible scenarios:
- *
- * <pre>
- * leaf foo {
- * type uint8 {
- * range 1..2;
- * }
- * }
- * </pre>
- * The leaf type's schema path does not match the schema path of the leaf. We do NOT want to strip it, as
- * we need to generate an inner class to hold the restrictions.
- *
- * <pre>
- * leaf foo {
- * type uint8 {
- * range 1..2;
- * }
- * default 1;
- * }
- * </pre>
- * The leaf type's schema path will match the schema path of the leaf. We do NOT want to strip it, as we need
- * to generate an inner class to hold the restrictions.
- *
- * <pre>
- * leaf foo {
- * type uint8;
- * default 1;
- * }
- * </pre>
- * The leaf type's schema path will match the schema path of the leaf. We DO want to strip it, as we will deal
- * with the default value ourselves.
- *
- * <pre>
- * leaf foo {
- * type uint8;
- * }
- * </pre>
- * The leaf type's schema path will not match the schema path of the leaf. We do NOT want to strip it.
- *
- * <p>
- * The situation is different for types which do not have a default instantiation in YANG: leafref, enumeration,
- * identityref, decimal64, bits and union. If these types are defined within this leaf's statement, a base type
- * will be instantiated. If the leaf defines a default statement, this base type will be visible via getBaseType().
- *
- * <pre>
- * leaf foo {
- * type decimal64 {
- * fraction-digits 2;
- * }
- * }
- * </pre>
- * The leaf type's schema path will not match the schema path of the leaf, and we do not want to strip it, as it
- * needs to be generated.
- *
- * <pre>
- * leaf foo {
- * type decimal64 {
- * fraction-digits 2;
- * }
- * default 1;
- * }
- * </pre>
- * The leaf type's schema path will match the schema path of the leaf, and we DO want to strip it.
- *
- * @param leaf Leaf for which we are acquiring the type
- * @return Potentially base type of the leaf type.
- */
- public static @NonNull TypeDefinition<?> compatType(final @NonNull TypedDataSchemaNode leaf) {
- final TypeDefinition<?> leafType = requireNonNull(leaf.getType());
-
- if (!leaf.getPath().equals(leafType.getPath())) {
- // Old parser semantics, or no new default/units defined for this leaf
- return leafType;
- }
-
- // We are dealing with a type generated for the leaf itself
- final TypeDefinition<?> baseType = leafType.getBaseType();
- checkArgument(baseType != null, "Leaf %s has type for leaf, but no base type", leaf);
-
- if (leaf.getPath().equals(baseType.getPath().getParent())) {
- // Internal instantiation of a base YANG type (decimal64 and similar)
- return baseType;
- }
-
- // At this point we have dealt with the easy cases. Now we need to perform per-type checking if there are no
- // new constraints introduced by this type. If there were not, we will return the base type.
- if (leafType instanceof BinaryTypeDefinition) {
- return baseTypeIfNotConstrained((BinaryTypeDefinition) leafType);
- } else if (leafType instanceof DecimalTypeDefinition) {
- return baseTypeIfNotConstrained((DecimalTypeDefinition) leafType);
- } else if (leafType instanceof InstanceIdentifierTypeDefinition) {
- return baseTypeIfNotConstrained((InstanceIdentifierTypeDefinition) leafType);
- } else if (leafType instanceof Int8TypeDefinition) {
- return baseTypeIfNotConstrained((Int8TypeDefinition) leafType);
- } else if (leafType instanceof Int16TypeDefinition) {
- return baseTypeIfNotConstrained((Int16TypeDefinition) leafType);
- } else if (leafType instanceof Int32TypeDefinition) {
- return baseTypeIfNotConstrained((Int32TypeDefinition) leafType);
- } else if (leafType instanceof Int64TypeDefinition) {
- return baseTypeIfNotConstrained((Int64TypeDefinition) leafType);
- } else if (leafType instanceof StringTypeDefinition) {
- return baseTypeIfNotConstrained((StringTypeDefinition) leafType);
- } else if (leafType instanceof Uint8TypeDefinition) {
- return baseTypeIfNotConstrained((Uint8TypeDefinition) leafType);
- } else if (leafType instanceof Uint16TypeDefinition) {
- return baseTypeIfNotConstrained((Uint16TypeDefinition) leafType);
- } else if (leafType instanceof Uint32TypeDefinition) {
- return baseTypeIfNotConstrained((Uint32TypeDefinition) leafType);
- } else if (leafType instanceof Uint64TypeDefinition) {
- return baseTypeIfNotConstrained((Uint64TypeDefinition) leafType);
- } else {
- // Other types cannot be constrained, return the base type
- return baseType;
- }
- }
-
- private static BinaryTypeDefinition baseTypeIfNotConstrained(final @NonNull BinaryTypeDefinition type) {
- return baseTypeIfNotConstrained(type, type.getBaseType());
- }
-
- private static TypeDefinition<?> baseTypeIfNotConstrained(final @NonNull DecimalTypeDefinition type) {
- return baseTypeIfNotConstrained(type, type.getBaseType());
- }
-
- private static TypeDefinition<?> baseTypeIfNotConstrained(final @NonNull InstanceIdentifierTypeDefinition type) {
- final InstanceIdentifierTypeDefinition base = type.getBaseType();
- return type.requireInstance() == base.requireInstance() ? base : type;
- }
-
- private static TypeDefinition<?> baseTypeIfNotConstrained(final @NonNull StringTypeDefinition type) {
- final StringTypeDefinition base = type.getBaseType();
- final List<PatternConstraint> patterns = type.getPatternConstraints();
- final Optional<LengthConstraint> optLengths = type.getLengthConstraint();
-
- if ((patterns.isEmpty() || patterns.equals(base.getPatternConstraints()))
- && (optLengths.isEmpty() || optLengths.equals(base.getLengthConstraint()))) {
- return base;
- }
-
- return type;
- }
-
- private static <T extends RangeRestrictedTypeDefinition<T, ?>> T baseTypeIfNotConstrained(final @NonNull T type) {
- return baseTypeIfNotConstrained(type, type.getBaseType());
- }
-
- private static <T extends RangeRestrictedTypeDefinition<T, ?>> T baseTypeIfNotConstrained(final @NonNull T type,
- final T base) {
- final Optional<?> optConstraint = type.getRangeConstraint();
- if (optConstraint.isEmpty()) {
- return base;
- }
- return optConstraint.equals(base.getRangeConstraint()) ? base : type;
- }
-
- private static <T extends LengthRestrictedTypeDefinition<T>> T baseTypeIfNotConstrained(final @NonNull T type,
- final T base) {
- final Optional<LengthConstraint> optConstraint = type.getLengthConstraint();
- if (optConstraint.isEmpty()) {
- return base;
- }
- return optConstraint.equals(base.getLengthConstraint()) ? base : type;
- }
-}
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.RuntimeEnumerationBuilder;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.RuntimeGeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.RuntimeGeneratedTypeBuilder;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
*/
@Beta
public final class RuntimeTypeProvider extends AbstractTypeProvider {
- public RuntimeTypeProvider(final SchemaContext schemaContext, final Map<SchemaNode, JavaTypeName> renames) {
+ public RuntimeTypeProvider(final EffectiveModelContext schemaContext, final Map<SchemaNode, JavaTypeName> renames) {
super(schemaContext, renames);
}
@VisibleForTesting
- RuntimeTypeProvider(final SchemaContext schemaContext) {
+ RuntimeTypeProvider(final EffectiveModelContext schemaContext) {
this(schemaContext, ImmutableMap.of());
}
package org.opendaylight.mdsal.binding.yang.types;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
}
private static void fillRecursively(final List<TypeDefinition<?>> list, final DataNodeContainer container) {
- final Collection<? extends DataSchemaNode> childNodes = container.getChildNodes();
- if (childNodes != null) {
- for (DataSchemaNode childNode : childNodes) {
- if (!childNode.isAugmenting()) {
- if (childNode instanceof ContainerSchemaNode) {
- fillRecursively(list, (ContainerSchemaNode) childNode);
- } else if (childNode instanceof ListSchemaNode) {
- fillRecursively(list, (ListSchemaNode) childNode);
- } else if (childNode instanceof ChoiceSchemaNode) {
- for (CaseSchemaNode caseNode : ((ChoiceSchemaNode) childNode).getCases()) {
- fillRecursively(list, caseNode);
- }
+ for (DataSchemaNode childNode : container.getChildNodes()) {
+ if (!childNode.isAugmenting()) {
+ if (childNode instanceof ContainerSchemaNode) {
+ fillRecursively(list, (ContainerSchemaNode) childNode);
+ } else if (childNode instanceof ListSchemaNode) {
+ fillRecursively(list, (ListSchemaNode) childNode);
+ } else if (childNode instanceof ChoiceSchemaNode) {
+ for (CaseSchemaNode caseNode : ((ChoiceSchemaNode) childNode).getCases()) {
+ fillRecursively(list, caseNode);
}
}
}
list.addAll(container.getTypeDefinitions());
- final Collection<? extends GroupingDefinition> groupings = container.getGroupings();
- if (groupings != null) {
- for (GroupingDefinition grouping : groupings) {
- fillRecursively(list, grouping);
- }
+ for (GroupingDefinition grouping : container.getGroupings()) {
+ fillRecursively(list, grouping);
}
}
}
*/
package org.opendaylight.mdsal.binding.generator.impl;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.opendaylight.mdsal.binding.generator.impl.SupportTestUtil.containsAttributes;
import static org.opendaylight.mdsal.binding.generator.impl.SupportTestUtil.containsMethods;
import java.util.List;
+import java.util.stream.Collectors;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
@Test
public void testNestedTypesInLeaf() {
- GeneratedTransferObject lfLeaf = null;
- int lfLeafCounter = 0;
- GeneratedTransferObject lf1Leaf = null;
- int lf1LeafCounter = 0;
- GeneratedTransferObject lf2Leaf = null;
- int lf2LeafCounter = 0;
- List<GeneratedType> enclosedTypes = parentContainer.getEnclosedTypes();
- assertEquals(5, enclosedTypes.size());
-
- for (GeneratedType genType : enclosedTypes) {
- if (genType instanceof GeneratedTransferObject) {
- if (genType.getName().equals("Lf")) {
- lfLeaf = (GeneratedTransferObject) genType;
- lfLeafCounter++;
- } else if (genType.getName().equals("Lf$1")) {
- lf1Leaf = (GeneratedTransferObject) genType;
- lf1LeafCounter++;
- } else if (genType.getName().equals("Lf$2")) {
- lf2Leaf = (GeneratedTransferObject) genType;
- lf2LeafCounter++;
- }
-
- }
- }
-
- // nested types in leaf, contains Lf?
- assertNotNull("Lf TO wasn't found.", lfLeaf);
- assertEquals("Lf TO has incorrect number of occurences.", 1, lfLeafCounter);
+ final List<GeneratedType> enclosedTypes = parentContainer.getEnclosedTypes();
+ assertEquals(3, enclosedTypes.size());
+
+ // nested types in leaf
+ final List<GeneratedTransferObject> lfLeafs = enclosedTypes.stream()
+ .filter(genType -> genType.getName().equals("Lf"))
+ .map(genType -> {
+ assertThat(genType, instanceOf(GeneratedTransferObject.class));
+ return (GeneratedTransferObject) genType;
+ })
+ .collect(Collectors.toList());
+ assertEquals("Lf TO has incorrect number of occurences.", 1, lfLeafs.size());
+ GeneratedTransferObject lfLeaf = lfLeafs.get(0);
assertEquals("Lf has incorrect package name.",
- "org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626.ParentContainer",
- lfLeaf.getIdentifier().immediatelyEnclosingClass().get().toString());
+ "org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626.ParentContainer",
+ lfLeaf.getIdentifier().immediatelyEnclosingClass().get().toString());
assertEquals("Lf generated TO has incorrect number of properties", 2, lfLeaf.getProperties().size());
containsAttributes(lfLeaf, true, true, true, new NameTypePattern("string", "String"));
containsAttributes(lfLeaf, true, false, true, new NameTypePattern("lf$1", "Lf$1"));
- // nested types in leaf, contains Lf1?
- assertNotNull("Lf$1 TO wasn't found.", lf1Leaf);
- assertEquals("Lf$1 TO has incorrect number of occurences.", 1, lf1LeafCounter);
- assertEquals("Lf$1 has incorrect package name.",
- "org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626.ParentContainer",
- lf1Leaf.getIdentifier().immediatelyEnclosingClass().get().toString());
-
- assertEquals("Lf generated TO has incorrect number of properties", 4, lf1Leaf.getProperties().size());
- containsAttributes(lf1Leaf, true, true, true, new NameTypePattern("uint32", "Uint32"));
- containsAttributes(lf1Leaf, true, true, true, new NameTypePattern("int8", "Byte"));
- containsAttributes(lf1Leaf, true, true, true, new NameTypePattern("string", "String"));
- containsAttributes(lf1Leaf, true, false, true, new NameTypePattern("lf$2", "Lf$2"));
+ // nested types in Lf
+ final List<GeneratedType> lfTypes = lfLeaf.getEnclosedTypes();
+ assertEquals(1, lfTypes.size());
- // nested types in leaf, contains Lf2?
- assertNotNull("Lf$2 TO wasn't found.", lf2Leaf);
- assertEquals("Lf$2 TO has incorrect number of occurences.", 1, lf2LeafCounter);
+ final GeneratedType lf1Leaf = lfTypes.get(0);
+ assertEquals("Lf$1", lf1Leaf.getName());
+ assertEquals("Lf$1 has incorrect package name.",
+ "org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626.ParentContainer.Lf",
+ lf1Leaf.getIdentifier().immediatelyEnclosingClass().get().toString());
+
+ assertThat(lf1Leaf, instanceOf(GeneratedTransferObject.class));
+ final GeneratedTransferObject lf1gto = (GeneratedTransferObject) lf1Leaf;
+ assertEquals("Lf$1 generated TO has incorrect number of properties", 4, lf1Leaf.getProperties().size());
+ containsAttributes(lf1gto, true, true, true, new NameTypePattern("uint32", "Uint32"));
+ containsAttributes(lf1gto, true, true, true, new NameTypePattern("int8", "Byte"));
+ containsAttributes(lf1gto, true, true, true, new NameTypePattern("string", "String"));
+ containsAttributes(lf1gto, true, false, true, new NameTypePattern("lf$2", "Lf$2"));
+
+ // nested types in Lf1
+ final List<GeneratedType> lf1Types = lf1Leaf.getEnclosedTypes();
+ assertEquals(1, lf1Types.size());
+
+ final GeneratedType lf2Leaf = lf1Types.get(0);
+ assertEquals("Lf$2", lf2Leaf.getName());
assertEquals("Lf$2 has incorrect package name.",
- "org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626.ParentContainer",
- lf2Leaf.getIdentifier().immediatelyEnclosingClass().get().toString());
+ "org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626.ParentContainer.Lf.Lf$1",
+ lf2Leaf.getIdentifier().immediatelyEnclosingClass().get().toString());
+
+ assertThat(lf2Leaf, instanceOf(GeneratedTransferObject.class));
+ final GeneratedTransferObject lf2gto = (GeneratedTransferObject) lf2Leaf;
assertEquals("Lf generated TO has incorrect number of properties", 2, lf2Leaf.getProperties().size());
- containsAttributes(lf2Leaf, true, true, true, new NameTypePattern("string", "String"));
- containsAttributes(lf2Leaf, true, true, true, new NameTypePattern("uint64", "Uint64"));
+ containsAttributes(lf2gto, true, true, true, new NameTypePattern("string", "String"));
+ containsAttributes(lf2gto, true, true, true, new NameTypePattern("uint64", "Uint64"));
}
@Test
containsAttributes(typeUnionTypedef, true, false, true, new NameTypePattern("typeUnion$1", "TypeUnion$1"));
List<GeneratedType> nestedUnions = typeUnionTypedef.getEnclosedTypes();
- assertEquals("Incorrect number of nested unions", 2, nestedUnions.size());
-
- GeneratedTransferObject typeUnion1 = null;
- int typeUnion1Counter = 0;
- GeneratedTransferObject typeUnion2 = null;
- int typeUnion2Counter = 0;
- for (GeneratedType genType : nestedUnions) {
- if (genType instanceof GeneratedTransferObject) {
- if (genType.getName().equals("TypeUnion$1")) {
- typeUnion1 = (GeneratedTransferObject) genType;
- typeUnion1Counter++;
- } else if (genType.getName().equals("TypeUnion$2")) {
- typeUnion2 = (GeneratedTransferObject) genType;
- typeUnion2Counter++;
- }
- }
- }
-
- assertNotNull("TypeUnion$1 TO wasn't found.", typeUnion1);
- assertEquals("TypeUnion$1 TO has incorrect number of occurences.", 1, typeUnion1Counter);
+ assertEquals("Incorrect number of nested unions", 1, nestedUnions.size());
+ GeneratedType typeUnion1 = nestedUnions.get(0);
+ assertEquals("TypeUnion$1", typeUnion1.getName());
assertEquals("TypeUnion$1 has incorrect package name.",
- "org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626", typeUnion1.getPackageName());
-
+ "org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626", typeUnion1.getPackageName());
assertEquals("TypeUnion1 generated TO has incorrect number of properties", 4,
typeUnion1.getProperties().size());
- containsAttributes(typeUnion1, true, true, true, new NameTypePattern("uint32", "Uint32"));
- containsAttributes(typeUnion1, true, true, true, new NameTypePattern("int8", "Byte"));
- containsAttributes(typeUnion1, true, true, true, new NameTypePattern("string", "String"));
- containsAttributes(typeUnion1, true, false, true, new NameTypePattern("typeUnion$2", "TypeUnion$2"));
+ assertThat(typeUnion1, instanceOf(GeneratedTransferObject.class));
+ GeneratedTransferObject typeUnion1gto = (GeneratedTransferObject) typeUnion1;
+ containsAttributes(typeUnion1gto, true, true, true, new NameTypePattern("uint32", "Uint32"));
+ containsAttributes(typeUnion1gto, true, true, true, new NameTypePattern("int8", "Byte"));
+ containsAttributes(typeUnion1gto, true, true, true, new NameTypePattern("string", "String"));
+ containsAttributes(typeUnion1gto, true, false, true, new NameTypePattern("typeUnion$2", "TypeUnion$2"));
- assertNotNull("TypeUnion$2 TO wasn't found.", typeUnion2);
- assertEquals("TypeUnion$2 TO has incorrect number of occurences.", 1, typeUnion2Counter);
- assertEquals("TypeUnion$2 has incorrect package name.",
- "org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626", typeUnion2.getPackageName());
+ List<GeneratedType> nestedUnions1 = typeUnion1.getEnclosedTypes();
+ assertEquals(1, nestedUnions1.size());
+ GeneratedType typeUnion2 = nestedUnions1.get(0);
+ assertEquals("TypeUnion$2", typeUnion2.getName());
+ assertEquals("TypeUnion$2 has incorrect package name.",
+ "org.opendaylight.yang.gen.v1.urn.bit.union.in.leaf.rev130626", typeUnion2.getPackageName());
assertEquals("TypeUnion2 generated TO has incorrect number of properties", 2,
typeUnion2.getProperties().size());
- containsAttributes(typeUnion2, true, true, true, new NameTypePattern("string", "String"));
- containsAttributes(typeUnion2, true, true, true, new NameTypePattern("uint64", "Uint64"));
+ assertThat(typeUnion2, instanceOf(GeneratedTransferObject.class));
+ GeneratedTransferObject typeUnion2gto = (GeneratedTransferObject) typeUnion2;
+ containsAttributes(typeUnion2gto, true, true, true, new NameTypePattern("string", "String"));
+ containsAttributes(typeUnion2gto, true, true, true, new NameTypePattern("uint64", "Uint64"));
}
@Test
+++ /dev/null
-/*
- * Copyright (c) 2016 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.mdsal.binding.generator.impl;
-
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import org.junit.Test;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-
-public class CodecTypeUtilsTest {
-
- @Test
- public void newIdentifiableItem() {
- assertNotNull(CodecTypeUtils.newIdentifiableItem(Identifiable.class, mock(Identifier.class)));
- }
-
- @Test
- public void privateConstructTest() throws NoSuchMethodException, ReflectiveOperationException {
- final Constructor<?> constructor = CodecTypeUtils.class.getDeclaredConstructor();
- constructor.setAccessible(true);
- try {
- constructor.newInstance();
- fail();
- } catch (InvocationTargetException e) {
- assertTrue(e.getCause() instanceof UnsupportedOperationException);
- }
- }
-}
\ No newline at end of file
assertNotNull(condLeafref);
Type condLeafRT = condLeafref.getReturnType();
assertNotNull(condLeafRT);
- assertEquals("java.lang.Object", condLeafRT.getFullyQualifiedName());
+ assertEquals("org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri",
+ condLeafRT.getFullyQualifiedName());
// InterfaceId
final List<GeneratedProperty> gtIfcKeyProps = gtIfcKey.getProperties();
final Collection<GeneratedType> types = DefaultBindingGenerator.generateFor(
YangParserTestUtils.parseYangResource("/mdsal161.yang"));
assertNotNull(types);
- assertEquals(24, types.size());
+ assertEquals(25, types.size());
assertKeyStructure(types, "org.opendaylight.yang.gen.v1.mdsal161.norev.WithGrpKey");
assertKeyStructure(types, "org.opendaylight.yang.gen.v1.mdsal161.norev.WithGrpExtKey");
*/
package org.opendaylight.mdsal.binding.generator.impl;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
final GeneratedType foo = generateTypes.stream().filter(type -> type.getFullyQualifiedName()
.equals("org.opendaylight.yang.gen.v1.urn.odl.yt320.norev.Foo")).findFirst().get();
- GeneratedTransferObject bar = null;
- GeneratedTransferObject bar1 = null;
- for (GeneratedType enc : foo.getEnclosedTypes()) {
- switch (enc.getName()) {
- case "Bar":
- assertTrue(enc instanceof GeneratedTransferObject);
- bar = (GeneratedTransferObject) enc;
- break;
- case "Bar$1":
- assertTrue(enc instanceof GeneratedTransferObject);
- bar1 = (GeneratedTransferObject) enc;
- break;
- default:
- throw new IllegalStateException("Unexpected type " + enc);
- }
- }
- assertNotNull(bar);
- assertTrue(bar.isUnionType());
- assertNotNull(bar1);
- assertTrue(bar1.isUnionType());
+ final List<GeneratedType> fooTypes = foo.getEnclosedTypes();
+ assertEquals(1, fooTypes.size());
+
+ final GeneratedType bar = fooTypes.get(0);
+ assertEquals("Bar", bar.getName());
+ assertThat(bar, instanceOf(GeneratedTransferObject.class));
+ assertTrue(((GeneratedTransferObject) bar).isUnionType());
+
+ final List<GeneratedType> barTypes = bar.getEnclosedTypes();
+ assertEquals(1, barTypes.size());
+
+ final GeneratedType bar1 = barTypes.get(0);
+ assertEquals("Bar$1", bar1.getName());
+ assertThat(bar1, instanceOf(GeneratedTransferObject.class));
+ assertTrue(((GeneratedTransferObject) bar1).isUnionType());
final Iterator<MethodSignature> it = foo.getMethodDefinitions().iterator();
assertTrue(it.hasNext());
final MethodSignature signature = methods.get(0);
assertEquals("switch$", signature.getName());
- assertEquals(3, types.size());
}
}
final List<GeneratedType> types = DefaultBindingGenerator.generateFor(
YangParserTestUtils.parseYangResourceDirectory("/mdsal-531"));
assertNotNull(types);
- assertEquals(10, types.size());
+ assertEquals(9, types.size());
}
}
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertThrows;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.mdsal.binding.generator.spi.TypeProvider;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
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.TypeDefinition;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class Bug4621 {
@Test
public void bug4621test() {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/bug4621.yang");
- final Module moduleValid = schemaContext.findModules(URI.create("foo")).iterator().next();
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource("/bug4621.yang");
+ final Module moduleValid = schemaContext.findModules(XMLNamespace.of("foo")).iterator().next();
final TypeProvider typeProvider = new RuntimeTypeProvider(schemaContext);
final QName listNode = QName.create(moduleValid.getQNameModule(), "neighbor");
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
}
@Override
- public boolean isConfiguration() {
- return false;
+ public Optional<Boolean> effectiveConfig() {
+ return Optional.of(Boolean.FALSE);
}
@Override
}
@Override
- public Collection<MustDefinition> getMustConstraints() {
+ public Collection<@NonNull MustDefinition> getMustConstraints() {
return ImmutableSet.of();
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import java.net.URI;
+import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTypeBuilder;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
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.type.StringTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
+import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
+@Ignore
public class TypeProviderImplTest {
-
@Test(expected = IllegalArgumentException.class)
public void testLeafRefRelativeSelfReference() {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource(
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource(
"/leafref/leafref-relative-invalid.yang");
- final Module moduleRelative = schemaContext.findModules(URI.create("urn:xml:ns:yang:lrr")).iterator().next();
+ final Module moduleRelative = schemaContext.findModules(XMLNamespace.of("urn:xml:ns:yang:lrr"))
+ .iterator().next();
final AbstractTypeProvider typeProvider = new RuntimeTypeProvider(schemaContext);
final QName listNode = QName.create(moduleRelative.getQNameModule(), "neighbor");
@Test(expected = IllegalArgumentException.class)
public void testLeafRefAbsoluteSelfReference() {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource(
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource(
"/leafref/leafref-absolute-invalid.yang");
- final Module moduleRelative = schemaContext.findModules(URI.create("urn:xml:ns:yang:lra")).iterator().next();
+ final Module moduleRelative = schemaContext.findModules(XMLNamespace.of("urn:xml:ns:yang:lra"))
+ .iterator().next();
final AbstractTypeProvider typeProvider = new RuntimeTypeProvider(schemaContext);
final QName listNode = QName.create(moduleRelative.getQNameModule(), "neighbor");
@Test
public void testLeafRefRelativeAndAbsoluteValidReference() {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/leafref/leafref-valid.yang");
- final Module moduleValid = schemaContext.findModules(URI.create("urn:xml:ns:yang:lrv")).iterator().next();
+ final EffectiveModelContext schemaContext =
+ YangParserTestUtils.parseYangResource("/leafref/leafref-valid.yang");
+ final Module moduleValid = schemaContext.findModules(XMLNamespace.of("urn:xml:ns:yang:lrv")).iterator().next();
final AbstractTypeProvider typeProvider = new RuntimeTypeProvider(schemaContext);
final QName listNode = QName.create(moduleValid.getQNameModule(), "neighbor");
@Test
public void testMethodsOfTypeProviderImpl() {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/base-yang-types.yang");
-
- final AbstractTypeProvider typeProvider = new RuntimeTypeProvider(schemaContext);
+ final AbstractTypeProvider typeProvider = new RuntimeTypeProvider(
+ YangParserTestUtils.parseYangResource("/base-yang-types.yang"));
final SchemaPath refTypePath = SchemaPath.create(true, QName.create("", "cont1"), QName.create("", "list1"));
final CodegenGeneratedTypeBuilder refType = new CodegenGeneratedTypeBuilder(
*/
package org.opendaylight.mdsal.binding.yang.types;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
/**
}
- public static SchemaContext createTestContext() {
+ public static EffectiveModelContext createTestContext() {
return YangParserTestUtils.parseYangResources(TypeProviderModel.class, "/base-yang-types.yang",
"/" + TEST_TYPE_PROVIDER_MODULE_NAME + ".yang", "/test-type-provider-b.yang");
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.doReturn;
import com.google.common.collect.Range;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
* @see org.opendaylight.mdsal.binding.yang.types.AbstractTypeProvider
* @author Lukas Sedlak <lsedlak@cisco.com>
*/
+@Ignore
@RunWith(MockitoJUnitRunner.class)
public class TypeProviderTest {
- public static SchemaContext SCHEMA_CONTEXT;
+ public static EffectiveModelContext SCHEMA_CONTEXT;
public static Module TEST_TYPE_PROVIDER;
@Mock
provider.javaTypeForSchemaDefinitionType(leafType, leaf);
}
- @Test(expected = IllegalArgumentException.class)
- public void provideTypeForLeafrefWithNullLeafrefTypeTest() {
- final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
-
- provider.provideTypeForLeafref(null, null, false);
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void provideTypeForLeafrefWithNullLeafrefTypePathStatementTest() {
- final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
-
- final LeafrefTypeWithNullXpath leafrePath = new LeafrefTypeWithNullXpath();
- provider.provideTypeForLeafref(leafrePath, this.schemaNode, false);
- }
-
- @Test(expected = NullPointerException.class)
- public void provideTypeForLeafrefWithNullParentModuleTest() {
- final AbstractTypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
- final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "bar",
- "leafref-value");
- final TypeDefinition<?> leafType = leaf.getType();
- assertTrue(leafType instanceof LeafrefTypeDefinition);
- doReturn(null).when(this.schemaNode).getPath();
- provider.provideTypeForLeafref((LeafrefTypeDefinition) leafType, this.schemaNode, false);
- }
-
@Test
public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() {
final TypeProvider provider = new RuntimeTypeProvider(SCHEMA_CONTEXT);
leaf cond-leafref {
type leafref {
- path "/tp:topology/tp:network-nodes/tp:network-node[node-id = current()/super-node]";
+ path "/tp:topology/tp:network-nodes/tp:network-node[node-id = current()/super-node]/tp:node-id";
}
}
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-model-util</artifactId>
+ <artifactId>yang-model-ri</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-test-util</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-model-util</artifactId>
+ <scope>test</scope>
+ </dependency>
</dependencies>
</project>
requires transitive org.opendaylight.mdsal.binding.generator.api;
requires org.opendaylight.mdsal.binding.spec.util;
requires org.opendaylight.yangtools.util;
- requires org.opendaylight.yangtools.yang.model.util;
+ requires org.opendaylight.yangtools.yang.model.api;
+ requires org.opendaylight.yangtools.yang.model.ri;
// Annotations
requires static transitive org.eclipse.jdt.annotation;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
-import org.opendaylight.yangtools.yang.model.util.type.DecimalTypeBuilder;
+import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
+import org.opendaylight.yangtools.yang.model.ri.type.DecimalTypeBuilder;
/**
* Contains the methods for converting strings to valid JAVA language strings
// comparison
if (type instanceof DecimalTypeDefinition) {
final DecimalTypeDefinition decimal = (DecimalTypeDefinition) type;
- final DecimalTypeBuilder tmpBuilder = BaseTypes.decimalTypeBuilder(decimal.getPath());
+ final DecimalTypeBuilder tmpBuilder = BaseTypes.decimalTypeBuilder(decimal.getQName());
tmpBuilder.setFractionDigits(decimal.getFractionDigits());
final DecimalTypeDefinition tmp = tmpBuilder.build();
}
@Override
- public RangeSet<T> getAllowedRanges() {
+ public RangeSet<@NonNull T> getAllowedRanges() {
return ImmutableRangeSet.of(Range.closed(min, max));
}
}
protected abstract T thisInstance();
- abstract AbstractEnumerationBuilder newEnumerationBuilder(JavaTypeName identifier);
-
@Override
public T addEnclosingTransferObject(final GeneratedTransferObject genTO) {
checkArgument(genTO != null, "Parameter genTO cannot be null!");
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-public final class CodegenGeneratedTOBuilder extends AbstractGeneratedTOBuilder {
-
+public class CodegenGeneratedTOBuilder extends AbstractGeneratedTOBuilder {
private Restrictions restrictions;
private GeneratedPropertyBuilder suid;
private String reference;
}
@Override
- public void setRestrictions(final Restrictions restrictions) {
+ public final void setRestrictions(final Restrictions restrictions) {
this.restrictions = restrictions;
}
@Override
- public void setSUID(final GeneratedPropertyBuilder newSuid) {
+ public final void setSUID(final GeneratedPropertyBuilder newSuid) {
this.suid = newSuid;
}
@Override
- public GeneratedTransferObject build() {
- return new GTO(this);
- }
-
- @Override
- public void setDescription(final String description) {
+ public final void setDescription(final String description) {
this.description = description;
}
@Override
- public void setModuleName(final String moduleName) {
+ public final void setModuleName(final String moduleName) {
this.moduleName = moduleName;
}
@Override
- public void setSchemaPath(final SchemaPath schemaPath) {
+ public final void setSchemaPath(final SchemaPath schemaPath) {
this.schemaPath = schemaPath;
}
@Override
- public void setReference(final String reference) {
+ public final void setReference(final String reference) {
this.reference = reference;
}
@Override
- AbstractEnumerationBuilder newEnumerationBuilder(final JavaTypeName identifier) {
- return new CodegenEnumerationBuilder(identifier);
+ public final GeneratedTransferObject build() {
+ return new GTO(this);
}
private static final class GTO extends AbstractGeneratedTransferObject {
return new GeneratedTypeImpl(this);
}
- @Override
- AbstractEnumerationBuilder newEnumerationBuilder(final JavaTypeName identifier) {
- return new CodegenEnumerationBuilder(identifier);
- }
-
@Override
protected CodegenGeneratedTypeBuilder thisInstance() {
return this;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-public final class RuntimeGeneratedTOBuilder extends AbstractGeneratedTOBuilder {
+public class RuntimeGeneratedTOBuilder extends AbstractGeneratedTOBuilder {
public RuntimeGeneratedTOBuilder(final JavaTypeName identifier) {
super(identifier);
}
@Override
- public void setRestrictions(final Restrictions restrictions) {
+ public final void setRestrictions(final Restrictions restrictions) {
// No-op
}
@Override
- public void setSUID(final GeneratedPropertyBuilder suid) {
+ public final void setSUID(final GeneratedPropertyBuilder suid) {
// No-op
}
@Override
- public void setDescription(final String description) {
+ public final void setDescription(final String description) {
// No-op
}
@Override
- public void setModuleName(final String moduleName) {
+ public final void setModuleName(final String moduleName) {
// No-op
}
@Override
- public void setSchemaPath(final SchemaPath schemaPath) {
+ public final void setSchemaPath(final SchemaPath schemaPath) {
// No-op
}
@Override
- public void setReference(final String reference) {
+ public final void setReference(final String reference) {
// No-op
}
return new GTO(this);
}
- @Override
- AbstractEnumerationBuilder newEnumerationBuilder(final JavaTypeName identifier) {
- return new RuntimeEnumerationBuilder(identifier);
- }
-
- private static final class GTO extends AbstractGeneratedTransferObject {
- GTO(final RuntimeGeneratedTOBuilder builder) {
+ protected static class GTO extends AbstractGeneratedTransferObject {
+ protected GTO(final RuntimeGeneratedTOBuilder builder) {
super(builder);
}
@Override
- public Restrictions getRestrictions() {
+ public final Restrictions getRestrictions() {
throw unsupported();
}
@Override
- public GeneratedProperty getSUID() {
+ public final GeneratedProperty getSUID() {
throw unsupported();
}
@Override
- public String getDescription() {
+ public final String getDescription() {
throw unsupported();
}
@Override
- public String getReference() {
+ public final String getReference() {
throw unsupported();
}
@Override
- public Iterable<QName> getSchemaPath() {
+ public final Iterable<QName> getSchemaPath() {
throw unsupported();
}
@Override
- public String getModuleName() {
+ public final String getModuleName() {
throw unsupported();
}
// No-op
}
- @Override
- AbstractEnumerationBuilder newEnumerationBuilder(final JavaTypeName identifier) {
- return new RuntimeEnumerationBuilder(identifier);
- }
-
@Override
public String toString() {
final StringBuilder builder = new StringBuilder();
import com.google.common.collect.Range;
import java.io.Serializable;
import java.util.Collection;
-import java.util.Optional;
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.BaseConstraints;
+import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
+import org.opendaylight.yangtools.yang.model.ri.type.DerivedTypes;
+import org.opendaylight.yangtools.yang.model.ri.type.InvalidLengthConstraintException;
+import org.opendaylight.yangtools.yang.model.ri.type.RestrictedTypes;
+import org.opendaylight.yangtools.yang.model.ri.type.StringTypeBuilder;
import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
-import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
-import org.opendaylight.yangtools.yang.model.util.type.DerivedTypes;
-import org.opendaylight.yangtools.yang.model.util.type.InvalidLengthConstraintException;
-import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes;
-import org.opendaylight.yangtools.yang.model.util.type.StringTypeBuilder;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class BindingGeneratorUtilTest {
- private static final SchemaPath ROOT_PATH = SchemaPath.create(true, QName.create("test", "root"));
+ private static final QName ROOT = QName.create("test", "root");
/*
* Tests methods:
@Test
public void getRestrictionsTest() throws InvalidLengthConstraintException {
- final Optional<String> absent = Optional.empty();
+ final PatternConstraint constraint = mock(PatternConstraint.class);
+
final StringTypeBuilder builder =
- RestrictedTypes.newStringBuilder(BaseTypes.stringType(), ROOT_PATH);
+ RestrictedTypes.newStringBuilder(BaseTypes.stringType(), ROOT);
- builder.addPatternConstraint(BaseConstraints.newPatternConstraint(".*", absent, absent));
+ builder.addPatternConstraint(constraint);
builder.setLengthConstraint(mock(ConstraintMetaDefinition.class), ImmutableList.of(ValueRange.of(1, 2)));
Restrictions restrictions = BindingGeneratorUtil.getRestrictions(builder.build());
assertEquals(1, restrictions.getPatternConstraints().size());
assertFalse(restrictions.isEmpty());
- assertTrue(restrictions.getPatternConstraints().contains(
- BaseConstraints.newPatternConstraint(".*", absent, absent)));
+ assertTrue(restrictions.getPatternConstraints().contains(constraint));
}
@Test
public void getEmptyRestrictionsTest() {
- final TypeDefinition<?> type = DerivedTypes.derivedTypeBuilder(BaseTypes.stringType(), ROOT_PATH).build();
+ final TypeDefinition<?> type = DerivedTypes.derivedTypeBuilder(BaseTypes.stringType(), ROOT).build();
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(type);
assertNotNull(restrictions);
@Test
public void getDefaultIntegerRestrictionsTest() {
- final TypeDefinition<?> type = DerivedTypes.derivedTypeBuilder(BaseTypes.int16Type(), ROOT_PATH).build();
+ final TypeDefinition<?> type = DerivedTypes.derivedTypeBuilder(BaseTypes.int16Type(), ROOT).build();
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(type);
assertNotNull(restrictions);
@Test
public void getDefaultUnsignedIntegerRestrictionsTest() {
- final TypeDefinition<?> type = DerivedTypes.derivedTypeBuilder(BaseTypes.uint16Type(), ROOT_PATH).build();
+ final TypeDefinition<?> type = DerivedTypes.derivedTypeBuilder(BaseTypes.uint16Type(), ROOT).build();
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(type);
assertNotNull(restrictions);
@Test
public void getDefaultDecimalRestrictionsTest() {
- final DecimalTypeDefinition base = BaseTypes.decimalTypeBuilder(ROOT_PATH).setFractionDigits(10).build();
- final TypeDefinition<?> type = DerivedTypes.derivedTypeBuilder(base, ROOT_PATH).build();
+ final DecimalTypeDefinition base = BaseTypes.decimalTypeBuilder(ROOT).setFractionDigits(10).build();
+ final TypeDefinition<?> type = DerivedTypes.derivedTypeBuilder(base, ROOT).build();
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(type);
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
-import org.opendaylight.yangtools.yang.model.util.type.EnumPairBuilder;
+import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
+import org.opendaylight.yangtools.yang.model.ri.type.EnumPairBuilder;
public class EnumerationBuilderImplTest {
@Test
public void testUpdateEnumPairsFromEnumTypeDef() {
- final EnumTypeDefinition enumTypeDefinition = BaseTypes.enumerationTypeBuilder(SchemaPath.SAME)
+ final EnumTypeDefinition enumTypeDefinition = BaseTypes.enumerationTypeBuilder(QName.create("test", "test"))
.addEnum(EnumPairBuilder.create("SomeName", 42).setDescription("Some Other Description")
.setReference("Some other reference").build()).build();
enumerationBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDefinition);
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-repo-spi</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-util</artifactId>
requires transitive org.opendaylight.yangtools.yang.binding;
requires transitive org.opendaylight.mdsal.binding.generator.api;
requires org.opendaylight.yangtools.yang.model.util;
+ requires org.opendaylight.yangtools.yang.repo.spi;
requires org.slf4j;
// Annotations
import java.util.Optional;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.model.api.DefaultType;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
-import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static <T extends SchemaNode> T getOriginalSchema(final T choice) {
@SuppressWarnings("unchecked")
- final T original = (T) SchemaNodeUtils.getRootOriginalIfPossible(choice);
+ final T original = (T) originalNodeOf(choice);
if (original != null) {
return original;
}
return Optional.of(potential);
}
if (potential != null) {
- SchemaNode potentialRoot = SchemaNodeUtils.getRootOriginalIfPossible(potential);
+ SchemaNode potentialRoot = originalNodeOf(potential);
if (originalDefinition.equals(potentialRoot)) {
return Optional.of(potential);
}
// sufficient to uniquelly determine equality of cases
//
for (CaseSchemaNode caze : instantiatedChoice.findCaseNodes(originalDefinition.getQName().getLocalName())) {
- if (originalDefinition.equals(SchemaNodeUtils.getRootOriginalIfPossible(caze))) {
+ if (originalDefinition.equals(originalNodeOf(caze))) {
return Optional.of(caze);
}
}
return Optional.empty();
}
+
+ private static @Nullable SchemaNode originalNodeOf(final SchemaNode node) {
+ return node instanceof DerivableSchemaNode ? ((DerivableSchemaNode) node).getOriginal().orElse(null) : null;
+ }
}
*/
package org.opendaylight.mdsal.binding.runtime.api;
+import static com.google.common.base.Verify.verify;
+import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMultimap;
import com.google.common.collect.Multimap;
+import com.google.common.collect.MultimapBuilder;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.util.Collection;
import java.util.IdentityHashMap;
+import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.yangtools.concepts.Immutable;
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.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public BindingRuntimeTypes(final EffectiveModelContext schemaContext,
final Map<Type, AugmentationSchemaNode> typeToAugmentation,
final Map<Type, WithStatus> typeToSchema, final Map<WithStatus, Type> schemaToType,
- final Multimap<Type, Type> choiceToCases, final Map<QName, Type> identities) {
+ final Map<QName, Type> identities) {
this.schemaContext = requireNonNull(schemaContext);
this.typeToAugmentation = ImmutableMap.copyOf(typeToAugmentation);
this.typeToSchema = ImmutableMap.copyOf(typeToSchema);
- this.choiceToCases = ImmutableMultimap.copyOf(choiceToCases);
this.identities = ImmutableMap.copyOf(identities);
// Careful to use identity for SchemaNodes, but only if needed
}
this.schemaToType = copy;
+
+ // Two-phase indexing of choice/case nodes. First we load all choices. Note we are using typeToSchema argument,
+ // not field, so as not to instantiate its entrySet.
+ final Set<GeneratedType> choiceTypes = typeToSchema.entrySet().stream()
+ .filter(entry -> entry.getValue() instanceof ChoiceEffectiveStatement)
+ .map(entry -> {
+ final Type key = entry.getKey();
+ verify(key instanceof GeneratedType, "Unexpected choice type %s", key);
+ return (GeneratedType) key;
+ })
+ .collect(Collectors.toUnmodifiableSet());
+
+ final Multimap<Type, Type> builder = MultimapBuilder.hashKeys(choiceTypes.size()).arrayListValues().build();
+ for (Entry<Type, WithStatus> entry : typeToSchema.entrySet()) {
+ if (entry.getValue() instanceof CaseEffectiveStatement) {
+ final Type type = entry.getKey();
+ verify(type instanceof GeneratedType, "Unexpected case type %s", type);
+ builder.put(verifyNotNull(implementedChoiceType(((GeneratedType) type).getImplements(), choiceTypes),
+ "Cannot determine choice type for %s", type), type);
+ }
+ }
+
+ choiceToCases = ImmutableMultimap.copyOf(builder);
+ }
+
+ private static GeneratedType implementedChoiceType(final List<Type> impls, final Set<GeneratedType> choiceTypes) {
+ for (Type impl : impls) {
+ if (impl instanceof GeneratedType && choiceTypes.contains(impl)) {
+ return (GeneratedType) impl;
+ }
+ }
+ return null;
}
public BindingRuntimeTypes(final EffectiveModelContext schemaContext,
final Map<Type, AugmentationSchemaNode> typeToAugmentation,
- final BiMap<Type, WithStatus> typeToDefiningSchema,
- final Multimap<Type, Type> choiceToCases, final Map<QName, Type> identities) {
- this(schemaContext, typeToAugmentation, typeToDefiningSchema, typeToDefiningSchema.inverse(), choiceToCases,
- identities);
+ final BiMap<Type, WithStatus> typeToDefiningSchema, final Map<QName, Type> identities) {
+ this(schemaContext, typeToAugmentation, typeToDefiningSchema, typeToDefiningSchema.inverse(), identities);
}
@Override
--- /dev/null
+/*
+ * Copyright (c) 2021 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.runtime.api;
+
+import com.google.common.annotations.Beta;
+import java.util.List;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
+
+/**
+ * A {@link GeneratedTransferObject} created for run-time representation of a {@code union}.
+ */
+@Beta
+public interface RuntimeGeneratedUnion extends GeneratedTransferObject {
+ /**
+ * List of property names corresponding to individual {@code type} statements within this union. The ordering of
+ * the returned list matches the ordering of the type statements.
+ *
+ * @return A list of property names.
+ */
+ @NonNull List<String> typePropertyNames();
+}
requires org.opendaylight.yangtools.util;
requires org.slf4j;
- uses org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+ uses org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
uses org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeGenerator;
// Annotations
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangParserException;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
/**
* Simple helpers to help with reconstruction of BindingRuntimeContext from generated binding classes. These involve
import org.opendaylight.yangtools.concepts.CheckedBuilder;
import org.opendaylight.yangtools.yang.binding.BindingObject;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParser;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
-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.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.parser.api.YangParser;
+import org.opendaylight.yangtools.yang.parser.api.YangParserException;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangSyntaxErrorException;
@Beta
public final class ModuleInfoSnapshotBuilder implements CheckedBuilder<ModuleInfoSnapshot, YangParserException> {
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
-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;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.parser.repo.YangTextSchemaContextResolver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ServiceLoader;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeGenerator;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
/**
* State derived from ServiceLoader. We statically bind to this state. If you need more dynamics, you should not be
* @param str the string that should get an upper case first character.
* @return the {@link String} {@code str} with an upper case first character.
*/
- private static @NonNull String toFirstUpper(final @NonNull String str) {
+ public static @NonNull String toFirstUpper(final @NonNull String str) {
if (str.isEmpty()) {
return str;
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import java.net.URI;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
public class BindingMappingTest {
@Test
public void basicTest() {
- assertTrue(BindingMapping.getRootPackageName(QName.create(QNameModule.create(URI.create("test:URI"),
+ assertTrue(BindingMapping.getRootPackageName(QName.create(QNameModule.create(XMLNamespace.of("test:URI"),
Revision.of("2017-10-26")), "test")).contains("test.uri"));
assertTrue(BindingMapping.normalizePackageName("1testpublic").contains("_1testpublic"));
assertTrue(BindingMapping.getMethodName(QName.create("testNS", "testLocalName")).equals("testLocalName"));
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
* Fails all future reads.
*
* @param exception a {@link ReadFailedException} to throw from a
- * {@link ReadTransaction#read(LogicalDatastoreType, InstanceIdentifier)} call.
+ * {@link ReadTransaction#read(LogicalDatastoreType, InstanceIdentifier)} call.
*/
void failReads(ReadFailedException exception);
* @param howManyTimes how many times to throw the passed exception, until it resets.
*
* @param exception a {@link ReadFailedException} to throw from a
- * {@link ReadTransaction#read(LogicalDatastoreType, InstanceIdentifier)} call.
+ * {@link ReadTransaction#read(LogicalDatastoreType, InstanceIdentifier)} call.
*/
void failReads(int howManyTimes, ReadFailedException exception);
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<link>https://commons.apache.org/proper/commons-lang/javadocs/api-3.10/</link>
<link>https://commons.apache.org/proper/commons-codec/apidocs/</link>
- <link>https://www.javadoc.io/doc/org.opendaylight.odlparent/odlparent-docs/8.1.1/</link>
- <link>https://www.javadoc.io/doc/org.opendaylight.yangtools/yangtools-docs/6.0.5/</link>
+ <link>https://www.javadoc.io/doc/org.opendaylight.odlparent/odlparent-docs/9.0.0/</link>
+ <link>https://www.javadoc.io/doc/org.opendaylight.yangtools/yangtools-docs/7.0.1-SNAPSHOT/</link>
</links>
<groups>
<group>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>6.0.5</version>
+ <version>7.0.1-SNAPSHOT</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-repo-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-repo-spi</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
requires transitive org.opendaylight.yangtools.yang.data.api;
requires transitive org.opendaylight.yangtools.yang.model.api;
+ requires transitive org.opendaylight.yangtools.yang.repo.api;
+ requires transitive org.opendaylight.yangtools.yang.repo.spi;
requires transitive org.opendaylight.mdsal.common.api;
requires org.opendaylight.yangtools.concepts;
requires org.opendaylight.yangtools.util;
* an exception derived from ReadFailedException.</li>
* </ul>
*/
- FluentFuture<Optional<NormalizedNode<?,?>>> read(LogicalDatastoreType store, YangInstanceIdentifier path);
+ FluentFuture<Optional<NormalizedNode>> read(LogicalDatastoreType store, YangInstanceIdentifier path);
/**
* Checks if data is available in the logical data store located at provided path.
* @param data the data object to be written to the specified path
* @throws IllegalStateException if the transaction has already been submitted
*/
- void put(LogicalDatastoreType store, YangInstanceIdentifier path, NormalizedNode<?, ?> data);
+ void put(LogicalDatastoreType store, YangInstanceIdentifier path, NormalizedNode data);
/**
* Merges a piece of data with the existing data at a specified path. Any pre-existing data which is not explicitly
* @param data the data object to be merged to the specified path
* @throws IllegalStateException if the transaction has already been submitted
*/
- void merge(LogicalDatastoreType store, YangInstanceIdentifier path, NormalizedNode<?, ?> data);
+ void merge(LogicalDatastoreType store, YangInstanceIdentifier path, NormalizedNode data);
/**
* Removes a piece of data from specified path. This operation does not fail if the specified path does not exist.
* @throws NullPointerException if any argument is null
*/
@NonNull ListenableFuture<? extends DOMRpcResult> invokeRpc(@NonNull DOMRpcIdentifier rpc,
- @NonNull NormalizedNode<?, ?> input);
+ @NonNull NormalizedNode input);
/**
* Return the relative invocation cost of this implementation. Default implementation return 0.
* @return Invocation result, null if the operation has not produced a result. This might
* be the case if the operation does not produce a result, or if it failed.
*/
- @Nullable NormalizedNode<?, ?> getResult();
+ @Nullable NormalizedNode getResult();
}
* @return A {@link ListenableFuture} which will return either a result structure, or report a subclass
* of {@link DOMRpcException} reporting a transport error.
*/
- @NonNull ListenableFuture<? extends DOMRpcResult> invokeRpc(@NonNull QName type,
- @NonNull NormalizedNode<?, ?> input);
+ @NonNull ListenableFuture<? extends DOMRpcResult> invokeRpc(@NonNull QName type, @NonNull NormalizedNode input);
/**
* Register a {@link DOMRpcAvailabilityListener} with this service to receive notifications
return new MatchAny(ImmutableList.of(this, other));
}
- public abstract boolean test(@Nullable NormalizedNode<?, ?> data);
+ public abstract boolean test(@Nullable NormalizedNode data);
final void appendTo(final StringBuilder sb) {
sb.append(op()).append('(');
}
@Override
- public boolean test(final @Nullable NormalizedNode<?, ?> data) {
+ public boolean test(final @Nullable NormalizedNode data) {
for (Match component : components()) {
if (!component.test(data)) {
return false;
}
@Override
- public boolean test(final @Nullable NormalizedNode<?, ?> data) {
+ public boolean test(final @Nullable NormalizedNode data) {
for (Match component : components()) {
if (component.test(data)) {
return true;
}
@Override
- public boolean test(final @Nullable NormalizedNode<?, ?> data) {
+ public boolean test(final @Nullable NormalizedNode data) {
return data != null;
}
}
@Override
- public boolean test(final @Nullable NormalizedNode<?, ?> data) {
+ public boolean test(final @Nullable NormalizedNode data) {
return !match.test(data);
}
}
@Override
- public final boolean test(final @Nullable NormalizedNode<?, ?> data) {
- return data instanceof LeafNode ? testValue(((LeafNode<?>) data).getValue()) : testValue(null);
+ public final boolean test(final @Nullable NormalizedNode data) {
+ return data instanceof LeafNode ? testValue(((LeafNode<?>) data).body()) : testValue(null);
}
abstract boolean testValue(@Nullable Object data);
*/
@Beta
@NonNullByDefault
-public interface DOMQueryResult extends Iterable<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>>, Immutable {
+public interface DOMQueryResult extends Iterable<Entry<YangInstanceIdentifier, NormalizedNode>>, Immutable {
- default Stream<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> stream() {
+ default Stream<Entry<YangInstanceIdentifier, NormalizedNode>> stream() {
return StreamSupport.stream(spliterator(), false);
}
- default Stream<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> parallelStream() {
+ default Stream<Entry<YangInstanceIdentifier, NormalizedNode>> parallelStream() {
return StreamSupport.stream(spliterator(), true);
}
- default List<? extends Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> items() {
+ default List<? extends Entry<YangInstanceIdentifier, NormalizedNode>> items() {
return stream().collect(Collectors.toUnmodifiableList());
}
return SimpleDOMQueryResult.EMPTY_INSTANCE;
}
- static DOMQueryResult of(final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> item) {
+ static DOMQueryResult of(final Entry<YangInstanceIdentifier, NormalizedNode> item) {
return new SimpleDOMQueryResult(ImmutableList.of(item));
}
- static DOMQueryResult of(final List<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> items) {
+ static DOMQueryResult of(final List<Entry<YangInstanceIdentifier, NormalizedNode>> items) {
return items.isEmpty() ? of() : new SimpleDOMQueryResult(items);
}
}
final class SimpleDOMQueryResult implements DOMQueryResult {
static final SimpleDOMQueryResult EMPTY_INSTANCE = new SimpleDOMQueryResult(ImmutableList.of());
- private final ImmutableList<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> items;
+ private final ImmutableList<Entry<YangInstanceIdentifier, NormalizedNode>> items;
- SimpleDOMQueryResult(final ImmutableList<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> items) {
+ SimpleDOMQueryResult(final ImmutableList<Entry<YangInstanceIdentifier, NormalizedNode>> items) {
this.items = items;
}
- SimpleDOMQueryResult(final List<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> items) {
+ SimpleDOMQueryResult(final List<Entry<YangInstanceIdentifier, NormalizedNode>> items) {
this(ImmutableList.copyOf(items));
}
@Override
- public Iterator<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> iterator() {
+ public Iterator<Entry<YangInstanceIdentifier, NormalizedNode>> iterator() {
return items.iterator();
}
@Override
- public Spliterator<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> spliterator() {
+ public Spliterator<Entry<YangInstanceIdentifier, NormalizedNode>> spliterator() {
return items.spliterator();
}
@Override
- public List<? extends Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> items() {
+ public List<? extends Entry<YangInstanceIdentifier, NormalizedNode>> items() {
return items;
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class DOMDataTreeIdentifierTest {
private static final String TEST_LISTS = "test-lists";
private static final String COMPARE_FIRST_LISTS = "A-test-lists";
private static final String COMPARE_SECOND_LISTS = "B-test-lists";
- private static final QNameModule TEST_MODULE = QNameModule.create(URI.create(
+ private static final QNameModule TEST_MODULE = QNameModule.create(XMLNamespace.of(
"urn:opendaylight:params:xml:ns:yang:controller:md:sal:test:store"));
private static final YangInstanceIdentifier REF_YII_IID = YangInstanceIdentifier.create(
new YangInstanceIdentifier.NodeIdentifier(QName.create(TEST_MODULE, REF_LISTS)));
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
public class DOMRpcIdentifierTest {
private static final String LOCAL_IDENT = "local";
- private static final QNameModule TEST_MODULE = QNameModule.create(URI.create(
+ private static final QNameModule TEST_MODULE = QNameModule.create(XMLNamespace.of(
"urn:opendaylight:params:xml:ns:yang:controller:md:sal:test:store"));
private static final QName LOCAL_QNAME = QName.create(TEST_MODULE, LOCAL_IDENT);
abstract ListMultimap<K, D> decomposeIdentifiers(Set<I> instances);
- abstract E createOperationEntry(EffectiveModelContext context, K key, Map<D, List<M>> implementations);
+ abstract @Nullable E createOperationEntry(EffectiveModelContext context, K key, Map<D, List<M>> implementations);
}
import org.opendaylight.mdsal.dom.api.DOMActionInstance;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
-import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
-import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
/**
* Definition of Action routing table.
@Override
protected DOMActionRoutingTableEntry createOperationEntry(final EffectiveModelContext context,
final Absolute type, final Map<DOMDataTreeIdentifier, List<DOMActionImplementation>> implementations) {
- final ActionDefinition actionDef = findActionDefinition(context, type);
- if (actionDef == null) {
- //FIXME: return null directly instead of providing kind of unknown entry.
- return null;
- }
-
- return new DOMActionRoutingTableEntry(type, implementations);
- }
-
- private static ActionDefinition findActionDefinition(final SchemaContext context, final Absolute path) {
- // FIXME: use direct search
- final SchemaPath legacy = path.asSchemaPath();
- final SchemaNode node = SchemaContextUtil.findDataSchemaNode(context, legacy.getParent());
- if (node instanceof ActionNodeContainer) {
- return ((ActionNodeContainer) node).findAction(legacy.getLastComponent()).orElse(null);
- }
- return null;
+ return context.findSchemaTreeNode(ActionDefinition.class, type)
+ .map(dummy -> new DOMActionRoutingTableEntry(type, implementations))
+ .orElse(null);
}
}
}
@Override
- public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
+ public FluentFuture<Optional<NormalizedNode>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
return getSubtransaction(store).read(path);
}
}
@Override
- public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
+ public FluentFuture<Optional<NormalizedNode>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
return getSubtransaction(store).read(path);
}
}
@Override
- public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data) {
+ public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode data) {
checkRunning(commitImpl);
getSubtransaction(store).write(path, data);
}
}
@Override
- public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data) {
+ public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode data) {
checkRunning(commitImpl);
getSubtransaction(store).merge(path, data);
}
private final class RpcServiceFacade implements DOMRpcService {
@Override
- public ListenableFuture<? extends DOMRpcResult> invokeRpc(final QName type, final NormalizedNode<?, ?> input) {
+ public ListenableFuture<? extends DOMRpcResult> invokeRpc(final QName type, final NormalizedNode input) {
final AbstractDOMRpcRoutingTableEntry entry = (AbstractDOMRpcRoutingTableEntry) routingTable.getEntry(type);
if (entry == null) {
return Futures.immediateFailedFuture(
}
static ListenableFuture<? extends DOMRpcResult> invoke(final AbstractDOMRpcRoutingTableEntry entry,
- final NormalizedNode<?, ?> input) {
+ final NormalizedNode input) {
if (entry instanceof UnknownDOMRpcRoutingTableEntry) {
return Futures.immediateFailedFuture(
new DOMRpcImplementationNotAvailableException("%s is not resolved to an RPC", entry.getType()));
}
private static ListenableFuture<? extends DOMRpcResult> invokeRoutedRpc(
- final RoutedDOMRpcRoutingTableEntry entry, final NormalizedNode<?, ?> input) {
- final Optional<NormalizedNode<?, ?>> maybeKey = NormalizedNodes.findNode(input,
+ final RoutedDOMRpcRoutingTableEntry entry, final NormalizedNode input) {
+ final Optional<NormalizedNode> maybeKey = NormalizedNodes.findNode(input,
entry.getRpcId().getContextReference());
// Routing key is present, attempt to deliver as a routed RPC
if (maybeKey.isPresent()) {
- final NormalizedNode<?, ?> key = maybeKey.get();
- final Object value = key.getValue();
+ final NormalizedNode key = maybeKey.get();
+ final Object value = key.body();
if (value instanceof YangInstanceIdentifier) {
final YangInstanceIdentifier iid = (YangInstanceIdentifier) value;
}
private static ListenableFuture<? extends DOMRpcResult> invokeGlobalRpc(
- final GlobalDOMRpcRoutingTableEntry entry, final NormalizedNode<?, ?> input) {
+ final GlobalDOMRpcRoutingTableEntry entry, final NormalizedNode input) {
return entry.getImplementations(YangInstanceIdentifier.empty()).get(0).invokeRpc(entry.getRpcId(), input);
}
}
import org.opendaylight.yangtools.util.ListenerRegistry;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
-import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.parser.repo.YangTextSchemaContextResolver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* Reads /test from readTx Read should return Absent.
*
*/
- final ListenableFuture<Optional<NormalizedNode<?, ?>>> readTxContainer = readTx
- .read(OPERATIONAL, TestModel.TEST_PATH);
+ final ListenableFuture<Optional<NormalizedNode>> readTxContainer = readTx.read(OPERATIONAL,
+ TestModel.TEST_PATH);
assertFalse(readTxContainer.get().isPresent());
}
writeTx.commit().get();
- final Optional<NormalizedNode<?, ?>> afterCommitRead = domBroker.newReadOnlyTransaction()
+ final Optional<NormalizedNode> afterCommitRead = domBroker.newReadOnlyTransaction()
.read(OPERATIONAL, TestModel.TEST_PATH).get();
assertTrue(afterCommitRead.isPresent());
}
@Test(expected = ReadFailedException.class)
@SuppressWarnings({"checkstyle:IllegalThrows", "checkstyle:AvoidHidingCauseException"})
public void basicTests() throws Throwable {
- final DataContainerChild<?, ?> outerList = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ final DataContainerChild outerList = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
.withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1))
.build();
- final NormalizedNode<?, ?> testContainer = Builders.containerBuilder()
+ final NormalizedNode testContainer = Builders.containerBuilder()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(outerList)
.build();
domStore.registerTreeChangeListener(TestModel.TEST_PATH, listener);
verify(listener, times(1)).onInitialData();
- final NormalizedNode<?, ?> testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
DOMStoreReadWriteTransaction writeTx = domStore.newReadWriteTransaction();
assertNotNull(writeTx);
writeTx.write(TestModel.TEST_PATH, testNode);
final ArgumentCaptor<Collection> candidateCapture = ArgumentCaptor.forClass(Collection.class);
doNothing().when(listener).onDataTreeChanged(any());
- final NormalizedNode<?, ?> testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
DOMStoreReadWriteTransaction writeTx = domStore.newReadWriteTransaction();
assertNotNull(writeTx);
import org.opendaylight.yangtools.util.concurrent.SpecialExecutors;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
private ExecutorService futureExecutor;
private CommitExecutorService commitExecutor;
- private static final DataContainerChild<?, ?> OUTER_LIST =
- ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ private static final MapNode OUTER_LIST = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
.withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1))
.build();
- private static final DataContainerChild<?, ?> OUTER_LIST_2 =
- ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ private static final MapNode OUTER_LIST_2 = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
.withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 2))
.build();
- private static final NormalizedNode<?, ?> TEST_CONTAINER = Builders.containerBuilder()
+ private static final NormalizedNode TEST_CONTAINER = Builders.containerBuilder()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(OUTER_LIST)
.build();
- private static final NormalizedNode<?, ?> TEST_CONTAINER_2 = Builders.containerBuilder()
+ private static final NormalizedNode TEST_CONTAINER_2 = Builders.containerBuilder()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(OUTER_LIST_2)
.build();
listenerReg.close();
}
- private static void checkChange(final NormalizedNode<?, ?> expectedBefore,
- final NormalizedNode<?, ?> expectedAfter,
- final ModificationType expectedMod,
- final DataTreeCandidateNode candidateNode) {
+ private static void checkChange(final NormalizedNode expectedBefore, final NormalizedNode expectedAfter,
+ final ModificationType expectedMod, final DataTreeCandidateNode candidateNode) {
if (expectedBefore != null) {
assertTrue(candidateNode.getDataBefore().isPresent());
assertEquals(expectedBefore, candidateNode.getDataBefore().get());
private static void assertTestContainerExists(final DOMDataTreeReadTransaction readTx)
throws InterruptedException, ExecutionException {
- final ListenableFuture<Optional<NormalizedNode<?, ?>>> readFuture =
- readTx.read(OPERATIONAL, TestModel.TEST_PATH);
- final Optional<NormalizedNode<?, ?>> readedData = readFuture.get();
+ final ListenableFuture<Optional<NormalizedNode>> readFuture = readTx.read(OPERATIONAL, TestModel.TEST_PATH);
+ final Optional<NormalizedNode> readedData = readFuture.get();
assertTrue(readedData.isPresent());
}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
abstract class TestUtils {
- private static final DataContainerChild<?, ?> OUTER_LIST = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ private static final MapNode OUTER_LIST = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
.withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1)).build();
private static final String TOP_LEVEL_LIST_FOO_KEY_VALUE = "foo";
.withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
.build();
- private static final DataContainerChild<?, ?> CHILD_LIST = ImmutableNodes.mapNodeBuilder(TestModel.TEST_QNAME)
+ private static final MapNode CHILD_LIST = ImmutableNodes.mapNodeBuilder(TestModel.TEST_QNAME)
.withNodeIdentifier(NodeIdentifier.create(TestModel.TEST_QNAME))
.withChild(TOP_LEVEL_LIST_NODE)
.build();
- static final NormalizedNode<?, ?> TEST_CONTAINER = Builders.containerBuilder()
+ static final NormalizedNode TEST_CONTAINER = Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
.withChild(OUTER_LIST)
.build();
- static final NormalizedNode<?, ?> TEST_CHILD = Builders.containerBuilder()
+ static final NormalizedNode TEST_CHILD = Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
.withChild(CHILD_LIST)
.build();
}
@Override
- public FluentFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode<?, ?> input) {
+ public FluentFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode input) {
requireNonNull(input);
return unknownRpc;
}
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.SystemMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
protected static final MapNode TEN_ITEM_INNER_LIST = initInnerListItems(10);
private static MapNode initInnerListItems(final int count) {
- final CollectionNodeBuilder<MapEntryNode, MapNode> mapEntryBuilder = ImmutableNodes
+ final CollectionNodeBuilder<MapEntryNode, SystemMapNode> mapEntryBuilder = ImmutableNodes
.mapNodeBuilder(BenchmarkModel.INNER_LIST_QNAME);
for (int i = 1; i <= count; ++i) {
return mapEntryBuilder.build();
}
- protected static final NormalizedNode<?, ?>[] OUTER_LIST_ONE_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_100K,
+ protected static final NormalizedNode[] OUTER_LIST_ONE_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_100K,
ONE_ITEM_INNER_LIST);
- protected static final NormalizedNode<?, ?>[] OUTER_LIST_TWO_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_50K,
+ protected static final NormalizedNode[] OUTER_LIST_TWO_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_50K,
TWO_ITEM_INNER_LIST);
- protected static final NormalizedNode<?, ?>[] OUTER_LIST_TEN_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_10K,
+ protected static final NormalizedNode[] OUTER_LIST_TEN_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_10K,
TEN_ITEM_INNER_LIST);
- private static NormalizedNode<?, ?>[] initOuterListItems(final int outerListItemsCount, final MapNode innerList) {
- final NormalizedNode<?, ?>[] outerListItems = new NormalizedNode[outerListItemsCount];
+ private static NormalizedNode[] initOuterListItems(final int outerListItemsCount, final MapNode innerList) {
+ final NormalizedNode[] outerListItems = new NormalizedNode[outerListItemsCount];
for (int i = 0; i < outerListItemsCount; ++i) {
int outerListKey = i;
public abstract void tearDown();
- protected static DataContainerChild<?, ?> provideOuterListNode() {
+ protected static DataContainerChild provideOuterListNode() {
return ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(BenchmarkModel.TEST_QNAME))
.withChild(ImmutableNodes.mapNodeBuilder(BenchmarkModel.OUTER_LIST_QNAME).build()).build();
<L extends DOMDataTreeChangeListener> ListenerRegistration<L> registerTreeChangeListener(
final YangInstanceIdentifier treeId, final L listener, final DataTreeSnapshot snapshot) {
final AbstractDOMDataTreeChangeListenerRegistration<L> reg = registerTreeChangeListener(treeId, listener);
- final Optional<NormalizedNode<?, ?>> preExistingData = snapshot.readNode(YangInstanceIdentifier.empty());
+ final Optional<NormalizedNode> preExistingData = snapshot.readNode(YangInstanceIdentifier.empty());
if (!preExistingData.isPresent()) {
listener.onInitialData();
return reg;
}
- final NormalizedNode<?, ?> data = preExistingData.get();
+ final NormalizedNode data = preExistingData.get();
if (treeId.isEmpty()) {
checkState(data instanceof DataContainerNode, "Unexpected root node %s", data);
- if (((DataContainerNode) data).getValue().isEmpty()) {
+ if (((DataContainerNode) data).isEmpty()) {
// If we are listening on root of data tree we still get empty normalized node, root is always present,
// we should filter this out separately and notify it by 'onInitialData()' once.
// Otherwise, it is just a valid data node with empty value which also should be notified by
/**
* Writes /test in writeTx.
*/
- NormalizedNode<?, ?> testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
writeTx.write(TestModel.TEST_PATH, testNode);
/**
* Reads /test from writeTx Read should return container.
*/
- ListenableFuture<Optional<NormalizedNode<?, ?>>> writeTxContainer = writeTx.read(TestModel.TEST_PATH);
+ ListenableFuture<Optional<NormalizedNode>> writeTxContainer = writeTx.read(TestModel.TEST_PATH);
assertEquals("read: isPresent", true, writeTxContainer.get().isPresent());
assertEquals("read: data", testNode, writeTxContainer.get().get());
/**
* Reads /test from readTx Read should return Absent.
*/
- ListenableFuture<Optional<NormalizedNode<?, ?>>> readTxContainer = readTx.read(TestModel.TEST_PATH);
+ ListenableFuture<Optional<NormalizedNode>> readTxContainer = readTx.read(TestModel.TEST_PATH);
assertEquals("read: isPresent", false, readTxContainer.get().isPresent());
}
/**
* Writes /test in writeTx.
*/
- NormalizedNode<?, ?> testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
writeTx.write(TestModel.TEST_PATH, testNode);
/**
* Reads /test from writeTx Read should return container.
*/
- ListenableFuture<Optional<NormalizedNode<?, ?>>> writeTxContainer = writeTx.read(TestModel.TEST_PATH);
+ ListenableFuture<Optional<NormalizedNode>> writeTxContainer = writeTx.read(TestModel.TEST_PATH);
assertEquals("read: isPresent", true, writeTxContainer.get().isPresent());
assertEquals("read: data", testNode, writeTxContainer.get().get());
assertThreePhaseCommit(cohort);
- Optional<NormalizedNode<?, ?>> afterCommitRead = domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH)
- .get();
+ Optional<NormalizedNode> afterCommitRead = domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH).get();
assertEquals("After commit read: isPresent", true, afterCommitRead.isPresent());
assertEquals("After commit read: data", testNode, afterCommitRead.get());
}
assertThreePhaseCommit(writeTx.ready());
- Optional<NormalizedNode<?, ?>> afterCommitRead =
- domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH).get();
+ Optional<NormalizedNode> afterCommitRead = domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH).get();
assertEquals("After commit read: isPresent", true, afterCommitRead.isPresent());
// Delete /test and verify
assertThreePhaseCommit(writeTx.ready());
- Optional<NormalizedNode<?, ?>> afterCommitRead =
+ Optional<NormalizedNode> afterCommitRead =
domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH).get();
assertEquals("After commit read: isPresent", true, afterCommitRead.isPresent());
assertEquals("After commit read: data", containerNode, afterCommitRead.get());
@Test
public void testReadyWithMissingMandatoryData() throws InterruptedException {
DOMStoreWriteTransaction writeTx = domStore.newWriteOnlyTransaction();
- NormalizedNode<?, ?> testNode = ImmutableContainerNodeBuilder.create()
+ NormalizedNode testNode = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new NodeIdentifier(TestModel.MANDATORY_DATA_TEST_QNAME))
.addChild(ImmutableNodes.leafNode(TestModel.OPTIONAL_QNAME, "data"))
.build();
DOMStoreThreePhaseCommitCohort cohort = writeTx.ready();
- assertTrue(cohort.canCommit().get().booleanValue());
+ assertTrue(cohort.canCommit().get());
cohort.preCommit().get();
cohort.abort().get();
- Optional<NormalizedNode<?, ?>> afterCommitRead = domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH)
- .get();
- assertFalse(afterCommitRead.isPresent());
+ assertEquals(Optional.empty(), domStore.newReadOnlyTransaction().read(TestModel.TEST_PATH).get());
}
@Test
private static void assertThreePhaseCommit(final DOMStoreThreePhaseCommitCohort cohort)
throws InterruptedException, ExecutionException {
- assertTrue(cohort.canCommit().get().booleanValue());
+ assertTrue(cohort.canCommit().get());
cohort.preCommit().get();
cohort.commit().get();
}
- private static Optional<NormalizedNode<?, ?>> assertTestContainerWrite(final DOMStoreReadWriteTransaction writeTx)
+ private static Optional<NormalizedNode> assertTestContainerWrite(final DOMStoreReadWriteTransaction writeTx)
throws InterruptedException, ExecutionException {
/**
*
/**
* Reads /test from readTx Read should return container.
*/
- private static Optional<NormalizedNode<?, ?>> assertTestContainerExists(final DOMStoreReadTransaction readTx)
+ private static Optional<NormalizedNode> assertTestContainerExists(final DOMStoreReadTransaction readTx)
throws InterruptedException, ExecutionException {
- ListenableFuture<Optional<NormalizedNode<?, ?>>> writeTxContainer = readTx.read(TestModel.TEST_PATH);
+ ListenableFuture<Optional<NormalizedNode>> writeTxContainer = readTx.read(TestModel.TEST_PATH);
assertTrue(writeTxContainer.get().isPresent());
return writeTxContainer.get();
}
-
}
*/
package org.opendaylight.mdsal.dom.schema.osgi.impl;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
import org.osgi.framework.BundleContext;
import org.osgi.service.component.ComponentFactory;
import org.osgi.service.component.annotations.Activate;
import org.opendaylight.mdsal.binding.runtime.spi.ModuleInfoSnapshotResolver;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
import org.osgi.service.component.ComponentFactory;
import org.osgi.service.component.ComponentInstance;
import org.slf4j.Logger;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
import org.osgi.framework.BundleContext;
import org.osgi.service.component.ComponentFactory;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import org.osgi.service.component.ComponentFactory;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.service.component.ComponentFactory;
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-dom-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>odlext-model-api</artifactId>
+ </dependency>
<!-- Test Dependencies -->
<dependency>
exports org.opendaylight.mdsal.dom.spi.store;
requires transitive org.opendaylight.mdsal.dom.api;
+ requires transitive org.opendaylight.yangtools.yang.model.api;
+ requires transitive org.opendaylight.yangtools.yang.repo.api;
+ requires transitive org.opendaylight.yangtools.yang.repo.spi;
+ requires org.opendaylight.yangtools.odlext.model.api;
requires org.opendaylight.yangtools.util;
+ requires org.opendaylight.yangtools.yang.data.api;
requires org.slf4j;
// Annotations
private static final long serialVersionUID = 1L;
@SuppressFBWarnings(value = "SE_BAD_FIELD", justification = "Interfaces do not specify Serializable")
- private final @Nullable NormalizedNode<?, ?> result;
+ private final @Nullable NormalizedNode result;
private final Collection<? extends RpcError> errors;
- public DefaultDOMRpcResult(final NormalizedNode<?, ?> result, final RpcError... errors) {
+ public DefaultDOMRpcResult(final NormalizedNode result, final RpcError... errors) {
this(result, asCollection(errors));
}
this(null, asCollection(errors));
}
- public DefaultDOMRpcResult(final @Nullable NormalizedNode<?, ?> result) {
+ public DefaultDOMRpcResult(final @Nullable NormalizedNode result) {
this(result, Collections.emptyList());
}
- public DefaultDOMRpcResult(final @Nullable NormalizedNode<?, ?> result,
+ public DefaultDOMRpcResult(final @Nullable NormalizedNode result,
final Collection<? extends RpcError> errors) {
this.result = result;
this.errors = requireNonNull(errors);
}
@Override
- public @Nullable NormalizedNode<?, ?> getResult() {
+ public @Nullable NormalizedNode getResult() {
return result;
}
protected abstract @NonNull DOMDataTreeReadTransaction delegate();
@Override
- public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
+ public FluentFuture<Optional<NormalizedNode>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
return delegate().read(store, path);
}
protected abstract @NonNull DOMDataTreeReadWriteTransaction delegate();
@Override
- public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
+ public FluentFuture<Optional<NormalizedNode>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
return delegate().read(store, path);
}
}
@Override
- public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data) {
+ public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode data) {
delegate().put(store, path, data);
}
@Override
- public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data) {
+ public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode data) {
delegate().merge(store, path, data);
}
}
@Override
- public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data) {
+ public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode data) {
delegate().put(store, path, data);
}
@Override
- public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data) {
+ public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode data) {
delegate().merge(store, path, data);
}
protected abstract @NonNull DOMRpcImplementation delegate();
@Override
- public ListenableFuture<? extends DOMRpcResult> invokeRpc(final DOMRpcIdentifier type,
- final NormalizedNode<?, ?> input) {
+ public ListenableFuture<? extends DOMRpcResult> invokeRpc(final DOMRpcIdentifier type, final NormalizedNode input) {
return delegate().invokeRpc(type, input);
}
}
}
@Override
- public @Nullable NormalizedNode<?, ?> getResult() {
+ public @Nullable NormalizedNode getResult() {
return delegate().getResult();
}
}
protected abstract @NonNull DOMRpcService delegate();
@Override
- public ListenableFuture<? extends DOMRpcResult> invokeRpc(final QName type, final NormalizedNode<?, ?> input) {
+ public ListenableFuture<? extends DOMRpcResult> invokeRpc(final QName type, final NormalizedNode input) {
return delegate().invokeRpc(type, input);
}
return new DOMDataTreeReadTransaction() {
@Override
- public FluentFuture<Optional<NormalizedNode<?, ?>>> read(
+ public FluentFuture<Optional<NormalizedNode>> read(
final LogicalDatastoreType store, final YangInstanceIdentifier path) {
return tx.getTransaction().read(store, path);
}
import static java.util.Objects.requireNonNull;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Identifiable;
+import org.opendaylight.yangtools.odlext.model.api.ContextReferenceEffectiveStatement;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
public abstract class RpcRoutingStrategy implements Identifiable<QName> {
- // FIXME: deprecate context-reference
- private static final QName CONTEXT_REFERENCE = QName.create("urn:opendaylight:yang:extension:yang-ext",
- "2013-07-09", "context-reference").intern();
- private final QName identifier;
+ private final @NonNull QName identifier;
private RpcRoutingStrategy(final QName identifier) {
this.identifier = requireNonNull(identifier);
public abstract boolean isContextBasedRouted();
public static RpcRoutingStrategy from(final RpcDefinition rpc) {
- for (DataSchemaNode schemaNode : rpc.getInput().getChildNodes()) {
- Optional<QName> context = getRoutingContext(schemaNode);
- if (context.isPresent()) {
- return new RoutedRpcStrategy(rpc.getQName(), context.get(), schemaNode.getQName());
+ // FIXME: deprecate context-reference
+ for (EffectiveStatement<?, ?> stmt : rpc.getInput().asEffectiveStatement().effectiveSubstatements()) {
+ if (stmt instanceof SchemaTreeEffectiveStatement) {
+ final Optional<QName> context =
+ stmt.findFirstEffectiveSubstatementArgument(ContextReferenceEffectiveStatement.class);
+ if (context.isPresent()) {
+ return new RoutedRpcStrategy(rpc.getQName(), context.orElseThrow(),
+ ((SchemaTreeEffectiveStatement<?>) stmt).argument());
+ }
}
}
return new GlobalRpcStrategy(rpc.getQName());
}
- public static Optional<QName> getRoutingContext(final DataSchemaNode schemaNode) {
- for (UnknownSchemaNode extension : schemaNode.getUnknownSchemaNodes()) {
- if (CONTEXT_REFERENCE.equals(extension.getNodeType())) {
- return Optional.ofNullable(extension.getQName());
- }
- }
- return Optional.empty();
- }
-
private static final class RoutedRpcStrategy extends RpcRoutingStrategy {
private final QName context;
private final QName leaf;
* @return Result of evaluation
* @throws NullPointerException if any argument is null
*/
- public static DOMQueryResult evaluateOn(final DOMQuery query, final NormalizedNode<?, ?> queryRoot) {
+ public static DOMQueryResult evaluateOn(final DOMQuery query, final NormalizedNode queryRoot) {
final YangInstanceIdentifier path = query.getSelect();
return path.isEmpty() ? evalSingle(query, queryRoot) : new LazyDOMQueryResult(query, queryRoot);
}
* @return Result of evaluation
* @throws NullPointerException if any argument is null
*/
- public static DOMQueryResult evaluateOnRoot(final DOMQuery query, final NormalizedNode<?, ?> root) {
- NormalizedNode<?, ?> evalRoot = root;
+ public static DOMQueryResult evaluateOnRoot(final DOMQuery query, final NormalizedNode root) {
+ NormalizedNode evalRoot = root;
for (PathArgument arg : query.getRoot().getPathArguments()) {
- final Optional<NormalizedNode<?, ?>> next = NormalizedNodes.findNode(root, arg);
+ final Optional<NormalizedNode> next = NormalizedNodes.findNode(root, arg);
if (next.isEmpty()) {
return DOMQueryResult.of();
}
return evaluateOn(query, evalRoot);
}
- private static DOMQueryResult evalSingle(final DOMQuery query, final NormalizedNode<?, ?> data) {
+ private static DOMQueryResult evalSingle(final DOMQuery query, final NormalizedNode data) {
return DOMQueryMatcher.matchesAll(data, query.getPredicates()) ? DOMQueryResult.of()
: DOMQueryResult.of(new SimpleImmutableEntry<>(query.getRoot(), data));
}
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
@NonNullByDefault
-final class DOMQueryIterator extends AbstractIterator<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> {
+final class DOMQueryIterator extends AbstractIterator<Entry<YangInstanceIdentifier, NormalizedNode>> {
private static class Frame {
- final NormalizedNode<?, ?> data;
+ final NormalizedNode data;
final @Nullable PathArgument select;
@SuppressFBWarnings(value = "NP_STORE_INTO_NONNULL_FIELD", justification = "Ungrokked @Nullable")
- Frame(final NormalizedNode<?, ?> data) {
+ Frame(final NormalizedNode data) {
this.data = requireNonNull(data);
// The only case when this can be null: if this a top-level container, as ensured by the sole caller
select = null;
}
- Frame(final NormalizedNode<?, ?> data, final PathArgument selectArg) {
+ Frame(final NormalizedNode data, final PathArgument selectArg) {
this.data = requireNonNull(data);
this.select = requireNonNull(selectArg);
}
private static final class MapFrame extends Frame {
final Iterator<MapEntryNode> iter;
- MapFrame(final NormalizedNode<?, ?> data, final PathArgument selectArg, final Iterator<MapEntryNode> iter) {
+ MapFrame(final NormalizedNode data, final PathArgument selectArg, final Iterator<MapEntryNode> iter) {
super(data, selectArg);
this.iter = requireNonNull(iter);
}
// The predicates which need to be evaluated
private final List<? extends DOMQueryPredicate> predicates;
- DOMQueryIterator(final DOMQuery query, final NormalizedNode<?, ?> queryRoot) {
+ DOMQueryIterator(final DOMQuery query, final NormalizedNode queryRoot) {
// Note: DOMQueryEvaluator has taken care of the empty case, this is always non-empty
remainingSelect.addAll(query.getSelect().getPathArguments());
currentPath.addAll(query.getRoot().getPathArguments());
}
@Override
- protected Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> computeNext() {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> next = findNext();
+ protected Entry<YangInstanceIdentifier, NormalizedNode> computeNext() {
+ final Entry<YangInstanceIdentifier, NormalizedNode> next = findNext();
return next != null ? next : endOfData();
}
@SuppressFBWarnings(value = "NP_NONNULL_RETURN_VIOLATION", justification = "Ungrokked @Nullable")
// TODO: this is a huge method which could be restructured with hard tailcalls, alas we do not have those (yet?)
// Any such refactor better have some benchmarks to show non-regression.
- private @Nullable Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> findNext() {
+ private @Nullable Entry<YangInstanceIdentifier, NormalizedNode> findNext() {
// We always start with non-empty frames, as we signal end of data when we reach the end. 'currentPath' points
// to the next frame to process.
}
// 2. we are at a normal container, where we need to resolve a child. This is also a bit involved, so now:
- final Optional<NormalizedNode<?, ?>> optChild = NormalizedNodes.getDirectChild(current.data, next);
+ final Optional<NormalizedNode> optChild = NormalizedNodes.getDirectChild(current.data, next);
if (optChild.isEmpty()) {
// If we did not find the child, as we can have only a single match. Unwind to next possible match.
current = unwind(current, next);
// If we have a child see if this is the ultimate select step, if so, short circuit stack. We do not record
// ourselves.
- final NormalizedNode<?, ?> child = optChild.orElseThrow();
+ final NormalizedNode child = optChild.orElseThrow();
if (remainingSelect.isEmpty()) {
// This is the ultimate step in lookup, process it without churning the stack by imposing a dedicated
// Frame. In either case we are done with this frame, unwinding it in both cases.
final MapNode map = (MapNode) child;
final PathArgument target = remainingSelect.peek();
if (target instanceof NodeIdentifierWithPredicates) {
- final Optional<MapEntryNode> optEntry = map.getChild((NodeIdentifierWithPredicates) target);
- if (optEntry.isPresent()) {
- final MapEntryNode entry = optEntry.orElseThrow();
+ final MapEntryNode entry = map.childByArg((NodeIdentifierWithPredicates) target);
+ if (entry != null) {
if (remainingSelect.size() != 1) {
// We need to perform further selection push this frame, an empty frame for the map and
// finally a frame for the map entry.
// We have a wildcard, expand it
frames.push(current);
currentPath.addLast(next);
- current = new MapFrame(child, next, map.getValue().iterator());
+ current = new MapFrame(child, next, map.body().iterator());
} else {
// Next step in iteration, deal with it
frames.push(current);
}
// Construct child path. This concatenates currentPath and child's identifier.
- private YangInstanceIdentifier createIdentifier(final NormalizedNode<?, ?> child) {
+ private YangInstanceIdentifier createIdentifier(final NormalizedNode child) {
currentPath.addLast(child.getIdentifier());
final YangInstanceIdentifier ret = YangInstanceIdentifier.create(currentPath);
currentPath.removeLast();
}
// Save a frame for further processing return its child as an item.
- private Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> pushAndReturn(final Frame frame,
- final MapEntryNode child) {
+ private Entry<YangInstanceIdentifier, NormalizedNode> pushAndReturn(final Frame frame, final MapEntryNode child) {
final YangInstanceIdentifier childPath = createIdentifier(child);
// Push the frame back to work, return the result
}
// Unwind any leftover frames and return a matching item
- private Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> unwindAndReturn(final Frame frame,
- final PathArgument next, final NormalizedNode<?, ?> child) {
+ private Entry<YangInstanceIdentifier, NormalizedNode> unwindAndReturn(final Frame frame, final PathArgument next,
+ final NormalizedNode child) {
final YangInstanceIdentifier childPath = createIdentifier(child);
unwind(frame, next);
return Map.entry(childPath, child);
}
}
- private boolean matches(final NormalizedNode<?, ?> data) {
+ private boolean matches(final NormalizedNode data) {
return DOMQueryMatcher.matchesAll(data, predicates);
}
}
// Utility class
}
- static boolean matchesAll(final NormalizedNode<?, ?> data, final List<? extends DOMQueryPredicate> predicates) {
+ static boolean matchesAll(final NormalizedNode data, final List<? extends DOMQueryPredicate> predicates) {
// TODO: it would be nice if predicates were somehow structured -- can we perhaps sort them by their
// InstanceIdentifier? If the predicates are sharing a common subpath. Hence if we can guarantee
// predicates are in a certain order, we would not end up in subsequent re-lookups of the same node.
return true;
}
- private static boolean matchesAny(final Match match, final NormalizedNode<?, ?> data,
+ private static boolean matchesAny(final Match match, final NormalizedNode data,
final Deque<PathArgument> pathArgs) {
// Guaranteed to have at least one item
final PathArgument pathArg = pathArgs.pop();
return matchesChild(match, data, pathArg);
}
- final Optional<NormalizedNode<?, ?>> direct = NormalizedNodes.getDirectChild(data, pathArg);
+ final Optional<NormalizedNode> direct = NormalizedNodes.getDirectChild(data, pathArg);
if (direct.isPresent()) {
final boolean ret = matchesAny(match, direct.orElseThrow(), pathArgs);
pathArgs.push(pathArg);
// We may be dealing with a wildcard here. NodeIdentifier is a final class, hence this is as fast as it gets.
if (pathArg instanceof NodeIdentifier && data instanceof MapNode) {
- for (MapEntryNode child : ((MapNode) data).getValue()) {
+ for (MapEntryNode child : ((MapNode) data).body()) {
if (matchesAny(match, child, pathArgs)) {
pathArgs.push(pathArg);
return true;
return false;
}
- private static boolean matchesChild(final Match match, final NormalizedNode<?, ?> data,
- final PathArgument pathArg) {
+ private static boolean matchesChild(final Match match, final NormalizedNode data, final PathArgument pathArg) {
// Try the direct approach...
- final Optional<NormalizedNode<?, ?>> direct = NormalizedNodes.getDirectChild(data, pathArg);
+ final Optional<NormalizedNode> direct = NormalizedNodes.getDirectChild(data, pathArg);
if (direct.isPresent()) {
return match.test(direct.orElseThrow());
}
// We may be dealing with a wildcard here. NodeIdentifier is a final class, hence this is as fast as it gets.
if (pathArg instanceof NodeIdentifier && data instanceof MapNode) {
- for (MapEntryNode child : ((MapNode) data).getValue()) {
+ for (MapEntryNode child : ((MapNode) data).body()) {
if (match.test(child)) {
return true;
}
@NonNullByDefault
final class LazyDOMQueryResult implements DOMQueryResult {
- private final NormalizedNode<?, ?> queryRoot;
+ private final NormalizedNode queryRoot;
private final DOMQuery query;
- LazyDOMQueryResult(final DOMQuery query, final NormalizedNode<?, ?> queryRoot) {
+ LazyDOMQueryResult(final DOMQuery query, final NormalizedNode queryRoot) {
this.query = requireNonNull(query);
this.queryRoot = requireNonNull(queryRoot);
}
@Override
- public Iterator<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> iterator() {
+ public Iterator<Entry<YangInstanceIdentifier, NormalizedNode>> iterator() {
return new DOMQueryIterator(query, queryRoot);
}
}
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public interface DOMStoreReadTransaction extends DOMStoreTransaction {
-
/**
* Reads data from provided logical data store located at provided path.
*
* {@link ReadFailedException} or an exception derived from ReadFailedException.</li>
* </ul>
*/
- FluentFuture<Optional<NormalizedNode<?,?>>> read(YangInstanceIdentifier path);
+ FluentFuture<Optional<NormalizedNode>> read(YangInstanceIdentifier path);
/**
* Checks if data is available in the logical data store located at provided path.
* @throws IllegalStateException if the client code already sealed transaction and invoked
* {@link #ready()}
*/
- void write(YangInstanceIdentifier path, NormalizedNode<?, ?> data);
+ void write(YangInstanceIdentifier path, NormalizedNode data);
/**
* Store a provided data at specified path. This acts as a add / replace operation, which is to
* @throws IllegalStateException if the client code already sealed transaction and invoked
* {@link #ready()}
*/
- void merge(YangInstanceIdentifier path, NormalizedNode<?, ?> data);
+ void merge(YangInstanceIdentifier path, NormalizedNode data);
/**
* Deletes data and whole subtree located at provided path.
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public FluentFuture<Optional<NormalizedNode<?,?>>> read(final YangInstanceIdentifier path) {
+ public FluentFuture<Optional<NormalizedNode>> read(final YangInstanceIdentifier path) {
LOG.debug("Tx: {} Read: {}", getIdentifier(), path);
requireNonNull(path, "Path must not be null.");
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public FluentFuture<Optional<NormalizedNode<?,?>>> read(final YangInstanceIdentifier path) {
+ public FluentFuture<Optional<NormalizedNode>> read(final YangInstanceIdentifier path) {
LOG.debug("Tx: {} Read: {}", getIdentifier(), path);
requireNonNull(path, "Path must not be null.");
- final Optional<NormalizedNode<?, ?>> result;
+ final Optional<NormalizedNode> result;
try {
result = readSnapshotNode(path);
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public void write(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void write(final YangInstanceIdentifier path, final NormalizedNode data) {
checkNotReady();
final DataTreeModification tree = mutableTree;
@SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public void merge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void merge(final YangInstanceIdentifier path, final NormalizedNode data) {
checkNotReady();
final DataTreeModification tree = mutableTree;
* @param path Path to read
* @return null if the the transaction has been closed;
*/
- final Optional<NormalizedNode<?, ?>> readSnapshotNode(final YangInstanceIdentifier path) {
+ final Optional<NormalizedNode> readSnapshotNode(final YangInstanceIdentifier path) {
return readyImpl == null ? null : mutableTree.readNode(path);
}
@Test
public void basicTest() throws Exception {
RpcError rpcError = mock(RpcError.class);
- NormalizedNode<?, ?> normalizedNode = mock(NormalizedNode.class);
+ NormalizedNode normalizedNode = mock(NormalizedNode.class);
DefaultDOMRpcResult defaultDOMRpcResult = new DefaultDOMRpcResult(normalizedNode, rpcError);
assertEquals(normalizedNode, defaultDOMRpcResult.getResult());
assertTrue(defaultDOMRpcResult.getErrors().contains(rpcError));
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class RpcRoutingStrategyTest {
@BeforeClass
public static void beforeClass() {
- final EffectiveModelContext ctx = YangParserTestUtils.parseYangSources(StatementParserMode.DEFAULT_MODE, null,
+ final EffectiveModelContext ctx = YangParserTestUtils.parseYangSources(YangParserConfiguration.DEFAULT, null,
YangTextSchemaSource.delegateForByteSource("yang-ext.yang",
$YangModuleInfoImpl.getInstance().getYangTextByteSource()),
YangTextSchemaSource.forResource(RpcRoutingStrategy.class, "/rpc-routing-strategy.yang"));
@Test
public void basicTest() throws Exception {
- final NormalizedNode<?, ?> testNode = mock(NormalizedNode.class);
- final Optional<NormalizedNode<?, ?>> optional = Optional.of(testNode);
+ final NormalizedNode testNode = mock(NormalizedNode.class);
+ final Optional<NormalizedNode> optional = Optional.of(testNode);
doReturn("testNode").when(testNode).toString();
doReturn(Optional.of(testNode)).when(DATA_TREE_SNAPSHOT).readNode(YangInstanceIdentifier.empty());
assertTrue(snapshotBackedReadTransaction.exists(YangInstanceIdentifier.empty()).get());
@Test
public void basicTest() throws Exception {
- final NormalizedNode<?, ?> testNode = mock(NormalizedNode.class);
- final Optional<NormalizedNode<?, ?>> optional = Optional.of(testNode);
+ final NormalizedNode testNode = mock(NormalizedNode.class);
+ final Optional<NormalizedNode> optional = Optional.of(testNode);
doReturn("testNode").when(testNode).toString();
doReturn(Optional.of(testNode)).when(DATA_TREE_MODIFICATION).readNode(YangInstanceIdentifier.empty());
assertTrue(snapshotBackedReadWriteTransaction.exists(YangInstanceIdentifier.empty()).get());
mock(TransactionReadyPrototype.class);
private static final DOMStoreThreePhaseCommitCohort DOM_STORE_THREE_PHASE_COMMIT_COHORT =
mock(DOMStoreThreePhaseCommitCohort.class);
- private static final NormalizedNode<?, ?> NORMALIZED_NODE = mock(NormalizedNode.class);
- private static final Optional<NormalizedNode<?, ?>> NORMALIZED_NODE_OPTIONAL = Optional.of(NORMALIZED_NODE);
+ private static final NormalizedNode NORMALIZED_NODE = mock(NormalizedNode.class);
+ private static final Optional<NormalizedNode> NORMALIZED_NODE_OPTIONAL = Optional.of(NORMALIZED_NODE);
private static SnapshotBackedWriteTransaction<Object> snapshotBackedWriteTransaction;
@Before
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>6.0.5</version>
+ <version>7.0.1-SNAPSHOT</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<?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="[6,7)">odl-yangtools-data-api</feature>
+ <feature version="[7,8)">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="[6,7)">odl-yangtools-common</feature>
+ <feature version="[7,8)">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-runtime-api">
<feature name="odl-mdsal-binding-runtime-api">
- <feature version="[6,7)">odl-yangtools-data</feature>
- <feature version="[6,7)">odl-yangtools-parser</feature>
+ <feature version="[7,8)">odl-yangtools-data</feature>
+ <feature version="[7,8)">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="[6,7)">odl-yangtools-common</feature>
+ <feature version="[7,8)">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="[6,7)">odl-yangtools-data-api</feature>
+ <feature version="[7,8)">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-eos-common">
<feature name="odl-mdsal-eos-common">
- <feature version="[6,7)">odl-yangtools-data-api</feature>
+ <feature version="[7,8)">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="[6,7)">odl-yangtools-data-api</feature>
+ <feature version="[7,8)">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="[6,7)">odl-yangtools-netty</feature>
+ <feature version="[7,8)">odl-yangtools-netty</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
}
@Override
- public void write(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void write(final YangInstanceIdentifier path, final NormalizedNode data) {
LOG.trace("BackupModification - WRITE - {} - DATA: {}", path, data);
transaction.put(datastore, path, data);
}
@Override
- public void merge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void merge(final YangInstanceIdentifier path, final NormalizedNode data) {
throw new UnsupportedOperationException();
}
}
@Override
- public Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier path) {
+ public Optional<NormalizedNode> readNode(final YangInstanceIdentifier path) {
throw new UnsupportedOperationException();
}
}
@Override
- public void write(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void write(final YangInstanceIdentifier path, final NormalizedNode data) {
LOG.trace("Write {} data {}", path, data);
transaction.write(path, data);
}
@Override
- public Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier path) {
+ public Optional<NormalizedNode> readNode(final YangInstanceIdentifier path) {
throw new UnsupportedOperationException();
}
}
@Override
- public void merge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void merge(final YangInstanceIdentifier path, final NormalizedNode data) {
throw new UnsupportedOperationException();
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.SystemMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
verify(sinkChain, timeout(2000).times(1)).newWriteOnlyTransaction();
// verify that the initial data invoked onDataTreeChanged() and was transferred to sink
- ArgumentCaptor<NormalizedNode<?, ?>> dataCaptor = ArgumentCaptor.forClass(NormalizedNode.class);
+ ArgumentCaptor<NormalizedNode> dataCaptor = ArgumentCaptor.forClass(NormalizedNode.class);
verify(sinkTx, timeout(2000).times(1)).put(any(), any(), dataCaptor.capture());
// verify that the initial state contains everything
- NormalizedNode<?, ?> capturedInitialState = dataCaptor.getAllValues().iterator().next();
- NormalizedNode<?, ?> expectedEntityState = generateNormalizedNodeForEntities(deltaCount);
+ NormalizedNode capturedInitialState = dataCaptor.getAllValues().iterator().next();
+ NormalizedNode expectedEntityState = generateNormalizedNodeForEntities(deltaCount);
assertEquals(expectedEntityState, capturedInitialState);
verify(sinkTx, timeout(2000).times(1)).commit();
}
private static ContainerNode generateNormalizedNodeForEntities(final int amount) {
- final CollectionNodeBuilder<MapEntryNode, MapNode> builder = ImmutableNodes.mapNodeBuilder(ENTITY_QNAME);
+ final CollectionNodeBuilder<MapEntryNode, SystemMapNode> builder = ImmutableNodes.mapNodeBuilder(ENTITY_QNAME);
for (int i = 0; i < amount; i++) {
builder.withChild(ImmutableNodes.mapEntry(ENTITY_QNAME, ENTITY_NAME_QNAME, "testEntity" + i));
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
private final TracingBroker tracingBroker;
private final List<String> logs = new ArrayList<>();
- AbstractTracingWriteTransaction(DOMDataTreeWriteTransaction delegate, TracingBroker tracingBroker) {
+ AbstractTracingWriteTransaction(final DOMDataTreeWriteTransaction delegate, final TracingBroker tracingBroker) {
this.delegate = requireNonNull(delegate);
this.tracingBroker = requireNonNull(tracingBroker);
recordOp(null, null, "instantiate", null);
}
- private void recordOp(LogicalDatastoreType store, YangInstanceIdentifier yiid, String method,
- NormalizedNode<?, ?> node) {
+ private void recordOp(final LogicalDatastoreType store, final YangInstanceIdentifier yiid, final String method,
+ final NormalizedNode node) {
if (yiid != null && !tracingBroker.isWriteWatched(yiid, store)) {
return;
}
- final Object value = node != null ? node.getValue() : null;
+ final Object value = node != null ? node.body() : null;
if (value != null && value instanceof ImmutableSet && ((Set<?>)value).isEmpty()) {
if (TracingBroker.LOG.isDebugEnabled()) {
// If we don’t have an id, we don’t expect data either
sb.append(" Data: ");
if (node != null) {
- sb.append(node.getValue());
+ sb.append(node.body());
} else {
sb.append("null");
}
}
@Override
- public void put(LogicalDatastoreType store, YangInstanceIdentifier yiid, NormalizedNode<?, ?> node) {
+ public void put(final LogicalDatastoreType store, final YangInstanceIdentifier yiid, final NormalizedNode node) {
recordOp(store, yiid, "put", node);
delegate.put(store, yiid, node);
}
@Override
- public void merge(LogicalDatastoreType store, YangInstanceIdentifier yiid, NormalizedNode<?, ?> node) {
+ public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier yiid, final NormalizedNode node) {
recordOp(store, yiid, "merge", node);
delegate.merge(store, yiid, node);
}
}
@Override
- public void delete(LogicalDatastoreType store, YangInstanceIdentifier yiid) {
+ public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier yiid) {
recordOp(store, yiid, "delete", null);
delegate.delete(store, yiid);
}
// https://jira.opendaylight.org/browse/CONTROLLER-1792
@Override
- public final boolean equals(Object object) {
+ public final boolean equals(final Object object) {
return object == this || delegate.equals(object);
}
private final DOMDataTreeReadTransaction delegate;
- TracingReadOnlyTransaction(DOMDataTreeReadTransaction delegate,
- CloseTrackedRegistry<TracingReadOnlyTransaction> readOnlyTransactionsRegistry) {
+ TracingReadOnlyTransaction(final DOMDataTreeReadTransaction delegate,
+ final CloseTrackedRegistry<TracingReadOnlyTransaction> readOnlyTransactionsRegistry) {
super(readOnlyTransactionsRegistry);
this.delegate = requireNonNull(delegate);
}
@Override
- public FluentFuture<Optional<NormalizedNode<?, ?>>> read(LogicalDatastoreType store, YangInstanceIdentifier path) {
+ public FluentFuture<Optional<NormalizedNode>> read(final LogicalDatastoreType store,
+ final YangInstanceIdentifier path) {
return delegate.read(store, path);
}
@Override
- public FluentFuture<Boolean> exists(LogicalDatastoreType store, YangInstanceIdentifier path) {
+ public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
return delegate.exists(store, path);
}
// https://jira.opendaylight.org/browse/CONTROLLER-1792
@Override
- public final boolean equals(Object object) {
+ public final boolean equals(final Object object) {
return object == this || delegate.equals(object);
}
private final CloseTrackedTrait<TracingReadWriteTransaction> closeTracker;
private final DOMDataTreeReadWriteTransaction delegate;
- TracingReadWriteTransaction(DOMDataTreeReadWriteTransaction delegate, TracingBroker tracingBroker,
- CloseTrackedRegistry<TracingReadWriteTransaction> readWriteTransactionsRegistry) {
+ TracingReadWriteTransaction(final DOMDataTreeReadWriteTransaction delegate, final TracingBroker tracingBroker,
+ final CloseTrackedRegistry<TracingReadWriteTransaction> readWriteTransactionsRegistry) {
super(delegate, tracingBroker);
this.closeTracker = new CloseTrackedTrait<>(readWriteTransactionsRegistry, this);
this.delegate = requireNonNull(delegate);
}
@Override
- public FluentFuture<Optional<NormalizedNode<?, ?>>> read(LogicalDatastoreType store, YangInstanceIdentifier yiid) {
+ public FluentFuture<Optional<NormalizedNode>> read(final LogicalDatastoreType store,
+ final YangInstanceIdentifier yiid) {
return delegate.read(store, yiid);
}
@Override
- public FluentFuture<Boolean> exists(LogicalDatastoreType store, YangInstanceIdentifier yiid) {
+ public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier yiid) {
return delegate.exists(store, yiid);
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
import java.util.List;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
+import org.opendaylight.yangtools.yang.parser.api.YangParserException;
/**
* An entity which can assemble a set of sources into a SchemaContext. Note that unlike other variations on this
import java.net.URL;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.opendaylight.yangtools.concepts.AbstractIdentifiable;
+import org.opendaylight.yangtools.concepts.AbstractSimpleIdentifiable;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
*/
@Beta
@NonNullByDefault
-public final class SourceReference extends AbstractIdentifiable<SourceIdentifier> implements Immutable {
+public final class SourceReference extends AbstractSimpleIdentifiable<SourceIdentifier> implements Immutable {
// List vs. Set vs. Collection here is a class design decision based on use. We expect these objects to be used
// frequently, but for a short time. Locations may end up being ignored by SchemaContextResolver, hence it does not
// make sense to ensure a Set here just to de-duplicate URLs.
import com.google.common.annotations.Beta;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangParserException;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
/**
* Main entrypoint for instantiating YangLibSupport implementations.
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.module.list.Module;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.module.list.Module.ConformanceType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.module.list.module.Submodule;
-import org.opendaylight.yangtools.rcf8528.data.util.AbstractMountPointContextFactory;
import org.opendaylight.yangtools.rfc8528.data.api.MountPointContextFactory;
import org.opendaylight.yangtools.rfc8528.data.api.MountPointIdentifier;
import org.opendaylight.yangtools.rfc8528.data.api.YangLibraryConstants.ContainerName;
+import org.opendaylight.yangtools.rfc8528.data.util.AbstractMountPointContextFactory;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.api.YangParserException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
protected EffectiveModelContext bindLibrary(final ContainerName containerName, final ContainerNode libData)
throws YangParserException {
checkArgument(containerName == ContainerName.RFC7895, "Unsupported container type %s", containerName);
- checkArgument(ModulesState.QNAME.equals(libData.getNodeType()), "Unexpected container %s", libData);
+ checkArgument(ModulesState.QNAME.equals(libData.getIdentifier().getNodeType()),
+ "Unexpected container %s", libData);
// DOM-to-Binding magic
return bindLibrary(verifyNotNull(codec.deserialize(libData)));
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangParserException;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Reference;
import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeGenerator;
import org.opendaylight.mdsal.yanglib.api.YangLibSupport;
import org.opendaylight.mdsal.yanglib.api.YangLibSupportFactory;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangParserException;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
@Beta
@MetaInfServices
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.module.list.ModuleKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.YangIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
-import org.opendaylight.yangtools.yang.parser.impl.YangParserFactoryImpl;
+import org.opendaylight.yangtools.yang.parser.api.YangParserException;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultYangParserFactory;
public class YangModuleLibrarySupportTest {
private static final BindingRuntimeGenerator BINDING_RUNTIME_GENERATOR = new DefaultBindingRuntimeGenerator();
- private static final YangParserFactory YANG_PARSER_FACTORY = new YangParserFactoryImpl();
+ private static final YangParserFactory YANG_PARSER_FACTORY = new DefaultYangParserFactory();
private BindingRuntimeContext runtimeContext;
private BindingCodecTree codecTree;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.yang.library.parameters.Schema;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.yang.library.parameters.SchemaKey;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.YangIdentifier;
-import org.opendaylight.yangtools.rcf8528.data.util.AbstractMountPointContextFactory;
import org.opendaylight.yangtools.rfc8528.data.api.MountPointContextFactory;
import org.opendaylight.yangtools.rfc8528.data.api.MountPointIdentifier;
import org.opendaylight.yangtools.rfc8528.data.api.YangLibraryConstants.ContainerName;
+import org.opendaylight.yangtools.rfc8528.data.util.AbstractMountPointContextFactory;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.api.YangParserException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangParserException;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Reference;
import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeGenerator;
import org.opendaylight.mdsal.yanglib.api.YangLibSupport;
import org.opendaylight.mdsal.yanglib.api.YangLibSupportFactory;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.api.YangParserException;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
@Beta
@MetaInfServices
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.YangIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
-import org.opendaylight.yangtools.yang.parser.impl.YangParserFactoryImpl;
+import org.opendaylight.yangtools.yang.parser.api.YangParserException;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultYangParserFactory;
public class LegacyYangLibraryFormatTest {
private static final BindingRuntimeGenerator BINDING_RUNTIME_GENERATOR = new DefaultBindingRuntimeGenerator();
- private static final YangParserFactory YANG_PARSER_FACTORY = new YangParserFactoryImpl();
+ private static final YangParserFactory YANG_PARSER_FACTORY = new DefaultYangParserFactory();
private BindingRuntimeContext runtimeContext;
private BindingCodecTree codecTree;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.YangIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
-import org.opendaylight.yangtools.yang.parser.impl.YangParserFactoryImpl;
+import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultYangParserFactory;
public class YangLibrarySupportTest {
private static final BindingRuntimeGenerator BINDING_RUNTIME_GENERATOR = new DefaultBindingRuntimeGenerator();
- private static final YangParserFactory YANG_PARSER_FACTORY = new YangParserFactoryImpl();
+ private static final YangParserFactory YANG_PARSER_FACTORY = new DefaultYangParserFactory();
private YangLibrarySupport yangLib;
private BindingRuntimeContext runtimeContext;
public void setUp() throws Exception {
runtimeContext = BindingRuntimeHelpers.createRuntimeContext();
final DefaultBindingCodecTreeFactory codecFactory = new DefaultBindingCodecTreeFactory();
- yangLib = new YangLibrarySupport(YANG_PARSER_FACTORY, BINDING_RUNTIME_GENERATOR,
- codecFactory);
+ yangLib = new YangLibrarySupport(YANG_PARSER_FACTORY, BINDING_RUNTIME_GENERATOR, codecFactory);
codecTree = codecFactory.create(runtimeContext);
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.0</version>
<relativePath/>
</parent>
Code Review / mdsal.git / commitdiff