import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
final class BindingDOMRpcImplementationAdapter implements DOMRpcImplementation {
}
@Override
- public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode<?, ?> input) {
+ public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final ContainerNode input) {
final SchemaPath schemaPath = rpc.getType();
final CurrentAdapterSerializer serializer = adapterContext.currentSerializer();
final DataObject bindingInput = input != null ? deserialize(serializer, schemaPath, input) : null;
}
private DataObject deserialize(final CurrentAdapterSerializer serializer, final SchemaPath rpcPath,
- final NormalizedNode<?, ?> input) {
+ final ContainerNode input) {
if (ENABLE_CODEC_SHORTCUT && input instanceof BindingLazyContainerNode) {
return ((BindingLazyContainerNode<?>) input).getDataObject();
}
final SchemaPath inputSchemaPath = rpcPath.createChild(inputQname);
- return serializer.fromNormalizedNodeRpcData(inputSchemaPath, (ContainerNode) input);
+ return serializer.fromNormalizedNodeRpcData(inputSchemaPath, input);
}
private ListenableFuture<RpcResult<?>> invoke(final SchemaPath schemaPath, final DataObject input) {
import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
final class LazyDOMRpcResultFuture extends AbstractFuture<DOMRpcResult> implements BindingRpcFutureAware {
private static final ExceptionMapper<DOMRpcException> DOM_RPC_EX_MAPPER = new ExceptionMapper<>("rpc",
return new DefaultDOMRpcResult(codec.toNormalizedNodeRpcData((DataContainer) inputData));
}
- return new DefaultDOMRpcResult((NormalizedNode<?, ?>) null);
+ return new DefaultDOMRpcResult((ContainerNode) null);
}
return new DefaultDOMRpcResult(input.getErrors());
}
import com.google.common.util.concurrent.ListenableFuture;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
/**
* Interface implemented by an individual RPC implementation. This API allows for dispatch
* @throws NullPointerException if any argument is null
*/
@NonNull ListenableFuture<? extends DOMRpcResult> invokeRpc(@NonNull DOMRpcIdentifier rpc,
- @NonNull NormalizedNode<?, ?> input);
+ @NonNull ContainerNode input);
/**
* Return the relative invocation cost of this implementation. Default implementation return 0.
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.RpcError;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
/**
* Interface defining a result of an RPC call.
* @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 ContainerNode getResult();
}
import com.google.common.util.concurrent.ListenableFuture;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
/**
* of {@link DOMRpcException} reporting a transport error.
*/
@NonNull ListenableFuture<? extends DOMRpcResult> invokeRpc(@NonNull SchemaPath type,
- @NonNull NormalizedNode<?, ?> input);
+ @NonNull ContainerNode input);
/**
* Register a {@link DOMRpcAvailabilityListener} with this service to receive notifications
* about RPC implementations becoming (un)available. The listener will be invoked with the
* current implementations reported and will be kept uptodate as implementations come and go.
* Users should note that using a listener does not necessarily mean that
- * {@link #invokeRpc(SchemaPath, NormalizedNode)} will not report a failure due to
+ * {@link #invokeRpc(SchemaPath, ContainerNode)} will not report a failure due to
* {@link DOMRpcImplementationNotAvailableException} and need to be ready to handle it.
* Implementations are encouraged to take reasonable precautions to prevent this scenario from
* occurring.
private final class RpcServiceFacade implements DOMRpcService {
@Override
- public ListenableFuture<? extends DOMRpcResult> invokeRpc(final SchemaPath type,
- final NormalizedNode<?, ?> input) {
+ public ListenableFuture<? extends DOMRpcResult> invokeRpc(final SchemaPath type, final ContainerNode 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 ContainerNode input) {
if (entry instanceof UnknownDOMRpcRoutingTableEntry) {
return Futures.immediateFailedFuture(
new DOMRpcImplementationNotAvailableException("SchemaPath %s is not resolved to an RPC",
}
private static ListenableFuture<? extends DOMRpcResult> invokeRoutedRpc(
- final RoutedDOMRpcRoutingTableEntry entry, final NormalizedNode<?, ?> input) {
+ final RoutedDOMRpcRoutingTableEntry entry, final ContainerNode input) {
final Optional<NormalizedNode<?, ?>> maybeKey = NormalizedNodes.findNode(input,
entry.getRpcId().getContextReference());
}
private static ListenableFuture<? extends DOMRpcResult> invokeGlobalRpc(
- final GlobalDOMRpcRoutingTableEntry entry, final NormalizedNode<?, ?> input) {
+ final GlobalDOMRpcRoutingTableEntry entry, final ContainerNode input) {
return entry.getImplementations(YangInstanceIdentifier.empty()).get(0).invokeRpc(entry.getRpcId(), input);
}
}
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.ContainerNode;
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.NormalizedNode;
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.impl.ImmutableMapEntryNodeBuilder;
.withChild(TOP_LEVEL_LIST_NODE)
.build();
- static final NormalizedNode<?, ?> TEST_CONTAINER = Builders.containerBuilder()
+ static final ContainerNode TEST_CONTAINER = Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
.withChild(OUTER_LIST)
.build();
- static final NormalizedNode<?, ?> TEST_CHILD = Builders.containerBuilder()
+ static final ContainerNode 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 ContainerNode input) {
requireNonNull(input);
return unknownRpc;
}
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.RpcError;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
/**
* Utility class implementing {@link DefaultDOMRpcResult}.
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 ContainerNode result;
private final Collection<? extends RpcError> errors;
- public DefaultDOMRpcResult(final NormalizedNode<?, ?> result, final RpcError... errors) {
+ public DefaultDOMRpcResult(final ContainerNode result, final RpcError... errors) {
this(result, asCollection(errors));
}
this(null, asCollection(errors));
}
- public DefaultDOMRpcResult(final @Nullable NormalizedNode<?, ?> result) {
+ public DefaultDOMRpcResult(final @Nullable ContainerNode result) {
this(result, Collections.emptyList());
}
- public DefaultDOMRpcResult(final @Nullable NormalizedNode<?, ?> result,
+ public DefaultDOMRpcResult(final @Nullable ContainerNode result,
final Collection<? extends RpcError> errors) {
this.result = result;
this.errors = requireNonNull(errors);
}
@Override
- public @Nullable NormalizedNode<?, ?> getResult() {
+ public @Nullable ContainerNode getResult() {
return result;
}
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
/**
- * Utility implementation which implements {@link DOMRpcImplementation} by forwarding it to
- * a backing delegate.
+ * Utility implementation which implements {@link DOMRpcImplementation} by forwarding it to a backing delegate.
*/
public abstract class ForwardingDOMRpcImplementation extends ForwardingObject implements DOMRpcImplementation {
@Override
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 ContainerNode input) {
return delegate().invokeRpc(type, input);
}
}
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.yangtools.yang.common.RpcError;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
/**
* Utility class which implements {@link DOMRpcResult} by forwarding all methods
}
@Override
- public @Nullable NormalizedNode<?, ?> getResult() {
+ public @Nullable ContainerNode getResult() {
return delegate().getResult();
}
}
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
/**
protected abstract @NonNull DOMRpcService delegate();
@Override
- public ListenableFuture<? extends DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
+ public ListenableFuture<? extends DOMRpcResult> invokeRpc(final SchemaPath type, final ContainerNode input) {
return delegate().invokeRpc(type, input);
}
import java.util.Collections;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.RpcError;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
public class DefaultDOMRpcResultTest {
-
@Test
public void basicTest() throws Exception {
RpcError rpcError = mock(RpcError.class);
- NormalizedNode<?, ?> normalizedNode = mock(NormalizedNode.class);
+ ContainerNode normalizedNode = mock(ContainerNode.class);
DefaultDOMRpcResult defaultDOMRpcResult = new DefaultDOMRpcResult(normalizedNode, rpcError);
assertEquals(normalizedNode, defaultDOMRpcResult.getResult());
assertTrue(defaultDOMRpcResult.getErrors().contains(rpcError));