Bump upstreams

[mdsal.git] / dom / mdsal-dom-broker / src / main / java / org / opendaylight / mdsal / dom / broker / DOMRpcRoutingTable.java

diff --git a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMRpcRoutingTable.java b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMRpcRoutingTable.java
index 432d3b2aeaa7cddaf4d09a8ffb1f59d0f2af6cb6..495b040eff590a120f503f160fc020408aa4e92b 100644 (file)
--- a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMRpcRoutingTable.java
+++ b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMRpcRoutingTable.java
@@ -13,23 +13,22 @@ import com.google.common.collect.ListMultimap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
 import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
-import org.opendaylight.mdsal.dom.spi.RpcRoutingStrategy;
+import org.opendaylight.mdsal.dom.spi.ContentRoutedRpcContext;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.stmt.RpcEffectiveStatement;
 
 final class DOMRpcRoutingTable extends AbstractDOMRoutingTable<DOMRpcIdentifier, YangInstanceIdentifier,
-        DOMRpcImplementation, DOMRpcAvailabilityListener, AbstractDOMRpcRoutingTableEntry> {
+        DOMRpcImplementation, DOMRpcAvailabilityListener, QName, AbstractDOMRpcRoutingTableEntry> {
     static final DOMRpcRoutingTable EMPTY = new DOMRpcRoutingTable(ImmutableMap.of(), null);
 
-    private DOMRpcRoutingTable(final Map<SchemaPath, AbstractDOMRpcRoutingTableEntry> rpcs,
-            final SchemaContext schemaContext) {
+    private DOMRpcRoutingTable(final Map<QName, AbstractDOMRpcRoutingTableEntry> rpcs,
+            final EffectiveModelContext schemaContext) {
         super(rpcs, schemaContext);
     }
 
@@ -39,15 +38,14 @@ final class DOMRpcRoutingTable extends AbstractDOMRoutingTable<DOMRpcIdentifier,
     }
 
     @Override
-    protected AbstractDOMRoutingTable newInstance(final Map<SchemaPath, AbstractDOMRpcRoutingTableEntry> operations,
-            final SchemaContext schemaContext) {
+    protected DOMRpcRoutingTable newInstance(final Map<QName, AbstractDOMRpcRoutingTableEntry> operations,
+            final EffectiveModelContext schemaContext) {
         return new DOMRpcRoutingTable(operations, schemaContext);
     }
 
     @Override
-    protected ListMultimap<SchemaPath, YangInstanceIdentifier> decomposeIdentifiers(
-            final Set<DOMRpcIdentifier> rpcs) {
-        final ListMultimap<SchemaPath, YangInstanceIdentifier> ret = LinkedListMultimap.create();
+    protected ListMultimap<QName, YangInstanceIdentifier> decomposeIdentifiers(final Set<DOMRpcIdentifier> rpcs) {
+        final ListMultimap<QName, YangInstanceIdentifier> ret = LinkedListMultimap.create();
         for (DOMRpcIdentifier i : rpcs) {
             ret.put(i.getType(), i.getContextReference());
         }
@@ -55,35 +53,25 @@ final class DOMRpcRoutingTable extends AbstractDOMRoutingTable<DOMRpcIdentifier,
     }
 
     @Override
-    AbstractDOMRpcRoutingTableEntry createOperationEntry(final SchemaContext context, final SchemaPath key,
+    AbstractDOMRpcRoutingTableEntry createOperationEntry(final EffectiveModelContext context, final QName key,
             final Map<YangInstanceIdentifier, List<DOMRpcImplementation>> implementations) {
-        final RpcDefinition rpcDef = findRpcDefinition(context, key);
+        final var rpcDef = findRpcDefinition(context, key);
         if (rpcDef == null) {
             return new UnknownDOMRpcRoutingTableEntry(key, implementations);
         }
 
-        final RpcRoutingStrategy strategy = RpcRoutingStrategy.from(rpcDef);
-        if (strategy.isContextBasedRouted()) {
-            return new RoutedDOMRpcRoutingTableEntry(rpcDef, YangInstanceIdentifier.of(strategy.getLeaf()),
+        final var contentContext = ContentRoutedRpcContext.forRpc(rpcDef);
+        return contentContext == null ? new GlobalDOMRpcRoutingTableEntry(rpcDef.argument(), implementations)
+            : new RoutedDOMRpcRoutingTableEntry(rpcDef.argument(), YangInstanceIdentifier.of(contentContext.leaf()),
                 implementations);
-        }
-
-        return new GlobalDOMRpcRoutingTableEntry(rpcDef, implementations);
     }
 
-    private static RpcDefinition findRpcDefinition(final SchemaContext context, final SchemaPath schemaPath) {
-        if (context != null) {
-            final QName qname = schemaPath.getPathFromRoot().iterator().next();
-            final Module module = context.findModule(qname.getModule()).orElse(null);
-            if (module != null && module.getRpcs() != null) {
-                for (RpcDefinition rpc : module.getRpcs()) {
-                    if (qname.equals(rpc.getQName())) {
-                        return rpc;
-                    }
-                }
-            }
-        }
-
-        return null;
+    private static @Nullable RpcEffectiveStatement findRpcDefinition(final EffectiveModelContext context,
+            final QName qname) {
+        return context == null ? null : context.findModuleStatement(qname.getModule())
+            .flatMap(module -> module.findSchemaTreeNode(qname))
+            .filter(RpcEffectiveStatement.class::isInstance)
+            .map(RpcEffectiveStatement.class::cast)
+            .orElse(null);
     }
 }