<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>2.1.8</version>
+ <version>3.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="odl-mdsal-${project.version}">
<feature name="odl-mdsal-broker-local" version="${project.version}">
<feature version="[5,6)">odl-lmax-3</feature>
- <feature version="[2.1,3)">odl-yangtools-codec</feature>
+ <feature version="[3,4)">odl-yangtools-codec</feature>
<bundle start-level="40">mvn:org.opendaylight.controller/blueprint/${blueprint.version}</bundle>
</feature>
</features>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>2.1.8</version>
+ <version>3.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
@SuppressWarnings("checkstyle:IllegalCatch")
private void notifyAllListeners(final Set<SchemaPath> added) {
- final Iterator<ListenerRegistration<NotificationInterestListener>> listeners = interestListeners.iterator();
+ final Iterator<? extends ListenerRegistration<? extends NotificationInterestListener>> listeners =
+ interestListeners.getRegistrations().iterator();
if (listeners.hasNext()) {
final Set<Class<? extends Notification>> baEvent = translate(added);
while (listeners.hasNext()) {
final Iterator<YangInstanceIdentifier.PathArgument> toEnter = domArgumentList.iterator();
DataTreeCandidateNode current = domData;
while (toEnter.hasNext() && current != null) {
- current = current.getModifiedChild(toEnter.next());
+ current = current.getModifiedChild(toEnter.next()).orElse(null);
}
return current != null && current.getModificationType() != UNMODIFIED ? create(childCodec, current) : null;
}
* 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.controller.md.sal.binding.impl;
import java.util.Collection;
-import java.util.Map;
import java.util.Optional;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDataAware;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
return new WithContextRef(rpcName.getLastComponent(), data, contextRef, codec);
}
- @Override
- public Map<QName, String> getAttributes() {
- return delegate().getAttributes();
- }
-
private ContainerNode delegate() {
if (domData == null) {
domData = registry.toNormalizedNodeRpcData(bindingData);
return delegate().getChild(child);
}
- @Override
- public final Object getAttributeValue(final QName name) {
- return delegate().getAttributeValue(name);
- }
-
@Override
public final DataObject bindingData() {
return bindingData;
public synchronized void changeSchema(final SchemaContext newContext) {
schemaContext = newContext;
- for (ListenerRegistration<SchemaContextListener> listener : listeners) {
+ for (ListenerRegistration<? extends SchemaContextListener> listener : listeners.getRegistrations()) {
listener.getInstance().onGlobalContextUpdated(schemaContext);
}
}
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>2.1.8</version>
+ <version>3.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
private NormalizedNodeWriter normalizedNodeWriter;
private boolean headerWritten;
private QName lastLeafSetQName;
+ private boolean inSimple;
AbstractNormalizedNodeDataOutput(final DataOutput output) {
this.output = Preconditions.checkNotNull(output);
}
@Override
- public void leafNode(final NodeIdentifier name, final Object value) throws IOException, IllegalArgumentException {
+ public void startLeafNode(final NodeIdentifier name) throws IOException {
Preconditions.checkNotNull(name, "Node identifier should not be null");
- LOG.trace("Writing a new leaf node");
+ LOG.trace("Starting a new leaf node");
startNode(name.getNodeType(), NodeTypes.LEAF_NODE);
-
- writeObject(value);
+ inSimple = true;
}
@Override
- public void startLeafSet(final NodeIdentifier name, final int childSizeHint)
-
- throws IOException, IllegalArgumentException {
+ public void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
Preconditions.checkNotNull(name, "Node identifier should not be null");
LOG.trace("Starting a new leaf set");
}
@Override
- public void startOrderedLeafSet(final NodeIdentifier name, final int childSizeHint)
- throws IOException, IllegalArgumentException {
+ public void startOrderedLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
Preconditions.checkNotNull(name, "Node identifier should not be null");
LOG.trace("Starting a new ordered leaf set");
}
@Override
- public void leafSetEntryNode(final QName name, final Object value) throws IOException, IllegalArgumentException {
- LOG.trace("Writing a new leaf set entry node");
+ public void startLeafSetEntryNode(final NodeWithValue<?> name) throws IOException {
+ LOG.trace("Starting a new leaf set entry node");
output.writeByte(NodeTypes.LEAF_SET_ENTRY_NODE);
// lastLeafSetQName is set if the parent LeafSetNode was previously written. Otherwise this is a
// stand alone LeafSetEntryNode so write out it's name here.
if (lastLeafSetQName == null) {
- writeQName(name);
+ writeQName(name.getNodeType());
}
-
- writeObject(value);
+ inSimple = true;
}
@Override
- public void startContainerNode(final NodeIdentifier name, final int childSizeHint)
- throws IOException, IllegalArgumentException {
+ public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
Preconditions.checkNotNull(name, "Node identifier should not be null");
LOG.trace("Starting a new container node");
}
@Override
- public void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint)
- throws IOException, IllegalArgumentException {
+ public void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
Preconditions.checkNotNull(name, "Node identifier should not be null");
LOG.trace("Starting a new yang modeled anyXml node");
}
@Override
- public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint)
- throws IOException, IllegalArgumentException {
+ public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) throws IOException {
Preconditions.checkNotNull(name, "Node identifier should not be null");
LOG.trace("Starting a new unkeyed list");
}
@Override
- public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint)
- throws IOException, IllegalStateException {
+ public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException {
Preconditions.checkNotNull(name, "Node identifier should not be null");
LOG.trace("Starting a new unkeyed list item");
}
@Override
- public void startMapNode(final NodeIdentifier name, final int childSizeHint)
- throws IOException, IllegalArgumentException {
+ public void startMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
Preconditions.checkNotNull(name, "Node identifier should not be null");
LOG.trace("Starting a new map node");
@Override
public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint)
- throws IOException, IllegalArgumentException {
+ throws IOException {
Preconditions.checkNotNull(identifier, "Node identifier should not be null");
LOG.trace("Starting a new map entry node");
startNode(identifier.getNodeType(), NodeTypes.MAP_ENTRY_NODE);
writeKeyValueMap(identifier.getKeyValues());
-
}
@Override
- public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint)
- throws IOException, IllegalArgumentException {
+ public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
Preconditions.checkNotNull(name, "Node identifier should not be null");
LOG.trace("Starting a new ordered map node");
}
@Override
- public void startChoiceNode(final NodeIdentifier name, final int childSizeHint)
- throws IOException, IllegalArgumentException {
+ public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
Preconditions.checkNotNull(name, "Node identifier should not be null");
LOG.trace("Starting a new choice node");
}
@Override
- public void startAugmentationNode(final AugmentationIdentifier identifier)
- throws IOException, IllegalArgumentException {
+ public void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException {
Preconditions.checkNotNull(identifier, "Node identifier should not be null");
LOG.trace("Starting a new augmentation node");
}
@Override
- public void anyxmlNode(final NodeIdentifier name, final Object value) throws IOException, IllegalArgumentException {
+ public void startAnyxmlNode(final NodeIdentifier name) throws IOException {
Preconditions.checkNotNull(name, "Node identifier should not be null");
- LOG.trace("Writing any xml node");
-
+ LOG.trace("Starting any xml node");
startNode(name.getNodeType(), NodeTypes.ANY_XML_NODE);
+ inSimple = true;
+ }
+ @Override
+ public void scalarValue(final Object value) throws IOException {
+ writeObject(value);
+ }
+
+ @Override
+ public void domSourceValue(final DOMSource value) throws IOException {
try {
StreamResult xmlOutput = new StreamResult(new StringWriter());
- TransformerFactory.newInstance().newTransformer().transform((DOMSource)value, xmlOutput);
+ TransformerFactory.newInstance().newTransformer().transform(value, xmlOutput);
writeObject(xmlOutput.getWriter().toString());
} catch (TransformerException | TransformerFactoryConfigurationError e) {
throw new IOException("Error writing anyXml", e);
}
@Override
- public void endNode() throws IOException, IllegalStateException {
+ public void endNode() throws IOException {
LOG.trace("Ending the node");
- lastLeafSetQName = null;
- output.writeByte(NodeTypes.END_NODE);
+ if (!inSimple) {
+ lastLeafSetQName = null;
+ output.writeByte(NodeTypes.END_NODE);
+ }
+ inSimple = false;
}
@Override
private void startNode(final QName qname, final byte nodeType) throws IOException {
Preconditions.checkNotNull(qname, "QName of node identifier should not be null.");
+ Preconditions.checkState(!inSimple, "Attempted to start a child in a simple node");
ensureHeaderWritten();
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.builder.api.ListNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.slf4j.Logger;
private QName lastLeafSetQName;
- private NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier,
- Object, LeafNode<Object>> leafBuilder;
+ private NormalizedNodeBuilder<YangInstanceIdentifier.NodeIdentifier, Object, LeafNode<Object>> leafBuilder;
@SuppressWarnings("rawtypes")
- private NormalizedNodeAttrBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> leafSetEntryBuilder;
+ private NormalizedNodeBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> leafSetEntryBuilder;
private final StringBuilder reusableStringBuilder = new StringBuilder(50);
}
}
- private NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier,
- Object, LeafNode<Object>> leafBuilder() {
+ private NormalizedNodeBuilder<YangInstanceIdentifier.NodeIdentifier, Object, LeafNode<Object>> leafBuilder() {
if (leafBuilder == null) {
leafBuilder = Builders.leafBuilder();
}
}
@SuppressWarnings("rawtypes")
- private NormalizedNodeAttrBuilder<NodeWithValue, Object,
- LeafSetEntryNode<Object>> leafSetEntryBuilder() {
+ private NormalizedNodeBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> leafSetEntryBuilder() {
if (leafSetEntryBuilder == null) {
leafSetEntryBuilder = Builders.leafSetEntryBuilder();
}
import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.requireNonNull;
+import java.io.IOException;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.NoSuchElementException;
import java.util.Optional;
import javax.xml.transform.dom.DOMSource;
-import org.opendaylight.yangtools.yang.common.QName;
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.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
-import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
state = State.OPEN;
}
- @SuppressWarnings("unchecked")
@Override
- public void leafNode(final NodeIdentifier nodeIdentifier, final Object value) {
- checkNotSealed();
-
- NormalizedNodeBuilderWrapper parent = stack.peek();
- LeafNode<Object> leafNode = Builders.leafBuilder().withNodeIdentifier(nodeIdentifier).withValue(value).build();
- if (parent != null) {
- if (hasValidSchema(nodeIdentifier.getNodeType(), parent)) {
- parent.builder().addChild(leafNode);
- }
- } else {
- // If there's no parent node then this is a stand alone LeafNode.
- if (nodePathSchemaNode != null) {
- this.normalizedNode = leafNode;
- }
-
- state = State.CLOSED;
- }
+ public void startLeafNode(final NodeIdentifier name) {
+ addBuilder(Builders.leafBuilder().withNodeIdentifier(name), name);
}
@Override
addBuilder(Builders.orderedLeafSetBuilder().withNodeIdentifier(nodeIdentifier), nodeIdentifier);
}
- @SuppressWarnings("unchecked")
@Override
- public void leafSetEntryNode(final QName name, final Object value) {
- checkNotSealed();
-
- NormalizedNodeBuilderWrapper parent = stack.peek();
- if (parent != null) {
- if (hasValidSchema(name, parent)) {
- parent.builder().addChild(Builders.leafSetEntryBuilder().withValue(value)
- .withNodeIdentifier(new NodeWithValue<>(parent.nodeType(), value))
- .build());
- }
- } else {
- // If there's no parent LeafSetNode then this is a stand alone
- // LeafSetEntryNode.
- if (nodePathSchemaNode != null) {
- this.normalizedNode = Builders.leafSetEntryBuilder().withValue(value).withNodeIdentifier(
- new NodeWithValue<>(name, value)).build();
- }
-
- state = State.CLOSED;
- }
+ public void startLeafSetEntryNode(final NodeWithValue<?> name) throws IOException {
+ addBuilder(Builders.leafSetEntryBuilder().withNodeIdentifier(name), name);
}
@Override
addBuilder(Builders.augmentationBuilder().withNodeIdentifier(augmentationIdentifier), augmentationIdentifier);
}
- @SuppressWarnings("unchecked")
@Override
- public void anyxmlNode(final NodeIdentifier nodeIdentifier, final Object value) {
- checkNotSealed();
+ public void startAnyxmlNode(final NodeIdentifier name) {
+ addBuilder(Builders.anyXmlBuilder().withNodeIdentifier(name), name);
+ }
- NormalizedNodeBuilderWrapper parent = stack.peek();
- AnyXmlNode anyXmlNode = Builders.anyXmlBuilder().withNodeIdentifier(nodeIdentifier).withValue((DOMSource) value)
- .build();
- if (parent != null) {
- if (hasValidSchema(nodeIdentifier.getNodeType(), parent)) {
- parent.builder().addChild(anyXmlNode);
- }
- } else {
- // If there's no parent node then this is a stand alone AnyXmlNode.
- if (nodePathSchemaNode != null) {
- this.normalizedNode = anyXmlNode;
- }
+ @Override
+ public void domSourceValue(final DOMSource value) {
+ setValue(value);
+ }
- state = State.CLOSED;
- }
+ @Override
+ public void scalarValue(final Object value) {
+ setValue(value);
}
- @SuppressWarnings("unchecked")
@Override
public void endNode() {
checkNotSealed();
return;
}
- final NormalizedNode<?, ?> newNode = child.builder().build();
+ final NormalizedNode<?, ?> newNode = child.build();
final NormalizedNodeBuilderWrapper parent = stack.peek();
if (parent == null) {
normalizedNode = newNode;
state = State.CLOSED;
} else {
- parent.builder().addChild(newNode);
+ parent.addChild(newNode);
}
}
checkState(state == State.OPEN, "Illegal operation in state %s", state);
}
- private static boolean hasValidSchema(final QName name, final NormalizedNodeBuilderWrapper parent) {
- final DataSchemaContextNode<?> parentSchema = parent.getSchema();
- final boolean valid = parentSchema != null && parentSchema.getChild(name) != null;
- if (!valid) {
- LOG.debug("Schema not found for {}", name);
- }
-
- return valid;
+ private void setValue(final Object value) {
+ checkNotSealed();
+ final NormalizedNodeBuilderWrapper current = stack.peek();
+ checkState(current != null, "Attempted to set value %s while no node is open", value);
+ current.setValue(value);
}
- private NormalizedNodeBuilderWrapper addBuilder(final NormalizedNodeContainerBuilder<?, ?, ?, ?> builder,
+ private <T extends NormalizedNodeBuilder<?, ?, ?>> NormalizedNodeBuilderWrapper addBuilder(final T builder,
final PathArgument identifier) {
checkNotSealed();
final DataSchemaContextNode<?> schemaNode;
final NormalizedNodeBuilderWrapper parent = stack.peek();
if (parent != null) {
- final DataSchemaContextNode<?> parentSchema = parent.getSchema();
- schemaNode = parentSchema == null ? null : parentSchema.getChild(identifier);
+ schemaNode = parent.childSchema(identifier);
} else {
schemaNode = nodePathSchemaNode;
}
*/
package org.opendaylight.controller.cluster.datastore.node.utils.transformer;
+import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.requireNonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
final class NormalizedNodeBuilderWrapper {
- private final NormalizedNodeContainerBuilder<?, ?, ?, ?> builder;
+ @SuppressWarnings("rawtypes")
+ private final NormalizedNodeBuilder builder;
private final PathArgument identifier;
private final DataSchemaContextNode<?> schemaNode;
- NormalizedNodeBuilderWrapper(final NormalizedNodeContainerBuilder<?, ?, ?, ?> builder,
+ NormalizedNodeBuilderWrapper(final NormalizedNodeBuilder<?, ?, ?> builder,
final PathArgument identifier, final @Nullable DataSchemaContextNode<?> schemaNode) {
this.builder = requireNonNull(builder);
this.identifier = requireNonNull(identifier);
this.schemaNode = schemaNode;
}
- @SuppressWarnings("rawtypes")
- NormalizedNodeContainerBuilder builder() {
- return builder;
- }
-
- QName nodeType() {
- return identifier.getNodeType();
- }
-
PathArgument identifier() {
return identifier;
}
@Nullable DataSchemaContextNode<?> getSchema() {
return schemaNode;
}
+
+ @Nullable DataSchemaContextNode<?> childSchema(final PathArgument child) {
+ if (schemaNode == null) {
+ return null;
+ }
+
+ checkState(builder instanceof NormalizedNodeContainerBuilder,
+ "Attempted to lookup child %s in non-container %s", schemaNode);
+ return schemaNode.getChild(child);
+ }
+
+ NormalizedNode<?, ?> build() {
+ return builder.build();
+ }
+
+ @SuppressWarnings({ "rawtypes", "unchecked" })
+ void addChild(final NormalizedNode<?, ?> child) {
+ checkState(builder instanceof NormalizedNodeContainerBuilder,
+ "Attempted to add child %s to non-container builder %s", child, builder);
+ ((NormalizedNodeContainerBuilder) builder).addChild(child);
+ }
+
+ @SuppressWarnings("unchecked")
+ void setValue(final Object value) {
+ checkState(!(builder instanceof NormalizedNodeContainerBuilder),
+ "Attempted to set value %s on container builder %s", value, builder);
+ builder.withValue(value);
+ }
}
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.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
}
- public static DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> createBaseTestContainerBuilder() {
+ public static DataContainerNodeBuilder<NodeIdentifier, ContainerNode> createBaseTestContainerBuilder() {
// Create a list of shoes
// This is to test leaf list entry
final LeafSetEntryNode<Object> nike = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
MapEntryNode augMapEntry = createAugmentedListEntry(1, "First Test");
// Create a bits leaf
- NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>>
+ NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>>
myBits = Builders.leafBuilder()
.withNodeIdentifier(new NodeIdentifier(QName.create(TEST_QNAME, "my-bits")))
.withValue(ImmutableSet.of("foo", "bar"));
public static ContainerNode createFamily() {
- final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode>
+ final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode>
familyContainerBuilder = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(FAMILY_QNAME));
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.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
@Override
@SuppressFBWarnings("BC_UNCONFIRMED_CAST")
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
.mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg);
for (final Entry<QName, Object> keyValue :
((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) {
}
@Override
- public final DataTreeCandidateNode getModifiedChild(final PathArgument identifier) {
+ public final Optional<DataTreeCandidateNode> getModifiedChild(final PathArgument identifier) {
throw new UnsupportedOperationException("Not implemented");
}
return delegate;
}
+ @Override
+ public SchemaContext getSchemaContext() {
+ return delegate.getSchemaContext();
+ }
+
@Override
public void delete(final YangInstanceIdentifier yangInstanceIdentifier) {
try {
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
-import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNodes;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidates;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.SchemaValidationFailedException;
import org.slf4j.Logger;
DataTreeCandidateNode modifiedChild = candidate.getRootNode();
for (final PathArgument pathArgument : listenerPath.getPathArguments()) {
- modifiedChild = modifiedChild.getModifiedChild(pathArgument);
+ modifiedChild = modifiedChild.getModifiedChild(pathArgument).orElse(null);
}
+
if (modifiedChild == null) {
- modifiedChild = new EmptyDataTreeCandidateNode(dataTree.getRootPath().getLastPathArgument());
+ modifiedChild = DataTreeCandidateNodes.empty(dataTree.getRootPath().getLastPathArgument());
}
return DataTreeCandidates.newDataTreeCandidate(dataTree.getRootPath(), modifiedChild);
registrations.clear();
}
}
-
- private static final class EmptyDataTreeCandidateNode implements DataTreeCandidateNode {
-
- private final PathArgument identifier;
-
- EmptyDataTreeCandidateNode(final PathArgument identifier) {
- this.identifier = requireNonNull(identifier, "Identifier should not be null");
- }
-
- @Override
- public PathArgument getIdentifier() {
- return identifier;
- }
-
- @Override
- public Collection<DataTreeCandidateNode> getChildNodes() {
- return Collections.emptySet();
- }
-
- @Override
- @SuppressWarnings("checkstyle:hiddenField")
- public DataTreeCandidateNode getModifiedChild(final PathArgument identifier) {
- return null;
- }
-
- @Override
- public ModificationType getModificationType() {
- return ModificationType.UNMODIFIED;
- }
-
- @Override
- public Optional<NormalizedNode<?, ?>> getDataAfter() {
- return Optional.empty();
- }
-
- @Override
- public Optional<NormalizedNode<?, ?>> getDataBefore() {
- return Optional.empty();
- }
- }
}
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.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
}
public static ContainerNode createFamily() {
- final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode>
- familyContainerBuilder = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
+ final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> familyContainerBuilder =
+ ImmutableContainerNodeBuilder.create().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(FAMILY_QNAME));
final CollectionNodeBuilder<MapEntryNode, MapNode> childrenBuilder = mapNodeBuilder(CHILDREN_QNAME);
candidateRoot = candidate.getRootNode();
checkChange(TEST_CONTAINER, TEST_CONTAINER_2, ModificationType.SUBTREE_MODIFIED, candidateRoot);
final DataTreeCandidateNode modifiedChild = candidateRoot
- .getModifiedChild(new YangInstanceIdentifier.NodeIdentifier(TestModel.OUTER_LIST_QNAME));
- assertNotNull(modifiedChild);
+ .getModifiedChild(new YangInstanceIdentifier.NodeIdentifier(TestModel.OUTER_LIST_QNAME)).get();
checkChange(OUTER_LIST, OUTER_LIST_2, ModificationType.WRITE, modifiedChild);
listenerReg.close();
}
assertNotNull(candidate);
candidateRoot = candidate.getRootNode();
checkChange(OUTER_LIST, listAfter, ModificationType.SUBTREE_MODIFIED, candidateRoot);
- final DataTreeCandidateNode entry1Canditate = candidateRoot.getModifiedChild(outerListEntryId1);
+ final DataTreeCandidateNode entry1Canditate = candidateRoot.getModifiedChild(outerListEntryId1).get();
checkChange(outerListEntry1, null, ModificationType.DELETE, entry1Canditate);
- final DataTreeCandidateNode entry2Canditate = candidateRoot.getModifiedChild(outerListEntryId2);
+ final DataTreeCandidateNode entry2Canditate = candidateRoot.getModifiedChild(outerListEntryId2).get();
checkChange(null, outerListEntry2, ModificationType.WRITE, entry2Canditate);
- final DataTreeCandidateNode entry3Canditate = candidateRoot.getModifiedChild(outerListEntryId3);
+ final DataTreeCandidateNode entry3Canditate = candidateRoot.getModifiedChild(outerListEntryId3).get();
checkChange(null, outerListEntry3, ModificationType.WRITE, entry3Canditate);
listenerReg.close();
}
package org.opendaylight.controller.md.sal.dom.store.impl;
import java.util.Collection;
-import java.util.Collections;
import java.util.Optional;
import java.util.concurrent.ExecutorService;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.sal.core.spi.data.AbstractDOMStoreTreeChangePublisher;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.util.concurrent.QueuedNotificationManager;
-import org.opendaylight.yangtools.util.concurrent.QueuedNotificationManager.Invoker;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.slf4j.LoggerFactory;
final class InMemoryDOMStoreTreeChangePublisher extends AbstractDOMStoreTreeChangePublisher {
- private static final Invoker<AbstractDOMDataTreeChangeListenerRegistration<?>, DataTreeCandidate> MANAGER_INVOKER =
- (listener, notification) -> {
- // FIXME: this is inefficient, as we could grab the entire queue for the listener and post it
- listener.getInstance().onDataTreeChanged(Collections.singletonList(notification));
- };
-
private static final Logger LOG = LoggerFactory.getLogger(InMemoryDOMStoreTreeChangePublisher.class);
+
private final QueuedNotificationManager<AbstractDOMDataTreeChangeListenerRegistration<?>, DataTreeCandidate>
notificationManager;
InMemoryDOMStoreTreeChangePublisher(final ExecutorService listenerExecutor, final int maxQueueSize) {
- notificationManager = new QueuedNotificationManager<>(listenerExecutor, MANAGER_INVOKER, maxQueueSize,
+ notificationManager = QueuedNotificationManager.create(listenerExecutor, (listener, notifications) -> {
+ // FIXME: we are not checking for listener being closed
+ listener.getInstance().onDataTreeChanged(notifications);
+ }, maxQueueSize,
"DataTreeChangeListenerQueueMgr");
}
- private InMemoryDOMStoreTreeChangePublisher(QueuedNotificationManager<
+ private InMemoryDOMStoreTreeChangePublisher(final QueuedNotificationManager<
AbstractDOMDataTreeChangeListenerRegistration<?>, DataTreeCandidate> notificationManager) {
this.notificationManager = notificationManager;
}
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.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
NAME_QNAME, topName));
}
- protected static DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> top() {
+ protected static DataContainerNodeBuilder<NodeIdentifier, ContainerNode> top() {
return Builders.containerBuilder().withNodeIdentifier(
new NodeIdentifier(Top.QNAME));
}