import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
/**
* Modified Data Object. Represents a modification of DataObject, which has a few kinds as indicated by
* @throws IllegalArgumentException If supplied {@code listItem} class is not valid child according
* to generated model.
*/
- <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>> @Nullable DataObjectModification<N>
+ <N extends KeyAware<K> & ChildOf<? super T>, K extends Key<N>> @Nullable DataObjectModification<N>
getModifiedChildListItem(@NonNull Class<N> listItem, @NonNull K listKey);
/**
* @throws IllegalArgumentException If supplied {@code listItem} class is not valid child according
* to generated model.
*/
- <H extends ChoiceIn<? super T> & DataObject, C extends Identifiable<K> & ChildOf<? super H>,
- K extends Identifier<C>> @Nullable DataObjectModification<C> getModifiedChildListItem(
+ <H extends ChoiceIn<? super T> & DataObject, C extends KeyAware<K> & ChildOf<? super H>,
+ K extends Key<C>> @Nullable DataObjectModification<C> getModifiedChildListItem(
@NonNull Class<H> caseType, @NonNull Class<C> listItem, @NonNull K listKey);
/**
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceNotification;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedListNotification;
return registerListener(spec, path, listener, MoreExecutors.directExecutor());
}
- <P extends DataObject &
Identifiable<K>, N extends KeyedListNotification<N, P, K>, K extends Identifier<P>>
+ <P extends DataObject &
KeyAware<K>, N extends KeyedListNotification<N, P, K>, K extends Key<P>>
@NonNull Registration registerListener(InstanceNotificationSpec<N, P> spec, KeyedInstanceIdentifier<P, K> path,
KeyedListListener<P, N, K> listener, Executor executor);
- default <P extends DataObject &
Identifiable<K>, N extends KeyedListNotification<N, P, K>, K extends Identifier<P>>
+ default <P extends DataObject &
KeyAware<K>, N extends KeyedListNotification<N, P, K>, K extends Key<P>>
@NonNull Registration registerListener(final InstanceNotificationSpec<N, P> spec,
final KeyedInstanceIdentifier<P, K> path, final KeyedListListener<P, N, K> listener) {
return registerListener(spec, path, listener, MoreExecutors.directExecutor());
* Interface for listeners on instance (YANG 1.1) notifications defined in a {@code list} with a {@code key}.
*/
@FunctionalInterface
- interface KeyedListListener<P extends DataObject & Identifiable<K>, N extends KeyedListNotification<N, P, K>,
- K extends
Identifier<P>> extends EventListener {
+ interface KeyedListListener<P extends DataObject & KeyAware<K>, N extends KeyedListNotification<N, P, K>,
+ K extends
Key<P>> extends EventListener {
/**
* Process an instance notification.
*
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
/**
* Intermediate Query builder stage, which allows the specification of the query result type to be built up via
* @return This builder
* @throws NullPointerException if childClass is null
*/
- <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>>
- @NonNull DescendantQueryBuilder<N> extractChild(Class<@NonNull N> listItem, K listKey);
+ <N extends KeyAware<K> & ChildOf<? super T>, K extends Key<N>> @NonNull DescendantQueryBuilder<N> extractChild(
+ Class<@NonNull N> listItem, K listKey);
/**
* Add a child path component to the specification of what needs to be extracted. This method, along with its
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.TypeObject;
import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.Empty;
* @return This builder
* @throws NullPointerException if childClass is null
*/
- <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>>
- @NonNull MatchBuilderPath<O, N> extractChild(Class<@NonNull N> listItem, K listKey);
+ <N extends KeyAware<K> & ChildOf<? super T>, K extends Key<N>> @NonNull MatchBuilderPath<O, N> extractChild(
+ Class<@NonNull N> listItem, K listKey);
/**
* Match an {@code boolean} leaf's value.
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
@Override
@SuppressWarnings("unchecked")
- public final <C extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<C>> DataObjectModification<C>
+ public final <C extends KeyAware<K> & ChildOf<? super T>, K extends Key<C>> DataObjectModification<C>
getModifiedChildListItem(final Class<C> listItem, final K listKey) {
return (DataObjectModification<C>) getModifiedChild(IdentifiableItem.of(listItem, listKey));
}
@Override
@SuppressWarnings("unchecked")
- public final <H extends ChoiceIn<? super T> & DataObject, C extends Identifiable<K> & ChildOf<? super H>,
- K extends Identifier<C>> DataObjectModification<C> getModifiedChildListItem(final Class<H> caseType,
+ public final <H extends ChoiceIn<? super T> & DataObject, C extends KeyAware<K> & ChildOf<? super H>,
+ K extends Key<C>> DataObjectModification<C> getModifiedChildListItem(final Class<H> caseType,
final Class<C> listItem, final K listKey) {
return (DataObjectModification<C>) getModifiedChild(IdentifiableItem.of(caseType, listItem, listKey));
}
import org.opendaylight.mdsal.dom.api.DOMService;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceNotification;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedListNotification;
}
@Override
- public <P extends DataObject &
Identifiable<K>, N extends KeyedListNotification<N, P, K>, K extends Identifier<P>>
+ public <P extends DataObject &
KeyAware<K>, N extends KeyedListNotification<N, P, K>, K extends Key<P>>
Registration registerListener(final InstanceNotificationSpec<N, P> spec,
final KeyedInstanceIdentifier<P, K> path, final KeyedListListener<P, N, K> listener,
final Executor executor) {
import java.util.concurrent.Executor;
import org.opendaylight.mdsal.binding.api.InstanceNotificationService.KeyedListListener;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedListNotification;
-final class KeyedInstanceNotificationListenerAdapter<P extends DataObject &
Identifiable<K>, K extends Identifier<P>,
+final class KeyedInstanceNotificationListenerAdapter<P extends DataObject &
KeyAware<K>, K extends Key<P>,
N extends KeyedListNotification<N, P, K>>
extends AbstractInstanceNotificationListenerAdapter<P, N, KeyedListListener<P, N, K>> {
KeyedInstanceNotificationListenerAdapter(final AdapterContext adapterContext, final Class<N> notificationClass,
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
final class DefaultDescendantQueryBuilder<R extends DataObject, T extends DataObject>
implements DescendantQueryBuilder<T> {
@Override
@SuppressWarnings("unchecked")
- public <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>>
- DescendantQueryBuilder<N> extractChild(final Class<@NonNull N> listItem, final K listKey) {
+ public <N extends KeyAware<K> & ChildOf<? super T>, K extends Key<N>> DescendantQueryBuilder<N> extractChild(
+ final Class<@NonNull N> listItem, final K listKey) {
childPath.child(listItem, listKey);
return (DefaultDescendantQueryBuilder<R, N>) this;
}
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.TypeObject;
import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.Empty;
@Override
@SuppressWarnings("unchecked")
- public <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>>
- MatchBuilderPath<O, N> extractChild(final Class<@NonNull N> listItem, final K listKey) {
+ public <N extends KeyAware<K> & ChildOf<? super T>, K extends Key<N>> MatchBuilderPath<O, N> extractChild(
+ final Class<@NonNull N> listItem, final K listKey) {
target.child(listItem, listKey);
return (MatchBuilderPath<O, N>) this;
}
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
/**
* Event Stream Writer for Binding Representation.
* <code>choice</code> <code>unkeyed list</code> node.
* @throws IOException if an underlying IO error occurs
*/
- <T extends DataObject & Identifiable<?>> void startMapNode(Class<T> mapEntryType, int childSizeHint)
- throws IOException;
+ <T extends DataObject & KeyAware<?>> void startMapNode(Class<T> mapEntryType, int childSizeHint) throws IOException;
/**
* Emits start of ordered map node event.
* <code>choice</code> <code>unkeyed list</code> node.
* @throws IOException if an underlying IO error occurs
*/
- <T extends DataObject & Identifiable<?>> void startOrderedMapNode(Class<T> mapEntryType, int childSizeHint)
+ <T extends DataObject & KeyAware<?>> void startOrderedMapNode(Class<T> mapEntryType, int childSizeHint)
throws IOException;
/**
* If node was emitted outside <code>map entry</code> node.
* @throws IOException if an underlying IO error occurs
*/
- void startMapEntryNode(Identifier<?> keyValues, int childSizeHint) throws IOException;
+ void startMapEntryNode(Key<?> keyValues, int childSizeHint) throws IOException;
/**
* Emits start of choice node.
import org.opendaylight.yangtools.yang.binding.BaseNotification;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.binding.OpaqueObject;
import org.opendaylight.yangtools.yang.binding.RpcInput;
@Override
public IdentifiableItemCodec getPathArgumentCodec(final Class<?> listClz, final ListRuntimeType type) {
- final Optional<Class<Identifier<?>>> optIdentifier = ClassLoaderUtils.findFirstGenericArgument(listClz,
- Identifiable.class);
+ final Optional<Class<Key<?>>> optIdentifier = ClassLoaderUtils.findFirstGenericArgument(listClz,
+ KeyAware.class);
checkState(optIdentifier.isPresent(), "Failed to find identifier for %s", listClz);
- final Class<Identifier<?>> identifier = optIdentifier.orElseThrow();
+ final Class<Key<?>> identifier = optIdentifier.orElseThrow();
final Map<QName, ValueContext> valueCtx = new HashMap<>();
for (final ValueNodeCodecContext leaf : getLeafNodes(identifier, type.statement()).values()) {
final QName name = leaf.getDomPathArgument().getNodeType();
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.OpaqueObject;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
}
@Override
- public void startMapEntryNode(final Identifier<?> key, final int childSizeHint) throws IOException {
+ public void startMapEntryNode(final Key<?> key, final int childSizeHint) throws IOException {
duplicateSchemaEnter();
NodeIdentifierWithPredicates identifier = ((KeyedListNodeCodecContext<?, ?>) current()).serialize(key);
delegate.startMapEntryNode(identifier, childSizeHint);
}
@Override
- public <T extends DataObject & Identifiable<?>> void startMapNode(final Class<T> mapEntryType,
- final int childSizeHint) throws IOException {
+ public <T extends DataObject & KeyAware<?>> void startMapNode(final Class<T> mapEntryType, final int childSizeHint)
+ throws IOException {
delegate.startMapNode(enter(mapEntryType, NodeIdentifier.class), childSizeHint);
}
@Override
- public <T extends DataObject & Identifiable<?>> void startOrderedMapNode(final Class<T> mapEntryType,
+ public <T extends DataObject & KeyAware<?>> void startOrderedMapNode(final Class<T> mapEntryType,
final int childSizeHint) throws IOException {
delegate.startOrderedMapNode(enter(mapEntryType, NodeIdentifier.class), childSizeHint);
}
import org.opendaylight.mdsal.binding.runtime.api.ListRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.RuntimeTypeContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.PresenceEffectiveStatement;
}
return new ContainerNodeCodecContext(this);
} else if (type instanceof ListRuntimeType) {
- return Identifiable.class.isAssignableFrom(getBindingClass())
+ return KeyAware.class.isAssignableFrom(getBindingClass())
? KeyedListNodeCodecContext.create((DataContainerCodecPrototype<ListRuntimeType>) this)
: new ListNodeCodecContext(this);
} else if (type instanceof ChoiceRuntimeType) {
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.OpaqueObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
}
- protected static final <E extends DataObject & Identifiable<?>> void streamMap(final Class<E> childClass,
+ protected static final <E extends DataObject & KeyAware<?>> void streamMap(final Class<E> childClass,
final DataObjectStreamer<E> childStreamer, final DataObjectSerializerRegistry registry,
final BindingStreamEventWriter writer, final Map<?, ? extends E> value) throws IOException {
final int size = nullSize(value);
}
}
- protected static final <E extends DataObject & Identifiable<?>> void streamOrderedMap(final Class<E> childClass,
+ protected static final <E extends DataObject & KeyAware<?>> void streamOrderedMap(final Class<E> childClass,
final DataObjectStreamer<E> childStreamer, final DataObjectSerializerRegistry registry,
final BindingStreamEventWriter writer, final List<? extends E> value) throws IOException {
final int size = nullSize(value);
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
// startMapEntryNode(obj.key(), UNKNOWN_SIZE)
private static final StackManipulation START_MAP_ENTRY_NODE = new StackManipulation.Compound(
OBJ,
- invokeMethod(Identifiable.class, "key"),
+ invokeMethod(KeyAware.class, Naming.KEY_AWARE_KEY_NAME),
UNKNOWN_SIZE,
- invokeMethod(BindingStreamEventWriter.class, "startMapEntryNode", Identifier.class, int.class));
+ invokeMethod(BindingStreamEventWriter.class, "startMapEntryNode", Key.class, int.class));
// startUnkeyedListItem(UNKNOWN_SIZE)
private static final StackManipulation START_UNKEYED_LIST_ITEM = new StackManipulation.Compound(
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.OpaqueObject;
-//FIXME: Consider moving this to yang.binding.util.* in Be
+// FIXME: Consider moving this to yang.binding.util.* in Be
abstract class ForwardingBindingStreamEventWriter implements AnydataBindingStreamWriter {
protected abstract AnydataBindingStreamWriter delegate();
}
@Override
- public <T extends DataObject & Identifiable<?>> void startMapNode(final Class<T> mapEntryType,
- final int childSizeHint) throws IOException {
+ public <T extends DataObject & KeyAware<?>> void startMapNode(final Class<T> mapEntryType, final int childSizeHint)
+ throws IOException {
delegate().startMapNode(mapEntryType, childSizeHint);
}
@Override
- public <T extends DataObject & Identifiable<?>> void startOrderedMapNode(final Class<T> mapEntryType,
+ public <T extends DataObject & KeyAware<?>> void startOrderedMapNode(final Class<T> mapEntryType,
final int childSizeHint) throws IOException {
delegate().startOrderedMapNode(mapEntryType, childSizeHint);
}
@Override
- public void startMapEntryNode(final Identifier<?> keyValues, final int childSizeHint) throws IOException {
+ public void startMapEntryNode(final Key<?> keyValues, final int childSizeHint) throws IOException {
delegate().startMapEntryNode(keyValues, childSizeHint);
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.ImmutableOffsetMap;
import org.opendaylight.yangtools.util.ImmutableOffsetMapTemplate;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.slf4j.LoggerFactory;
/**
- * Codec support for extracting the {@link Identifiable#key()} method return from a MapEntryNode.
+ * Codec support for extracting the {@link KeyAware#key()} method return from a MapEntryNode.
*/
abstract sealed class IdentifiableItemCodec {
private static final class SingleKey extends IdentifiableItemCodec {
- private static final MethodType CTOR_TYPE = MethodType.methodType(Identifier.class, Object.class);
+ private static final MethodType CTOR_TYPE = MethodType.methodType(Key.class, Object.class);
private final ValueContext keyContext;
private final MethodHandle ctor;
private final QName keyName;
- SingleKey(final ListEffectiveStatement schema, final Class<? extends Identifier<?>> keyClass,
+ SingleKey(final ListEffectiveStatement schema, final Class<? extends Key<?>> keyClass,
final Class<?> identifiable, final QName keyName, final ValueContext keyContext) {
super(schema, keyClass, identifiable);
this.keyContext = requireNonNull(keyContext);
}
@Override
- Identifier<?> deserializeIdentifierImpl(final NodeIdentifierWithPredicates nip) throws Throwable {
- return (Identifier<?>) ctor.invokeExact(keyContext.deserialize(nip.getValue(keyName)));
+ Key<?> deserializeIdentifierImpl(final NodeIdentifierWithPredicates nip) throws Throwable {
+ return (Key<?>) ctor.invokeExact(keyContext.deserialize(nip.getValue(keyName)));
}
@Override
- NodeIdentifierWithPredicates serializeIdentifier(final QName qname, final Identifier<?> key) {
+ NodeIdentifierWithPredicates serializeIdentifier(final QName qname, final Key<?> key) {
return NodeIdentifierWithPredicates.of(qname, keyName, keyContext.getAndSerialize(key));
}
}
private final ImmutableList<QName> keysInBindingOrder;
private final MethodHandle ctor;
- MultiKey(final ListEffectiveStatement schema, final Class<? extends Identifier<?>> keyClass,
+ MultiKey(final ListEffectiveStatement schema, final Class<? extends Key<?>> keyClass,
final Class<?> identifiable, final Map<QName, ValueContext> keyValueContexts) {
super(schema, keyClass, identifiable);
final var tmpCtor = getConstructor(keyClass, keyValueContexts.size());
final var inv = MethodHandles.spreadInvoker(tmpCtor.type(), 0);
- ctor = inv.asType(inv.type().changeReturnType(Identifier.class)).bindTo(tmpCtor);
+ ctor = inv.asType(inv.type().changeReturnType(Key.class)).bindTo(tmpCtor);
/*
* We need to re-index to make sure we instantiate nodes in the order in which they are defined. We will
}
@Override
- Identifier<?> deserializeIdentifierImpl(final NodeIdentifierWithPredicates nip) throws Throwable {
+ Key<?> deserializeIdentifierImpl(final NodeIdentifierWithPredicates nip) throws Throwable {
final var bindingValues = new Object[keysInBindingOrder.size()];
int offset = 0;
for (var key : keysInBindingOrder) {
bindingValues[offset++] = keyValueContexts.get(key).deserialize(nip.getValue(key));
}
- return (Identifier<?>) ctor.invokeExact(bindingValues);
+ return (Key<?>) ctor.invokeExact(bindingValues);
}
@Override
- NodeIdentifierWithPredicates serializeIdentifier(final QName qname, final Identifier<?> key) {
+ NodeIdentifierWithPredicates serializeIdentifier(final QName qname, final Key<?> key) {
final var values = new Object[keyValueContexts.size()];
int offset = 0;
for (var valueCtx : keyValueContexts.values()) {
private final Class<?> identifiable;
private final QName qname;
- private IdentifiableItemCodec(final ListEffectiveStatement schema, final Class<? extends Identifier<?>> keyClass,
+ private IdentifiableItemCodec(final ListEffectiveStatement schema, final Class<? extends Key<?>> keyClass,
final Class<?> identifiable) {
this.identifiable = requireNonNull(identifiable);
qname = schema.argument();
}
- static IdentifiableItemCodec of(final ListEffectiveStatement schema, final Class<? extends Identifier<?>> keyClass,
+ static IdentifiableItemCodec of(final ListEffectiveStatement schema, final Class<? extends Key<?>> keyClass,
final Class<?> identifiable, final Map<QName, ValueContext> keyValueContexts) {
return switch (keyValueContexts.size()) {
case 0 -> throw new IllegalArgumentException(
@SuppressWarnings({ "rawtypes", "unchecked" })
final @NonNull IdentifiableItem<?, ?> domToBinding(final NodeIdentifierWithPredicates input) {
- return IdentifiableItem.of((Class) identifiable, (Identifier) deserializeIdentifier(requireNonNull(input)));
+ return IdentifiableItem.of((Class) identifiable, (Key) deserializeIdentifier(requireNonNull(input)));
}
final @NonNull NodeIdentifierWithPredicates bindingToDom(final IdentifiableItem<?, ?> input) {
}
@SuppressWarnings("checkstyle:illegalCatch")
- final @NonNull Identifier<?> deserializeIdentifier(final @NonNull NodeIdentifierWithPredicates input) {
+ final @NonNull Key<?> deserializeIdentifier(final @NonNull NodeIdentifierWithPredicates input) {
try {
return deserializeIdentifierImpl(input);
} catch (Throwable e) {
}
@SuppressWarnings("checkstyle:illegalThrows")
- abstract @NonNull Identifier<?> deserializeIdentifierImpl(@NonNull NodeIdentifierWithPredicates nip)
- throws Throwable;
+ abstract @NonNull Key<?> deserializeIdentifierImpl(@NonNull NodeIdentifierWithPredicates nip) throws Throwable;
- abstract @NonNull NodeIdentifierWithPredicates serializeIdentifier(QName qname, Identifier<?> key);
+ abstract @NonNull NodeIdentifierWithPredicates serializeIdentifier(QName qname, Key<?> key);
- static MethodHandle getConstructor(final Class<? extends Identifier<?>> clazz, final int nrArgs) {
+ static MethodHandle getConstructor(final Class<? extends Key<?>> clazz, final int nrArgs) {
for (var ctor : clazz.getConstructors()) {
// Check argument count
if (ctor.getParameterCount() != nrArgs) {
package org.opendaylight.mdsal.binding.dom.codec.impl;
import static java.util.Objects.requireNonNull;
-import static org.opendaylight.yangtools.yang.binding.contract.Naming.IDENTIFIABLE_KEY_NAME;
import java.lang.reflect.Method;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.runtime.api.ListRuntimeType;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.Ordering;
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;
-abstract sealed class KeyedListNodeCodecContext<I extends Identifier<D>, D extends DataObject & Identifiable<I>>
+abstract sealed class KeyedListNodeCodecContext<I extends Key<D>, D extends DataObject & KeyAware<I>>
extends ListNodeCodecContext<D> {
- private static final class Ordered<I extends Identifier<D>, D extends DataObject & Identifiable<I>>
+ private static final class Ordered<I extends Key<D>, D extends DataObject & KeyAware<I>>
extends KeyedListNodeCodecContext<I, D> {
Ordered(final DataContainerCodecPrototype<ListRuntimeType> prototype, final Method keyMethod,
final IdentifiableItemCodec codec) {
}
}
- static final class Unordered<I extends Identifier<D>, D extends DataObject & Identifiable<I>>
+ static final class Unordered<I extends Key<D>, D extends DataObject & KeyAware<I>>
extends KeyedListNodeCodecContext<I, D> {
Unordered(final DataContainerCodecPrototype<ListRuntimeType> prototype, final Method keyMethod,
final IdentifiableItemCodec codec) {
final Class<?> bindingClass = prototype.getBindingClass();
final Method keyMethod;
try {
- keyMethod = bindingClass.getMethod(IDENTIFIABLE_KEY_NAME);
+ keyMethod = bindingClass.getMethod(Naming.KEY_AWARE_KEY_NAME);
} catch (NoSuchMethodException e) {
throw new IllegalStateException("Required method not available", e);
}
}
@SuppressWarnings({ "rawtypes", "unchecked" })
- NodeIdentifierWithPredicates serialize(final Identifier<?> key) {
- return codec.bindingToDom(IdentifiableItem.of((Class)getBindingClass(), (Identifier)key));
+ NodeIdentifierWithPredicates serialize(final Key<?> key) {
+ return codec.bindingToDom(IdentifiableItem.of((Class)getBindingClass(), (Key)key));
}
- @NonNull Identifier<?> deserialize(final @NonNull NodeIdentifierWithPredicates arg) {
+ @NonNull Key<?> deserialize(final @NonNull NodeIdentifierWithPredicates arg) {
return codec.deserializeIdentifier(arg);
}
import org.opendaylight.mdsal.binding.dom.codec.impl.KeyedListNodeCodecContext.Unordered;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
* @param <K> key type
* @param <V> value type
*/
-final class LazyBindingMap<K extends Identifier<V>, V extends DataObject & Identifiable<K>>
+final class LazyBindingMap<K extends Key<V>, V extends DataObject & KeyAware<K>>
extends AbstractMap<K, V> implements Immutable {
private static final Logger LOG = LoggerFactory.getLogger(LazyBindingMap.class);
private static final String LAZY_CUTOFF_PROPERTY =
this.mapNode = requireNonNull(mapNode);
}
- static <K extends Identifier<V>, V extends DataObject & Identifiable<K>> @NonNull Map<K, V> create(
+ static <K extends Key<V>, V extends DataObject & KeyAware<K>> @NonNull Map<K, V> create(
final Unordered<K, V> codec, final MapNode mapNode, final int size) {
if (size == 1) {
// Do not bother with lazy instantiation in case of a singleton
return size > LAZY_CUTOFF ? new LazyBindingMap<>(codec, mapNode) : eagerMap(codec, mapNode, size);
}
- private static <K extends Identifier<V>, V extends DataObject & Identifiable<K>> @NonNull Map<K, V> eagerMap(
+ private static <K extends Key<V>, V extends DataObject & KeyAware<K>> @NonNull Map<K, V> eagerMap(
final Unordered<K, V> codec, final MapNode mapNode, final int size) {
final Builder<K, V> builder = ImmutableMap.builderWithExpectedSize(size);
for (MapEntryNode node : mapNode.body()) {
@Override
public boolean containsValue(final Object value) {
/*
- * This implementation relies on the relationship specified by Identifiable/Identifier and its use in binding
- * objects. The key is a wrapper object composed of a subset (or all) properties in the value, i.e. we have
- * a partial index.
+ * This implementation relies on the relationship specified by KeyAware/Key and its use in binding objects. The
+ * key is a wrapper object composed of a subset (or all) properties in the value, i.e. we have a partial index.
*
* Instead of performing an O(N) search, we extract the key from the value, look the for the corresponding
* mapping. If we find a mapping we check if the mapped value equals the the value being looked up.
}
Optional<V> lookupValue(final @NonNull Object key) {
- final NodeIdentifierWithPredicates childId = codec.serialize((Identifier<?>) key);
+ final NodeIdentifierWithPredicates childId = codec.serialize((Key<?>) key);
return mapNode.findChildByArg(childId).map(codec::createBindingProxy);
}
return new UnsupportedOperationException("Modification is not supported");
}
- abstract static class State<K extends Identifier<V>, V extends DataObject & Identifiable<K>> {
+ abstract static class State<K extends Key<V>, V extends DataObject & KeyAware<K>> {
abstract boolean containsKey(@NonNull Object key);
abstract V get(@NonNull Object key);
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @param <K> key type
* @param <V> value type
*/
-final class LazyBindingMapIterState<K extends Identifier<V>, V extends DataObject & Identifiable<K>>
+final class LazyBindingMapIterState<K extends Key<V>, V extends DataObject & KeyAware<K>>
extends LazyBindingMap.State<K, V> {
private static final Logger LOG = LoggerFactory.getLogger(LazyBindingMapIterState.class);
private static final VarHandle ENTRY_SET;
return (witness = KEY_SET.compareAndExchangeRelease(this, null, ret)) == null ? ret : (KeySet<K, V>) witness;
}
- private static final class EntrySet<K extends Identifier<V>, V extends DataObject & Identifiable<K>>
+ private static final class EntrySet<K extends Key<V>, V extends DataObject & KeyAware<K>>
extends AbstractSet<Entry<K, V>> implements Immutable {
private final Values<K, V> values;
}
}
- private static final class KeySet<K extends Identifier<V>, V extends DataObject & Identifiable<K>>
+ private static final class KeySet<K extends Key<V>, V extends DataObject & KeyAware<K>>
extends AbstractSet<K> implements Immutable {
private final Values<K, V> values;
@Override
public Iterator<K> iterator() {
- return Iterators.transform(values.iterator(), value -> value.key());
+ return Iterators.transform(values.iterator(), KeyAware::key);
}
@Override
* the array to hold all values upfront and populate it with MapEntry nodes. That allows us to perform lock-free
* access, as we just end up CASing MapEntryNodes with their Binding replacements.
*/
- private static final class Values<K extends Identifier<V>, V extends DataObject & Identifiable<K>>
+ private static final class Values<K extends Key<V>, V extends DataObject & KeyAware<K>>
extends AbstractSet<V> implements Immutable {
private final LazyBindingMap<K, V> map;
private final Object[] objects;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
/**
* @param <K> key type
* @param <V> value type
*/
-final class LazyBindingMapLookupState<K extends Identifier<V>, V extends DataObject & Identifiable<K>>
+final class LazyBindingMapLookupState<K extends Key<V>, V extends DataObject & KeyAware<K>>
extends LazyBindingMap.State<K, V> {
private static final VarHandle VALUES;
return (witness = VALUES.compareAndExchangeRelease(this, null, ret)) == null ? ret : (Values<K, V>) witness;
}
- private static final class EntrySet<K extends Identifier<V>, V extends DataObject & Identifiable<K>>
+ private static final class EntrySet<K extends Key<V>, V extends DataObject & KeyAware<K>>
extends AbstractSet<Entry<K, V>> implements Immutable {
private final Values<K, V> values;
}
}
- private static final class KeySet<K extends Identifier<V>, V extends DataObject & Identifiable<K>>
+ private static final class KeySet<K extends Key<V>, V extends DataObject & KeyAware<K>>
extends AbstractSet<K> implements Immutable {
private final Values<K, V> values;
}
}
- private static final class Values<K extends Identifier<V>, V extends DataObject & Identifiable<K>>
+ private static final class Values<K extends Key<V>, V extends DataObject & KeyAware<K>>
extends AbstractSet<V> implements Immutable {
private final LazyBindingMapLookupState<K, V> state;
final Object[] local = objects;
// When we have null objects it means we have everyone in state.objects
return local == null ? Iterators.unmodifiableIterator(state.objects.keySet().iterator())
- : Iterators.transform(new ValuesIter<>(this, local), value -> value.key());
+ : Iterators.transform(new ValuesIter<>(this, local), KeyAware::key);
}
LazyBindingMap<K, V> map() {
}
}
- private static final class ValuesIter<K extends Identifier<V>, V extends DataObject & Identifiable<K>>
+ private static final class ValuesIter<K extends Key<V>, V extends DataObject & KeyAware<K>>
extends AbstractIterator<V> {
private final Values<K, V> values;
private final Object[] objects;
import org.opendaylight.yang.gen.v1.urn.test.opendaylight.mdsal45.base.norev.cont.cont.choice.ContBase;
import org.opendaylight.yang.gen.v1.urn.test.opendaylight.mdsal45.base.norev.grp.GrpCont;
import org.opendaylight.yang.gen.v1.urn.test.opendaylight.mdsal45.base.norev.root.RootBase;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.Key;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
assertEquals(TopLevelList.class, instanceIdentifier.getTargetType());
assertFalse(instanceIdentifier.isWildcarded());
assertTrue(last instanceof InstanceIdentifier.IdentifiableItem);
- final Identifier<?> key = ((InstanceIdentifier.IdentifiableItem<?, ?>) last).getKey();
+ final Key<?> key = ((InstanceIdentifier.IdentifiableItem<?, ?>) last).getKey();
assertEquals(TopLevelListKey.class, key.getClass());
assertEquals(TOP_LEVEL_LIST_KEY_VALUE, ((TopLevelListKey)key).getName());
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelListKey;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
QName.create(OspfStatLsdbBrief.QNAME, "LsId"), 3,
QName.create(OspfStatLsdbBrief.QNAME, "AdvRtr"), "foo"))));
assertTrue(result instanceof KeyedInstanceIdentifier);
- final Identifier<?> key = ((KeyedInstanceIdentifier<?, ?>) result).getKey();
+ final var key = ((KeyedInstanceIdentifier<?, ?>) result).getKey();
assertEquals(new OspfStatLsdbBriefKey("foo", 1, 3, Uint8.valueOf(2)), key);
}
}
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.top.level.list.NestedListBuilder;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
public class LazyBindingMapTest extends AbstractBindingCodecTest {
private static Top TOP;
}
private static void assertSameIteratorObjects(final Collection<?> collection) {
- final Iterator<?> iter1 = collection.iterator();
- final Iterator<?> iter2 = collection.iterator();
+ final var iter1 = collection.iterator();
+ final var iter2 = collection.iterator();
while (iter1.hasNext()) {
// Both iterators should return same values
public void testLookupContainsKeyThrows() {
final Map<TopLevelListKey, TopLevelList> list = prepareData().getTopLevelList();
assertThrows(NullPointerException.class, () -> list.containsKey(null));
- assertThrows(ClassCastException.class, () -> list.containsKey(mock(Identifiable.class)));
+ assertThrows(ClassCastException.class, () -> list.containsKey(mock(KeyAware.class)));
}
@Test
GeneratedTransferObject createTypeImpl(final TypeBuilderFactory builderFactory) {
final var builder = builderFactory.newGeneratedTOBuilder(typeName());
- builder.addImplementsType(BindingTypes.identifier(Type.of(listGen.typeName())));
+ builder.addImplementsType(BindingTypes.key(Type.of(listGen.typeName())));
final var leafNames = statement().argument();
for (var listChild : listGen) {
*/
package org.opendaylight.mdsal.binding.generator.impl.reactor;
-import static org.opendaylight.mdsal.binding.model.ri.BindingTypes.identifiable;
+import static org.opendaylight.mdsal.binding.model.ri.BindingTypes.keyAware;
import java.util.List;
import org.eclipse.jdt.annotation.Nullable;
if (keyGen != null) {
// Add yang.binding.Identifiable and its key() method
final GeneratedType keyType = keyGen.getGeneratedType(builderFactory);
- builder.addImplementsType(identifiable(keyType));
- builder.addMethod(Naming.IDENTIFIABLE_KEY_NAME)
+ builder.addImplementsType(keyAware(keyType));
+ builder.addMethod(Naming.KEY_AWARE_KEY_NAME)
.setReturnType(keyType)
.addAnnotation(OVERRIDE_ANNOTATION);
}
MethodSignature getIfcKeyMethod = null;
for (final MethodSignature method : gtInterfaceMethods) {
- if (Naming.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
+ if (Naming.KEY_AWARE_KEY_NAME.equals(method.getName())) {
getIfcKeyMethod = method;
break;
}
MethodSignature getTunnelKeyMethod = null;
for (MethodSignature method : tunnelMethods) {
- if (Naming.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
+ if (Naming.KEY_AWARE_KEY_NAME.equals(method.getName())) {
getTunnelKeyMethod = method;
break;
}
assertNotNull("gtInterfaceMethods is null", gtInterfaceMethods);
MethodSignature getIfcKeyMethod = null;
for (final MethodSignature method : gtInterfaceMethods) {
- if (Naming.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
+ if (Naming.KEY_AWARE_KEY_NAME.equals(method.getName())) {
getIfcKeyMethod = method;
break;
}
assertNotNull("Tunnel methods are null", tunnelMethods);
MethodSignature getTunnelKeyMethod = null;
for (MethodSignature method : tunnelMethods) {
- if (Naming.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
+ if (Naming.KEY_AWARE_KEY_NAME.equals(method.getName())) {
getTunnelKeyMethod = method;
break;
}
MethodSignature getHigherLayerIf = null;
for (final MethodSignature method : gtIfcMethods) {
switch (method.getName()) {
- case Naming.IDENTIFIABLE_KEY_NAME:
+ case Naming.KEY_AWARE_KEY_NAME:
getIfcKey = method;
break;
case "getHigherLayerIf":
assertNotNull(gtTunnelMethods);
MethodSignature getTunnelKey = null;
for (MethodSignature method : gtTunnelMethods) {
- if (Naming.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
+ if (Naming.KEY_AWARE_KEY_NAME.equals(method.getName())) {
getTunnelKey = method;
}
}
final List<MethodSignature> methods = genType.getMethodDefinitions();
for (final MethodSignature method : methods) {
switch (method.getName()) {
- case Naming.IDENTIFIABLE_KEY_NAME:
+ case Naming.KEY_AWARE_KEY_NAME:
getSimpleListKeyMethodCount++;
getSimpleListKeyMethodReturnTypeName = method.getReturnType().getName();
break;
@«OVERRIDE.importedName»
«ELSE»
/**
- * Return current value associated with the property corresponding to {@link «targetType.importedName»#«Naming.IDENTIFIABLE_KEY_NAME»()}.
+ * Return current value associated with the property corresponding to {@link «targetType.importedName»#«Naming.KEY_AWARE_KEY_NAME»()}.
*
* @return current value
*/
«ENDIF»
- public «keyType.importedName» «Naming.IDENTIFIABLE_KEY_NAME»() {
+ public «keyType.importedName» «Naming.KEY_AWARE_KEY_NAME»() {
return key;
}
«IF augmentType !== null»
«generateCopyAugmentation(implType)»
«ENDIF»
- «IF keyType !== null && implementsIfc(targetType, BindingTypes.identifiable(targetType))»
+ «IF keyType !== null && implementsIfc(targetType, BindingTypes.keyAware(targetType))»
«val keyProps = new ArrayList((keyType as GeneratedTransferObject).properties)»
«keyProps.sort(KEY_PROPS_COMPARATOR)»
«val allProps = new ArrayList(properties)»
private static Type getKey(final GeneratedType type) {
for (MethodSignature m : type.getMethodDefinitions()) {
- if (Naming.IDENTIFIABLE_KEY_NAME.equals(m.getName())) {
+ if (Naming.KEY_AWARE_KEY_NAME.equals(m.getName())) {
return m.getReturnType();
}
}
import static org.opendaylight.yangtools.yang.binding.contract.Naming.BINDING_HASHCODE_NAME
import static org.opendaylight.yangtools.yang.binding.contract.Naming.BINDING_TO_STRING_NAME
import static org.opendaylight.yangtools.yang.binding.contract.Naming.BUILDER_SUFFIX
-import static org.opendaylight.yangtools.yang.binding.contract.Naming.IDENTIFIABLE_KEY_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.KEY_AWARE_KEY_NAME
import static org.opendaylight.yangtools.yang.binding.contract.Naming.NONNULL_PREFIX
import java.util.Collection
def private generateGetters() '''
«IF keyType !== null»
@«OVERRIDE.importedName»
- public «keyType.importedName» «IDENTIFIABLE_KEY_NAME»() {
+ public «keyType.importedName» «KEY_AWARE_KEY_NAME»() {
return key;
}
'''
override protected generateCopyKeys(List<GeneratedProperty> keyProps) '''
- if (base.«IDENTIFIABLE_KEY_NAME»() != null) {
- this.key = base.«IDENTIFIABLE_KEY_NAME»();
+ if (base.«KEY_AWARE_KEY_NAME»() != null) {
+ this.key = base.«KEY_AWARE_KEY_NAME»();
} else {
this.key = new «keyType.importedName»(«FOR keyProp : keyProps SEPARATOR ", "»base.«keyProp.getterMethodName»()«ENDFOR»);
}
import static org.opendaylight.yangtools.yang.binding.contract.Naming.AUGMENTABLE_AUGMENTATION_NAME
import static org.opendaylight.yangtools.yang.binding.contract.Naming.AUGMENTATION_FIELD
import static org.opendaylight.yangtools.yang.binding.contract.Naming.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME
-import static org.opendaylight.yangtools.yang.binding.contract.Naming.IDENTIFIABLE_KEY_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.KEY_AWARE_KEY_NAME
import com.google.common.collect.ImmutableList
import com.google.common.collect.ImmutableSet
def private generateSetters() '''
«IF keyType !== null»
/**
- * Set the key value corresponding to {@link «targetType.importedName»#«IDENTIFIABLE_KEY_NAME»()} to the specified
+ * Set the key value corresponding to {@link «targetType.importedName»#«KEY_AWARE_KEY_NAME»()} to the specified
* value.
*
* @param key desired value
'''
override protected generateCopyKeys(List<GeneratedProperty> keyProps) '''
- this.key = base.«IDENTIFIABLE_KEY_NAME»();
+ this.key = base.«KEY_AWARE_KEY_NAME»();
«FOR field : keyProps»
this.«field.fieldName» = base.«field.getterMethodName»();
«ENDFOR»
private static def Type findListType(GeneratedType type) {
for (Type implType : type.getImplements()) {
if (implType instanceof ParameterizedType) {
- val identifiable = BindingTypes.extractIdentifiable(implType)
+ val identifiable = BindingTypes.extractKeyType(implType)
if (identifiable !== null) {
return identifiable
}
// Test serialVersionUID generation
final Field suid = CompilationTestUtils.assertContainsField(linksKeyClass, "serialVersionUID", Long.TYPE);
suid.setAccessible(true);
- assertEquals(-8829501012356283881L, suid.getLong(null));
+ assertEquals(-8290985055387641395L, suid.getLong(null));
CompilationTestUtils.cleanUp(sourcesOutputDir, compiledOutputDir);
}
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.DataRoot;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceNotification;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedListAction;
import org.opendaylight.yangtools.yang.binding.KeyedListNotification;
@VisibleForTesting
static final ConcreteType AUGMENTATION = typeForClass(Augmentation.class);
@VisibleForTesting
- static final ConcreteType IDENTIFIABLE = typeForClass(Identifiable.class);
+ static final ConcreteType KEY_AWARE = typeForClass(KeyAware.class);
@VisibleForTesting
- static final ConcreteType IDENTIFIER = typeForClass(Identifier.class);
+ static final ConcreteType KEY = typeForClass(Key.class);
private static final ConcreteType ACTION = typeForClass(Action.class);
private static final ConcreteType CHILD_OF = typeForClass(ChildOf.class);
}
/**
- * Type specializing {@link Identifier} for a particular type.
+ * Type specializing {@link Key} for a particular type.
*
* @param type Type for which to specialize
- * @return A parameterized type corresponding to {@code Identifier<Type>}
+ * @return A parameterized type corresponding to {@code Key<Type>}
* @throws NullPointerException if {@code type} is {@code null}
*/
- public static ParameterizedType identifier(final Type type) {
- return parameterizedTypeFor(IDENTIFIER, type);
+ public static ParameterizedType key(final Type type) {
+ return parameterizedTypeFor(KEY, type);
}
/**
- * Type specializing {@link Identifiable} for a particular type.
+ * Type specializing {@link KeyAware} for a particular type.
*
* @param type Type for which to specialize
- * @return A parameterized type corresponding to {@code Identifiable<Type>}
+ * @return A parameterized type corresponding to {@code KeyAware<Type>}
* @throws NullPointerException if {@code type} is {@code null}
*/
- public static ParameterizedType identifiable(final Type type) {
- return parameterizedTypeFor(IDENTIFIABLE, type);
+ public static ParameterizedType keyAware(final Type type) {
+ return parameterizedTypeFor(KEY_AWARE, type);
}
/**
}
/**
- * Return the {@link Identifiable} type a parameterized {@link Identifier} type references.
+ * Return the {@link KeyAware} type a parameterized {@link Key} type references.
*
* @param type Parameterized type
- * @return Identifiable target, or null if {@code type} does not match the result of {@link #identifier(Type)}
+ * @return Identifiable target, or null if {@code type} does not match the result of {@link #key(Type)}
* @throws NullPointerException if {@code type} is {@code null}
*/
@Beta
- public static @Nullable Type extractIdentifiable(final ParameterizedType type) {
- if (IDENTIFIER.equals(type.getRawType())) {
+ public static @Nullable Type extractKeyType(final ParameterizedType type) {
+ if (KEY.equals(type.getRawType())) {
final var args = type.getActualTypeArguments();
if (args.length == 1) {
final var arg = args[0];
import org.opendaylight.yangtools.yang.binding.BaseIdentity;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.DataRoot;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
import org.opendaylight.yangtools.yang.binding.RpcService;
assertEquals("BASE_IDENTITY", typeForClass(BaseIdentity.class), BindingTypes.BASE_IDENTITY);
assertEquals("DATA_OBJECT", typeForClass(DataObject.class), BindingTypes.DATA_OBJECT);
assertEquals("DATA_ROOT", typeForClass(DataRoot.class), BindingTypes.DATA_ROOT);
- assertEquals("IDENTIFIABLE", typeForClass(Identifiable.class), BindingTypes.IDENTIFIABLE);
- assertEquals("IDENTIFIER", typeForClass(Identifier.class), BindingTypes.IDENTIFIER);
+ assertEquals("KEY_AWARE", typeForClass(KeyAware.class), BindingTypes.KEY_AWARE);
+ assertEquals("KEY", typeForClass(Key.class), BindingTypes.KEY);
assertEquals("INSTANCE_IDENTIFIER", typeForClass(InstanceIdentifier.class), BindingTypes.INSTANCE_IDENTIFIER);
assertEquals("NOTIFICATION_LISTENER", typeForClass(NotificationListener.class),
BindingTypes.NOTIFICATION_LISTENER);
* @return key associated with the component, or null if the component type
* is not present.
*/
- public final <N extends Identifiable<K> & DataObject, K extends Identifier<N>> @Nullable K firstKeyOf(
+ public final <N extends KeyAware<K> & DataObject, K extends Key<N>> @Nullable K firstKeyOf(
final Class<@NonNull N> listItem) {
for (final PathArgument i : pathArguments) {
if (listItem.equals(i.getType())) {
* @throws NullPointerException if any argument is null
*/
@SuppressWarnings("unchecked")
- public final <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>>
+ public final <N extends KeyAware<K> & ChildOf<? super T>, K extends Key<N>>
@NonNull KeyedInstanceIdentifier<N, K> child(final Class<@NonNull N> listItem, final K listKey) {
return (KeyedInstanceIdentifier<N, K>) childIdentifier(IdentifiableItem.of(listItem, listKey));
}
*/
// 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(
+ public final <C extends ChoiceIn<? super T> & DataObject, K extends Key<N>,
+ N extends KeyAware<K> & ChildOf<? super C>> @NonNull KeyedInstanceIdentifier<N, K> child(
final Class<@NonNull C> caze, final Class<@NonNull N> listItem, final K listKey) {
return (KeyedInstanceIdentifier<N, K>) childIdentifier(IdentifiableItem.of(caze, listItem, listKey));
}
* @return A new {@link Builder}
* @throws NullPointerException if any argument is null
*/
- public static <N extends Identifiable<K> & ChildOf<? extends DataRoot>,
- K extends Identifier<N>> @NonNull KeyedBuilder<N, K> builder(final Class<N> listItem,
+ public static <N extends KeyAware<K> & ChildOf<? extends DataRoot>,
+ K extends Key<N>> @NonNull KeyedBuilder<N, K> builder(final Class<N> listItem,
final K listKey) {
return new KeyedBuilder<>(IdentifiableItem.of(listItem, listKey));
}
* @throws NullPointerException if any argument is null
*/
public static <C extends ChoiceIn<? extends DataRoot> & DataObject,
- N extends Identifiable<K> & ChildOf<? super C>, K extends Identifier<N>>
+ N extends KeyAware<K> & ChildOf<? super C>, K extends Key<N>>
@NonNull KeyedBuilder<N, K> builder(final Class<C> caze, final Class<N> listItem,
final K listKey) {
return new KeyedBuilder<>(IdentifiableItem.of(caze, listItem, listKey));
return new RegularBuilder<>(Item.of(caze, container));
}
- public static <R extends DataRoot & DataObject, N extends Identifiable<K> & ChildOf<? super R>,
- K extends Identifier<N>>
+ public static <R extends DataRoot & DataObject, N extends KeyAware<K> & ChildOf<? super R>,
+ K extends Key<N>>
@NonNull KeyedBuilder<N, K> builderOfInherited(final Class<R> root,
final Class<N> listItem, final K listKey) {
// FIXME: we are losing root identity, hence namespaces may not work correctly
}
public static <R extends DataRoot & DataObject, C extends ChoiceIn<? super R> & DataObject,
- N extends Identifiable<K> & ChildOf<? super C>, K extends Identifier<N>>
+ N extends KeyAware<K> & ChildOf<? super C>, K extends Key<N>>
@NonNull KeyedBuilder<N, K> builderOfInherited(final Class<R> root,
final Class<C> caze, final Class<N> listItem, final K listKey) {
// FIXME: we are losing root identity, hence namespaces may not work correctly
hashBuilder.addArgument(arg);
- if (Identifiable.class.isAssignableFrom(type) && !(arg instanceof IdentifiableItem)) {
+ if (KeyAware.class.isAssignableFrom(type) && !(arg instanceof IdentifiableItem)) {
wildcard = true;
}
} while (it.hasNext());
* @throws NullPointerException if id is null.
*/
// FIXME: reconsider naming and design of this method
- public static <N extends Identifiable<K> & DataObject, K extends Identifier<N>> K keyOf(
+ public static <N extends KeyAware<K> & DataObject, K extends Key<N>> K keyOf(
final InstanceIdentifier<N> id) {
requireNonNull(id);
checkArgument(id instanceof KeyedInstanceIdentifier, "%s does not have a key", id);
}
final var type = arg.getType();
- return new InstanceIdentifier(type, pathArguments, wildcarded || Identifiable.class.isAssignableFrom(type),
+ return new InstanceIdentifier(type, pathArguments, wildcarded || KeyAware.class.isAssignableFrom(type),
hash);
}
* @param <I> An object that is identifiable by an identifier
* @param <T> The identifier of the object
*/
- public static class IdentifiableItem<I extends Identifiable<T> & DataObject, T extends Identifier<I>>
+ public static class IdentifiableItem<I extends KeyAware<T> & DataObject, T extends Key<I>>
extends AbstractPathArgument<I> {
@Serial
private static final long serialVersionUID = 1L;
* @return An IdentifiableItem
* @throws NullPointerException if any argument is null.
*/
- public static <T extends Identifiable<I> & DataObject, I extends Identifier<T>>
+ public static <T extends KeyAware<I> & DataObject, I extends Key<T>>
@NonNull IdentifiableItem<T, I> of(final Class<T> type, final I key) {
return new IdentifiableItem<>(type, key);
}
* @return A new PathArgument
* @throws NullPointerException if any argument is null.
*/
- public static <C extends ChoiceIn<?> & DataObject, T extends ChildOf<? super C> & Identifiable<I>,
- I extends Identifier<T>> @NonNull IdentifiableItem<T, I> of(final Class<C> caseType,
+ public static <C extends ChoiceIn<?> & DataObject, T extends ChildOf<? super C> & KeyAware<I>,
+ I extends Key<T>> @NonNull IdentifiableItem<T, I> of(final Class<C> caseType,
final Class<T> type, final I key) {
return new CaseIdentifiableItem<>(caseType, type, key);
}
}
private static final class CaseIdentifiableItem<C extends ChoiceIn<?> & DataObject,
- T extends ChildOf<? super C> & Identifiable<K>, K extends Identifier<T>> extends IdentifiableItem<T, K> {
+ T extends ChildOf<? super C> & KeyAware<K>, K extends Key<T>> extends IdentifiableItem<T, K> {
@Serial
private static final long serialVersionUID = 1L;
* @throws NullPointerException if {@code container} is null
*/
public final <N extends ChildOf<? super T>> Builder<N> child(final Class<N> container) {
- return append(Item.of(container), Identifiable.class.isAssignableFrom(container));
+ return append(Item.of(container), KeyAware.class.isAssignableFrom(container));
}
/**
*/
public final <C extends ChoiceIn<? super T> & DataObject, N extends ChildOf<? super C>> Builder<N> child(
final Class<C> caze, final Class<N> container) {
- return append(Item.of(caze, container), Identifiable.class.isAssignableFrom(container));
+ return append(Item.of(caze, container), KeyAware.class.isAssignableFrom(container));
}
/**
* @return this builder
* @throws NullPointerException if any argument is null
*/
- public final <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>> KeyedBuilder<N, K> child(
+ public final <N extends KeyAware<K> & ChildOf<? super T>, K extends Key<N>> KeyedBuilder<N, K> child(
final Class<@NonNull N> listItem, final K listKey) {
return append(IdentifiableItem.of(listItem, listKey));
}
* @return this builder
* @throws NullPointerException if any argument is null
*/
- public final <C extends ChoiceIn<? super T> & DataObject, K extends Identifier<N>,
- N extends Identifiable<K> & ChildOf<? super C>> KeyedBuilder<N, K> child(final Class<C> caze,
+ public final <C extends ChoiceIn<? super T> & DataObject, K extends Key<N>,
+ N extends KeyAware<K> & ChildOf<? super C>> KeyedBuilder<N, K> child(final Class<C> caze,
final Class<N> listItem, final K listKey) {
return append(IdentifiableItem.of(caze, listItem, listKey));
}
abstract <X extends DataObject> @NonNull RegularBuilder<X> append(Item<X> item, boolean isWildcard);
- abstract <X extends DataObject & Identifiable<Y>, Y extends Identifier<X>>
+ abstract <X extends DataObject & KeyAware<Y>, Y extends Key<X>>
@NonNull KeyedBuilder<X, Y> append(IdentifiableItem<X, Y> item);
}
- public static final class KeyedBuilder<T extends DataObject & Identifiable<K>, K extends Identifier<T>>
+ public static final class KeyedBuilder<T extends DataObject & KeyAware<K>, K extends Key<T>>
extends Builder<T> {
private @NonNull IdentifiableItem<T, K> lastItem;
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
- <X extends DataObject & Identifiable<Y>, Y extends Identifier<X>> KeyedBuilder<X, Y> append(
+ <X extends DataObject & KeyAware<Y>, Y extends Key<X>> KeyedBuilder<X, Y> append(
final IdentifiableItem<X, Y> item) {
appendItem(item, false);
lastItem = (IdentifiableItem) item;
private @NonNull Class<T> type;
RegularBuilder(final Item<T> item) {
- super(item, Identifiable.class.isAssignableFrom(item.getType()));
+ super(item, KeyAware.class.isAssignableFrom(item.getType()));
type = item.getType();
}
}
@Override
- <X extends DataObject & Identifiable<Y>, Y extends Identifier<X>> KeyedBuilder<X, Y> append(
+ <X extends DataObject & KeyAware<Y>, Y extends Key<X>> KeyedBuilder<X, Y> append(
final IdentifiableItem<X, Y> item) {
return new KeyedBuilder<>(this, item);
}
*/
package org.opendaylight.yangtools.yang.binding;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import org.opendaylight.yangtools.concepts.Identifier;
/**
* Object is unique identifier for another object.
*
* @param <T> Class of object for which this object is identifier
- * @author ttkacik
*/
-@SuppressFBWarnings(value = "NM_SAME_SIMPLE_NAME_AS_INTERFACE", justification = "This is binding specialization")
-public interface Identifier<T extends Identifiable<?>> extends org.opendaylight.yangtools.concepts.Identifier {
+public interface Key<T extends KeyAware<?>> extends Identifier {
}
* Identifiable object, which could be identified by it's key.
*
* @param <T> Identifier class for this object
- *
- * @author ttkacik
*/
-public interface Identifiable<T extends Identifier<? extends Identifiable<T>>> {
+public interface KeyAware<T extends Key<? extends KeyAware<T>>> {
/**
* Returns an unique key for the object.
*
* @param <T> Target data type
* @param <K> Target key type
*/
-public class KeyedInstanceIdentifier<T extends Identifiable<K> & DataObject, K extends Identifier<T>>
+public class KeyedInstanceIdentifier<T extends KeyAware<K> & DataObject, K extends Key<T>>
extends InstanceIdentifier<T> {
@Serial
private static final long serialVersionUID = 2L;
import java.io.Serial;
import org.eclipse.jdt.annotation.Nullable;
-final class KeyedInstanceIdentifierV2<T extends Identifiable<K> & DataObject, K extends Identifier<T>>
+final class KeyedInstanceIdentifierV2<T extends KeyAware<K> & DataObject, K extends Key<T>>
extends InstanceIdentifierV3<T> {
@Serial
private static final long serialVersionUID = 2L;
*
* @author Robert Varga
*/
-public interface KeyedListAction<K extends Identifier<T>, T extends DataObject & Identifiable<K>,
+public interface KeyedListAction<K extends Key<T>, T extends DataObject & KeyAware<K>,
I extends RpcInput, O extends RpcOutput> extends Action<KeyedInstanceIdentifier<T, K>, I, O> {
@Override
@CheckReturnValue
* @param <K> Parent data tree key type
*/
@Beta
-public interface KeyedListNotification<N extends KeyedListNotification<N, T, K>, T extends DataObject & Identifiable<K>,
- K extends Identifier<T>> extends InstanceNotification<N, T> {
+public interface KeyedListNotification<N extends KeyedListNotification<N, T, K>, T extends DataObject & KeyAware<K>,
+ K extends Key<T>> extends InstanceNotification<N, T> {
}
import org.opendaylight.yangtools.yang.binding.Action;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.BindingContract;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.Rpc;
import org.opendaylight.yangtools.yang.binding.RpcInput;
import org.opendaylight.yangtools.yang.binding.ScalarTypeObject;
public static final @NonNull String AUGMENTABLE_AUGMENTATION_NAME = "augmentation";
/**
- * Name of {@link Identifiable#key()}.
+ * Name of {@link KeyAware#key()}.
*/
- public static final @NonNull String IDENTIFIABLE_KEY_NAME = "key";
+ public static final @NonNull String KEY_AWARE_KEY_NAME = "key";
/**
* Name of {@link BindingContract#implementedInterface()}.
import java.util.stream.Collector;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
/**
- * Utility class for instantiating Maps containing {@link Identifiable} values. Unlike normal Map instantiation
+ * Utility class for instantiating Maps containing {@link KeyAware} values. Unlike normal Map instantiation
* utilities, methods in this class index values via their identifier, hence providing a more convenient API, amenable
* to fluent builders.
*
* <p>
* This class allows for two modes of operation:
* <ul>
- * <li>Unordered, available through {@link #of(Identifiable...)}/{@link #builder()} family of functions. Maps
+ * <li>Unordered, available through {@link #of(KeyAware...)}/{@link #builder()} family of functions. Maps
* instantiated through this, preferred, interface will have their iteration order randomized, as explain in
* Java 9+ unmodifiable collections.</li>
- * <li>Ordered, available through {@link #ordered(Identifiable...)}/{@link #orderedBuilder()} family of functions.
+ * <li>Ordered, available through {@link #ordered(KeyAware...)}/{@link #orderedBuilder()} family of functions.
* Maps instantiated through this interface have a predictable iteration order, as per {@link ImmutableMap}
* class design. The use of this interface is generally discouraged, as it may lead to code relying on map
* iteration order. Nevertheless it may prove useful where the goal is to have predictable outcomes and hence
* @return a {@code Map} containing the specified value
* @throws NullPointerException if the value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> of(final V v1) {
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> of(final V v1) {
return Map.of(v1.key(), v1);
}
* @throws IllegalArgumentException if the values contain duplicate keys
* @throws NullPointerException if any value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> of(final V v1, final V v2) {
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> of(final V v1, final V v2) {
return Map.of(v1.key(), v1, v2.key(), v2);
}
* @throws IllegalArgumentException if the values contain duplicate keys
* @throws NullPointerException if any value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> of(final V v1, final V v2,
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> of(final V v1, final V v2,
final V v3) {
return Map.of(v1.key(), v1, v2.key(), v2, v3.key(), v3);
}
* @throws IllegalArgumentException if the values contain duplicate keys
* @throws NullPointerException if any value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> of(final V v1, final V v2,
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> of(final V v1, final V v2,
final V v3, final V v4) {
return Map.of(v1.key(), v1, v2.key(), v2, v3.key(), v3, v4.key(), v4);
}
* @throws IllegalArgumentException if the values contain duplicate keys
* @throws NullPointerException if any value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> of(final V v1, final V v2,
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> of(final V v1, final V v2,
final V v3, final V v4, final V v5) {
return Map.of(v1.key(), v1, v2.key(), v2, v3.key(), v3, v4.key(), v4, v5.key(), v5);
}
* @throws IllegalArgumentException if the values contain duplicate keys
* @throws NullPointerException if any value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> of(final V v1, final V v2,
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> of(final V v1, final V v2,
final V v3, final V v4, final V v5, final V v6) {
return Map.of(v1.key(), v1, v2.key(), v2, v3.key(), v3, v4.key(), v4, v5.key(), v5, v6.key(), v6);
}
* @throws IllegalArgumentException if the values contain duplicate keys
* @throws NullPointerException if any value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> of(final V v1, final V v2,
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> of(final V v1, final V v2,
final V v3, final V v4, final V v5, final V v6, final V v7) {
return Map.of(v1.key(), v1, v2.key(), v2, v3.key(), v3, v4.key(), v4, v5.key(), v5, v6.key(), v6, v7.key(), v7);
}
* @throws IllegalArgumentException if the values contain duplicate keys
* @throws NullPointerException if any value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> of(final V v1, final V v2,
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> of(final V v1, final V v2,
final V v3, final V v4, final V v5, final V v6, final V v7, final V v8) {
return Map.of(v1.key(), v1, v2.key(), v2, v3.key(), v3, v4.key(), v4, v5.key(), v5, v6.key(), v6, v7.key(), v7,
v8.key(), v8);
* @throws IllegalArgumentException if the values contain duplicate keys
* @throws NullPointerException if any value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> of(final V v1, final V v2,
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> of(final V v1, final V v2,
final V v3, final V v4, final V v5, final V v6, final V v7, final V v8, final V v9) {
return Map.of(v1.key(), v1, v2.key(), v2, v3.key(), v3, v4.key(), v4, v5.key(), v5, v6.key(), v6, v7.key(), v7,
v8.key(), v8, v9.key(), v9);
* @throws IllegalArgumentException if the values contain duplicate keys
* @throws NullPointerException if any value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> of(final V v1, final V v2,
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> of(final V v1, final V v2,
final V v3, final V v4, final V v5, final V v6, final V v7, final V v8, final V v9, final V v10) {
return Map.of(v1.key(), v1, v2.key(), v2, v3.key(), v3, v4.key(), v4, v5.key(), v5, v6.key(), v6, v7.key(), v7,
v8.key(), v8, v9.key(), v9, v10.key(), v10);
* @throws NullPointerException if any value is {@code null}, or if the {@code values} array is {@code null}
*/
@SafeVarargs
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> of(final V... values) {
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> of(final V... values) {
return of(Arrays.asList(values));
}
* @throws IllegalArgumentException if there are any duplicate keys in the provided values
* @throws NullPointerException if any value is {@code null}, or if the {@code values} array is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> of(
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> of(
final Collection<V> values) {
return values.stream().collect(toMap());
}
/**
- * Returns a collector which collects binding {@link Identifiable} objects into an unmodifiable map. The resulting
+ * Returns a collector which collects binding {@link KeyAware} objects into an unmodifiable map. The resulting
* map is <b>NOT</b> guaranteed to retain iteration order of the stream it collects.
*
* @param <K> the {@code Map}'s key type
* @param <V> the {@code Map}'s value type
* @return A collector that accumulates the input elements into an unmodifiable map.
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>>
+ public static <K extends Key<V>, V extends KeyAware<K>>
@NonNull Collector<V, ?, ? extends Map<K, V>> toMap() {
- return Collectors.toUnmodifiableMap(Identifiable::key, v -> v);
+ return Collectors.toUnmodifiableMap(KeyAware::key, v -> v);
}
/**
* @param <V> the {@code Map}'s value type
* @return A {@link Builder} instance.
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Builder<K, V> builder() {
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Builder<K, V> builder() {
return builder(Builder.DEFAULT_INITIAL_CAPACITY);
}
* @param expectedSize Expected number of values in the resulting map
* @return A {@link Builder} instance.
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Builder<K, V> builder(
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Builder<K, V> builder(
final int expectedSize) {
return new UnorderedBuilder<>(expectedSize);
}
* @throws IllegalArgumentException if the values contain duplicate keys
* @throws NullPointerException if any value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> ordered(final V v1,
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> ordered(final V v1,
final V v2) {
return ImmutableMap.of(v1.key(), v1, v2.key(), v2);
}
* @throws IllegalArgumentException if the values contain duplicate keys
* @throws NullPointerException if any value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> ordered(final V v1,
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> ordered(final V v1,
final V v2, final V v3) {
return ImmutableMap.of(v1.key(), v1, v2.key(), v2, v3.key(), v3);
}
* @throws IllegalArgumentException if the values contain duplicate keys
* @throws NullPointerException if any value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> ordered(final V v1,
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> ordered(final V v1,
final V v2, final V v3, final V v4) {
return ImmutableMap.of(v1.key(), v1, v2.key(), v2, v3.key(), v3, v4.key(), v4);
}
* @throws IllegalArgumentException if the values contain duplicate keys
* @throws NullPointerException if any value is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> ordered(final V v1,
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> ordered(final V v1,
final V v2, final V v3, final V v4, final V v5) {
return ImmutableMap.of(v1.key(), v1, v2.key(), v2, v3.key(), v3, v4.key(), v4, v5.key(), v5);
}
* @throws NullPointerException if any value is {@code null}, or if the {@code values} array is {@code null}
*/
@SafeVarargs
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> ordered(final V... values) {
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> ordered(final V... values) {
return ordered(Arrays.asList(values));
}
* @throws IllegalArgumentException if there are any duplicate keys in the provided values
* @throws NullPointerException if any value is {@code null}, or if the {@code values} array is {@code null}
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Map<K, V> ordered(
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Map<K, V> ordered(
final Collection<V> values) {
return values.stream().collect(toOrderedMap());
}
/**
- * Returns a collector which collects binding {@link Identifiable} objects into an unmodifiable map. The resulting
+ * Returns a collector which collects binding {@link KeyAware} objects into an unmodifiable map. The resulting
* map will retain iteration order of the stream it collects.
*
* @param <K> the {@code Map}'s key type
* @param <V> the {@code Map}'s value type
* @return A collector that accumulates the input elements into an unmodifiable map.
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>>
+ public static <K extends Key<V>, V extends KeyAware<K>>
@NonNull Collector<V, ?, ? extends Map<K, V>> toOrderedMap() {
- return ImmutableMap.<V, K, V>toImmutableMap(Identifiable::key, v -> v);
+ return ImmutableMap.<V, K, V>toImmutableMap(KeyAware::key, v -> v);
}
/**
* @param <V> the {@code Map}'s value type
* @return A {@link Builder} instance.
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Builder<K, V> orderedBuilder() {
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Builder<K, V> orderedBuilder() {
return orderedBuilder(Builder.DEFAULT_INITIAL_CAPACITY);
}
* @param expectedSize Expected number of values in the resulting map
* @return A {@link Builder} instance.
*/
- public static <K extends Identifier<V>, V extends Identifiable<K>> @NonNull Builder<K, V> orderedBuilder(
+ public static <K extends Key<V>, V extends KeyAware<K>> @NonNull Builder<K, V> orderedBuilder(
final int expectedSize) {
return new OrderedBuilder<>(expectedSize);
}
/**
- * Builder producing a Map containing binding {@link Identifiable} values.
+ * Builder producing a Map containing binding {@link KeyAware} values.
*
* @param <K> the {@code Map}'s key type
* @param <V> the {@code Map}'s value type
*/
- public abstract static class Builder<K extends Identifier<V>, V extends Identifiable<K>> {
+ public abstract static class Builder<K extends Key<V>, V extends KeyAware<K>> {
static final int DEFAULT_INITIAL_CAPACITY = 4;
Builder() {
abstract void addEntries(Collection<Entry<K, V>> entries);
}
- private static final class OrderedBuilder<K extends Identifier<V>, V extends Identifiable<K>>
+ private static final class OrderedBuilder<K extends Key<V>, V extends KeyAware<K>>
extends Builder<K, V> {
private final ImmutableMap.Builder<K, V> delegate;
}
}
- private static final class UnorderedBuilder<K extends Identifier<V>, V extends Identifiable<K>>
+ private static final class UnorderedBuilder<K extends Key<V>, V extends KeyAware<K>>
extends Builder<K, V> {
private final ArrayList<Entry<K, V>> buffer;
@Test
public void keyOfTest() {
- final Identifier<?> identifier = mock(Identifier.class);
+ final Key<?> identifier = mock(Key.class);
assertEquals(identifier, InstanceIdentifier.keyOf(
- new KeyedInstanceIdentifier(Identifiable.class, ImmutableList.of(), false, 0, identifier)));
+ new KeyedInstanceIdentifier(KeyAware.class, ImmutableList.of(), false, 0, identifier)));
}
@Test
@Test
public void basicTest() {
- final Identifier<?> key = mock(Identifier.class);
+ final Key<?> key = mock(Key.class);
final KeyedInstanceIdentifier<?, ?> keyedInstanceIdentifier =
- new KeyedInstanceIdentifier(Identifiable.class, ImmutableList.of(), false, 0, key);
+ new KeyedInstanceIdentifier(KeyAware.class, ImmutableList.of(), false, 0, key);
assertEquals(key, keyedInstanceIdentifier.getKey());
assertFalse(keyedInstanceIdentifier.fastNonEqual(keyedInstanceIdentifier.builder().build()));
- assertTrue(new KeyedInstanceIdentifier(Identifiable.class, ImmutableList.of(), false, 0, null)
+ assertTrue(new KeyedInstanceIdentifier(KeyAware.class, ImmutableList.of(), false, 0, null)
.fastNonEqual(keyedInstanceIdentifier.builder().build()));
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
public interface Node extends
DataObject,
- Identifiable<NodeKey>,
+ KeyAware<NodeKey>,
ChildOf<Nodes>,
Augmentable<Node> {
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
public interface NodeChild extends
DataObject,
- Identifiable<NodeChildKey>,
+ KeyAware<NodeChildKey>,
ChildOf<Node> {
}
package org.opendaylight.yangtools.yang.binding.test.mock;
import java.io.Serial;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
-public class NodeChildKey implements Identifier<NodeChild> {
+public class NodeChildKey implements Key<NodeChild> {
@Serial
private static final long serialVersionUID = 1L;
package org.opendaylight.yangtools.yang.binding.test.mock;
import java.io.Serial;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
-public class NodeKey implements Identifier<Node> {
+public class NodeKey implements Key<Node> {
@Serial
private static final long serialVersionUID = 1L;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.DataRoot;
-import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
public void testEntityNameConstructor() {
Entity entity = new Entity(ENTITY_TYPE1, "foo");
- Identifier<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang
- .mdsal.core.general.entity.rev150930.Entity> keyID = entity.getIdentifier().firstKeyOf(
- org.opendaylight.yang.gen.v1.urn
- .opendaylight.params.xml.ns.yang.mdsal.core.general.entity.rev150930.Entity.class);
+ var keyID = entity.getIdentifier().firstKeyOf(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang
+ .mdsal.core.general.entity.rev150930.Entity.class);
assertNotNull("List key not found", keyID);
}
Code Review / mdsal.git / commitdiff