* @throws NullPointerException if {@code target} is null
*/
@SuppressWarnings("unchecked")
- public final <N extends DataObject> @NonNull InstanceIdentifier<N> verifyTarget(final Class<N> target) {
+ public final <N extends DataObject> @NonNull InstanceIdentifier<N> verifyTarget(final Class<@NonNull N> target) {
verify(target.equals(targetType), "Cannot adapt %s to %s", this, target);
return (InstanceIdentifier<N>) this;
}
* @return trimmed instance identifier, or null if the component type
* is not present.
*/
- public final <I extends DataObject> @Nullable InstanceIdentifier<I> firstIdentifierOf(final Class<I> type) {
+ public final <I extends DataObject> @Nullable InstanceIdentifier<I> firstIdentifierOf(
+ final Class<@NonNull I> type) {
int count = 1;
for (final PathArgument a : pathArguments) {
if (type.equals(a.getType())) {
* is not present.
*/
public final <N extends Identifiable<K> & DataObject, K extends Identifier<N>> @Nullable K firstKeyOf(
- final Class<N> listItem) {
+ final Class<@NonNull N> listItem) {
for (final PathArgument i : pathArguments) {
if (listItem.equals(i.getType())) {
@SuppressWarnings("unchecked")
* @return An InstanceIdentifier.
* @throws NullPointerException if {@code container} is null
*/
- public final <N extends ChildOf<? super T>> @NonNull InstanceIdentifier<N> child(final Class<N> container) {
+ public final <N extends ChildOf<? super T>> @NonNull InstanceIdentifier<N> child(
+ final Class<@NonNull N> container) {
return childIdentifier(Item.of(container));
}
*/
@SuppressWarnings("unchecked")
public final <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>>
- @NonNull KeyedInstanceIdentifier<N, K> child(final Class<N> listItem, final K listKey) {
+ @NonNull KeyedInstanceIdentifier<N, K> child(final Class<@NonNull N> listItem, final K listKey) {
return (KeyedInstanceIdentifier<N, K>) childIdentifier(IdentifiableItem.of(listItem, listKey));
}
* @return An InstanceIdentifier.
* @throws NullPointerException if any argument is null
*/
+ // FIXME: add a proper caller
public final <C extends ChoiceIn<? super T> & DataObject, N extends ChildOf<? super C>>
- @NonNull InstanceIdentifier<N> child(final Class<C> caze, final Class<N> container) {
+ @NonNull InstanceIdentifier<N> child(final Class<@NonNull C> caze, final Class<@NonNull N> container) {
return childIdentifier(Item.of(caze, container));
}
* @return An InstanceIdentifier.
* @throws NullPointerException if any argument is null
*/
+ // FIXME: add a proper caller
@SuppressWarnings("unchecked")
public final <C extends ChoiceIn<? super T> & DataObject, K extends Identifier<N>,
N extends Identifiable<K> & ChildOf<? super C>> @NonNull KeyedInstanceIdentifier<N, K> child(
- final Class<C> caze, final Class<N> listItem, final K listKey) {
+ final Class<@NonNull C> caze, final Class<@NonNull N> listItem, final K listKey) {
return (KeyedInstanceIdentifier<N, K>) childIdentifier(IdentifiableItem.of(caze, listItem, listKey));
}
* @throws NullPointerException if {@code container} is null
*/
public final <N extends DataObject & Augmentation<? super T>> @NonNull InstanceIdentifier<N> augmentation(
- final Class<N> container) {
+ final Class<@NonNull N> container) {
return childIdentifier(Item.of(container));
}
* @return InstanceIdentifier instance
*/
@SuppressWarnings("unchecked")
- public static <T extends DataObject> @NonNull InstanceIdentifier<T> create(final Class<T> type) {
+ public static <T extends DataObject> @NonNull InstanceIdentifier<T> create(final Class<@NonNull T> type) {
return (InstanceIdentifier<T>) create(ImmutableList.of(Item.of(type)));
}
* @throws NullPointerException if any argument is null
*/
<N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>>
- @NonNull InstanceIdentifierBuilder<N> child(Class<N> listItem, K listKey);
+ @NonNull InstanceIdentifierBuilder<N> child(Class<@NonNull N> listItem, K listKey);
/**
* Append the specified listItem as a child of the current InstanceIdentifier referenced by the builder. This
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 static org.mockito.Mockito.mock;
+import com.google.common.base.VerifyException;
import com.google.common.collect.ImmutableList;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import org.opendaylight.yangtools.yang.binding.test.mock.FooChild;
import org.opendaylight.yangtools.yang.binding.test.mock.InstantiatedFoo;
import org.opendaylight.yangtools.yang.binding.test.mock.Node;
+import org.opendaylight.yangtools.yang.binding.test.mock.NodeAugmentation;
import org.opendaylight.yangtools.yang.binding.test.mock.NodeChild;
import org.opendaylight.yangtools.yang.binding.test.mock.NodeChildKey;
import org.opendaylight.yangtools.yang.binding.test.mock.NodeKey;
assertFalse(instanceIdentifier1.equals(instanceIdentifier3));
assertFalse(instanceIdentifier1.equals(instanceIdentifier4));
- final InstanceIdentifier instanceIdentifier5 = InstanceIdentifier.create(Node.class);
+ final InstanceIdentifier<Node> instanceIdentifier5 = InstanceIdentifier.create(Node.class);
final Field hashField = InstanceIdentifier.class.getDeclaredField("hash");
hashField.setAccessible(true);
hashField.set(instanceIdentifier5, instanceIdentifier1.hashCode());
assertNotNull(InstanceIdentifier.create(ImmutableList.copyOf(instanceIdentifier1.getPathArguments())));
assertNotNull(InstanceIdentifier.create(Nodes.class).child(Node.class));
assertNotNull(InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(5)));
- assertNotNull(instanceIdentifier5.augmentation(DataObject.class));
+ assertNotNull(instanceIdentifier5.augmentation(NodeAugmentation.class));
assertNotNull(instanceIdentifier1.hashCode());
assertNotNull(instanceIdentifier1.toString());
@Test
public void firstKeyOfTest() {
final InstanceIdentifier<Node> instanceIdentifier =
- InstanceIdentifier.builder(Nodes.class).child(Node.class,new NodeKey(10)).build();
+ InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(10)).build();
final InstanceIdentifier<DataObject> instanceIdentifier1 = InstanceIdentifier.create(DataObject.class);
assertNotNull(instanceIdentifier.firstKeyOf(Node.class));
assertNull(instanceIdentifier1.firstKeyOf(Node.class));
assertTrue(builder3.hashCode() != builder4.hashCode());
}
+ @Test
+ public void verifyTargetTest() {
+ final InstanceIdentifier<Nodes> nodeId = InstanceIdentifier.create(Nodes.class);
+ assertSame(nodeId, nodeId.verifyTarget(Nodes.class));
+ assertThrows(VerifyException.class, () -> nodeId.verifyTarget(Node.class));
+ }
+
}