<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<plugin>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-maven-plugin</artifactId>
- <version>7.0.14</version>
+ <version>8.0.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
import com.google.common.annotations.Beta;
import java.io.Serializable;
-import java.math.BigDecimal;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Mutable;
import org.opendaylight.yangtools.yang.binding.BaseIdentity;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.TypeObject;
+import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
* @return A {@link ValueMatchBuilder}
* @throws NullPointerException if methodRef is null
*/
- @NonNull ComparableMatchBuilder<O, BigDecimal> leaf(Decimal64LeafReference<T> methodRef);
+ @NonNull ComparableMatchBuilder<O, Decimal64> leaf(Decimal64LeafReference<T> methodRef);
/**
* Match an {@code empty} leaf's value.
}
@FunctionalInterface
- public interface Decimal64LeafReference<P> extends LeafReference<P, BigDecimal> {
+ public interface Decimal64LeafReference<P> extends LeafReference<P, Decimal64> {
}
*/
package org.opendaylight.mdsal.binding.api.query;
-import java.math.BigDecimal;
import org.mockito.Mock;
import org.opendaylight.yang.gen.v1.mdsal.query.norev.Foo;
import org.opendaylight.yang.gen.v1.mdsal.query.norev.first.grp.System;
import org.opendaylight.yang.gen.v1.mdsal426.norev.BooleanCont;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns._default.value.test.norev.DecimalContainer;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.Uint64;
@SuppressWarnings("exports")
.querySubtree(InstanceIdentifier.create(DecimalContainer.class))
.matching()
.leaf(DecimalContainer::getDecimalLeaf5)
- .valueEquals(BigDecimal.ONE)
+ .valueEquals(Decimal64.valueOf("1.0"))
.build();
}
}
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.annotation</artifactId>
+ <artifactId>org.osgi.annotation.versioning</artifactId>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.core</artifactId>
+ <artifactId>org.osgi.framework</artifactId>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.cmpn</artifactId>
+ <artifactId>org.osgi.service.component</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.service.component.annotations</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.util.tracker</artifactId>
</dependency>
<dependency>
import org.opendaylight.yangtools.yang.binding.Action;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
+import org.opendaylight.yangtools.yang.common.ErrorTag;
+import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.common.YangConstants;
// Not representable: return an error
LOG.debug("Path {} is not representable in binding, rejecting invocation", path);
return Futures.immediateFuture(new SimpleDOMActionResult(List.of(RpcResultBuilder.newError(
- ErrorType.APPLICATION, "invalid-value", "Supplied path cannot be represented"))));
+ ErrorType.APPLICATION, ErrorTag.INVALID_VALUE, "Supplied path cannot be represented"))));
}
if (instance.isWildcarded()) {
// A wildcard path: return an error
LOG.debug("Path {} maps to a wildcard {}, rejecting invocation", path, instance);
return Futures.immediateFuture(new SimpleDOMActionResult(List.of(RpcResultBuilder.newError(
- ErrorType.APPLICATION, "invalid-value", "Supplied path does not identify a concrete instance"))));
+ ErrorType.APPLICATION, ErrorTag.INVALID_VALUE,
+ "Supplied path does not identify a concrete instance"))));
}
final ListenableFuture<RpcResult<?>> userFuture = implementation.invoke(instance,
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
/**
* Adapter wrapping Binding {@link DataTreeChangeListener} and exposing it as {@link DOMDataTreeChangeListener}
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.function.Function;
import java.util.function.Supplier;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
};
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private <T, F extends ListenableFuture<T>> F listenForFailure(final WriteTransaction tx, final F future) {
Futures.addCallback(future, new FutureCallback<T>() {
@Override
return future;
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void failTransactionChain(final WriteTransaction tx, final Throwable throwable) {
/*
* We asume correct state change for underlaying transaction
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
/**
* Defines structural mapping of Normalized Node to Binding data addressable by Instance Identifier. Not all binding
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.lang.reflect.Method;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
*/
abstract @Nullable InstanceIdentifier<?> extract(DataObject obj);
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private static @Nullable Method findGetValueMethod(final Class<?> type, final Class<?> returnType) {
try {
final Method method = type.getMethod(GET_VALUE_NAME);
import static com.google.common.base.Verify.verify;
import static java.util.Objects.requireNonNull;
-import static org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType.UNMODIFIED;
+import static org.opendaylight.yangtools.yang.data.tree.api.ModificationType.UNMODIFIED;
import com.google.common.base.MoreObjects;
import java.util.ArrayList;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
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.DataTreeCandidateNode;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
/**
* Lazily translated {@link DataTreeModification} based on {@link DataTreeCandidate}.
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.dom.api.DOMActionResult;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.yangtools.yang.common.ErrorSeverity;
import org.opendaylight.yangtools.yang.common.RpcError;
-import org.opendaylight.yangtools.yang.common.RpcError.ErrorSeverity;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import static java.util.Objects.requireNonNull;
-import java.math.BigDecimal;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.query.ComparableMatchBuilder;
import org.opendaylight.mdsal.binding.api.query.MatchBuilderPath;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.binding.TypeObject;
+import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
}
@Override
- public ComparableMatchBuilder<O, BigDecimal> leaf(final Decimal64LeafReference<T> methodRef) {
+ public ComparableMatchBuilder<O, Decimal64> leaf(final Decimal64LeafReference<T> methodRef) {
return comparableFor(methodRef);
}
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class BindingDOMDataTreeCommitCohortAdapterTest {
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
import com.google.common.util.concurrent.MoreExecutors;
import org.junit.Before;
public void onMountPointCreatedWithExceptionTest() throws Exception {
reset(listener);
bindingDOMMountPointListenerAdapter.onMountPointCreated(YangInstanceIdentifier.empty());
- verifyZeroInteractions(listener);
+ verifyNoInteractions(listener);
}
@Test
public void onMountPointRemovedWithExceptionTest() throws Exception {
reset(listener);
bindingDOMMountPointListenerAdapter.onMountPointRemoved(YangInstanceIdentifier.empty());
- verifyZeroInteractions(listener);
+ verifyNoInteractions(listener);
}
}
\ No newline at end of file
import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
public class BindingStructuralTypeTest {
@Test
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
public class LazyDataTreeModificationTest {
@Test
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.core</artifactId>
+ <artifactId>org.osgi.framework</artifactId>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.cmpn</artifactId>
+ <artifactId>org.osgi.service.component</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.service.component.annotations</artifactId>
</dependency>
<dependency>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.cmpn</artifactId>
+ <artifactId>org.osgi.service.component.annotations</artifactId>
</dependency>
<dependency>
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.binding.BindingObject;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
*/
abstract class AbstractBindingNormalizedNodeCache<T extends BindingObject, C extends NodeCodecContext>
extends CacheLoader<T, NormalizedNode> {
- private final LoadingCache<T, NormalizedNode> cache = CacheBuilder.newBuilder().weakValues().build(this);
-
+ private final LoadingCache<T, NormalizedNode> cache;
private final @NonNull C rootContext;
+ @SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "False positive")
AbstractBindingNormalizedNodeCache(final C rootContext) {
this.rootContext = requireNonNull(rootContext);
+ cache = CacheBuilder.newBuilder().weakValues().build(this);
}
/**
import com.google.common.collect.MultimapBuilder.SetMultimapBuilder;
import com.google.common.collect.Multimaps;
import com.google.common.collect.SetMultimap;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
.yangPathArgumentChild(arg);
}
- @SuppressWarnings("unchecked")
@Override
+ @SuppressWarnings("unchecked")
+ @SuppressFBWarnings(value = "NP_NONNULL_RETURN_VIOLATION", justification = "See FIXME below")
public D deserialize(final NormalizedNode data) {
checkArgument(data instanceof ChoiceNode);
final ChoiceNode casted = (ChoiceNode) data;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
-import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement;
abstract class KeyedListNodeCodecContext<I extends Identifier<D>, D extends DataObject & Identifiable<I>>
extends ListNodeCodecContext<D> {
final ListRuntimeType type = prototype.getType();
final IdentifiableItemCodec codec = prototype.getFactory().getPathArgumentCodec(bindingClass, type);
- return type.statement().findFirstEffectiveSubstatementArgument(OrderedByEffectiveStatement.class)
- .orElse(Ordering.SYSTEM) == Ordering.SYSTEM ? new Unordered<>(prototype, keyMethod, codec)
- : new Ordered<>(prototype, keyMethod, codec);
+ return type.statement().ordering() == Ordering.SYSTEM ? new Unordered<>(prototype, keyMethod, codec)
+ : new Ordered<>(prototype, keyMethod, codec);
}
@Override
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.UncheckedExecutionException;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
* @param qname input or output QName with namespace same as RPC
* @return input or output schema. Returns null if RPC does not have input/output specified.
*/
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private static @Nullable ContainerLike getRpcDataSchema(final @NonNull RpcDefinition rpc,
final @NonNull QName qname) {
requireNonNull(rpc, "Rpc Schema must not be null");
@Override
public Object serialize(final Object input) {
- if (input != null) {
- for (final UnionValueOptionContext valCtx : typeCodecs) {
- final Object domValue = valCtx.serialize(input);
- if (domValue != null) {
- return domValue;
- }
+ for (final UnionValueOptionContext valCtx : typeCodecs) {
+ final Object domValue = valCtx.serialize(input);
+ if (domValue != null) {
+ return domValue;
}
}
- return null;
+ throw new IllegalStateException("No codec matched value " + input);
}
}
NodeIdentifier.create(Foo.QNAME));
final var ex = assertThrows(IncorrectNestingException.class,
() -> codecContext.fromYangInstanceIdentifier(yiid));
- assertEquals("Argument (urn:odl:actions)foo is not valid child of list lst", ex.getMessage());
+ assertEquals("Argument (urn:odl:actions)foo is not valid child of "
+ + "EmptyListEffectiveStatement{argument=(urn:odl:actions)lst}", ex.getMessage());
}
}
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
return MoreObjects.toStringHelper(this).add("gen", gen).toString();
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private @NonNull Member addMember(final @NonNull Member member) {
if (members.isEmpty()) {
members = new ArrayList<>();
return member;
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private static @NonNull String packageString(final AbstractQName component) {
// Replace dashes with dots, as dashes are not allowed in package names
return component.getLocalName().replace('-', '.');
import org.opendaylight.mdsal.binding.runtime.api.LeafListRuntimeType;
import org.opendaylight.yangtools.yang.common.Ordering;
import org.opendaylight.yangtools.yang.model.api.stmt.LeafListEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement;
/**
* Generator corresponding to a {@code leaf-list} statement.
// List<Object>, we will try to narrow the return type in subclasses.
final Type type = super.methodReturnType(builderFactory);
final boolean isObject = Types.objectType().equals(type);
- final Ordering ordering = statement().findFirstEffectiveSubstatementArgument(OrderedByEffectiveStatement.class)
- .orElse(Ordering.SYSTEM);
- switch (ordering) {
- case SYSTEM:
- return isObject ? Types.setTypeWildcard() : Types.setTypeFor(type);
- case USER:
- return isObject ? Types.listTypeWildcard() : Types.listTypeFor(type);
- default:
- throw new IllegalStateException("Unexpected ordering " + ordering);
+
+ if (statement().ordering() == Ordering.SYSTEM) {
+ return isObject ? Types.setTypeWildcard() : Types.setTypeFor(type);
}
+ return isObject ? Types.listTypeWildcard() : Types.listTypeFor(type);
}
@Override
import org.opendaylight.yangtools.yang.common.Ordering;
import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
/**
Type methodReturnType(final TypeBuilderFactory builderFactory) {
final Type generatedType = super.methodReturnType(builderFactory);
// We are wrapping the generated type in either a List or a Map based on presence of the key
- if (keyGen != null) {
- final Ordering ordering = statement()
- .findFirstEffectiveSubstatementArgument(OrderedByEffectiveStatement.class)
- .orElse(Ordering.SYSTEM);
- if (ordering == Ordering.SYSTEM) {
- return Types.mapTypeFor(keyGen.getGeneratedType(builderFactory), generatedType);
- }
+ if (keyGen != null && statement().ordering() == Ordering.SYSTEM) {
+ return Types.mapTypeFor(keyGen.getGeneratedType(builderFactory), generatedType);
}
return Types.listTypeFor(generatedType);
for (var stmt : stmts) {
if (stmt instanceof SchemaTreeEffectiveStatement) {
final var qname = ((SchemaTreeEffectiveStatement<?>) stmt).getIdentifier();
- final Optional<? extends SchemaTreeEffectiveStatement<?>> child =
- target.get(SchemaTreeAwareEffectiveStatement.Namespace.class, qname);
- child.ifPresent(builder::add);
+ target.get(SchemaTreeNamespace.class, qname).ifPresent(builder::add);
} else {
builder.add(stmt);
}
}
@Override
- public <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends V> get(final Class<N> namespace,
- final K identifier) {
+ public <K, V, N extends IdentifierNamespace<K, V>> Optional<V> get(final Class<N> namespace, final K identifier) {
return Optional.empty();
}
}
@Override
- public Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+ public List<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
return substatements;
}
public AugmentEffectiveStatement asEffectiveStatement() {
return this;
}
-
- @Override
- @Deprecated(forRemoval = true)
- public Optional<AugmentationSchemaNode> getOriginalDefinition() {
- return schemaDelegate.getOriginalDefinition();
- }
}
list interface {
key "name";
- unique "type location";
leaf name {
type string;
list interface {
key "name";
- unique "type location";
leaf name {
type string;
list interface {
key "name";
- unique "type location";
+ unique "location";
description
"The list of interfaces on the device.";
}
}
}
-}
\ No newline at end of file
+}
<dependency>
<groupId>org.eclipse.xtend</groupId>
<artifactId>org.eclipse.xtend.lib</artifactId>
+ <version>2.26.0</version>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<plugin>
<groupId>org.eclipse.xtend</groupId>
<artifactId>xtend-maven-plugin</artifactId>
+ <version>2.26.0</version>
+ <executions>
+ <execution>
+ <goals>
+ <goal>compile</goal>
+ </goals>
+ <configuration>
+ <javaSourceVersion>${maven.compiler.release}</javaSourceVersion>
+ <outputDirectory>${project.build.directory}/generated-sources/xtend</outputDirectory>
+ </configuration>
+ </execution>
+ </executions>
</plugin>
</plugins>
</build>
addGenerator(b, new ShortRangeGenerator());
addGenerator(b, new IntegerRangeGenerator());
addGenerator(b, new LongRangeGenerator());
- addGenerator(b, new BigDecimalRangeGenerator());
+ addGenerator(b, new Decimal64RangeGenerator());
addGenerator(b, new Uint8RangeGenerator());
addGenerator(b, new Uint16RangeGenerator());
addGenerator(b, new Uint32RangeGenerator());
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * 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.mdsal.binding.java.api.generator;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-final class BigDecimalRangeGenerator extends AbstractBigRangeGenerator<BigDecimal> {
- BigDecimalRangeGenerator() {
- super(BigDecimal.class);
- }
-
- @Override
- protected String format(final BigDecimal value) {
- if (BigDecimal.ZERO.equals(value)) {
- return "java.math.BigDecimal.ZERO";
- }
- if (BigDecimal.ONE.equals(value)) {
- return "java.math.BigDecimal.ONE";
- }
- if (BigDecimal.TEN.equals(value)) {
- return "java.math.BigDecimal.TEN";
- }
-
- // FIXME: can we do something better?
- return "new java.math.BigDecimal(\"" + value + "\")";
- }
-
- @Override
- @Deprecated
- protected BigDecimal convert(final Number value) {
- if (value instanceof BigInteger) {
- return new BigDecimal((BigInteger)value);
- } else if (value instanceof Byte) {
- return new BigDecimal(value.intValue());
- } else if (value instanceof Short) {
- return new BigDecimal(value.intValue());
- } else if (value instanceof Integer) {
- return new BigDecimal(value.intValue());
- } else {
- return BigDecimal.valueOf(value.longValue());
- }
- }
-}
import static java.util.Objects.requireNonNull
import static org.opendaylight.mdsal.binding.model.ri.BaseYangTypes.BINARY_TYPE
import static org.opendaylight.mdsal.binding.model.ri.BaseYangTypes.BOOLEAN_TYPE
+import static org.opendaylight.mdsal.binding.model.ri.BaseYangTypes.DECIMAL64_TYPE
import static org.opendaylight.mdsal.binding.model.ri.BaseYangTypes.EMPTY_TYPE
import static org.opendaylight.mdsal.binding.model.ri.BaseYangTypes.INSTANCE_IDENTIFIER
import static org.opendaylight.mdsal.binding.model.ri.BaseYangTypes.INT16_TYPE
static val Comparator<GeneratedProperty> PROP_COMPARATOR = Comparator.comparing([prop | prop.name])
static val VALUEOF_TYPES = Set.of(
BOOLEAN_TYPE,
+ DECIMAL64_TYPE,
INT8_TYPE,
INT16_TYPE,
INT32_TYPE,
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * 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.mdsal.binding.java.api.generator;
+
+import org.opendaylight.yangtools.yang.common.Decimal64;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint8;
+
+final class Decimal64RangeGenerator extends AbstractBigRangeGenerator<Decimal64> {
+ Decimal64RangeGenerator() {
+ super(Decimal64.class);
+ }
+
+ @Override
+ protected String format(final Decimal64 value) {
+ return "org.opendaylight.yangtools.yang.common.Decimal64.valueOf(\"" + value + "\")";
+ }
+
+ @Override
+ @Deprecated
+ protected Decimal64 convert(final Number value) {
+ if (value instanceof Byte || value instanceof Short || value instanceof Integer
+ || value instanceof Uint8 || value instanceof Uint16) {
+ return Decimal64.valueOf(value.intValue());
+ } else {
+ return Decimal64.valueOf(value.longValue());
+ }
+ }
+}
import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.CodeHelpers;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.XMLNamespace;
+//import org.opendaylight.yangtools.yang.common.QName;
+//import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
if (node instanceof SchemaNode) {
final SchemaNode schema = (SchemaNode) node;
- sb.append("The schema path to identify an instance is\n");
- appendPath(sb.append("<i>"), def.getModule(), schema.getPath().getPathFromRoot());
- sb.append("</i>\n");
+// sb.append("The schema path to identify an instance is\n");
+// appendPath(sb.append("<i>"), def.getModule(), schema.getPath().getPathFromRoot());
+// sb.append("</i>\n");
if (hasBuilderClass(schema)) {
final String builderName = type.getName() + BindingMapping.BUILDER_SUFFIX;
}
}
- private static void appendPath(final StringBuilder sb, final ModuleEffectiveStatement module,
- final List<QName> path) {
- if (!path.isEmpty()) {
- // FIXME: this is module name, while when we switch, we end up using QName.toString() -- which is weird
- sb.append(module.argument().getLocalName());
- XMLNamespace currentNamespace = path.get(0).getNamespace();
-
- for (QName pathElement : path) {
- final XMLNamespace elementNamespace = pathElement.getNamespace();
- if (!elementNamespace.equals(currentNamespace)) {
- sb.append(pathElement);
- currentNamespace = elementNamespace;
- } else {
- sb.append(pathElement.getLocalName());
- }
- }
- }
- }
+// private static void appendPath(final StringBuilder sb, final ModuleEffectiveStatement module,
+// final List<QName> path) {
+// if (!path.isEmpty()) {
+// // FIXME: this is module name, while when we switch, we end up using QName.toString() -- which is weird
+// sb.append(module.argument().getLocalName());
+// XMLNamespace currentNamespace = path.get(0).getNamespace();
+//
+// for (QName pathElement : path) {
+// final XMLNamespace elementNamespace = pathElement.getNamespace();
+// if (!elementNamespace.equals(currentNamespace)) {
+// sb.append(pathElement);
+// currentNamespace = elementNamespace;
+// } else {
+// sb.append(pathElement.getLocalName());
+// }
+// }
+// }
+// }
private static boolean hasBuilderClass(final SchemaNode schemaNode) {
return schemaNode instanceof ContainerSchemaNode || schemaNode instanceof ListSchemaNode
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * 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.mdsal.binding.java.api.generator;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import org.junit.Test;
-
-public class BigDecimalRangeGeneratorTest {
-
- @Test
- @Deprecated
- public void convertTest() {
- BigDecimalRangeGenerator generator = new BigDecimalRangeGenerator();
- assertEquals(BigDecimal.valueOf(1L), generator.convert(1L));
- assertEquals(BigDecimal.valueOf(1), generator.convert(new BigInteger("1")));
- assertEquals(BigDecimal.valueOf(1), generator.convert(new Byte("1")));
- assertEquals(BigDecimal.valueOf(1), generator.convert(new Short("1")));
- assertEquals(BigDecimal.valueOf(1), generator.convert(new Integer("1")));
- assertNotNull(generator.format(BigDecimal.TEN));
- }
-}
\ No newline at end of file
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.WildcardType;
-import java.math.BigDecimal;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLClassLoader;
import org.opendaylight.mdsal.binding.model.ri.TypeConstants;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.annotations.RoutingContext;
+import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
CompilationTestUtils.assertContainsMethod(nodesClass, b.getClass(), "getIdBinary");
CompilationTestUtils.assertContainsMethod(nodesClass, pkg + ".Nodes$IdBits", "getIdBits", loader);
CompilationTestUtils.assertContainsMethod(nodesClass, Boolean.class, "getIdBoolean");
- CompilationTestUtils.assertContainsMethod(nodesClass, BigDecimal.class, "getIdDecimal64");
+ CompilationTestUtils.assertContainsMethod(nodesClass, Decimal64.class, "getIdDecimal64");
CompilationTestUtils.assertContainsMethod(nodesClass, Empty.class, "getIdEmpty");
CompilationTestUtils.assertContainsMethod(nodesClass, pkg + ".Nodes$IdEnumeration", "getIdEnumeration", loader);
testReturnTypeIdentityref(nodesClass, "getIdIdentityref", pkg + ".Alg");
CompilationTestUtils.assertContainsRestrictionCheck(builderObj, method, expectedMsg, arg);
method = CompilationTestUtils.assertContainsMethod(builderClass, builderClass, "setIdDecimal64",
- BigDecimal.class);
- final List<Range<BigDecimal>> rangeConstraints = new ArrayList<>();
- rangeConstraints.add(Range.closed(new BigDecimal("1.5"), new BigDecimal("5.5")));
- Object arg1 = new BigDecimal("1.4");
+ Decimal64.class);
+ final List<Range<Decimal64>> rangeConstraints = new ArrayList<>();
+ rangeConstraints.add(Range.closed(Decimal64.valueOf("1.5"), Decimal64.valueOf("5.5")));
+ Object arg1 = Decimal64.valueOf("1.4");
expectedMsg = String.format("Invalid range: %s, expected: %s.", arg1, rangeConstraints);
CompilationTestUtils.assertContainsRestrictionCheck(builderObj, method, expectedMsg, arg1);
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * 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.mdsal.binding.java.api.generator;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.math.BigInteger;
+import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.Decimal64;
+
+public class Decimal64RangeGeneratorTest {
+ @Test
+ @Deprecated
+ public void convertTest() {
+ Decimal64RangeGenerator generator = new Decimal64RangeGenerator();
+ Decimal64 one = Decimal64.valueOf(1);
+ assertEquals(one, generator.convert(1L));
+ assertEquals(one, generator.convert(new BigInteger("1")));
+ assertEquals(one, generator.convert(Byte.valueOf("1")));
+ assertEquals(one, generator.convert(Short.valueOf("1")));
+ assertEquals(one, generator.convert(Integer.valueOf("1")));
+ assertNotNull(generator.format(Decimal64.valueOf("10")));
+ }
+}
\ No newline at end of file
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
-import java.math.BigDecimal;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.Empty;
/**
* Test correct code generation.
- *
*/
public class TypedefCompilationTest extends BaseCompilationTest {
private static final String VAL = "_value";
// typedef my-decimal-type
assertFalse(myDecimalTypeClass.isInterface());
- CompilationTestUtils.assertContainsField(myDecimalTypeClass, VAL, BigDecimal.class);
+ CompilationTestUtils.assertContainsField(myDecimalTypeClass, VAL, Decimal64.class);
CompilationTestUtils.assertContainsFieldWithValue(myDecimalTypeClass, "serialVersionUID", Long.TYPE,
- 3143735729419861095L, BigDecimal.class);
+ 3143735729419861095L, Decimal64.class);
assertEquals(3, myDecimalTypeClass.getDeclaredFields().length);
- CompilationTestUtils.assertContainsMethod(myDecimalTypeClass, BigDecimal.class, "getValue");
- expectedConstructor = CompilationTestUtils.assertContainsConstructor(myDecimalTypeClass, BigDecimal.class);
+ CompilationTestUtils.assertContainsMethod(myDecimalTypeClass, Decimal64.class, "getValue");
+ expectedConstructor = CompilationTestUtils.assertContainsConstructor(myDecimalTypeClass, Decimal64.class);
CompilationTestUtils.assertContainsConstructor(myDecimalTypeClass, myDecimalTypeClass);
assertEquals(2, myDecimalTypeClass.getDeclaredConstructors().length);
- CompilationTestUtils.assertContainsMethod(myDecimalTypeClass, BigDecimal.class, GET_VAL);
+ CompilationTestUtils.assertContainsMethod(myDecimalTypeClass, Decimal64.class, GET_VAL);
CompilationTestUtils.assertContainsDefaultMethods(myDecimalTypeClass);
defInst = CompilationTestUtils.assertContainsMethod(myDecimalTypeClass, myDecimalTypeClass,
"getDefaultInstance", String.class);
assertEquals(7, myDecimalTypeClass.getDeclaredMethods().length);
- List<Range<BigDecimal>> decimalRangeConstraints = new ArrayList<>();
- decimalRangeConstraints.add(Range.closed(new BigDecimal("1.5"), new BigDecimal("5.5")));
- arg = new BigDecimal("1.4");
+ List<Range<Decimal64>> decimalRangeConstraints = new ArrayList<>();
+ decimalRangeConstraints.add(Range.closed(Decimal64.valueOf("1.5"), Decimal64.valueOf("5.5")));
+ arg = Decimal64.valueOf("1.4");
expectedMsg = String.format("Invalid range: %s, expected: %s.", arg, decimalRangeConstraints);
CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
- obj = expectedConstructor.newInstance(new BigDecimal("3.14"));
+ obj = expectedConstructor.newInstance(Decimal64.valueOf("3.14"));
assertEquals(obj, defInst.invoke(null, "3.14"));
// typedef my-decimal-type2
assertFalse(myDecimalType2Class.isInterface());
- CompilationTestUtils.assertContainsField(myDecimalType2Class, VAL, BigDecimal.class);
+ CompilationTestUtils.assertContainsField(myDecimalType2Class, VAL, Decimal64.class);
CompilationTestUtils.assertContainsFieldWithValue(myDecimalType2Class, "serialVersionUID", Long.TYPE,
- -672265764962082714L, BigDecimal.class);
+ -672265764962082714L, Decimal64.class);
assertEquals(3, myDecimalType2Class.getDeclaredFields().length);
- CompilationTestUtils.assertContainsMethod(myDecimalType2Class, BigDecimal.class, "getValue");
- expectedConstructor = CompilationTestUtils.assertContainsConstructor(myDecimalType2Class, BigDecimal.class);
+ CompilationTestUtils.assertContainsMethod(myDecimalType2Class, Decimal64.class, "getValue");
+ expectedConstructor = CompilationTestUtils.assertContainsConstructor(myDecimalType2Class, Decimal64.class);
CompilationTestUtils.assertContainsConstructor(myDecimalType2Class, myDecimalType2Class);
assertEquals(2, myDecimalType2Class.getDeclaredConstructors().length);
- CompilationTestUtils.assertContainsMethod(myDecimalType2Class, BigDecimal.class, GET_VAL);
+ CompilationTestUtils.assertContainsMethod(myDecimalType2Class, Decimal64.class, GET_VAL);
CompilationTestUtils.assertContainsDefaultMethods(myDecimalType2Class);
defInst = CompilationTestUtils.assertContainsMethod(myDecimalType2Class, myDecimalType2Class,
"getDefaultInstance", String.class);
assertEquals(7, myDecimalType2Class.getDeclaredMethods().length);
- List<Range<BigDecimal>> decimal2RangeConstraints = new ArrayList<>();
- decimal2RangeConstraints.add(Range.closed(new BigDecimal("0"), new BigDecimal("1")));
- arg = new BigDecimal("1.4");
+ List<Range<Decimal64>> decimal2RangeConstraints = new ArrayList<>();
+ decimal2RangeConstraints.add(Range.closed(Decimal64.valueOf("0.0"), Decimal64.valueOf("1.0")));
+ arg = Decimal64.valueOf("1.4");
expectedMsg = String.format("Invalid range: %s, expected: %s.", arg, decimal2RangeConstraints);
CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
- obj = expectedConstructor.newInstance(new BigDecimal("0.14"));
+ obj = expectedConstructor.newInstance(Decimal64.valueOf("0.14"));
assertEquals(obj, defInst.invoke(null, "0.14"));
// typedef union-ext1
list interface {
key "name";
- unique "type location";
+ unique "location";
description
"The list of interfaces on the device.";
}
}
}
-}
\ No newline at end of file
+}
*/
package org.opendaylight.mdsal.binding.model.ri;
-import java.math.BigDecimal;
import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
/**
* {@code Type} representation of {@code decimal64} YANG type.
*/
- public static final Type DECIMAL64_TYPE = Types.typeForClass(BigDecimal.class);
+ public static final Type DECIMAL64_TYPE = Types.typeForClass(Decimal64.class);
/**
* {@code Type} representation of {@code uint8} YANG type.
@Override
public AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
- if (packageName != null && name != null) {
- final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(JavaTypeName.create(packageName, name));
- if (!this.annotationBuilders.contains(builder)) {
- this.annotationBuilders = LazyCollections.lazyAdd(this.annotationBuilders, builder);
+ final var typeName = JavaTypeName.create(packageName, name);
+ for (var builder : annotationBuilders) {
+ if (typeName.equals(builder.getIdentifier())) {
return builder;
}
}
- return null;
+
+ final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(typeName);
+ annotationBuilders = LazyCollections.lazyAdd(annotationBuilders, builder);
+ return builder;
}
private boolean addParameter(final ParameterImpl param) {
@Override
public AnnotationType build() {
- return new AnnotationTypeImpl(getIdentifier(), this.annotationBuilders, this.parameters);
+ return new AnnotationTypeImpl(getIdentifier(), annotationBuilders, parameters);
}
@Override
for (final AnnotationTypeBuilder builder : annotationBuilders) {
a.add(builder.build());
}
- this.annotations = ImmutableList.copyOf(a);
+ annotations = ImmutableList.copyOf(a);
final List<String> p = new ArrayList<>();
for (final AnnotationType.Parameter parameter : parameters) {
p.add(parameter.getName());
}
- this.paramNames = ImmutableList.copyOf(p);
+ paramNames = ImmutableList.copyOf(p);
this.parameters = parameters.isEmpty() ? Collections.emptyList() : Collections.unmodifiableList(parameters);
}
@Override
public List<AnnotationType> getAnnotations() {
- return this.annotations;
+ return annotations;
}
@Override
public Parameter getParameter(final String paramName) {
if (paramName != null) {
- for (final AnnotationType.Parameter parameter : this.parameters) {
+ for (final AnnotationType.Parameter parameter : parameters) {
if (parameter.getName().equals(paramName)) {
return parameter;
}
@Override
public List<Parameter> getParameters() {
- return this.parameters;
+ return parameters;
}
@Override
public List<String> getParameterNames() {
- return this.paramNames;
+ return paramNames;
}
@Override
public boolean containsParameters() {
- return !this.parameters.isEmpty();
+ return !parameters.isEmpty();
}
@Override
ParameterImpl(final String name, final String value) {
this.name = name;
this.value = value;
- this.values = Collections.emptyList();
+ values = Collections.emptyList();
}
ParameterImpl(final String name, final List<String> values) {
this.name = name;
this.values = values;
- this.value = null;
+ value = null;
}
@Override
public String getName() {
- return this.name;
+ return name;
}
@Override
public String getValue() {
- return this.value;
+ return value;
}
@Override
public List<String> getValues() {
- return this.values;
+ return values;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
- result = prime * result + Objects.hashCode(this.name);
+ result = prime * result + Objects.hashCode(name);
return result;
}
return false;
}
final ParameterImpl other = (ParameterImpl) obj;
- return Objects.equals(this.name, other.name);
+ return Objects.equals(name, other.name);
}
@Override
public String toString() {
final StringBuilder builder = new StringBuilder();
builder.append("ParameterImpl [name=");
- builder.append(this.name);
+ builder.append(name);
builder.append(", value=");
- builder.append(this.value);
+ builder.append(value);
builder.append(", values=");
- builder.append(this.values);
+ builder.append(values);
builder.append("]");
return builder.toString();
}
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
AnnotationTypeBuilder annotationTypeBuilder = new AnnotationTypeBuilderImpl(
JavaTypeName.create("my.package", "MyName"));
- assertNull(annotationTypeBuilder.addAnnotation("my.package", null));
- assertNull(annotationTypeBuilder.addAnnotation(null, "MyName"));
+ assertThrows(NullPointerException.class, () -> annotationTypeBuilder.addAnnotation("my.package", null));
+ assertThrows(NullPointerException.class, () -> annotationTypeBuilder.addAnnotation(null, "MyName"));
assertNotNull(annotationTypeBuilder.addAnnotation("java.lang", "Deprecated"));
- assertNotNull(annotationTypeBuilder.addAnnotation("my.package2", "MyName2"));
- assertNull(annotationTypeBuilder.addAnnotation("my.package2", "MyName2"));
+ final var builder = annotationTypeBuilder.addAnnotation("my.package2", "MyName2");
+ assertNotNull(builder);
+ assertSame(builder, annotationTypeBuilder.addAnnotation("my.package2", "MyName2"));
AnnotationType annotationTypeInstance = annotationTypeBuilder.build();
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.core</artifactId>
+ <artifactId>org.osgi.framework</artifactId>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.cmpn</artifactId>
+ <artifactId>org.osgi.service.component</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.service.component.annotations</artifactId>
</dependency>
<dependency>
import com.google.common.collect.ImmutableList.Builder;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.MultimapBuilder;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
return next;
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private synchronized void unregister(final ImmutableList<RegisteredModuleInfo> regInfos) {
for (RegisteredModuleInfo regInfo : regInfos) {
if (!regInfo.decRef()) {
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicInteger;
this.commitAndThrowException = true;
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private FluentFuture<? extends CommitInfo> handleCommit(
final Supplier<FluentFuture<? extends CommitInfo>> commitMethod) {
if (howManyFailingCommits.decrementAndGet() == -1) {
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-reflect</artifactId>
+ <version>2.0.9</version>
+ <scope>test</scope>
</dependency>
</dependencies>
import com.google.common.base.VerifyException;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
return (Set<T>) set;
}
+ @SuppressFBWarnings(value = "DCN_NULLPOINTER_EXCEPTION",
+ justification = "Internal NPE->IAE conversion")
private static void checkCollectionField(final @NonNull Class<?> requiredClass,
final @NonNull String fieldName, final @Nullable Collection<?> collection) {
if (collection != null) {
import static java.util.Objects.requireNonNull;
import org.opendaylight.yangtools.concepts.HierarchicalIdentifier;
-import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
+import org.opendaylight.yangtools.yang.common.ErrorTag;
+import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
/**
public <P extends HierarchicalIdentifier<P>> DataValidationFailedException(final Class<P> pathType, final P path,
final String message, final Throwable cause) {
- super(message, cause, RpcResultBuilder.newError(ErrorType.APPLICATION, "invalid-value", message, null,
+ super(message, cause, RpcResultBuilder.newError(ErrorType.APPLICATION, ErrorTag.INVALID_VALUE, message, null,
path != null ? path.toString() : null, cause));
this.pathType = requireNonNull(pathType, "path type must not be null");
this.path = requireNonNull(path, "path must not be 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.mdsal.common.api;
-import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
+import org.opendaylight.yangtools.yang.common.ErrorTag;
+import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-
/**
-* Failure of asynchronous transaction commit caused by failure
-* of optimistic locking.
-* This exception is raised and returned when transaction commit
-* failed, because other transaction finished successfully
-* and modified same data as failed transaction.
-* Clients may recover from this error condition by
-* retrieving current state and submitting new updated
-* transaction.
-*
+* Failure of asynchronous transaction commit caused by failure of optimistic locking. This exception is raised and
+* returned when transaction commit failed, because other transaction finished successfully and modified same data as
+* failed transaction. Clients may recover from this error condition by retrieving current state and submitting a new
+* updated transaction.
*/
public class OptimisticLockFailedException extends TransactionCommitFailedException {
-
private static final long serialVersionUID = 1L;
public OptimisticLockFailedException(final String message, final Throwable cause) {
- super(message, cause, RpcResultBuilder.newError(ErrorType.APPLICATION, "resource-denied",
- message, null, null, cause));
+ super(message, cause,
+ RpcResultBuilder.newError(ErrorType.APPLICATION, ErrorTag.RESOURCE_DENIED, message, null, null, cause));
}
public OptimisticLockFailedException(final String message) {
this(message, null);
}
-
}
package org.opendaylight.mdsal.common.api;
import java.util.function.Supplier;
+import org.opendaylight.yangtools.yang.common.ErrorTag;
+import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcError;
-import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
/**
*/
public class TransactionCommitDeadlockException extends TransactionCommitFailedException {
private static final long serialVersionUID = 1L;
- private static final String DEADLOCK_MESSAGE =
- "An attempt to block on a ListenableFuture via a get method from a write "
- +
- "transaction submit was detected that would result in deadlock. The commit "
- +
- "result must be obtained asynchronously, e.g. via Futures#addCallback, to avoid deadlock.";
+ private static final String DEADLOCK_MESSAGE = "An attempt to block on a ListenableFuture via a get method from a "
+ + "write transaction submit was detected that would result in deadlock. The commit result must be obtained "
+ + "asynchronously, e.g. via Futures#addCallback, to avoid deadlock.";
private static final RpcError DEADLOCK_RPCERROR =
- RpcResultBuilder.newError(ErrorType.APPLICATION, "lock-denied", DEADLOCK_MESSAGE);
+ RpcResultBuilder.newError(ErrorType.APPLICATION, ErrorTag.LOCK_DENIED, DEADLOCK_MESSAGE);
public static final Supplier<Exception> DEADLOCK_EXCEPTION_SUPPLIER =
() -> new TransactionCommitDeadlockException(DEADLOCK_MESSAGE, DEADLOCK_RPCERROR);
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<link>https://commons.apache.org/proper/commons-lang/javadocs/api-3.10/</link>
<link>https://commons.apache.org/proper/commons-codec/apidocs/</link>
- <link>https://www.javadoc.io/doc/org.opendaylight.odlparent/odlparent-docs/9.0.13/</link>
- <link>https://www.javadoc.io/doc/org.opendaylight.yangtools/yangtools-docs/7.0.14/</link>
+ <link>https://www.javadoc.io/doc/org.opendaylight.odlparent/odlparent-docs/10.0.0/</link>
+ <link>https://www.javadoc.io/doc/org.opendaylight.yangtools/yangtools-docs/8.0.0-SNAPSHOT/</link>
</links>
<groups>
<group>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>7.0.14</version>
+ <version>8.0.0-SNAPSHOT</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-tree-api</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-api</artifactId>
requires transitive org.opendaylight.yangtools.yang.common;
requires transitive org.opendaylight.yangtools.yang.data.api;
+ requires transitive org.opendaylight.yangtools.yang.data.tree.api;
requires transitive org.opendaylight.yangtools.yang.model.api;
requires transitive org.opendaylight.yangtools.yang.repo.api;
requires transitive org.opendaylight.yangtools.yang.repo.spi;
*/
package org.opendaylight.mdsal.dom.api;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
/**
* An encapsulation of a data tree modification. This candidate is ready for atomic commit to the
import java.util.EventListener;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
/**
* Interface implemented by classes interested in receiving notifications about data tree changes. It provides
* A data change event may be triggered spuriously, e.g. such that data before and after compare as equal.
* Implementations of this interface are expected to recover from such events. Event producers are expected to exert
* reasonable effort to suppress such events. In other words, it is completely acceptable to observe
- * a {@link org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode}, which reports
- * a {@link org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType} other than UNMODIFIED, while
+ * a {@link org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode}, which reports
+ * a {@link org.opendaylight.yangtools.yang.data.tree.api.ModificationType} other than UNMODIFIED, while
* the before- and after- data items compare as equal.
*
* @param changes List of change events, may not be null or empty.
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.cmpn</artifactId>
+ <artifactId>org.osgi.service.component.annotations</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.service.metatype.annotations</artifactId>
</dependency>
<dependency>
* 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.mdsal.dom.broker;
import static java.util.Objects.requireNonNull;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
listener.onTransactionChainSuccessful(this);
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void transactionCompleted() {
if (COUNTER_UPDATER.decrementAndGet(this) == 0 && state == State.CLOSING) {
finishClose();
}
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void transactionFailed(final DOMDataTreeWriteTransaction tx, final Throwable cause) {
state = State.FAILED;
LOG.debug("Transaction chain {}Â failed.", this, cause);
import static java.util.Objects.requireNonNull;
import com.google.common.collect.MutableClassToInstanceMap;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
LOG.info("DOMMountPointService deactivated");
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
@SuppressWarnings("checkstyle:IllegalCatch")
private ObjectRegistration<DOMMountPoint> registerMountPoint(final SimpleDOMMountPoint mountPoint) {
final YangInstanceIdentifier mountPointId = mountPoint.getIdentifier();
};
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
@SuppressWarnings("checkstyle:IllegalCatch")
private void unregisterMountPoint(final YangInstanceIdentifier mountPointId) {
synchronized (mountPoints) {
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
return rpcProviderService;
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private synchronized void removeRpcImplementation(final DOMRpcImplementation implementation,
final Set<DOMRpcIdentifier> rpcs) {
final DOMRpcRoutingTable oldTable = routingTable;
listenerNotifier.execute(() -> notifyRemoved(newTable, implementation));
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private synchronized void removeRpcImplementations(final Map<DOMRpcIdentifier, DOMRpcImplementation> map) {
final DOMRpcRoutingTable oldTable = routingTable;
final DOMRpcRoutingTable newTable = (DOMRpcRoutingTable) oldTable.removeAll(map);
listenerNotifier.execute(() -> notifyRemoved(newTable, map.values()));
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private synchronized void removeActionImplementation(final DOMActionImplementation implementation,
final Set<DOMActionInstance> actions) {
final DOMActionRoutingTable oldTable = actionRoutingTable;
listenerNotifier.execute(() -> notifyActionChanged(newTable, implementation));
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private synchronized void removeListener(final ListenerRegistration<? extends DOMRpcAvailabilityListener> reg) {
listeners = ImmutableList.copyOf(Collections2.filter(listeners, input -> !reg.equals(input)));
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private synchronized void removeActionListener(final ListenerRegistration<? extends AvailabilityListener> reg) {
actionListeners = ImmutableList.copyOf(Collections2.filter(actionListeners, input -> !reg.equals(input)));
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private synchronized void notifyAdded(final DOMRpcRoutingTable newTable, final DOMRpcImplementation impl) {
for (Registration<?> l : listeners) {
l.addRpc(newTable, impl);
}
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private synchronized void notifyAdded(final DOMRpcRoutingTable newTable,
final Collection<? extends DOMRpcImplementation> impls) {
for (Registration<?> l : listeners) {
}
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private synchronized void notifyRemoved(final DOMRpcRoutingTable newTable, final DOMRpcImplementation impl) {
for (Registration<?> l : listeners) {
l.removeRpc(newTable, impl);
}
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private synchronized void notifyRemoved(final DOMRpcRoutingTable newTable,
final Collection<? extends DOMRpcImplementation> impls) {
for (Registration<?> l : listeners) {
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
public class DOMDataTreeChangeListenerTest extends AbstractDatastoreTest {
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-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.ModificationType;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
+import org.opendaylight.yangtools.yang.data.tree.api.ModificationType;
public class DOMDataTreeListenerTest extends AbstractDatastoreTest {
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-tree-ri</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-api</artifactId>
import com.google.common.util.concurrent.ListenableFuture;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
final class ChainedTransactionCommitImpl extends InMemoryDOMStoreThreePhaseCommitCohort {
private final DOMStoreTransactionChainImpl txChain;
txChain.transactionCommited(getTransaction());
return ret;
}
-
}
\ No newline at end of file
import org.opendaylight.mdsal.dom.spi.store.AbstractSnapshotBackedTransactionChain;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
final class DOMStoreTransactionChainImpl extends AbstractSnapshotBackedTransactionChain<String> {
private final InMemoryDOMDataStore store;
import org.opendaylight.yangtools.util.ExecutorServiceUtil;
import org.opendaylight.yangtools.util.concurrent.EqualityQueuedNotificationManager;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-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.DataTreeConfiguration;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
-import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTree;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeConfiguration;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataValidationFailedException;
+import org.opendaylight.yangtools.yang.data.tree.impl.di.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
import org.slf4j.Logger;
import org.opendaylight.mdsal.dom.spi.store.AbstractDOMStoreTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.ConflictingModificationAppliedException;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
-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.tree.api.ConflictingModificationAppliedException;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataValidationFailedException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidates;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.spi.DataTreeCandidates;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedTransactions;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction.TransactionReadyPrototype;
-import org.opendaylight.yangtools.yang.common.RpcError.ErrorSeverity;
-import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
+import org.opendaylight.yangtools.yang.common.ErrorSeverity;
+import org.opendaylight.yangtools.yang.common.ErrorTag;
+import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.ConflictingModificationAppliedException;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
+import org.opendaylight.yangtools.yang.data.tree.api.ConflictingModificationAppliedException;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataValidationFailedException;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class InMemoryDOMStoreThreePhaseCommitCohortTest {
final var error = errors.get(0);
assertEquals(ErrorSeverity.ERROR, error.getSeverity());
assertEquals(ErrorType.APPLICATION, error.getErrorType());
- assertEquals("resource-denied", error.getTag());
+ assertEquals(ErrorTag.RESOURCE_DENIED, error.getTag());
}
@Test
final var error = errors.get(0);
assertEquals(ErrorSeverity.ERROR, error.getSeverity());
assertEquals(ErrorType.APPLICATION, error.getErrorType());
- assertEquals("operation-failed", error.getTag());
+ assertEquals(ErrorTag.OPERATION_FAILED, error.getTag());
}
@Test
final var future = cohort.canCommit();
return assertThrows(ExecutionException.class, future::get).getCause();
}
-}
\ No newline at end of file
+}
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.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
public class InMemoryDataStoreTest {
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.annotation</artifactId>
+ <artifactId>org.osgi.annotation.versioning</artifactId>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.core</artifactId>
+ <artifactId>org.osgi.framework</artifactId>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.cmpn</artifactId>
+ <artifactId>org.osgi.service.component</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.service.component.annotations</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.util.tracker</artifactId>
</dependency>
<dependency>
<groupId>org.apache.karaf.features</groupId>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>odlext-model-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-tree-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-tree-spi</artifactId>
+ </dependency>
<!-- Test Dependencies -->
<dependency>
exports org.opendaylight.mdsal.dom.spi.store;
requires transitive org.opendaylight.mdsal.dom.api;
+ requires transitive org.opendaylight.yangtools.yang.data.tree.api;
requires transitive org.opendaylight.yangtools.yang.model.api;
requires transitive org.opendaylight.yangtools.yang.repo.api;
requires transitive org.opendaylight.yangtools.yang.repo.spi;
requires org.opendaylight.yangtools.odlext.model.api;
requires org.opendaylight.yangtools.util;
requires org.opendaylight.yangtools.yang.data.api;
+ requires org.opendaylight.yangtools.yang.data.tree.spi;
requires org.slf4j;
// Annotations
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.dom.api.DOMActionResult;
import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.yang.common.ErrorTag;
+import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcError;
-import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
}
public SimpleDOMActionResult(final ContainerNode output) {
- this.errors = ImmutableList.of();
+ errors = ImmutableList.of();
this.output = requireNonNull(output);
}
// As per RFC7950 page 80 (top)
public static SimpleDOMActionResult ofMalformedMessage(final Exception cause) {
- return new SimpleDOMActionResult(ImmutableList.of(RpcResultBuilder.newError(ErrorType.RPC, "malformed-message",
- cause.getMessage(), null, null, requireNonNull(cause))), null);
+ return new SimpleDOMActionResult(ImmutableList.of(RpcResultBuilder.newError(ErrorType.RPC,
+ ErrorTag.MALFORMED_MESSAGE, cause.getMessage(), null, null, requireNonNull(cause))), null);
}
@Override
import org.opendaylight.mdsal.dom.spi.RegistrationTreeNode;
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.DataTreeCandidate;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidates;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
+import org.opendaylight.yangtools.yang.data.tree.api.ModificationType;
+import org.opendaylight.yangtools.yang.data.tree.spi.DataTreeCandidates;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedReadTransaction.TransactionClosePrototype;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction.TransactionReadyPrototype;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
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.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
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.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.annotations.Beta;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
/**
* Interface implemented by {@link DOMStoreTransaction}s which are backed by a {@link DataTreeSnapshot}.
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedReadTransaction.TransactionClosePrototype;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction.TransactionReadyPrototype;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
/**
* Public utility class for instantiating snapshot-backed transactions.
import org.eclipse.jdt.annotation.Nullable;
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.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.mdsal.dom.spi.AbstractDOMDataTreeChangeListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-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.ModificationType;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
+import org.opendaylight.yangtools.yang.data.tree.api.ModificationType;
public class AbstractDOMStoreTreeChangePublisherTest extends AbstractDOMStoreTreeChangePublisher {
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class AbstractSnapshotBackedTransactionChainTest {
import org.opendaylight.mdsal.common.api.ReadFailedException;
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.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
@SuppressWarnings("checkstyle:IllegalCatch")
public class SnapshotBackedReadTransactionTest {
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction.TransactionReadyPrototype;
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.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
public class SnapshotBackedReadWriteTransactionTest {
import org.junit.Test;
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction.TransactionReadyPrototype;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
public class SnapshotBackedTransactionsTest {
@Test
import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction.TransactionReadyPrototype;
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.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
public class SnapshotBackedWriteTransactionTest {
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.cmpn</artifactId>
+ <artifactId>org.osgi.service.component.annotations</artifactId>
</dependency>
<dependency>
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Multimap;
import com.google.common.collect.Table;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Optional;
import java.util.UUID;
}
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void removeEntity(final DOMEntity entity) {
synchronized (entities) {
entities.remove(entity.getType(), entity.getIdentifier());
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>7.0.14</version>
+ <version>8.0.0-SNAPSHOT</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-binding-api">
<feature name="odl-mdsal-binding-api">
- <feature version="[7,8)">odl-yangtools-data-api</feature>
+ <feature version="[8,9)">odl-yangtools-data-api</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-binding-base">
<feature name="odl-mdsal-binding-base">
- <feature version="[7,8)">odl-yangtools-common</feature>
+ <feature version="[8,9)">odl-yangtools-common</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-runtime-api">
<feature name="odl-mdsal-binding-runtime-api">
- <feature version="[7,8)">odl-yangtools-data</feature>
- <feature version="[7,8)">odl-yangtools-parser</feature>
+ <feature version="[8,9)">odl-yangtools-data</feature>
+ <feature version="[8,9)">odl-yangtools-parser</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-common">
<feature name="odl-mdsal-common">
- <feature version="[7,8)">odl-yangtools-common</feature>
+ <feature version="[8,9)">odl-yangtools-common</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-dom-api">
<feature name="odl-mdsal-dom-api">
- <feature version="[7,8)">odl-yangtools-data-api</feature>
+ <feature version="[8,9)">odl-yangtools-data-api</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-eos-common">
<feature name="odl-mdsal-eos-common">
- <feature version="[7,8)">odl-yangtools-data-api</feature>
+ <feature version="[8,9)">odl-yangtools-data-api</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-exp-yanglib-api">
<feature name="odl-mdsal-exp-yanglib-api">
- <feature version="[7,8)">odl-yangtools-data-api</feature>
+ <feature version="[8,9)">odl-yangtools-data-api</feature>
</feature>
</features>
<feature name="odl-mdsal-replicate-netty" version="${project.version}">
<configfile finalname="etc/org.opendaylight.mdsal.replicate.netty.sink.cfg">mvn:org.opendaylight.mdsal/mdsal-replicate-netty/${project.version}/config/sink</configfile>
<configfile finalname="etc/org.opendaylight.mdsal.replicate.netty.source.cfg">mvn:org.opendaylight.mdsal/mdsal-replicate-netty/${project.version}/config/source</configfile>
- <feature version="[9,10)">odl-netty-4</feature>
- <feature version="[7,8)">odl-yangtools-codec</feature>
+ <feature version="[10,11)">odl-netty-4</feature>
+ <feature version="[8,9)">odl-yangtools-codec</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-mdsal-uint24-netty">
<feature name="odl-mdsal-uint24-netty">
- <feature version="[7,8)">odl-yangtools-netty</feature>
+ <feature version="[8,9)">odl-yangtools-netty</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteOperations;
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.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModificationCursor;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModificationCursor;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
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.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModificationCursor;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModificationCursor;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteOperations;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidates;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
+import org.opendaylight.yangtools.yang.data.tree.spi.DataTreeCandidates;
@Beta
public final class DataTreeCandidateUtils {
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.cmpn</artifactId>
+ <artifactId>org.osgi.service.component.annotations</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.service.metatype.annotations</artifactId>
</dependency>
<dependency>
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.List;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.codec.binfmt.DataTreeCandidateInputOutput;
import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataOutput;
import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeStreamVersion;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
abstract class AbstractSourceMessage {
private static final class Empty extends AbstractSourceMessage {
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.ReusableStreamReceiver;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.codec.binfmt.DataTreeCandidateInputOutput;
import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataInput;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.ReusableImmutableNormalizedNodeStreamWriter;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataInput;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
}
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void serviceTransitionCompleted() {
markDirty();
if (tryLock()) {
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
*
* @author Michael Vorburger.ch
*/
-class CloseTrackedTrait<T extends CloseTracked<T>> implements CloseTracked<T> {
+final class CloseTrackedTrait<T extends CloseTracked<T>> implements CloseTracked<T> {
// NB: It's important that we keep a Throwable here, and not directly the StackTraceElement[] !
// This is because creating a new Throwable() is a lot less expensive in terms of runtime overhead
private final CloseTrackedRegistry<T> closeTrackedRegistry;
private final CloseTracked<T> realCloseTracked;
- CloseTrackedTrait(CloseTrackedRegistry<T> transactionChainRegistry, CloseTracked<T> realCloseTracked) {
+ CloseTrackedTrait(final CloseTrackedRegistry<T> transactionChainRegistry, final CloseTracked<T> realCloseTracked) {
if (transactionChainRegistry.isDebugContextEnabled()) {
// NB: We're NOT doing the (expensive) getStackTrace() here just yet (only below)
// TODO When we're on Java 9, then instead use the new java.lang.StackWalker API..
writeWatches.add(watch);
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private boolean isRegistrationWatched(final YangInstanceIdentifier iid, final LogicalDatastoreType store) {
if (registrationWatches.isEmpty()) {
return true;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.cmpn</artifactId>
+ <artifactId>org.osgi.service.component.annotations</artifactId>
</dependency>
<dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
Code Review / mdsal.git / commitdiff