default <P extends DataObject, A extends Action<? extends InstanceIdentifier<P>, ?, ?>> A getActionHandle(
final ActionSpec<A, P> spec, final LogicalDatastoreType dataStore, final InstanceIdentifier<P> path) {
- return getActionHandle(spec, ImmutableSet.of(DataTreeIdentifier.create(dataStore, path)));
+ return getActionHandle(spec, ImmutableSet.of(DataTreeIdentifier.of(dataStore, path)));
}
default <P extends DataObject, A extends Action<? extends InstanceIdentifier<P>, ?, ?>> A getActionHandle(
@Override
public void writeExternal(final ObjectOutput out) throws IOException {
- id.getDatastoreType().writeTo(out);
- out.writeObject(id.getRootIdentifier());
+ id.datastore().writeTo(out);
+ out.writeObject(id.path());
}
@Override
public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- id = DataTreeIdentifier.create(LogicalDatastoreType.readFrom(in), (InstanceIdentifier<?>) in.readObject());
+ id = DataTreeIdentifier.of(LogicalDatastoreType.readFrom(in), (InstanceIdentifier<?>) in.readObject());
}
@java.io.Serial
private static <T extends DataObject> @NonNull DataTreeIdentifier<T> checkNotWildcard(
final DataTreeIdentifier<T> treeId) {
- final var instanceIdentifier = treeId.getRootIdentifier();
+ final var instanceIdentifier = treeId.path();
if (instanceIdentifier.isWildcarded()) {
throw new IllegalArgumentException("Cannot register listener for wildcard " + instanceIdentifier);
}
import com.google.common.base.MoreObjects;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.common.api.LogicalDatastorePath;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.yangtools.concepts.HierarchicalIdentifier;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
- * A unique identifier for a particular subtree. It is composed of the logical
- * data store type and the instance identifier of the root node.
+ * A Binding version of {@link LogicalDatastorePath}. Uses {@link InstanceIdentifier} for path addressing.
*/
-public final class DataTreeIdentifier<T extends DataObject> implements HierarchicalIdentifier<DataTreeIdentifier<?>> {
+public final class DataTreeIdentifier<T extends DataObject>
+ implements LogicalDatastorePath<@NonNull DataTreeIdentifier<?>, @NonNull InstanceIdentifier<?>> {
@java.io.Serial
private static final long serialVersionUID = 1L;
private final @NonNull InstanceIdentifier<T> rootIdentifier;
private final @NonNull LogicalDatastoreType datastoreType;
- private DataTreeIdentifier(final @NonNull LogicalDatastoreType datastoreType,
- final @NonNull InstanceIdentifier<T> rootIdentifier) {
- this.datastoreType = requireNonNull(datastoreType);
- this.rootIdentifier = requireNonNull(rootIdentifier);
+ private DataTreeIdentifier(final @NonNull LogicalDatastoreType datastore,
+ final @NonNull InstanceIdentifier<T> path) {
+ datastoreType = requireNonNull(datastore);
+ rootIdentifier = requireNonNull(path);
}
+ /**
+ * Create a new {@link DataTreeIdentifier} with specified datastore and path.
+ *
+ * @param <T> target {@link DataObject} type
+ * @param datastore {@link LogicalDatastoreType} of this identifier
+ * @param path {@link InstanceIdentifier} path of this identifier
+ * @throws NullPointerException if any argument is {@code null}
+ */
+ public static <T extends DataObject> @NonNull DataTreeIdentifier<T> of(
+ final @NonNull LogicalDatastoreType datastore, final @NonNull InstanceIdentifier<T> path) {
+ return new DataTreeIdentifier<>(datastore, path);
+ }
+
+ /**
+ * Create a new {@link DataTreeIdentifier} with specified datastore and path.
+ *
+ * @param <T> target {@link DataObject} type
+ * @param datastore {@link LogicalDatastoreType} of this identifier
+ * @param path {@link InstanceIdentifier} path of this identifier
+ * @throws NullPointerException if any argument is {@code null}
+ * @deprecated Use {@link #of(LogicalDatastoreType, InstanceIdentifier)} instead
+ */
+ @Deprecated(since = "13.0.0", forRemoval = true)
public static <T extends DataObject> @NonNull DataTreeIdentifier<T> create(
- final @NonNull LogicalDatastoreType datastoreType, final @NonNull InstanceIdentifier<T> rootIdentifier) {
- return new DataTreeIdentifier<>(datastoreType, rootIdentifier);
+ final @NonNull LogicalDatastoreType datastore, final @NonNull InstanceIdentifier<T> path) {
+ return of(datastore, path);
+ }
+
+ @Override
+ public LogicalDatastoreType datastore() {
+ return datastoreType;
}
/**
* Return the logical data store type.
*
* @return Logical data store type. Guaranteed to be non-null.
+ * @deprecated Use {@link #datastore()} instead
*/
+ @Deprecated(since = "13.0.0", forRemoval = true)
public @NonNull LogicalDatastoreType getDatastoreType() {
- return datastoreType;
+ return datastore();
+ }
+
+ @Override
+ public InstanceIdentifier<T> path() {
+ return rootIdentifier;
}
/**
* Return the {@link InstanceIdentifier} of the root node.
*
* @return Instance identifier corresponding to the root node.
+ * @deprecated Use {@link #path()} instead
*/
+ @Deprecated(since = "13.0.0", forRemoval = true)
public @NonNull InstanceIdentifier<T> getRootIdentifier() {
- return rootIdentifier;
- }
-
- @Override
- public boolean contains(final DataTreeIdentifier<?> other) {
- return datastoreType == other.datastoreType && rootIdentifier.contains(other.rootIdentifier);
+ return path();
}
@Override
@Test
void testThrowExceptionOnRegister() {
final var itemIID = InstanceIdentifier.builder(RegisterListenerTest.class).child(Item.class).build();
- final var itemDTI = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, itemIID);
+ final var itemDTI = DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, itemIID);
doCallRealMethod().when(dataBroker).registerDataListener(any(), any());
final var dataListenerException = assertThrows(IllegalArgumentException.class,
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
class DataTreeIdentifierTest {
- private static final DataTreeIdentifier<TestDataObject1> TEST_IDENTIFIER1 = DataTreeIdentifier.create(
- LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(TestDataObject1.class));
- private static final DataTreeIdentifier<TestDataObject2> TEST_IDENTIFIER2 = DataTreeIdentifier.create(
- LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(TestDataObject2.class));
+ private static final DataTreeIdentifier<TestDataObject1> TEST_IDENTIFIER1 =
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(TestDataObject1.class));
+ private static final DataTreeIdentifier<TestDataObject2> TEST_IDENTIFIER2 =
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(TestDataObject2.class));
@Test
void basicTest() throws Exception {
- assertEquals(LogicalDatastoreType.OPERATIONAL, TEST_IDENTIFIER1.getDatastoreType());
- assertEquals(InstanceIdentifier.create(TestDataObject1.class), TEST_IDENTIFIER1.getRootIdentifier());
+ assertEquals(LogicalDatastoreType.OPERATIONAL, TEST_IDENTIFIER1.datastore());
+ assertEquals(InstanceIdentifier.create(TestDataObject1.class), TEST_IDENTIFIER1.path());
}
@Test
void containsTest() {
- assertTrue(TEST_IDENTIFIER1.contains(DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.create(TestDataObject1.class))), "Contains");
- assertFalse(TEST_IDENTIFIER1.contains(TEST_IDENTIFIER2), "Not Contains");
+ assertTrue(TEST_IDENTIFIER1.contains(
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(TestDataObject1.class))));
+ assertFalse(TEST_IDENTIFIER1.contains(TEST_IDENTIFIER2));
}
@Test
void hashCodeTest() {
assertEquals(TEST_IDENTIFIER1.hashCode(),
- DataTreeIdentifier.create(
- LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(TestDataObject1.class)).hashCode());
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(TestDataObject1.class))
+ .hashCode());
assertNotEquals(TEST_IDENTIFIER1.hashCode(), TEST_IDENTIFIER2.hashCode());
}
@Test
void equalsTest() {
- assertEquals(TEST_IDENTIFIER1, TEST_IDENTIFIER1, "Equals");
- assertEquals(TEST_IDENTIFIER1, DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.create(TestDataObject1.class)), "Equals");
- assertNotEquals(TEST_IDENTIFIER1, DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
- InstanceIdentifier.create(TestDataObject1.class)), "Different");
- assertNotEquals(TEST_IDENTIFIER1, TEST_IDENTIFIER2, "Different");
- assertNotEquals(TEST_IDENTIFIER1, null, "Equals null");
- assertNotEquals(TEST_IDENTIFIER1, new Object(), "Different object");
+ assertEquals(TEST_IDENTIFIER1, TEST_IDENTIFIER1);
+ assertEquals(TEST_IDENTIFIER1,
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL,InstanceIdentifier.create(TestDataObject1.class)));
+ assertNotEquals(TEST_IDENTIFIER1,
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.create(TestDataObject1.class)));
+ assertNotEquals(TEST_IDENTIFIER1, TEST_IDENTIFIER2);
+ assertNotEquals(TEST_IDENTIFIER1, null);
+ assertNotEquals(TEST_IDENTIFIER1, new Object());
}
@Test
AbstractInstanceNotificationListenerAdapter(final AdapterContext adapterContext, final Class<N> nofiticationClass,
final L delegate, final Executor executor) {
this.adapterContext = requireNonNull(adapterContext);
- this.notificationClass = requireNonNull(nofiticationClass);
+ notificationClass = requireNonNull(nofiticationClass);
this.delegate = requireNonNull(delegate);
this.executor = requireNonNull(executor);
}
return;
}
- final var bindingPath = serializer.fromYangInstanceIdentifier(path.getRootIdentifier());
+ final var bindingPath = serializer.fromYangInstanceIdentifier(path.path());
executor.execute(() -> onNotification(delegate, bindingPath, castNotification));
}
break;
case Naming.ACTION_INVOKE_NAME:
if (args.length == 2) {
- final InstanceIdentifier<?> path = (InstanceIdentifier<?>) requireNonNull(args[0]);
+ final var path = (InstanceIdentifier<?>) requireNonNull(args[0]);
checkArgument(!path.isWildcarded(), "Cannot invoke action on wildcard path %s", path);
- final RpcInput input = (RpcInput) requireNonNull(args[1]);
- final CurrentAdapterSerializer serializer = currentSerializer();
+ final var input = (RpcInput) requireNonNull(args[1]);
+ final var serializer = currentSerializer();
final ListenableFuture<? extends DOMActionResult> future = getDelegate().invokeAction(actionPath,
- new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL,
serializer.toYangInstanceIdentifier(path)),
serializer.toLazyNormalizedNodeActionInput(spec.type(), inputName, input));
@Override
public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
if (Naming.ACTION_INVOKE_NAME.equals(method.getName()) && args.length == 2) {
- final InstanceIdentifier<?> path = (InstanceIdentifier<?>) requireNonNull(args[0]);
- checkState(nodes.contains(DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, path)),
+ final var path = (InstanceIdentifier<?>) requireNonNull(args[0]);
+ checkState(nodes.contains(DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, path)),
"Cannot service %s", path);
}
return delegate.invoke(proxy, method, args);
final Impl impl = new Impl(adapterContext(), actionPath, spec.type(), implementation);
final DOMActionInstance instance = validNodes.isEmpty()
// Register on the entire datastore
- ? DOMActionInstance.of(actionPath, new DOMDataTreeIdentifier(datastore, YangInstanceIdentifier.of()))
+ ? DOMActionInstance.of(actionPath, DOMDataTreeIdentifier.of(datastore, YangInstanceIdentifier.of()))
// Register on specific instances
: DOMActionInstance.of(actionPath, validNodes.stream()
- .map(node -> serializer.toDOMDataTreeIdentifier(DataTreeIdentifier.create(datastore, node)))
+ .map(node -> serializer.toDOMDataTreeIdentifier(DataTreeIdentifier.of(datastore, node)))
.collect(Collectors.toUnmodifiableSet()));
public ListenableFuture<? extends DOMActionResult> invokeAction(final Absolute type,
final DOMDataTreeIdentifier path, final ContainerNode input) {
final CurrentAdapterSerializer codec = adapterContext.currentSerializer();
- final InstanceIdentifier<DataObject> instance = codec.fromYangInstanceIdentifier(path.getRootIdentifier());
+ final InstanceIdentifier<DataObject> instance = codec.fromYangInstanceIdentifier(path.path());
if (instance == null) {
// Not representable: return an error
LOG.debug("Path {} is not representable in binding, rejecting invocation", path);
public <T extends DataObject> Registration registerDataTreeChangeListener(final DataTreeIdentifier<T> treeId,
final DataTreeChangeListener<T> listener) {
final var domIdentifier = toDomTreeIdentifier(treeId);
- final var storeType = treeId.getDatastoreType();
- final var target = treeId.getRootIdentifier().getTargetType();
+ final var storeType = treeId.datastore();
+ final var target = treeId.path().getTargetType();
final var augment = Augmentation.class.isAssignableFrom(target) ? target : null;
final var domListener = listener instanceof ClusteredDataTreeChangeListener
}
private @NonNull DOMDataTreeIdentifier toDomTreeIdentifier(final DataTreeIdentifier<?> treeId) {
- return new DOMDataTreeIdentifier(treeId.getDatastoreType(),
- currentSerializer().toYangInstanceIdentifier(treeId.getRootIdentifier()));
+ return DOMDataTreeIdentifier.of(treeId.datastore(),
+ currentSerializer().toYangInstanceIdentifier(treeId.path()));
}
private @NonNull DOMDataTreeIdentifier toDomTreeInstance(final DataTreeIdentifier<?> treeId) {
- final var instanceIdentifier = treeId.getRootIdentifier();
+ final var instanceIdentifier = treeId.path();
if (instanceIdentifier.isWildcarded()) {
throw new IllegalArgumentException("Cannot register listener for wildcard " + instanceIdentifier);
}
@Override
public <D extends DataObject, T extends DataTreeCommitCohort<D>> ObjectRegistration<T> registerCommitCohort(
final DataTreeIdentifier<D> subtree, final T cohort) {
- final var target = subtree.getRootIdentifier().getTargetType();
+ final var target = subtree.path().getTargetType();
final var adapter = new BindingDOMDataTreeCommitCohortAdapter<>(adapterContext(), cohort,
Augmentation.class.isAssignableFrom(target) ? target : null);
final var domPath = currentSerializer().toDOMDataTreeIdentifier(subtree);
}
DOMDataTreeIdentifier toDOMDataTreeIdentifier(final DataTreeIdentifier<?> path) {
- return new DOMDataTreeIdentifier(path.getDatastoreType(), toYangInstanceIdentifier(path.getRootIdentifier()));
+ return DOMDataTreeIdentifier.of(path.datastore(), toYangInstanceIdentifier(path.path()));
}
Collection<DOMDataTreeIdentifier> toDOMDataTreeIdentifiers(final Collection<DataTreeIdentifier<?>> subtrees) {
final @NonNull InstanceIdentifier<?> path, final @NonNull DOMInstanceNotificationListener listener) {
final var serializer = adapterContext.currentSerializer();
return domNotifService.registerNotificationListener(
- new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, serializer.toYangInstanceIdentifier(path)),
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, serializer.toYangInstanceIdentifier(path)),
serializer.getNotificationPath(spec).lastNodeIdentifier(), listener);
}
}
final var codec = serializer.getSubtreeCodec(bindingPath);
final var modification = LazyDataObjectModification.from(codec, domChange.getRootNode());
return modification == null ? null
- : new LazyDataTreeModification(DataTreeIdentifier.create(datastoreType, bindingPath), modification);
+ : new LazyDataTreeModification(DataTreeIdentifier.of(datastoreType, bindingPath), modification);
}
@SuppressWarnings({"unchecked", "rawtypes"})
static <T extends DataObject> @Nullable DataTreeModification<T> from(final CurrentAdapterSerializer serializer,
final DOMDataTreeCandidate candidate, final Class<T> augment) {
final var domRootPath = candidate.getRootPath();
- final var bindingPath = createBindingPath(serializer, domRootPath.getRootIdentifier(), augment);
+ final var bindingPath = createBindingPath(serializer, domRootPath.path(), augment);
final var codec = serializer.getSubtreeCodec(bindingPath);
final var modification = LazyDataObjectModification.from(codec, candidate.getRootNode());
return modification == null ? null
- : new LazyDataTreeModification(DataTreeIdentifier.create(domRootPath.getDatastoreType(), bindingPath),
- modification);
+ : new LazyDataTreeModification(DataTreeIdentifier.of(domRootPath.datastore(), bindingPath), modification);
}
static <T extends DataObject> @NonNull List<DataTreeModification<T>> from(final CurrentAdapterSerializer codec,
private static @NonNull DOMDataTreeIdentifier toDomPath(final CurrentAdapterSerializer serializer,
final InstanceIdentifier<?> path) {
- return new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, serializer.toYangInstanceIdentifier(path));
+ return DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, serializer.toYangInstanceIdentifier(path));
}
private @NonNull DOMNotification toDomNotification(final CurrentAdapterSerializer serializer,
@Test
public void registerWithException() {
final var adapter = assertDataBrokerAdapter();
- final var ex = assertThrows(UnsupportedOperationException.class, () -> adapter.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Top.class)),
+ final var ex = assertThrows(UnsupportedOperationException.class,
+ () -> adapter.registerDataTreeChangeListener(
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Top.class)),
mock(DataTreeChangeListener.class)));
assertEquals("Underlying data broker does not expose DOMDataTreeChangeService.", ex.getMessage());
}
doReturn(mockDOMReg).when(mockDOMService).registerDataTreeChangeListener(
domDataTreeIdentifier(TOP_YIID),
any(DOMDataTreeChangeListener.class));
- final DataTreeIdentifier<Top> treeId = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, TOP_PATH);
+ final DataTreeIdentifier<Top> treeId = DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, TOP_PATH);
final TestClusteredDataTreeChangeListener mockClusteredListener = new TestClusteredDataTreeChangeListener();
service.registerDataTreeChangeListener(treeId , mockClusteredListener);
}
static DOMDataTreeIdentifier domDataTreeIdentifier(final YangInstanceIdentifier yangID) {
- return argThat(arg -> arg.getDatastoreType() == LogicalDatastoreType.CONFIGURATION
- && yangID.equals(arg.getRootIdentifier()));
+ return argThat(arg -> arg.datastore() == LogicalDatastoreType.CONFIGURATION && yangID.equals(arg.path()));
}
private static final class TestClusteredDataTreeChangeListener implements ClusteredDataTreeChangeListener<Top> {
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class BindingDOMDataTreeCommitCohortAdapterTest {
-
@Test
public void canCommitTest() {
final DataTreeCommitCohort<?> cohort = mock(DataTreeCommitCohort.class);
final DOMDataTreeCandidate domDataTreeCandidate = mock(DOMDataTreeCandidate.class);
final DOMDataTreeIdentifier domDataTreeIdentifier =
- new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.of());
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.of());
final var bindingPath = InstanceIdentifier.create(BooleanContainer.class);
doReturn(bindingPath).when(registry).fromYangInstanceIdentifier(any());
final BindingDataObjectCodecTreeNode<?> bindingCodecTreeNode = mock(BindingDataObjectCodecTreeNode.class);
doReturn(PostCanCommitStep.NOOP_SUCCESSFUL_FUTURE).when(cohort).canCommit(any(), any());
adapter.canCommit(txId, null, List.of(domDataTreeCandidate, domDataTreeCandidate));
- ArgumentCaptor<Collection> modifications = ArgumentCaptor.forClass(Collection.class);
+ final var modifications = ArgumentCaptor.forClass(Collection.class);
verify(cohort).canCommit(eq(txId), modifications.capture());
assertEquals(2, modifications.getValue().size());
}
final var registryAdapter = new BindingDOMDataTreeCommitCohortRegistryAdapter(bindingTestContext.getCodec(),
cohortRegistry);
- final var dataTreeIdentifier = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
+ final var dataTreeIdentifier = DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.create(Top.class));
final DataTreeCommitCohort<Top> dataTreeCommitCohort = mock(DataTreeCommitCohort.class);
try (var objectRegistration = registryAdapter.registerCommitCohort(dataTreeIdentifier, dataTreeCommitCohort)) {
final var wildCard = InstanceIdentifier.builder(ListenerTest.class).child(ListItem.class).build();
final var reg = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, wildCard), listener);
+ DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, wildCard), listener);
final var item = writeListItem();
public void testThrowExceptionOnRegister() {
final InstanceIdentifier<Item> instanceIdentifier = InstanceIdentifier.builder(RegisterListenerTest.class)
.child(Item.class).build();
- final DataTreeIdentifier<Item> itemsDataTreeIdentifier = DataTreeIdentifier.create(
- LogicalDatastoreType.OPERATIONAL,
+ final DataTreeIdentifier<Item> itemsDataTreeIdentifier = DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL,
instanceIdentifier);
final Throwable dataListenerException = assertThrows(IllegalArgumentException.class,
.child(Item.class, new ItemKey(item.key())).build();
dataBroker.registerDataListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, instanceIdentifier), listener);
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, instanceIdentifier), listener);
verify(listener, timeout(100)).dataChangedTo(item);
}
.child(Item.class, new ItemKey(item.key())).build();
dataBroker.registerDataChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, instanceIdentifier), changeListener);
+ DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, instanceIdentifier), changeListener);
verify(changeListener, timeout(100)).dataChanged(null, item);
}
private static final PathArgument BAR_ARGUMENT = Iterables.getLast(BAR_PATH.getPathArguments());
private static final TopLevelList BAR_DATA = topLevelList(TOP_BAR_KEY);
private static final DataTreeIdentifier<Top> TOP_IDENTIFIER
- = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, TOP_PATH);
+ = DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, TOP_PATH);
private static final Top TOP_INITIAL_DATA = top(FOO_DATA);
@Test
public void testWildcardedListListener() throws Exception {
final EventCapturingListener<TopLevelList> listener = new EventCapturingListener<>();
- final DataTreeIdentifier<TopLevelList> wildcard = DataTreeIdentifier.create(
+ final DataTreeIdentifier<TopLevelList> wildcard = DataTreeIdentifier.of(
LogicalDatastoreType.OPERATIONAL, TOP_PATH.child(TopLevelList.class));
dataBrokerImpl.registerDataTreeChangeListener(wildcard, listener);
putTx(TOP_PATH, TOP_INITIAL_DATA).commit().get();
final DataTreeModification<TopLevelList> fooWriteEvent = Iterables.getOnlyElement(listener.nextEvent());
- assertEquals(FOO_PATH, fooWriteEvent.getRootPath().getRootIdentifier());
+ assertEquals(FOO_PATH, fooWriteEvent.getRootPath().path());
verifyModification(fooWriteEvent.getRootNode(), FOO_ARGUMENT, ModificationType.WRITE);
putTx(BAR_PATH, BAR_DATA).commit().get();
final DataTreeModification<TopLevelList> barWriteEvent = Iterables.getOnlyElement(listener.nextEvent());
- assertEquals(BAR_PATH, barWriteEvent.getRootPath().getRootIdentifier());
+ assertEquals(BAR_PATH, barWriteEvent.getRootPath().path());
verifyModification(barWriteEvent.getRootNode(), BAR_ARGUMENT, ModificationType.WRITE);
deleteTx(BAR_PATH).commit().get();
final DataTreeModification<TopLevelList> barDeleteEvent = Iterables.getOnlyElement(listener.nextEvent());
- assertEquals(BAR_PATH, barDeleteEvent.getRootPath().getRootIdentifier());
+ assertEquals(BAR_PATH, barDeleteEvent.getRootPath().path());
verifyModification(barDeleteEvent.getRootNode(), BAR_ARGUMENT, ModificationType.DELETE);
}
putTx(TOP_PATH, TOP_INITIAL_DATA).commit().get();
final EventCapturingListener<TopLevelList> listener = new EventCapturingListener<>();
- final DataTreeIdentifier<TopLevelList> wildcard = DataTreeIdentifier.create(
+ final DataTreeIdentifier<TopLevelList> wildcard = DataTreeIdentifier.of(
LogicalDatastoreType.OPERATIONAL, TOP_PATH.child(TopLevelList.class));
dataBrokerImpl.registerDataTreeChangeListener(wildcard, listener);
final DataTreeModification<TopLevelList> fooWriteEvent = Iterables.getOnlyElement(listener.nextEvent());
- assertEquals(FOO_PATH, fooWriteEvent.getRootPath().getRootIdentifier());
+ assertEquals(FOO_PATH, fooWriteEvent.getRootPath().path());
verifyModification(fooWriteEvent.getRootNode(), FOO_ARGUMENT, ModificationType.WRITE);
}
final AdapterContext codec = new ConstantAdapterContext(registry);
final DOMDataTreeCandidate domDataTreeCandidate = mock(DOMDataTreeCandidate.class);
final DOMDataTreeIdentifier domDataTreeIdentifier =
- new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.of());
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.of());
final var bindingPath = InstanceIdentifier.create(BooleanContainer.class);
doReturn(bindingPath).when(registry).fromYangInstanceIdentifier(any());
final BindingDataObjectCodecTreeNode<?> bindingCodecTreeNode = mock(BindingDataObjectCodecTreeNode.class);
public class Mdsal298Test extends AbstractDataBrokerTest {
private static final InstanceIdentifier<Container> CONTAINER = InstanceIdentifier.create(Container.class);
- private static final DataTreeIdentifier<Container> CONTAINER_TID = DataTreeIdentifier.create(CONFIGURATION,
+ private static final DataTreeIdentifier<Container> CONTAINER_TID = DataTreeIdentifier.of(CONFIGURATION,
CONTAINER);
private static final NodeIdentifier CONTAINER_NID = new NodeIdentifier(Container.QNAME);
private static final QName FOO_QNAME = QName.create(Container.QNAME, "foo");
private static final QName BAZ_QNAME = QName.create(UnaddressableCont.QNAME, "baz");
private static final InstanceIdentifier<WithChoice> CHOICE_CONTAINER = InstanceIdentifier.create(WithChoice.class);
- private static final DataTreeIdentifier<WithChoice> CHOICE_CONTAINER_TID = DataTreeIdentifier.create(CONFIGURATION,
+ private static final DataTreeIdentifier<WithChoice> CHOICE_CONTAINER_TID = DataTreeIdentifier.of(CONFIGURATION,
CHOICE_CONTAINER);
private static final NodeIdentifier CHOICE_CONTAINER_NID = new NodeIdentifier(WithChoice.QNAME);
private static final NodeIdentifier CHOICE_NID = new NodeIdentifier(Foo.QNAME);
private static final InstanceIdentifier<AddressableCont> ADDRESSABLE_CONTAINER =
InstanceIdentifier.create(AddressableCont.class);
- private static final DataTreeIdentifier<AddressableCont> ADDRESSABLE_CONTAINER_TID = DataTreeIdentifier.create(
+ private static final DataTreeIdentifier<AddressableCont> ADDRESSABLE_CONTAINER_TID = DataTreeIdentifier.of(
CONFIGURATION, ADDRESSABLE_CONTAINER);
private static final NodeIdentifier ADDRESSABLE_CONTAINER_NID = new NodeIdentifier(AddressableCont.QNAME);
private static final InstanceIdentifier<UnaddressableCont> UNADDRESSABLE_CONTAINER =
InstanceIdentifier.create(UnaddressableCont.class);
- private static final DataTreeIdentifier<UnaddressableCont> UNADDRESSABLE_CONTAINER_TID = DataTreeIdentifier.create(
+ private static final DataTreeIdentifier<UnaddressableCont> UNADDRESSABLE_CONTAINER_TID = DataTreeIdentifier.of(
CONFIGURATION, UNADDRESSABLE_CONTAINER);
private static final NodeIdentifier UNADDRESSABLE_CONTAINER_NID = new NodeIdentifier(UnaddressableCont.QNAME);
final DataTreeChangeListener<T> listener = mock(DataTreeChangeListener.class);
doNothing().when(listener).onDataTreeChanged(anyCollection());
- final DataTreeIdentifier<T> dti = DataTreeIdentifier.create(CONFIGURATION,
- InstanceIdentifier.create(bindingClass));
+ final DataTreeIdentifier<T> dti = DataTreeIdentifier.of(CONFIGURATION, InstanceIdentifier.create(bindingClass));
getDataBroker().registerDataTreeChangeListener(dti, listener);
final DOMDataTreeWriteTransaction domTx = getDomBroker().newWriteOnlyTransaction();
ImmutableNodes.containerNode(qname));
domTx.commit().get();
- final ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class);
+ final var captor = ArgumentCaptor.forClass(Collection.class);
verify(listener).onDataTreeChanged(captor.capture());
Collection<DataTreeModification<T>> capture = captor.getValue();
assertEquals(1, capture.size());
if (!matcher.apply(mod)) {
final var rootNode = mod.getRootNode();
fail("Received unexpected notification: type: %s, path: %s, before: %s, after: %s".formatted(
- rootNode.getModificationType(), mod.getRootPath().getRootIdentifier(), rootNode.getDataBefore(),
+ rootNode.getModificationType(), mod.getRootPath().path(), rootNode.getDataBefore(),
rootNode.getDataAfter()));
return;
}
protected final <T extends DataObject> @NonNull ModificationCollector<T> createCollector(
final LogicalDatastoreType store, final InstanceIdentifier<T> path) {
final var listener = new TestListener<T>();
- final var reg = getDataBroker().registerDataTreeChangeListener(DataTreeIdentifier.create(store, path),
- listener);
+ final var reg = getDataBroker().registerDataTreeChangeListener(DataTreeIdentifier.of(store, path), listener);
listener.awaitSync();
return new ModificationCollector<>(listener, reg);
}
final InstanceIdentifier<T> path, final DataMatcher<T> checkDataBefore,
final DataMatcher<T> checkDataAfter) {
return modification -> type == modification.getRootNode().getModificationType()
- && path.equals(modification.getRootPath().getRootIdentifier())
+ && path.equals(modification.getRootPath().path())
&& checkDataBefore.apply(modification.getRootNode().getDataBefore())
&& checkDataAfter.apply(modification.getRootNode().getDataAfter());
}
module org.opendaylight.mdsal.common.api {
exports org.opendaylight.mdsal.common.api;
+ requires transitive org.opendaylight.yangtools.concepts;
requires transitive org.opendaylight.yangtools.yang.common;
requires transitive org.opendaylight.yangtools.util;
--- /dev/null
+/*
+ * Copyright (c) 2023 PANTHEON.tech, s.r.o. 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.common.api;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.opendaylight.yangtools.concepts.HierarchicalIdentifier;
+
+/**
+ * A path to a subtree within a particular datastore.
+ */
+@NonNullByDefault
+public interface LogicalDatastorePath<T extends LogicalDatastorePath<T, P>, P extends HierarchicalIdentifier<P>>
+ extends HierarchicalIdentifier<T> {
+ /**
+ * Return the {@link LogicalDatastoreType}.
+ *
+ * @return the {@link LogicalDatastoreType}
+ */
+ LogicalDatastoreType datastore();
+
+ /**
+ * Return the absolute path.
+ *
+ * @return the absolute path
+ */
+ P path();
+
+ @Override
+ default boolean contains(final T other) {
+ return datastore() == other.datastore() && path().contains(other.path());
+ }
+}
public static DOMActionInstance of(final Absolute type, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path) {
- return new DOMActionInstance(type, ImmutableSet.of(new DOMDataTreeIdentifier(datastore, path)));
+ return new DOMActionInstance(type, ImmutableSet.of(DOMDataTreeIdentifier.of(datastore, path)));
}
/**
import com.google.common.base.MoreObjects;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.mdsal.common.api.LogicalDatastorePath;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.yangtools.concepts.HierarchicalIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
- * A unique identifier for a particular subtree. It is composed of the logical data store type and the instance
- * identifier of the root node.
+ * A DOM version of {@link LogicalDatastorePath}. Uses {@link YangInstanceIdentifier} for path addressing.
*/
@NonNullByDefault
-public final class DOMDataTreeIdentifier implements HierarchicalIdentifier<DOMDataTreeIdentifier>,
+public final class DOMDataTreeIdentifier implements LogicalDatastorePath<DOMDataTreeIdentifier, YangInstanceIdentifier>,
Comparable<DOMDataTreeIdentifier> {
@java.io.Serial
private static final long serialVersionUID = 1L;
private final YangInstanceIdentifier rootIdentifier;
private final LogicalDatastoreType datastoreType;
- public DOMDataTreeIdentifier(final LogicalDatastoreType datastoreType,
- final YangInstanceIdentifier rootIdentifier) {
- this.datastoreType = requireNonNull(datastoreType);
- this.rootIdentifier = requireNonNull(rootIdentifier);
+ /**
+ * Default constructor.
+ *
+ * @param datastore {@link LogicalDatastoreType} of this identifier
+ * @param path {@link YangInstanceIdentifier} path of this identifier
+ * @throws NullPointerException if any argument is {@code null}
+ * @deprecated Use {@link #of(LogicalDatastoreType, YangInstanceIdentifier)} instead
+ */
+ @Deprecated(since = "13.0.0", forRemoval = true)
+ public DOMDataTreeIdentifier(final LogicalDatastoreType datastore, final YangInstanceIdentifier path) {
+ datastoreType = requireNonNull(datastore);
+ rootIdentifier = requireNonNull(path);
+ }
+
+ /**
+ * Create a new {@link DOMDataTreeIdentifier} with specified datastore and path.
+ *
+ * @param datastore {@link LogicalDatastoreType} of this identifier
+ * @param path {@link YangInstanceIdentifier} path of this identifier
+ * @throws NullPointerException if any argument is {@code null}
+ */
+ public static DOMDataTreeIdentifier of(final LogicalDatastoreType datastore, final YangInstanceIdentifier path) {
+ return new DOMDataTreeIdentifier(datastore, path);
+ }
+
+ @Override
+ public LogicalDatastoreType datastore() {
+ return datastoreType;
}
/**
* Return the logical data store type.
*
* @return Logical data store type. Guaranteed to be non-null.
+ * @deprecated Use {@link #datastore()} instead
*/
+ @Deprecated(since = "13.0.0", forRemoval = true)
public LogicalDatastoreType getDatastoreType() {
- return datastoreType;
+ return datastore();
+ }
+
+ @Override
+ public YangInstanceIdentifier path() {
+ return rootIdentifier;
}
/**
* Return the {@link YangInstanceIdentifier} of the root node.
*
* @return Instance identifier corresponding to the root node.
+ * @deprecated Use {@link #path()} instead
*/
+ @Deprecated(since = "13.0.0", forRemoval = true)
public YangInstanceIdentifier getRootIdentifier() {
- return rootIdentifier;
- }
-
- @Override
- public boolean contains(final DOMDataTreeIdentifier other) {
- return datastoreType == other.datastoreType && rootIdentifier.contains(other.rootIdentifier);
+ return path();
}
public DOMDataTreeIdentifier toOptimized() {
final var opt = rootIdentifier.toOptimized();
- return opt == rootIdentifier ? this : new DOMDataTreeIdentifier(datastoreType, opt);
- }
-
- @Override
- public int hashCode() {
- return datastoreType.hashCode() * 31 + rootIdentifier.hashCode();
- }
-
- @Override
- public boolean equals(final @Nullable Object obj) {
- return this == obj || obj instanceof DOMDataTreeIdentifier other && datastoreType == other.datastoreType
- && rootIdentifier.equals(other.rootIdentifier);
+ return opt == rootIdentifier ? this : DOMDataTreeIdentifier.of(datastoreType, opt);
}
@Override
return otherIter.hasNext() ? -1 : 0;
}
+ @Override
+ public int hashCode() {
+ return datastoreType.hashCode() * 31 + rootIdentifier.hashCode();
+ }
+
+ @Override
+ public boolean equals(final @Nullable Object obj) {
+ return this == obj || obj instanceof DOMDataTreeIdentifier other && datastoreType == other.datastoreType
+ && rootIdentifier.equals(other.rootIdentifier);
+ }
+
@Override
public String toString() {
return MoreObjects.toStringHelper(this).add("datastore", datastoreType).add("root", rootIdentifier).toString();
@Override
public void writeExternal(final ObjectOutput out) throws IOException {
- id.getDatastoreType().writeTo(out);
- out.writeObject(id.getRootIdentifier());
+ id.datastore().writeTo(out);
+ out.writeObject(id.path());
}
@Override
public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
- id = new DOMDataTreeIdentifier(LogicalDatastoreType.readFrom(in), (YangInstanceIdentifier) in.readObject());
+ id = DOMDataTreeIdentifier.of(LogicalDatastoreType.readFrom(in), (YangInstanceIdentifier) in.readObject());
}
@java.io.Serial
private static final YangInstanceIdentifier TEST_YII_IID =
YangInstanceIdentifier.of(QName.create(TEST_MODULE, TEST_LISTS));
private static final DOMDataTreeIdentifier REF_TREE =
- new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, REF_YII_IID);
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, REF_YII_IID);
private static final DOMDataTreeIdentifier TEST_DIFF_TREE =
- new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,TEST_YII_IID);
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL,TEST_YII_IID);
@Test
void constructTest() {
- assertNotNull(new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, REF_YII_IID), "Instantiation");
+ assertNotNull(DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, REF_YII_IID), "Instantiation");
}
@Test
void hashCodeTest() {
assertEquals(REF_TREE.hashCode(),
- new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, REF_YII_IID).hashCode());
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, REF_YII_IID).hashCode());
assertNotEquals(REF_TREE.hashCode(), TEST_DIFF_TREE.hashCode());
}
@Test
void equalsTest() {
- assertEquals(REF_TREE, new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, REF_YII_IID));
- assertNotEquals(REF_TREE, new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, REF_YII_IID));
+ assertEquals(REF_TREE, DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, REF_YII_IID));
+ assertNotEquals(REF_TREE, DOMDataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, REF_YII_IID));
assertEquals(REF_TREE, REF_TREE);
assertNotEquals(REF_TREE, new Object());
assertNotEquals(REF_TREE, TEST_DIFF_TREE);
final var compareFirstIid = YangInstanceIdentifier.of(QName.create(TEST_MODULE, COMPARE_FIRST_LISTS));
final var compareSecondIid = YangInstanceIdentifier.of(QName.create(TEST_MODULE, COMPARE_SECOND_LISTS));
- assertEquals(0, REF_TREE.compareTo(new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, REF_YII_IID)));
+ assertEquals(0, REF_TREE.compareTo(DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, REF_YII_IID)));
assertNotEquals(0,
- REF_TREE.compareTo(new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, REF_YII_IID)));
- assertEquals(1, new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
+ REF_TREE.compareTo(DOMDataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, REF_YII_IID)));
+ assertEquals(1, DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL,
YangInstanceIdentifier.of(QName.create(TEST_MODULE, REF_LISTS), QName.create(TEST_MODULE, TEST_LISTS)))
.compareTo(REF_TREE));
- assertTrue(new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, compareFirstIid)
- .compareTo(new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, compareSecondIid)) < 0);
- assertTrue(new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, compareSecondIid)
- .compareTo(new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, compareFirstIid)) > 0);
+ assertTrue(DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, compareFirstIid)
+ .compareTo(DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, compareSecondIid)) < 0);
+ assertTrue(DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, compareSecondIid)
+ .compareTo(DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, compareFirstIid)) > 0);
}
@Test
void containsTest() {
- assertTrue(REF_TREE.contains(new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, REF_YII_IID)));
+ assertTrue(REF_TREE.contains(DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, REF_YII_IID)));
assertEquals(false, REF_TREE.contains(TEST_DIFF_TREE));
}
if (treeChange) {
supportedExtensions = List.of((DOMDataTreeChangeService) (treeId, listener) -> {
- final var dsType = treeId.getDatastoreType();
+ final var dsType = treeId.datastore();
if (getTxFactories().get(dsType) instanceof DOMStoreTreeChangePublisher publisher) {
- return publisher.registerTreeChangeListener(treeId.getRootIdentifier(), listener);
+ return publisher.registerTreeChangeListener(treeId.path(), listener);
}
throw new IllegalStateException("Publisher for " + dsType + " data store is not available");
});
@Override
public ListenableFuture<? extends DOMActionResult> invokeAction(final Absolute type,
final DOMDataTreeIdentifier path, final ContainerNode input) {
- final YangInstanceIdentifier pathRoot = path.getRootIdentifier();
+ final YangInstanceIdentifier pathRoot = path.path();
checkArgument(!pathRoot.isEmpty(), "Action path must not be empty");
final DOMActionRoutingTableEntry entry = (DOMActionRoutingTableEntry) actionRoutingTable.getEntry(type);
final Absolute type, final DOMDataTreeIdentifier path, final ContainerNode input) {
var impls = entry.getImplementations(path);
if (impls == null) {
- impls = entry.getImplementations(
- new DOMDataTreeIdentifier(path.getDatastoreType(), YangInstanceIdentifier.of()));
+ impls = entry.getImplementations(DOMDataTreeIdentifier.of(path.datastore(), YangInstanceIdentifier.of()));
if (impls == null) {
return Futures.immediateFailedFuture(new DOMActionNotAvailableException(
"No implementation of Action %s available for %s", type, path));
.withChild(OUTER_LIST_2)
.build();
- private static final DOMDataTreeIdentifier ROOT_DATA_TREE_ID = new DOMDataTreeIdentifier(
- LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
+ private static final DOMDataTreeIdentifier ROOT_DATA_TREE_ID =
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, TestModel.TEST_PATH);
- private static final DOMDataTreeIdentifier OUTER_LIST_DATA_TREE_ID = new DOMDataTreeIdentifier(
- LogicalDatastoreType.CONFIGURATION, TestModel.OUTER_LIST_PATH);
+ private static final DOMDataTreeIdentifier OUTER_LIST_DATA_TREE_ID =
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, TestModel.OUTER_LIST_PATH);
@Before
public void setupStore() {
private static ListenableFuture<? extends DOMActionResult> invokeBaz(final DOMActionService actionService,
final YangInstanceIdentifier path) {
return actionService.invokeAction(Actions.BAZ_TYPE,
- new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, path),
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, path),
Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(Actions.INPUT)).build());
}
}
*/
@Beta
public final class DOMDataTreePrefixTable<V> {
-
private static final Logger LOG = LoggerFactory.getLogger(DOMDataTreePrefixTable.class);
+
private final Map<LogicalDatastoreType, DOMDataTreePrefixTableEntry<V>> roots =
new EnumMap<>(LogicalDatastoreType.class);
private DOMDataTreePrefixTable() {
-
+ // Hidden in purpose
}
public static <V> DOMDataTreePrefixTable<V> create() {
* @return closest non-null entry towards root or null if no entry towards root exists.
*/
public @Nullable DOMDataTreePrefixTableEntry<V> lookup(final @NonNull DOMDataTreeIdentifier prefix) {
- final DOMDataTreePrefixTableEntry<V> t = roots.get(prefix.getDatastoreType());
- return t == null ? null : t.lookup(prefix.getRootIdentifier());
+ final var entryt = roots.get(prefix.datastore());
+ return entryt == null ? null : entryt.lookup(prefix.path());
}
/**
* @throws IllegalStateException If value is already stored for provided prefix
*/
public void store(final @NonNull DOMDataTreeIdentifier prefix, final @NonNull V value) {
- DOMDataTreePrefixTableEntry<V> domDataTreePrefixTableEntry = roots.get(prefix.getDatastoreType());
+ var domDataTreePrefixTableEntry = roots.get(prefix.datastore());
if (domDataTreePrefixTableEntry == null) {
domDataTreePrefixTableEntry = new DOMDataTreePrefixTableEntry<>();
- roots.put(prefix.getDatastoreType(), domDataTreePrefixTableEntry);
+ roots.put(prefix.datastore(), domDataTreePrefixTableEntry);
}
- domDataTreePrefixTableEntry.store(prefix.getRootIdentifier(), value);
+ domDataTreePrefixTableEntry.store(prefix.path(), value);
}
/**
* @param prefix to be removed
*/
public void remove(final @NonNull DOMDataTreeIdentifier prefix) {
- final DOMDataTreePrefixTableEntry<V> t = roots.get(prefix.getDatastoreType());
- if (t == null) {
+ final var entry = roots.get(prefix.datastore());
+ if (entry == null) {
LOG.warn("Shard registration {} points to non-existent table", prefix);
return;
}
- t.remove(prefix.getRootIdentifier());
+ entry.remove(prefix.path());
}
}
final Object testObject = new Object();
final YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.of(QName.create("", "test"));
final DOMDataTreeIdentifier domDataTreeIdentifier =
- new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, yangInstanceIdentifier);
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, yangInstanceIdentifier);
domDataTreePrefixTable.store(domDataTreeIdentifier, testObject);
assertEquals(QName.create("", "test"),
assertNull(domDataTreePrefixTable.lookup(domDataTreeIdentifier));
final DOMDataTreeIdentifier invalidDOMDataTreeIdentifier =
- new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, yangInstanceIdentifier);
+ DOMDataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, yangInstanceIdentifier);
domDataTreePrefixTable.remove(invalidDOMDataTreeIdentifier);
assertNull(domDataTreePrefixTable.lookup(invalidDOMDataTreeIdentifier));
}
final var ext = delegate.extension(type);
if (DOMDataTreeChangeService.class.equals(type) && ext instanceof DOMDataTreeChangeService treeChange) {
return type.cast((DOMDataTreeChangeService) (domDataTreeIdentifier, listener) -> {
- final var rootId = domDataTreeIdentifier.getRootIdentifier();
- if (isRegistrationWatched(rootId, domDataTreeIdentifier.getDatastoreType())) {
+ final var rootId = domDataTreeIdentifier.path();
+ if (isRegistrationWatched(rootId, domDataTreeIdentifier.datastore())) {
LOG.warn("{} registration (registerDataTreeChangeListener) for {} from {}.",
listener instanceof ClusteredDOMDataTreeChangeListener ? "Clustered" : "Non-clustered",
toPathString(rootId), getStackSummary());
Code Review / mdsal.git / commitdiff