import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
throw new UnsupportedOperationException("Utilities class should not be instantiated");
}
- public static CollectionNodeBuilder<MapEntryNode, MapNode> mapNodeBuilder() {
+ public static @NonNull CollectionNodeBuilder<MapEntryNode, MapNode> mapNodeBuilder() {
return ImmutableMapNodeBuilder.create();
}
- public static CollectionNodeBuilder<MapEntryNode, MapNode> mapNodeBuilder(final QName name) {
+ public static @NonNull CollectionNodeBuilder<MapEntryNode, MapNode> mapNodeBuilder(final QName name) {
return mapNodeBuilder(NodeIdentifier.create(name));
}
- public static CollectionNodeBuilder<MapEntryNode, MapNode> mapNodeBuilder(final NodeIdentifier name) {
+ public static @NonNull CollectionNodeBuilder<MapEntryNode, MapNode> mapNodeBuilder(final NodeIdentifier name) {
return ImmutableMapNodeBuilder.create().withNodeIdentifier(name);
}
* @param name QName which will be used as node identifier
* @return An unordered Map node
*/
- public static MapNode mapNode(final QName name) {
+ public static @NonNull MapNode mapNode(final QName name) {
return mapNodeBuilder(name).build();
}
- private static CollectionNodeBuilder<MapEntryNode, OrderedMapNode> orderedMapNodeBuilder(final QName qname) {
+ private static @NonNull CollectionNodeBuilder<MapEntryNode, OrderedMapNode> orderedMapNodeBuilder(
+ final QName qname) {
return orderedMapNodeBuilder().withNodeIdentifier(NodeIdentifier.create(qname));
}
- private static CollectionNodeBuilder<MapEntryNode, OrderedMapNode> orderedMapNodeBuilder() {
+ private static @NonNull CollectionNodeBuilder<MapEntryNode, OrderedMapNode> orderedMapNodeBuilder() {
return ImmutableOrderedMapNodeBuilder.create();
}
* @param name QName which will be used as node identifier
* @return An ordered Map node
*/
- public static OrderedMapNode orderedMapNode(final QName name) {
+ public static @NonNull OrderedMapNode orderedMapNode(final QName name) {
return orderedMapNodeBuilder(name).build();
}
* @param <T> Type of leaf node value
* @return Leaf node with supplied identifier and value
*/
- public static <T> LeafNode<T> leafNode(final NodeIdentifier name, final T value) {
+ public static <T> @NonNull LeafNode<T> leafNode(final NodeIdentifier name, final T value) {
return ImmutableLeafNodeBuilder.<T>create()
.withNodeIdentifier(name)
.withValue(value)
* @param <T> Type of leaf node value
* @return Leaf node with supplied identifier and value
*/
- public static <T> LeafNode<T> leafNode(final QName name, final T value) {
+ public static <T> @NonNull LeafNode<T> leafNode(final QName name, final T value) {
return leafNode(NodeIdentifier.create(name), value);
}
- public static DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder(
+ public static @NonNull DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder(
final QName nodeName, final QName keyName, final Object keyValue) {
return ImmutableMapEntryNodeBuilder.create()
.withNodeIdentifier(new NodeIdentifierWithPredicates(nodeName, keyName, keyValue))
.withChild(leafNode(keyName, keyValue));
}
- public static DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder() {
+ public static @NonNull DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder() {
return ImmutableMapEntryNodeBuilder.create();
}
- public static MapEntryNode mapEntry(final QName nodeName,final QName keyName,final Object keyValue) {
+ public static @NonNull MapEntryNode mapEntry(final QName nodeName,final QName keyName,final Object keyValue) {
return mapEntryBuilder(nodeName, keyName, keyValue).build();
}
* @param name QName which will be used as node identifier
* @return A container node
*/
- public static ContainerNode containerNode(final QName name) {
+ public static @NonNull ContainerNode containerNode(final QName name) {
return ImmutableContainerNodeBuilder.create().withNodeIdentifier(NodeIdentifier.create(name)).build();
}
* @param name QName which will be used as node identifier
* @return A choice node
*/
- public static ChoiceNode choiceNode(final QName name) {
+ public static @NonNull ChoiceNode choiceNode(final QName name) {
return ImmutableChoiceNodeBuilder.create().withNodeIdentifier(NodeIdentifier.create(name)).build();
}
* @param name QName which will be used as node identifier
* @return An unkeyed list node
*/
- public static UnkeyedListNode listNode(final QName name) {
+ public static @NonNull UnkeyedListNode listNode(final QName name) {
return ImmutableUnkeyedListNodeBuilder.create().withNodeIdentifier(NodeIdentifier.create(name)).build();
}
* @param id instance identifier to convert to node structure starting from root
* @return serialized normalized node for provided instance Id
*/
- public static NormalizedNode<?, ?> fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id) {
+ public static @NonNull NormalizedNode<?, ?> fromInstanceId(final SchemaContext ctx,
+ final YangInstanceIdentifier id) {
return fromInstanceId(ctx, id, Optional.empty(), Optional.empty());
}
* instance identifier
* @return serialized normalized node for provided instance Id with overridden last child.
*/
- public static NormalizedNode<?, ?> fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id,
+ public static @NonNull NormalizedNode<?, ?> fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id,
final NormalizedNode<?, ?> deepestElement) {
return fromInstanceId(ctx, id, Optional.of(deepestElement), Optional.empty());
}
* @return serialized normalized node for provided instance Id with (optionally) overridden last child
* and (optionally) marked with specific operation attribute.
*/
- public static NormalizedNode<?, ?> fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id,
+ public static @NonNull NormalizedNode<?, ?> fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id,
final Optional<NormalizedNode<?, ?>> deepestElement, final Optional<Entry<QName, ModifyAction>> operation) {
final PathArgument topLevelElement;
final InstanceIdToNodes<?> instanceIdToNodes;
*/
package org.opendaylight.yangtools.yang.data.impl.schema;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Deque;
-import javax.annotation.Nonnull;
import javax.xml.transform.dom.DOMSource;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.odlext.model.api.YangModeledAnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
* @param builder Builder to which data will be written.
* @return {@link NormalizedNodeStreamWriter} which writes data
*/
- public static NormalizedNodeStreamWriter from(final NormalizedNodeContainerBuilder<?, ?, ?, ?> builder) {
+ public static @NonNull NormalizedNodeStreamWriter from(final NormalizedNodeContainerBuilder<?, ?, ?, ?> builder) {
return new ImmutableNormalizedNodeStreamWriter(builder);
}
@SuppressWarnings({"rawtypes","unchecked"})
public void endNode() {
final NormalizedNodeContainerBuilder finishedBuilder = builders.poll();
- Preconditions.checkState(finishedBuilder != null, "Node which should be closed does not exists.");
+ checkState(finishedBuilder != null, "Node which should be closed does not exists.");
final NormalizedNodeContainerBuilder current = getCurrent();
- Preconditions.checkState(current != null, "Reached top level node, which could not be closed in this writer.");
+ checkState(current != null, "Reached top level node, which could not be closed in this writer.");
final NormalizedNode<PathArgument, ?> product = finishedBuilder.build();
current.addChild(product);
nextSchema = null;
public void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint) {
checkDataNodeContainer();
- Preconditions.checkArgument(nextSchema instanceof YangModeledAnyXmlSchemaNode,
+ checkArgument(nextSchema instanceof YangModeledAnyXmlSchemaNode,
"Schema of this node should be instance of YangModeledAnyXmlSchemaNode");
final DataContainerNodeAttrBuilder<NodeIdentifier, YangModeledAnyXmlNode> builder =
UNKNOWN_SIZE == childSizeHint
@Override
public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) {
- Preconditions.checkArgument(getCurrent() instanceof NormalizedNodeResultBuilder
+ checkArgument(getCurrent() instanceof NormalizedNodeResultBuilder
|| getCurrent() instanceof ImmutableUnkeyedListNodeBuilder);
final DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> builder =
UNKNOWN_SIZE == childSizeHint ? ImmutableUnkeyedListEntryNodeBuilder.create()
@Override
public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint) {
if (!(getCurrent() instanceof NormalizedNodeResultBuilder)) {
- Preconditions.checkArgument(getCurrent() instanceof ImmutableMapNodeBuilder
+ checkArgument(getCurrent() instanceof ImmutableMapNodeBuilder
|| getCurrent() instanceof ImmutableOrderedMapNodeBuilder);
}
@Override
public void startAugmentationNode(final AugmentationIdentifier identifier) {
checkDataNodeContainer();
- Preconditions.checkArgument(!(getCurrent() instanceof ImmutableAugmentationNodeBuilder));
+ checkArgument(!(getCurrent() instanceof ImmutableAugmentationNodeBuilder));
enter(Builders.augmentationBuilder().withNodeIdentifier(identifier));
}
@SuppressWarnings("rawtypes")
final NormalizedNodeContainerBuilder current = getCurrent();
if (!(current instanceof NormalizedNodeResultBuilder)) {
- Preconditions.checkArgument(current instanceof DataContainerNodeBuilder<?, ?>, "Invalid nesting of data.");
+ checkArgument(current instanceof DataContainerNodeBuilder<?, ?>, "Invalid nesting of data.");
}
}
}
@Override
- public void nextDataSchemaNode(@Nonnull final DataSchemaNode schema) {
- nextSchema = Preconditions.checkNotNull(schema);
+ public void nextDataSchemaNode(final DataSchemaNode schema) {
+ nextSchema = requireNonNull(schema);
}
}
import java.util.Map.Entry;
import java.util.Optional;
import javax.xml.transform.dom.DOMSource;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
* @param operation Optional modify operation to be set on the last child
* @return NormalizedNode structure corresponding to submitted instance ID
*/
- abstract NormalizedNode<?, ?> create(PathArgument first, Iterator<PathArgument> others,
+ abstract
@NonNull NormalizedNode<?, ?> create(PathArgument first, Iterator<PathArgument> others,
Optional<NormalizedNode<?, ?>> deepestChild, Optional<Entry<QName, ModifyAction>> operation);
abstract boolean isMixin();
import java.util.Map;
import java.util.Optional;
import java.util.Set;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
return dataChildByName == null ? findSchemaForChild(schema, qname, schema.getChildNodes()) : dataChildByName;
}
- @Nullable
- public static DataSchemaNode findSchemaForChild(final DataNodeContainer schema, final QName qname,
+ public static @Nullable DataSchemaNode findSchemaForChild(final DataNodeContainer schema, final QName qname,
final boolean strictMode) {
if (strictMode) {
return findSchemaForChild(schema, qname);
* @throws IllegalArgumentException
* if the schema node does not allow children
*/
- @Nullable
- public static SchemaNode findDataChildSchemaByQName(final SchemaNode node, final QName qname) {
+ public static @Nullable SchemaNode findDataChildSchemaByQName(final SchemaNode node, final QName qname) {
if (node instanceof DataNodeContainer) {
SchemaNode child = ((DataNodeContainer) node).getDataChildByName(qname);
if (child == null && node instanceof SchemaContext) {
package org.opendaylight.yangtools.yang.data.impl.schema.builder.api;
import java.util.Collection;
+import org.eclipse.jdt.annotation.NonNull;
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.NormalizedNode;
@Override
CollectionNodeBuilder<V, R> withNodeIdentifier(NodeIdentifier nodeIdentifier);
- CollectionNodeBuilder<V, R> withChild(V child);
+ @NonNull CollectionNodeBuilder<V, R> withChild(V child);
- CollectionNodeBuilder<V, R> withoutChild(PathArgument key);
+ @NonNull CollectionNodeBuilder<V, R> withoutChild(PathArgument key);
}
package org.opendaylight.yangtools.yang.data.impl.schema.builder.api;
import java.util.Collection;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
@Override
DataContainerNodeBuilder<I, R> withNodeIdentifier(I nodeIdentifier);
- DataContainerNodeBuilder<I, R> withChild(DataContainerChild<?, ?> child);
+ @NonNull DataContainerNodeBuilder<I, R> withChild(DataContainerChild<?, ?> child);
- DataContainerNodeBuilder<I, R> withoutChild(PathArgument key);
+ @NonNull DataContainerNodeBuilder<I, R> withoutChild(PathArgument key);
}
\ No newline at end of file
import java.util.Collection;
import java.util.Map;
+import org.eclipse.jdt.annotation.NonNull;
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;
@Override
ListNodeBuilder<T, V> withoutChild(PathArgument key);
- ListNodeBuilder<T, V> withChildValue(T child);
+ @NonNull ListNodeBuilder<T, V> withChildValue(T child);
- ListNodeBuilder<T, LeafSetEntryNode<T>> withChildValue(T value, Map<QName, String> attributes);
+ @NonNull ListNodeBuilder<T, LeafSetEntryNode<T>> withChildValue(T value, Map<QName, String> attributes);
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.api;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public interface NormalizedNodeBuilder<I extends PathArgument, V, R extends NormalizedNode<I, ?>> {
+public interface NormalizedNodeBuilder<I extends PathArgument, V, R extends NormalizedNode<I, ?>> extends Builder<R> {
- NormalizedNodeBuilder<I, V, R> withValue(V value);
+ @NonNull NormalizedNodeBuilder<I, V, R> withValue(V value);
- NormalizedNodeBuilder<I, V, R> withNodeIdentifier(I nodeIdentifier);
+ @NonNull NormalizedNodeBuilder<I, V, R> withNodeIdentifier(I nodeIdentifier);
+ @Override
R build();
}
package org.opendaylight.yangtools.yang.data.impl.schema.builder.api;
import java.util.Collection;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
extends NormalizedNodeBuilder<K, Collection<CV>, P> {
@Override
- NormalizedNodeContainerBuilder<K,CK,CV,P> withNodeIdentifier(K nodeIdentifier);
+ NormalizedNodeContainerBuilder<K, CK, CV, P> withNodeIdentifier(K nodeIdentifier);
@Override
- NormalizedNodeContainerBuilder<K,CK,CV,P> withValue(Collection<CV> value);
+ NormalizedNodeContainerBuilder<K, CK, CV, P> withValue(Collection<CV> value);
- NormalizedNodeContainerBuilder<K,CK,CV,P> addChild(CV child);
+ @NonNull NormalizedNodeContainerBuilder<K, CK, CV, P> addChild(CV child);
- NormalizedNodeContainerBuilder<K,CK,CV,P> removeChild(CK key);
+ @NonNull NormalizedNodeContainerBuilder<K, CK, CV, P> removeChild(CK key);
}
import java.util.Map;
import javax.xml.transform.dom.DOMSource;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
public class ImmutableAnyXmlNodeBuilder
extends AbstractImmutableNormalizedNodeBuilder<NodeIdentifier, DOMSource, AnyXmlNode> {
- public static NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> create() {
+ public static @NonNull NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> create() {
return new ImmutableAnyXmlNodeBuilder();
}
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
import javax.xml.transform.dom.DOMSource;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
super.withNodeIdentifier(NodeIdentifier.create(schema.getQName()));
}
- public static NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> create(
+ public static @NonNull NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> create(
final AnyXmlSchemaNode schema) {
return new ImmutableAnyXmlNodeSchemaAwareBuilder(schema);
}
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
import java.util.Map;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
super(node);
}
- public static DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> create() {
+ public static
@NonNull DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> create() {
return new ImmutableAugmentationNodeBuilder();
}
- public static DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> create(final int sizeHint) {
+ public static @NonNull DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> create(
+ final int sizeHint) {
return new ImmutableAugmentationNodeBuilder(sizeHint);
}
- public static DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> create(
+ public static
@NonNull DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> create(
final AugmentationNode node) {
if (!(node instanceof ImmutableAugmentationNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
return super.withChild(validator.validateChild(child));
}
- public static DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> create(
+ public static
@NonNull DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> create(
final AugmentationSchemaNode schema) {
return new ImmutableAugmentationNodeSchemaAwareBuilder(schema);
}
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
import java.util.Map;
+import org.eclipse.jdt.annotation.NonNull;
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.ChoiceNode;
super(node);
}
- public static DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> create() {
+ public static @NonNull DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> create() {
return new ImmutableChoiceNodeBuilder();
}
- public static DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> create(final int sizeHint) {
+ public static @NonNull DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> create(final int sizeHint) {
return new ImmutableChoiceNodeBuilder(sizeHint);
}
- public static DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> create(final ChoiceNode node) {
+ public static @NonNull DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> create(final ChoiceNode node) {
if (!(node instanceof ImmutableChoiceNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
import static java.util.Objects.requireNonNull;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
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.DataContainerChild;
return super.build();
}
- public static DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> create(final ChoiceSchemaNode schema) {
+ public static @NonNull DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> create(final ChoiceSchemaNode schema) {
return new ImmutableChoiceNodeSchemaAwareBuilder(schema);
}
}
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
import java.util.Map;
+import org.eclipse.jdt.annotation.NonNull;
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;
super(node);
}
- public static DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> create() {
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> create() {
return new ImmutableContainerNodeBuilder();
}
- public static DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> create(final int sizeHint) {
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> create(final int sizeHint) {
return new ImmutableContainerNodeBuilder(sizeHint);
}
- public static DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> create(final ContainerNode node) {
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> create(
+ final ContainerNode node) {
if (!(node instanceof ImmutableContainerNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
+import org.eclipse.jdt.annotation.NonNull;
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.DataContainerChild;
super.withNodeIdentifier(NodeIdentifier.create(schema.getQName()));
}
- public static DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> create(final ContainerSchemaNode schema) {
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> create(
+ final ContainerSchemaNode schema) {
return new ImmutableContainerNodeSchemaAwareBuilder(schema);
}
- public static DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> create(final ContainerSchemaNode schema,
- final ContainerNode node) {
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> create(
+ final ContainerSchemaNode schema, final ContainerNode node) {
if (!(node instanceof ImmutableContainerNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
import java.util.Map;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
public class ImmutableLeafNodeBuilder<T>
extends AbstractImmutableNormalizedNodeBuilder<NodeIdentifier, T, LeafNode<T>> {
- public static <T> NormalizedNodeAttrBuilder<NodeIdentifier, T, LeafNode<T>> create() {
+ public static <T> @NonNull NormalizedNodeAttrBuilder<NodeIdentifier, T, LeafNode<T>> create() {
return new ImmutableLeafNodeBuilder<>();
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
public final class ImmutableLeafNodeSchemaAwareBuilder<T> extends ImmutableLeafNodeBuilder<T> {
-
private ImmutableLeafNodeSchemaAwareBuilder(final LeafSchemaNode schema) {
super.withNodeIdentifier(NodeIdentifier.create(schema.getQName()));
}
- public static <T> NormalizedNodeAttrBuilder<NodeIdentifier, T, LeafNode<T>> create(final LeafSchemaNode schema) {
+ public static <T> @NonNull NormalizedNodeAttrBuilder<NodeIdentifier, T, LeafNode<T>> create(
+ final LeafSchemaNode schema) {
return new ImmutableLeafNodeSchemaAwareBuilder<>(schema);
}
import java.util.Map;
import java.util.Objects;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
public class ImmutableLeafSetEntryNodeBuilder<T>
extends AbstractImmutableNormalizedNodeBuilder<NodeWithValue, T, LeafSetEntryNode<T>> {
- public static <T> ImmutableLeafSetEntryNodeBuilder<T> create() {
+ public static <T> @NonNull ImmutableLeafSetEntryNodeBuilder<T> create() {
return new ImmutableLeafSetEntryNodeBuilder<>();
}
import static java.util.Objects.requireNonNull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
this.schema = requireNonNull(schema);
}
- public static <T> NormalizedNodeAttrBuilder<NodeWithValue, T, LeafSetEntryNode<T>> create(
+ public static <T> @NonNull NormalizedNodeAttrBuilder<NodeWithValue, T, LeafSetEntryNode<T>> create(
final LeafListSchemaNode schema) {
return new ImmutableLeafSetEntryNodeSchemaAwareBuilder<>(schema);
}
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
-import org.opendaylight.yangtools.concepts.Immutable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.MapAdaptor;
import org.opendaylight.yangtools.util.UnmodifiableCollection;
import org.opendaylight.yangtools.yang.common.QName;
value = MapAdaptor.getDefaultInstance().takeSnapshot(node.children);
}
- public static <T> ListNodeBuilder<T, LeafSetEntryNode<T>> create() {
+ public static <T> @NonNull ListNodeBuilder<T, LeafSetEntryNode<T>> create() {
return new ImmutableLeafSetNodeBuilder<>();
}
- public static <T> ListNodeBuilder<T, LeafSetEntryNode<T>> create(final int sizeHint) {
+ public static <T> @NonNull ListNodeBuilder<T, LeafSetEntryNode<T>> create(final int sizeHint) {
return new ImmutableLeafSetNodeBuilder<>(sizeHint);
}
- public static <T> ListNodeBuilder<T, LeafSetEntryNode<T>> create(final LeafSetNode<T> node) {
+ public static <T> @NonNull ListNodeBuilder<T, LeafSetEntryNode<T>> create(final LeafSetNode<T> node) {
if (!(node instanceof ImmutableLeafSetNode<?>)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
return withChildValue(childValue, Collections.emptyMap());
}
- protected static final class ImmutableLeafSetNode<T> extends
- AbstractImmutableNormalizedValueNode<NodeIdentifier, Collection<LeafSetEntryNode<T>>> implements
- Immutable, LeafSetNode<T> {
+ protected static final class ImmutableLeafSetNode<T>
+ extends AbstractImmutableNormalizedValueNode<NodeIdentifier, Collection<LeafSetEntryNode<T>>>
+ implements LeafSetNode<T> {
private final Map<NodeWithValue, LeafSetEntryNode<T>> children;
import static java.util.Objects.requireNonNull;
import java.util.Collections;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
super.withNodeIdentifier(new NodeIdentifier(schema.getQName()));
}
- public static <T> ListNodeBuilder<T, LeafSetEntryNode<T>> create(final LeafListSchemaNode schema) {
+ public static <T> @NonNull ListNodeBuilder<T, LeafSetEntryNode<T>> create(final LeafListSchemaNode schema) {
return new ImmutableLeafSetNodeSchemaAwareBuilder<>(schema);
}
- public static <T> ListNodeBuilder<T, LeafSetEntryNode<T>> create(final LeafListSchemaNode schema,
+ public static <T> @NonNull ListNodeBuilder<T, LeafSetEntryNode<T>> create(final LeafListSchemaNode schema,
final LeafSetNode<T> node) {
if (!(node instanceof ImmutableLeafSetNode<?>)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
fillQnames(node.getValue(), childrenQNamesToPaths);
}
- public static DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> create() {
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> create() {
return new ImmutableMapEntryNodeBuilder();
}
- public static DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> create(final int sizeHint) {
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> create(
+ final int sizeHint) {
return new ImmutableMapEntryNodeBuilder(sizeHint);
}
- public static DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> create(
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> create(
final MapEntryNode node) {
if (!(node instanceof ImmutableMapEntryNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.ImmutableMapTemplate;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
return super.build();
}
- public static DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> create(
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> create(
final ListSchemaNode schema) {
return new ImmutableMapEntryNodeSchemaAwareBuilder(schema);
}
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
-import org.opendaylight.yangtools.concepts.Immutable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.MapAdaptor;
import org.opendaylight.yangtools.util.UnmodifiableCollection;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
this.value = MapAdaptor.getDefaultInstance().takeSnapshot(node.children);
}
- public static CollectionNodeBuilder<MapEntryNode, MapNode> create() {
+ public static @NonNull CollectionNodeBuilder<MapEntryNode, MapNode> create() {
return new ImmutableMapNodeBuilder();
}
- public static CollectionNodeBuilder<MapEntryNode, MapNode> create(final int sizeHint) {
+ public static @NonNull CollectionNodeBuilder<MapEntryNode, MapNode> create(final int sizeHint) {
return new ImmutableMapNodeBuilder(sizeHint);
}
}
protected static final class ImmutableMapNode
- extends AbstractImmutableNormalizedNode<NodeIdentifier, Collection<MapEntryNode>>
- implements Immutable, MapNode {
+ extends AbstractImmutableNormalizedNode<NodeIdentifier, Collection<MapEntryNode>> implements MapNode {
private final Map<NodeIdentifierWithPredicates, MapEntryNode> children;
import com.google.common.base.Preconditions;
import java.util.Collections;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
super.withNodeIdentifier(NodeIdentifier.create(schema.getQName()));
}
- public static CollectionNodeBuilder<MapEntryNode, MapNode> create(final ListSchemaNode schema) {
+ public static @NonNull CollectionNodeBuilder<MapEntryNode, MapNode> create(final ListSchemaNode schema) {
return new ImmutableMapNodeSchemaAwareBuilder(schema);
}
- public static CollectionNodeBuilder<MapEntryNode, MapNode> create(final ListSchemaNode schema, final MapNode node) {
+ public static @NonNull CollectionNodeBuilder<MapEntryNode, MapNode> create(final ListSchemaNode schema,
+ final MapNode node) {
if (!(node instanceof ImmutableMapNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Optional;
-import org.opendaylight.yangtools.concepts.Immutable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.UnmodifiableCollection;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
dirty = true;
}
- public static <T> ListNodeBuilder<T, LeafSetEntryNode<T>> create() {
+ public static <T> @NonNull ListNodeBuilder<T, LeafSetEntryNode<T>> create() {
return new ImmutableOrderedLeafSetNodeBuilder<>();
}
- public static <T> ListNodeBuilder<T, LeafSetEntryNode<T>> create(final LeafSetNode<T> node) {
+ public static <T> @NonNull ListNodeBuilder<T, LeafSetEntryNode<T>> create(final LeafSetNode<T> node) {
if (!(node instanceof ImmutableOrderedLeafSetNode<?>)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
return withChildValue(childValue, Collections.emptyMap());
}
- protected static final class ImmutableOrderedLeafSetNode<T> extends
- AbstractImmutableNormalizedNode<NodeIdentifier, Collection<LeafSetEntryNode<T>>> implements
- Immutable, OrderedLeafSetNode<T> {
+ protected static final class ImmutableOrderedLeafSetNode<T>
+ extends AbstractImmutableNormalizedNode<NodeIdentifier, Collection<LeafSetEntryNode<T>>>
+ implements OrderedLeafSetNode<T> {
private final Map<NodeWithValue, LeafSetEntryNode<T>> children;
import static java.util.Objects.requireNonNull;
import java.util.Collections;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
super.withNodeIdentifier(new NodeIdentifier(schema.getQName()));
}
- public static <T> ListNodeBuilder<T, LeafSetEntryNode<T>> create(final LeafListSchemaNode schema) {
+ public static <T> @NonNull ListNodeBuilder<T, LeafSetEntryNode<T>> create(final LeafListSchemaNode schema) {
return new ImmutableOrderedLeafSetNodeSchemaAwareBuilder<>(schema);
}
- public static <T> ListNodeBuilder<T, LeafSetEntryNode<T>> create(final LeafListSchemaNode schema,
+ public static <T> @NonNull ListNodeBuilder<T, LeafSetEntryNode<T>> create(final LeafListSchemaNode schema,
final LeafSetNode<T> node) {
if (!(node instanceof ImmutableOrderedLeafSetNode<?>)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Optional;
-import org.opendaylight.yangtools.concepts.Immutable;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.UnmodifiableCollection;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
this.dirty = true;
}
- public static CollectionNodeBuilder<MapEntryNode, OrderedMapNode> create() {
+ public static @NonNull CollectionNodeBuilder<MapEntryNode, OrderedMapNode> create() {
return new ImmutableOrderedMapNodeBuilder();
}
- public static CollectionNodeBuilder<MapEntryNode, OrderedMapNode> create(final int sizeHint) {
+ public static @NonNull CollectionNodeBuilder<MapEntryNode, OrderedMapNode> create(final int sizeHint) {
return new ImmutableOrderedMapNodeBuilder(sizeHint);
}
- public static CollectionNodeBuilder<MapEntryNode, OrderedMapNode> create(final MapNode node) {
+ public static @NonNull CollectionNodeBuilder<MapEntryNode, OrderedMapNode> create(final MapNode node) {
if (!(node instanceof ImmutableOrderedMapNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
protected static final class ImmutableOrderedMapNode
extends AbstractImmutableNormalizedNode<NodeIdentifier, Collection<MapEntryNode>>
- implements Immutable, OrderedMapNode {
+ implements OrderedMapNode {
private final Map<NodeIdentifierWithPredicates, MapEntryNode> children;
import com.google.common.base.Preconditions;
import java.util.Collections;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
super.withNodeIdentifier(NodeIdentifier.create(schema.getQName()));
}
- public static CollectionNodeBuilder<MapEntryNode, OrderedMapNode> create(final ListSchemaNode schema) {
+ public static @NonNull CollectionNodeBuilder<MapEntryNode, OrderedMapNode> create(final ListSchemaNode schema) {
return new ImmutableOrderedMapNodeSchemaAwareBuilder(schema);
}
- public static CollectionNodeBuilder<MapEntryNode, OrderedMapNode> create(final ListSchemaNode schema,
+ public static @NonNull CollectionNodeBuilder<MapEntryNode, OrderedMapNode> create(final ListSchemaNode schema,
final MapNode node) {
if (!(node instanceof ImmutableOrderedMapNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
import java.util.Map;
+import org.eclipse.jdt.annotation.NonNull;
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;
super(node);
}
- public static DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> create() {
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> create() {
return new ImmutableUnkeyedListEntryNodeBuilder();
}
- public static DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> create(final int sizeHint) {
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> create(
+ final int sizeHint) {
return new ImmutableUnkeyedListEntryNodeBuilder(sizeHint);
}
- public static DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> create(
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> create(
final UnkeyedListEntryNode node) {
if (!(node instanceof ImmutableUnkeyedListEntryNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
-import org.opendaylight.yangtools.concepts.Immutable;
+import org.eclipse.jdt.annotation.NonNull;
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.UnkeyedListEntryNode;
this.dirty = true;
}
- public static CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> create() {
+ public static @NonNull CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> create() {
return new ImmutableUnkeyedListNodeBuilder();
}
- public static CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> create(final int sizeHint) {
+ public static @NonNull CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> create(final int sizeHint) {
return new ImmutableUnkeyedListNodeBuilder();
}
- public static CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> create(final UnkeyedListNode node) {
+ public static @NonNull CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> create(
+ final UnkeyedListNode node) {
if (!(node instanceof ImmutableUnkeyedListNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
}
protected static final class EmptyImmutableUnkeyedListNode extends
- AbstractImmutableNormalizedNode<NodeIdentifier, Collection<UnkeyedListEntryNode>> implements Immutable,
- UnkeyedListNode {
+ AbstractImmutableNormalizedNode<NodeIdentifier, Collection<UnkeyedListEntryNode>>
+ implements UnkeyedListNode {
protected EmptyImmutableUnkeyedListNode(final NodeIdentifier nodeIdentifier) {
super(nodeIdentifier);
}
protected static final class ImmutableUnkeyedListNode extends
AbstractImmutableNormalizedValueNode<NodeIdentifier, Collection<UnkeyedListEntryNode>>
- implements Immutable, UnkeyedListNode {
+ implements UnkeyedListNode {
private final ImmutableList<UnkeyedListEntryNode> children;
import com.google.common.base.Preconditions;
import java.util.Map;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.odlext.model.api.YangModeledAnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
this.contentSchema = yangModeledAnyXMLSchemaNode.getSchemaOfAnyXmlData();
}
- public static DataContainerNodeAttrBuilder<NodeIdentifier, YangModeledAnyXmlNode> create(
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifier, YangModeledAnyXmlNode> create(
final YangModeledAnyXmlSchemaNode yangModeledAnyXMLSchemaNode) {
return new ImmutableYangModeledAnyXmlNodeBuilder(yangModeledAnyXMLSchemaNode);
}
- public static DataContainerNodeAttrBuilder<NodeIdentifier, YangModeledAnyXmlNode> create(
+ public static @NonNull DataContainerNodeAttrBuilder<NodeIdentifier, YangModeledAnyXmlNode> create(
final YangModeledAnyXmlSchemaNode yangModeledAnyXMLSchemaNode, final int sizeHint) {
return new ImmutableYangModeledAnyXmlNodeBuilder(yangModeledAnyXMLSchemaNode, sizeHint);
}
private static final class ImmutableYangModeledAnyXmlNode extends
AbstractImmutableDataContainerAttrNode<NodeIdentifier> implements YangModeledAnyXmlNode {
- private final ContainerSchemaNode contentSchema;
+ private final @NonNull ContainerSchemaNode contentSchema;
ImmutableYangModeledAnyXmlNode(final NodeIdentifier nodeIdentifier,
final Map<PathArgument, DataContainerChild<? extends PathArgument, ?>> value,
"Schema of yang modeled anyXml content cannot be null.");
}
- @Nonnull
@Override
public ContainerSchemaNode getSchemaOfAnyXmlData() {
return contentSchema;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.nodes;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
public abstract class AbstractImmutableNormalizedNode<K extends PathArgument,V> implements NormalizedNode<K, V>,
Immutable {
- private final K nodeIdentifier;
+ private final @NonNull K nodeIdentifier;
protected AbstractImmutableNormalizedNode(final K nodeIdentifier) {
- this.nodeIdentifier = Preconditions.checkNotNull(nodeIdentifier, "nodeIdentifier");
+ this.nodeIdentifier = requireNonNull(nodeIdentifier, "nodeIdentifier");
}
@Override
import static java.util.Objects.requireNonNull;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
public abstract class AbstractImmutableNormalizedValueNode<K extends PathArgument, V> extends
AbstractImmutableNormalizedNode<K, V> {
- @Nonnull
- private final V value;
+ private final @NonNull V value;
- protected AbstractImmutableNormalizedValueNode(final K nodeIdentifier, @Nonnull final V value) {
+ protected AbstractImmutableNormalizedValueNode(final K nodeIdentifier, final @NonNull V value) {
super(nodeIdentifier);
this.value = requireNonNull(value);
}
return wrapValue(value);
}
- @Nonnull
- protected final V value() {
+ protected final @NonNull V value() {
return value;
}
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
return Collections.unmodifiableSet(delegate.keySet());
}
- @Nonnull
@Override
public Collection<DataContainerChild<? extends PathArgument, ?>> values() {
if (values == null) {
import com.google.common.base.Preconditions;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
-import javax.annotation.Nonnull;
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.tree.DataTreeSnapshotCursor;
}
@Override
- public final void enter(@Nonnull final PathArgument... path) {
+ public final void enter(final PathArgument... path) {
enter(Arrays.asList(path));
}
import static com.google.common.base.Preconditions.checkState;
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateTip;
*
* @return Current tip root node, may not be null.
*/
- @Nonnull protected abstract TreeNode getTipRoot();
+ protected abstract @NonNull TreeNode getTipRoot();
- @NonNull abstract YangInstanceIdentifier getRootPath();
+ abstract @NonNull YangInstanceIdentifier getRootPath();
@Override
public final void validate(final DataTreeModification modification) throws DataValidationFailedException {
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
return verifyNotNull(mod.getModificationType(), "Node %s does not have resolved modification type", mod);
}
- private static Optional<NormalizedNode<?, ?>> optionalData(final TreeNode meta) {
+ private static @NonNull Optional<NormalizedNode<?, ?>> optionalData(final TreeNode meta) {
return meta == null ? Optional.empty() : Optional.of(meta.getData());
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final class DataTreeState {
private final LatestOperationHolder holder;
private final SchemaContext schemaContext;
- private final TreeNode root;
+ private final @NonNull TreeNode root;
private DataTreeState(final TreeNode root) {
- this.root = Preconditions.checkNotNull(root);
+ this.root = requireNonNull(root);
holder = new LatestOperationHolder();
schemaContext = null;
}
private DataTreeState(final TreeNode root, final LatestOperationHolder holder, final SchemaContext schemaContext) {
// It should be impossible to instantiate a new root without a SchemaContext
- this.schemaContext = Preconditions.checkNotNull(schemaContext);
- this.holder = Preconditions.checkNotNull(holder);
- this.root = Preconditions.checkNotNull(root);
+ this.schemaContext = requireNonNull(schemaContext);
+ this.holder = requireNonNull(holder);
+ this.root = requireNonNull(root);
}
static DataTreeState createInitial(final TreeNode root) {
return new DataTreeState(root);
}
- TreeNode getRoot() {
+ @NonNull TreeNode getRoot() {
return root;
}
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
}
@Override
- @Nonnull
protected TreeNode getTipRoot() {
return state.getRoot();
}
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import com.google.common.base.MoreObjects;
-import javax.annotation.Nonnull;
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.tree.DataTreeCandidateNode;
}
@Override
- @Nonnull
public PathArgument getIdentifier() {
throw new IllegalStateException("Attempted to get identifier of the root node");
}
}
@Override
- @Nonnull
protected TreeNode getTipRoot() {
return root.getNewMeta();
}
import java.util.Map.Entry;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
-import javax.annotation.Nonnull;
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;
}
@Override
- public void applyToCursor(@Nonnull final DataTreeModificationCursor cursor) {
+ public void applyToCursor(final DataTreeModificationCursor cursor) {
for (final ModifiedNode child : rootNode.getChildren()) {
applyNode(cursor, child);
}
}
@Override
- public DataTreeModificationCursor createCursor(@Nonnull final YangInstanceIdentifier path) {
+ public DataTreeModificationCursor createCursor(final YangInstanceIdentifier path) {
final OperationWithModification op = resolveModificationFor(path);
return openCursor(new InMemoryDataTreeModificationCursor(this, path, op));
}
import java.util.Deque;
import java.util.Iterator;
import java.util.Optional;
-import javax.annotation.Nonnull;
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;
}
@Override
- public void enter(@Nonnull final PathArgument child) {
+ public void enter(final PathArgument child) {
stack.push(resolveChildModification(child));
}
@Override
@SuppressWarnings("checkstyle:illegalCatch")
- public void enter(
@Nonnull final Iterable<PathArgument> path) {
+ public void enter(final Iterable<PathArgument> path) {
int depth = 0;
for (PathArgument child : path) {
try {
}
@Override
- public Optional<NormalizedNode<?, ?>> readNode(@Nonnull final PathArgument child) {
+ public Optional<NormalizedNode<?, ?>> readNode(final PathArgument child) {
return stack.peek().read(child, getParent().getVersion());
}
import static java.util.Objects.requireNonNull;
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
}
@Override
- public DataTreeSnapshotCursor createCursor(@Nonnull final YangInstanceIdentifier path) {
+ public DataTreeSnapshotCursor createCursor(final YangInstanceIdentifier path) {
final Optional<NormalizedNode<?, ?>> maybeRoot = NormalizedNodes.findNode(rootNode.getData(), path);
if (!maybeRoot.isPresent()) {
return null;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Optional;
-import javax.annotation.Nonnull;
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;
}
@Override
- public void enter(@Nonnull final PathArgument child) {
+ public void enter(final PathArgument child) {
final Optional<NormalizedNode<?, ?>> maybeChildNode = NormalizedNodes.getDirectChild(stack.peek(), child);
checkArgument(maybeChildNode.isPresent(), "Child %s not found", child);
@Override
@SuppressWarnings("checkstyle:illegalCatch")
- public void enter(
@Nonnull final Iterable<PathArgument> path) {
+ public void enter(final Iterable<PathArgument> path) {
final Optional<NormalizedNode<?, ?>> maybeChildNode = NormalizedNodes.findNode(stack.peek(), path);
checkArgument(maybeChildNode.isPresent(), "Child %s not found", path);
}
@Override
- public Optional<NormalizedNode<?, ?>> readNode(@Nonnull final PathArgument child) {
+ public Optional<NormalizedNode<?, ?>> readNode(final PathArgument child) {
return NormalizedNodes.findNode(stack.peek(), child);
}
}
import java.util.Map;
import java.util.Optional;
import java.util.function.Predicate;
-import javax.annotation.Nonnull;
import javax.annotation.concurrent.NotThreadSafe;
+import org.eclipse.jdt.annotation.NonNull;
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.NormalizedNodeContainer;
*
* @return Currently-written value
*/
- @Nonnull
- NormalizedNode<?, ?> getWrittenValue() {
+ @NonNull NormalizedNode<?, ?> getWrittenValue() {
return verifyNotNull(value);
}
return Optional.ofNullable(children.get(child));
}
- private Optional<TreeNode> metadataFromSnapshot(@Nonnull final PathArgument child) {
+ private Optional<TreeNode> metadataFromSnapshot(final @NonNull PathArgument child) {
return original.isPresent() ? original.get().getChild(child) : Optional.empty();
}
- private Optional<TreeNode> metadataFromData(@Nonnull final PathArgument child, final Version modVersion) {
+ private Optional<TreeNode> metadataFromData(final @NonNull PathArgument child, final Version modVersion) {
if (writtenOriginal == null) {
// Lazy instantiation, as we do not want do this for all writes. We are using the modification's version
// here, as that version is what the SchemaAwareApplyOperation will see when dealing with the resulting
* @param modVersion Version allocated by the calling {@link InMemoryDataTreeModification}
* @return Before-image tree node as observed by that child.
*/
- private Optional<TreeNode> findOriginalMetadata(@Nonnull final PathArgument child, final Version modVersion) {
+ private Optional<TreeNode> findOriginalMetadata(final @NonNull PathArgument child, final Version modVersion) {
switch (operation) {
case DELETE:
// DELETE implies non-presence
* @return {@link ModifiedNode} for specified child, with {@link #getOriginal()}
* containing child metadata if child was present in original data.
*/
- ModifiedNode modifyChild(@Nonnull final PathArgument child, @Nonnull final ModificationApplyOperation childOper,
- @Nonnull final Version modVersion) {
+ ModifiedNode modifyChild(final @NonNull PathArgument child, final @NonNull ModificationApplyOperation childOper,
+ final @NonNull Version modVersion) {
clearSnapshot();
if (operation == LogicalOperation.NONE) {
updateOperationType(LogicalOperation.TOUCH);
+ operation + ", childModification=" + children + "]";
}
- void resolveModificationType(@Nonnull final ModificationType type) {
+ void resolveModificationType(final @NonNull ModificationType type) {
modType = type;
}
import java.util.Collection;
import java.util.Collections;
import java.util.Optional;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
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;
final class NoopDataTreeCandidate extends AbstractDataTreeCandidate {
private static final DataTreeCandidateNode ROOT = new DataTreeCandidateNode() {
@Override
- @Nonnull
public ModificationType getModificationType() {
return ModificationType.UNMODIFIED;
}
- @Nonnull
@Override
public Collection<DataTreeCandidateNode> getChildNodes() {
return Collections.emptyList();
}
@Override
- @Nonnull
public PathArgument getIdentifier() {
throw new IllegalStateException("Attempted to read identifier of the no-operation change");
}
@Override
- @Nonnull
public Optional<NormalizedNode<?, ?>> getDataAfter() {
return Optional.empty();
}
@Override
- @Nonnull
public Optional<NormalizedNode<?, ?>> getDataBefore() {
return Optional.empty();
}
return null;
}
};
- private final TreeNode afterRoot;
+
+ private final @NonNull TreeNode afterRoot;
protected NoopDataTreeCandidate(final YangInstanceIdentifier rootPath, final ModifiedNode modificationRoot,
final TreeNode afterRoot) {
}
@Override
- @Nonnull
protected TreeNode getTipRoot() {
return afterRoot;
}
Code Review / yangtools.git / commitdiff