*/
package org.opendaylight.netconf.sal.connect.netconf.schema.mapping;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
import static java.util.Objects.requireNonNull;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.CREATE_SUBSCRIPTION_RPC_QNAME;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.IETF_NETCONF_NOTIFICATIONS;
import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.net.URISyntaxException;
import java.time.Instant;
import java.util.AbstractMap;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.Deque;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
+import org.checkerframework.checker.lock.qual.GuardedBy;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMActionResult;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.MissingNameSpaceException;
import org.opendaylight.netconf.api.xml.XmlElement;
-import org.opendaylight.netconf.sal.connect.api.MessageTransformer;
+import org.opendaylight.netconf.sal.connect.api.ActionTransformer;
+import org.opendaylight.netconf.sal.connect.api.NotificationTransformer;
+import org.opendaylight.netconf.sal.connect.api.RpcTransformer;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.MessageCounter;
import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
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.RpcResult;
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.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
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.SchemaInferenceStack;
-import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
-public class NetconfMessageTransformer implements MessageTransformer<NetconfMessage> {
+public class NetconfMessageTransformer
+ implements ActionTransformer, NotificationTransformer, RpcTransformer<ContainerNode, DOMRpcResult> {
private static final Logger LOG = LoggerFactory.getLogger(NetconfMessageTransformer.class);
private static final ImmutableSet<XMLNamespace> BASE_OR_NOTIFICATION_NS = ImmutableSet.of(
}
@VisibleForTesting
- static ImmutableMap<Absolute, ActionDefinition> getActions(final SchemaContext schemaContext) {
- final Map<Absolute, ActionDefinition> values = new HashMap<>();
- final SchemaInferenceStack stack = SchemaInferenceStack.of((EffectiveModelContext) schemaContext);
- findAction(schemaContext, values, stack);
- return ImmutableMap.copyOf(values);
+ static ImmutableMap<Absolute, ActionDefinition> getActions(final EffectiveModelContext schemaContext) {
+ final var builder = ImmutableMap.<Absolute, ActionDefinition>builder();
+ findAction(schemaContext, new ArrayDeque<QName>(), builder);
+ return builder.build();
}
- private static void findAction(final DataSchemaNode dataSchemaNode, final Map<Absolute, ActionDefinition> builder,
- final SchemaInferenceStack stack) {
+ private static void findAction(final DataSchemaNode dataSchemaNode, final Deque<QName> path,
+ final ImmutableMap.Builder<Absolute, ActionDefinition> builder) {
if (dataSchemaNode instanceof ActionNodeContainer) {
for (ActionDefinition actionDefinition : ((ActionNodeContainer) dataSchemaNode).getActions()) {
- stack.enterSchemaTree(actionDefinition.getQName());
- builder.put(stack.toSchemaNodeIdentifier(), actionDefinition);
- stack.exit();
+ path.addLast(actionDefinition.getQName());
+ builder.put(Absolute.of(path), actionDefinition);
+ path.removeLast();
}
}
if (dataSchemaNode instanceof DataNodeContainer) {
for (DataSchemaNode innerDataSchemaNode : ((DataNodeContainer) dataSchemaNode).getChildNodes()) {
- stack.enterSchemaTree(innerDataSchemaNode.getQName());
- findAction(innerDataSchemaNode, builder, stack);
- stack.exit();
+ path.addLast(innerDataSchemaNode.getQName());
+ findAction(innerDataSchemaNode, path, builder);
+ path.removeLast();
}
} else if (dataSchemaNode instanceof ChoiceSchemaNode) {
for (CaseSchemaNode caze : ((ChoiceSchemaNode) dataSchemaNode).getCases()) {
- stack.enterSchemaTree(caze.getQName());
- findAction(caze, builder, stack);
- stack.exit();
+ path.addLast(caze.getQName());
+ findAction(caze, path, builder);
+ path.removeLast();
}
}
}
"Unable to parse notification " + message + ", cannot find namespace", e);
}
- Collection<? extends NotificationDefinition> notificationDefinitions =
- mappedNotifications.get(notificationNoRev);
- Element element = stripped.getValue().getDomElement();
-
- NestedNotificationInfo nestedNotificationInfo = null;
- if (notificationDefinitions.isEmpty()) {
- // check if notification is nested notification
- Optional<NestedNotificationInfo> nestedNotificationOptional = findNestedNotification(message, element);
- if (nestedNotificationOptional.isPresent()) {
- nestedNotificationInfo = nestedNotificationOptional.get();
- notificationDefinitions = List.of(nestedNotificationInfo.notificationDefinition);
- element = (Element) nestedNotificationInfo.notificationNode;
- }
- }
- Preconditions.checkArgument(notificationDefinitions.size() > 0,
- "Unable to parse notification %s, unknown notification. Available notifications: %s",
- notificationDefinitions, mappedNotifications.keySet());
-
- final NotificationDefinition mostRecentNotification = getMostRecentNotification(notificationDefinitions);
-
- final SchemaInferenceStack stack = SchemaInferenceStack.of(mountContext.getEffectiveModelContext());
- if (nestedNotificationInfo != null) {
- final QNameModule targetModule = mostRecentNotification.getQName().getModule();
- nestedNotificationInfo.domDataTreeIdentifier.getRootIdentifier().getPathArguments().stream()
- .filter(arg -> !(arg instanceof NodeIdentifierWithPredicates))
- .filter(arg -> !(arg instanceof AugmentationIdentifier))
- .map(arg -> arg.getNodeType().bindTo(targetModule))
- .forEach(stack::enterSchemaTree);
- } else {
- stack.enterSchemaTree(mostRecentNotification.getQName());
+ final var matchingTopLevel = mappedNotifications.get(notificationNoRev);
+ final var element = stripped.getValue().getDomElement();
+ if (!matchingTopLevel.isEmpty()) {
+ final var notification = getMostRecentNotification(matchingTopLevel);
+ // FIXME: we really should have a pre-constructed identifier here
+ return new NetconfDeviceNotification(toNotification(Absolute.of(notification.getQName()), element),
+ stripped.getKey());
}
- final ContainerNode content;
+ final var nestedInfo = findNestedNotification(message, element)
+ .orElseThrow(() -> new IllegalArgumentException("Unable to parse notification for " + element
+ + ". Available notifications: " + mappedNotifications.keySet()));
+ final var schemaPath = nestedInfo.schemaPath;
+ return new NetconfDeviceTreeNotification(toNotification(schemaPath, nestedInfo.element), schemaPath,
+ stripped.getKey(), nestedInfo.instancePath);
+ }
+
+ @GuardedBy("this")
+ private ContainerNode toNotification(final Absolute notificationPath, final Element element) {
+ final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
try {
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
- final XmlParserStream xmlParser = XmlParserStream.create(writer, mountContext, stack.toInference(),
- strictParsing);
+ final XmlParserStream xmlParser = XmlParserStream.create(writer, mountContext,
+ SchemaInferenceStack.of(mountContext.getEffectiveModelContext(), notificationPath).toInference(),
+ strictParsing);
xmlParser.traverse(new DOMSource(element));
- content = (ContainerNode) resultHolder.getResult();
} catch (XMLStreamException | URISyntaxException | IOException | SAXException
| UnsupportedOperationException e) {
throw new IllegalArgumentException(String.format("Failed to parse notification %s", element), e);
}
-
- if (nestedNotificationInfo != null) {
- return new NetconfDeviceTreeNotification(content,
- stack.toSchemaNodeIdentifier(),
- stripped.getKey(), nestedNotificationInfo.domDataTreeIdentifier);
- }
-
- return new NetconfDeviceNotification(content, stripped.getKey());
+ return (ContainerNode) resultHolder.getResult();
}
private Optional<NestedNotificationInfo> findNestedNotification(final NetconfMessage message,
final QName topLevelNodeQName = QName.create(element.getNamespaceURI(), element.getLocalName());
for (DataSchemaNode childNode : module.getChildNodes()) {
if (topLevelNodeQName.isEqualWithoutRevision(childNode.getQName())) {
- return Optional.of(traverseXmlNodeContainingNotification(element, childNode,
+ return Optional.of(traverseXmlNodeContainingNotification(element, childNode, new ArrayList<>(),
YangInstanceIdentifier.builder()));
}
}
return Optional.empty();
}
+ // FIXME: this method is using QNames which are not bound to a Revision. Why is that?
+ // FIXME: furthermore this does not handle the entirety of schema layout: notably missing a choice/case schema nodes
private NestedNotificationInfo traverseXmlNodeContainingNotification(final Node xmlNode,
- final SchemaNode schemaNode, final YangInstanceIdentifier.InstanceIdentifierBuilder builder) {
- if (schemaNode instanceof ContainerSchemaNode) {
- ContainerSchemaNode dataContainerNode = (ContainerSchemaNode) schemaNode;
- builder.node(QName.create(xmlNode.getNamespaceURI(), xmlNode.getLocalName()));
+ final SchemaNode schemaNode, final List<QName> schemaBuilder,
+ final InstanceIdentifierBuilder instanceBuilder) {
+ if (schemaNode instanceof ContainerSchemaNode containerSchema) {
+ instanceBuilder.node(QName.create(xmlNode.getNamespaceURI(), xmlNode.getLocalName()));
+ schemaBuilder.add(containerSchema.getQName());
- Entry<Node, SchemaNode> xmlContainerChildPair = findXmlContainerChildPair(xmlNode, dataContainerNode);
+ Entry<Node, SchemaNode> xmlContainerChildPair = findXmlContainerChildPair(xmlNode, containerSchema);
return traverseXmlNodeContainingNotification(xmlContainerChildPair.getKey(),
- xmlContainerChildPair.getValue(), builder);
- } else if (schemaNode instanceof ListSchemaNode) {
- ListSchemaNode listSchemaNode = (ListSchemaNode) schemaNode;
- builder.node(QName.create(xmlNode.getNamespaceURI(), xmlNode.getLocalName()));
+ xmlContainerChildPair.getValue(), schemaBuilder, instanceBuilder);
+ } else if (schemaNode instanceof ListSchemaNode listSchema) {
+ instanceBuilder.node(QName.create(xmlNode.getNamespaceURI(), xmlNode.getLocalName()));
+ schemaBuilder.add(listSchema.getQName());
- Map<QName, Object> listKeys = findXmlListKeys(xmlNode, listSchemaNode);
- builder.nodeWithKey(QName.create(xmlNode.getNamespaceURI(), xmlNode.getLocalName()), listKeys);
+ Map<QName, Object> listKeys = findXmlListKeys(xmlNode, listSchema);
+ instanceBuilder.nodeWithKey(QName.create(xmlNode.getNamespaceURI(), xmlNode.getLocalName()), listKeys);
- Entry<Node, SchemaNode> xmlListChildPair = findXmlListChildPair(xmlNode, listSchemaNode);
+ Entry<Node, SchemaNode> xmlListChildPair = findXmlListChildPair(xmlNode, listSchema);
return traverseXmlNodeContainingNotification(xmlListChildPair.getKey(),
- xmlListChildPair.getValue(), builder);
+ xmlListChildPair.getValue(), schemaBuilder, instanceBuilder);
} else if (schemaNode instanceof NotificationDefinition) {
- builder.node(QName.create(xmlNode.getNamespaceURI(), xmlNode.getLocalName()));
+ // FIXME: this should not be here: it does not form a valid YangInstanceIdentifier
+ instanceBuilder.node(QName.create(xmlNode.getNamespaceURI(), xmlNode.getLocalName()));
+ schemaBuilder.add(schemaNode.getQName());
- NotificationDefinition notificationDefinition = (NotificationDefinition) schemaNode;
- return new NestedNotificationInfo(notificationDefinition,
- new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, builder.build()), xmlNode);
+ return new NestedNotificationInfo(Absolute.of(schemaBuilder),
+ new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, instanceBuilder.build()), xmlNode);
}
throw new IllegalStateException("No notification found");
}
QName currentNodeQName = QName.create(currentNode.getNamespaceURI(), currentNode.getLocalName());
SchemaNode schemaChildNode = childrenWithoutRevision.get(currentNodeQName);
if (schemaChildNode != null) {
- return new AbstractMap.SimpleEntry<>(currentNode, schemaChildNode);
+ return Map.entry(currentNode, schemaChildNode);
}
}
}
}
@Override
- public NetconfMessage toRpcRequest(final QName rpc, final NormalizedNode payload) {
+ public NetconfMessage toRpcRequest(final QName rpc, final ContainerNode payload) {
// In case no input for rpc is defined, we can simply construct the payload here
// Determine whether a base netconf operation is being invoked
currentMappedRpcs = mappedRpcs;
}
- final RpcDefinition mappedRpc = Preconditions.checkNotNull(currentMappedRpcs.get(rpc),
+ final RpcDefinition mappedRpc = checkNotNull(currentMappedRpcs.get(rpc),
"Unknown rpc %s, available rpcs: %s", rpc, currentMappedRpcs.keySet());
if (mappedRpc.getInput().getChildNodes().isEmpty()) {
return new NetconfMessage(NetconfMessageTransformUtil.prepareDomResultForRpcRequest(rpc, counter)
.getNode().getOwnerDocument());
}
- Preconditions.checkNotNull(payload, "Transforming an rpc with input: %s, payload cannot be null", rpc);
+ checkNotNull(payload, "Transforming an rpc with input: %s, payload cannot be null", rpc);
- Preconditions.checkArgument(payload instanceof ContainerNode,
- "Transforming an rpc with input: %s, payload has to be a container, but was: %s", rpc, payload);
final DOMResult result = NetconfMessageTransformUtil.prepareDomResultForRpcRequest(rpc, counter);
try {
// If the schema context for netconf device does not contain model for base netconf operations,
// This way operations like lock/unlock are supported even if the source for base model was not provided
final EffectiveModelContext ctx = needToUseBaseCtx ? baseSchema.getEffectiveModelContext()
: mountContext.getEffectiveModelContext();
- NetconfMessageTransformUtil.writeNormalizedOperationInput((ContainerNode) payload, result, Absolute.of(rpc),
+ NetconfMessageTransformUtil.writeNormalizedOperationInput(payload, result, Absolute.of(rpc),
ctx);
} catch (final XMLStreamException | IOException | IllegalStateException e) {
throw new IllegalStateException("Unable to serialize input of " + rpc, e);
public NetconfMessage toActionRequest(final Absolute action, final DOMDataTreeIdentifier domDataTreeIdentifier,
final NormalizedNode payload) {
final ActionDefinition actionDef = actions.get(action);
- Preconditions.checkArgument(actionDef != null, "Action does not exist: %s", action);
+ checkArgument(actionDef != null, "Action does not exist: %s", action);
final InputSchemaNode inputDef = actionDef.getInput();
if (inputDef.getChildNodes().isEmpty()) {
domDataTreeIdentifier, counter, actionDef.getQName()).getNode().getOwnerDocument());
}
- Preconditions.checkNotNull(payload, "Transforming an action with input: %s, payload cannot be null", action);
- Preconditions.checkArgument(payload instanceof ContainerNode,
+ checkNotNull(payload, "Transforming an action with input: %s, payload cannot be null", action);
+ checkArgument(payload instanceof ContainerNode,
"Transforming an action with input: %s, payload has to be a container, but was: %s", action, payload);
final DOMResult result = NetconfMessageTransformUtil.prepareDomResultForActionRequest(contextTree,
}
@Override
- public synchronized DOMRpcResult toRpcResult(final NetconfMessage message, final QName rpc) {
- final NormalizedNode normalizedNode;
+ public synchronized DOMRpcResult toRpcResult(final RpcResult<NetconfMessage> resultPayload, final QName rpc) {
+ if (!resultPayload.isSuccessful()) {
+ return new DefaultDOMRpcResult(resultPayload.getErrors());
+ }
+
+ final var message = resultPayload.getResult();
+ final ContainerNode normalizedNode;
if (NetconfMessageTransformUtil.isDataRetrievalOperation(rpc)) {
normalizedNode = Builders.containerBuilder()
.withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_RPC_REPLY_NODEID)
}
final RpcDefinition rpcDefinition = currentMappedRpcs.get(rpc);
- Preconditions.checkArgument(rpcDefinition != null,
- "Unable to parse response of %s, the rpc is unknown", rpc);
+ checkArgument(rpcDefinition != null, "Unable to parse response of %s, the rpc is unknown", rpc);
// In case no input for rpc is defined, we can simply construct the payload here
- normalizedNode = parseResult(message, rpcDefinition,
- Absolute.of(rpcDefinition.getQName(), rpcDefinition.getOutput().getQName()));
+ normalizedNode = parseResult(message, Absolute.of(rpc), rpcDefinition);
}
return new DefaultDOMRpcResult(normalizedNode);
}
@Override
public DOMActionResult toActionResult(final Absolute action, final NetconfMessage message) {
final ActionDefinition actionDefinition = actions.get(action);
- Preconditions.checkArgument(actionDefinition != null, "Action does not exist: %s", action);
+ checkArgument(actionDefinition != null, "Action does not exist: %s", action);
+ final ContainerNode normalizedNode = parseResult(message, action, actionDefinition);
- final List<QName> actionIds = action.getNodeIdentifiers();
- final ContainerNode normalizedNode = (ContainerNode) parseResult(message, actionDefinition,
- Absolute.of(ImmutableList.<QName>builderWithExpectedSize(actionIds.size() + 1)
- .addAll(actionIds).add(actionDefinition.getOutput().getQName())
- .build()));
if (normalizedNode == null) {
return new SimpleDOMActionResult(List.of());
} else {
}
}
- private NormalizedNode parseResult(final NetconfMessage message, final OperationDefinition operationDefinition,
- final Absolute operationPath) {
+ private ContainerNode parseResult(final NetconfMessage message, final Absolute operationPath,
+ final OperationDefinition operationDef) {
final Optional<XmlElement> okResponseElement = XmlElement.fromDomDocument(message.getDocument())
.getOnlyChildElementWithSameNamespaceOptionally("ok");
- if (operationDefinition.getOutput().getChildNodes().isEmpty()) {
- Preconditions.checkArgument(okResponseElement.isPresent(),
- "Unexpected content in response of rpc: %s, %s", operationDefinition.getQName(), message);
+ final var operOutput = operationDef.getOutput();
+ if (operOutput.getChildNodes().isEmpty()) {
+ checkArgument(okResponseElement.isPresent(), "Unexpected content in response of operation: %s, %s",
+ operationDef.getQName(), message);
return null;
- } else {
- if (okResponseElement.isPresent()) {
- LOG.debug("Received response <ok/> for RPC with defined Output");
- return null;
- }
+ }
+ if (okResponseElement.isPresent()) {
+ // FIXME: could be an action as well
+ LOG.debug("Received response <ok/> for RPC with defined Output");
+ return null;
+ }
- final Element element = message.getDocument().getDocumentElement();
- final Inference inference = SchemaInferenceStack.of(mountContext.getEffectiveModelContext(),
- operationPath).toInference();
- try {
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
- final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
- final XmlParserStream xmlParser = XmlParserStream.create(writer, mountContext,
- inference, strictParsing);
- xmlParser.traverse(new DOMSource(element));
- return resultHolder.getResult();
- } catch (XMLStreamException | URISyntaxException | IOException | SAXException e) {
- throw new IllegalArgumentException(String.format("Failed to parse RPC response %s", element), e);
- }
+ final var operSteps = operationPath.getNodeIdentifiers();
+ final var outputPath = Absolute.of(ImmutableList.<QName>builderWithExpectedSize(operSteps.size() + 1)
+ .addAll(operSteps)
+ .add(operOutput.getQName())
+ .build());
+ // FIXME: we should have a cached inference here, or XMLParserStream should accept Absolute instead
+ final var inference = SchemaInferenceStack.of(mountContext.getEffectiveModelContext(), outputPath)
+ .toInference();
+
+ final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
+ final Element element = message.getDocument().getDocumentElement();
+ try {
+ final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
+ final XmlParserStream xmlParser = XmlParserStream.create(writer, mountContext, inference, strictParsing);
+ xmlParser.traverse(new DOMSource(element));
+ } catch (XMLStreamException | URISyntaxException | IOException | SAXException e) {
+ throw new IllegalArgumentException(String.format("Failed to parse RPC response %s", element), e);
}
+ return (ContainerNode) resultHolder.getResult();
}
@Beta
}
private static final class NestedNotificationInfo {
- private final NotificationDefinition notificationDefinition;
- private final DOMDataTreeIdentifier domDataTreeIdentifier;
- private final Node notificationNode;
-
- NestedNotificationInfo(final NotificationDefinition notificationDefinition,
- final DOMDataTreeIdentifier domDataTreeIdentifier, final Node notificationNode) {
- this.notificationDefinition = notificationDefinition;
- this.domDataTreeIdentifier = domDataTreeIdentifier;
- this.notificationNode = notificationNode;
+ final @NonNull DOMDataTreeIdentifier instancePath;
+ final @NonNull Absolute schemaPath;
+ final @NonNull Element element;
+
+ NestedNotificationInfo(final Absolute schemaPath, final DOMDataTreeIdentifier instancePath,
+ final Node documentNode) {
+ this.schemaPath = requireNonNull(schemaPath);
+ this.instancePath = requireNonNull(instancePath);
+ checkArgument(documentNode instanceof Element, "Unexpected document node %s", documentNode);
+ element = (Element) documentNode;
}
}
}
Code Review / netconf.git / blobdiff