import static java.util.Objects.requireNonNull;
import com.google.common.base.Throwables;
-import com.google.common.base.Verify;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.UncheckedExecutionException;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
-import java.util.Iterator;
import java.util.List;
import java.util.Optional;
+import java.util.function.BiFunction;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.mdsal.binding.dom.codec.api.IncorrectNestingException;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.runtime.api.ActionRuntimeType;
+import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeTypes;
+import org.opendaylight.mdsal.binding.runtime.api.ChoiceRuntimeType;
+import org.opendaylight.mdsal.binding.runtime.api.CompositeRuntimeType;
+import org.opendaylight.mdsal.binding.runtime.api.ContainerLikeRuntimeType;
+import org.opendaylight.mdsal.binding.runtime.api.DataRuntimeType;
+import org.opendaylight.mdsal.binding.runtime.api.NotificationRuntimeType;
+import org.opendaylight.mdsal.binding.runtime.api.RuntimeType;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.util.ClassLoaderUtils;
import org.opendaylight.yangtools.yang.binding.Action;
import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.binding.RpcInput;
import org.opendaylight.yangtools.yang.binding.RpcOutput;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerLike;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
-final class SchemaRootCodecContext<D extends DataObject> extends DataContainerCodecContext<D, EffectiveModelContext> {
+final class SchemaRootCodecContext<D extends DataObject> extends DataContainerCodecContext<D, BindingRuntimeTypes> {
private final LoadingCache<Class<? extends DataObject>, DataContainerCodecContext<?, ?>> childrenByClass =
CacheBuilder.newBuilder().build(new CacheLoader<>() {
@Override
public DataContainerCodecContext<?, ?> load(final Class<? extends DataObject> key) {
- if (Notification.class.isAssignableFrom(key)) {
- return createNotificationDataContext(key);
- }
- if (RpcInput.class.isAssignableFrom(key) || RpcOutput.class.isAssignableFrom(key)) {
- return createRpcDataContext(key);
- }
return createDataTreeChildContext(key);
}
});
}
});
+ private final LoadingCache<Class<?>, NotificationCodecContext<?>> notificationsByClass = CacheBuilder.newBuilder()
+ .build(new CacheLoader<Class<?>, NotificationCodecContext<?>>() {
+ @Override
+ public NotificationCodecContext<?> load(final Class<?> key) {
+ checkArgument(key.isInterface(), "Supplied class must be interface.");
+
+ // TODO: we should be able to work with bindingChild() instead of schemaTreeChild() here
+ final QName qname = BindingReflections.findQName(key);
+ final RuntimeType child = getType().schemaTreeChild(qname);
+ checkArgument(child instanceof NotificationRuntimeType, "Supplied %s is not valid notification",
+ key);
+ return new NotificationCodecContext<>(key, (NotificationRuntimeType) child, factory());
+ }
+ });
+
+ private final LoadingCache<Class<?>, ContainerNodeCodecContext<?>> rpcDataByClass = CacheBuilder.newBuilder()
+ .build(new CacheLoader<Class<?>, ContainerNodeCodecContext<?>>() {
+ @Override
+ public ContainerNodeCodecContext<?> load(final Class<?> key) {
+ final BiFunction<BindingRuntimeTypes, QName, Optional<? extends ContainerLikeRuntimeType<?, ?>>> lookup;
+ if (RpcInput.class.isAssignableFrom(key)) {
+ lookup = BindingRuntimeTypes::findRpcInput;
+ } else if (RpcOutput.class.isAssignableFrom(key)) {
+ lookup = BindingRuntimeTypes::findRpcOutput;
+ } else {
+ throw new IllegalArgumentException(key + " does not represent an RPC container");
+ }
+
+ final CodecContextFactory factory = factory();
+ final BindingRuntimeContext context = factory.getRuntimeContext();
+
+ final QName qname = BindingReflections.findQName(key);
+ final QNameModule qnameModule = qname.getModule();
+ final Module module = context.getEffectiveModelContext().findModule(qnameModule)
+ .orElseThrow(() -> new IllegalArgumentException("Failed to find module for " + qnameModule));
+ final String className = Naming.getClassName(qname);
+
+ for (final RpcDefinition potential : module.getRpcs()) {
+ final QName potentialQName = potential.getQName();
+ /*
+ * Check if rpc and class represents data from same module and then checks if rpc local name
+ * produces same class name as class name appended with Input/Output based on QName associated
+ * with binding class.
+ *
+ * FIXME: Rework this to have more precise logic regarding Binding Specification.
+ */
+ if (key.getSimpleName().equals(Naming.getClassName(potentialQName) + className)) {
+ final ContainerLike schema = getRpcDataSchema(potential, qname);
+ checkArgument(schema != null, "Schema for %s does not define input / output.", potentialQName);
+
+ final ContainerLikeRuntimeType<?, ?> type = lookup.apply(context.getTypes(), potentialQName)
+ .orElseThrow(() -> new IllegalArgumentException("Cannot find runtime type for " + key));
+
+ return (ContainerNodeCodecContext) DataContainerCodecPrototype.from(key,
+ (ContainerLikeRuntimeType<?, ?>) type, factory).get();
+ }
+ }
+
+ throw new IllegalArgumentException("Supplied class " + key + " is not valid RPC class.");
+ }
+ });
+
private final LoadingCache<QName, DataContainerCodecContext<?,?>> childrenByQName =
CacheBuilder.newBuilder().build(new CacheLoader<>() {
@Override
- public DataContainerCodecContext<?, ?> load(final QName qname) {
- final DataSchemaNode childSchema = getSchema().dataChildByName(qname);
- childNonNull(childSchema, qname, "Argument %s is not valid child of %s", qname, getSchema());
+ public DataContainerCodecContext<?, ?> load(final QName qname) throws ClassNotFoundException {
+ final var type = getType();
+ final var child = childNonNull(type.schemaTreeChild(qname), qname,
+ "Argument %s is not valid child of %s", qname, type);
+ if (!(child instanceof DataRuntimeType)) {
+ throw IncorrectNestingException.create("Argument %s is not valid data tree child of %s", qname,
+ type);
+ }
+
+ // TODO: improve this check?
+ final var childSchema = child.statement();
if (childSchema instanceof DataNodeContainer || childSchema instanceof ChoiceSchemaNode) {
- @SuppressWarnings("unchecked")
- final Class<? extends DataObject> childCls = (Class<? extends DataObject>)
- factory().getRuntimeContext().getClassForSchema(childSchema);
- return streamChild(childCls);
+ return streamChild(factory().getRuntimeContext().loadClass(child.javaType()));
}
throw new UnsupportedOperationException("Unsupported child type " + childSchema.getClass());
CacheBuilder.newBuilder().build(new CacheLoader<>() {
@Override
public RpcInputCodec<?> load(final Absolute key) {
- final ContainerLike schema = getRpcDataSchema(getSchema(), key);
- @SuppressWarnings("unchecked")
- final Class<? extends DataContainer> cls = (Class<? extends DataContainer>)
- factory().getRuntimeContext().getClassForSchema(schema);
- return getRpc(cls);
+ final var rpcName = key.firstNodeIdentifier();
+ final var context = factory().getRuntimeContext();
+
+ final Class<? extends DataContainer> container = switch (key.lastNodeIdentifier().getLocalName()) {
+ case "input" -> context.getRpcInput(rpcName);
+ case "output" -> context.getRpcOutput(rpcName);
+ default -> throw new IllegalArgumentException("Unhandled path " + key);
+ };
+
+ return getRpc(container);
}
});
CacheBuilder.newBuilder().build(new CacheLoader<>() {
@Override
public NotificationCodecContext<?> load(final Absolute key) {
- final SchemaTreeEffectiveStatement<?> stmt = getSchema().findSchemaTreeNode(key)
- .orElseThrow(() -> new IllegalArgumentException("Cannot find statement at " + key));
- checkArgument(stmt instanceof NotificationDefinition, "Statement %s is not a notification", stmt);
-
- @SuppressWarnings("unchecked")
- final Class<? extends Notification<?>> clz = (Class<? extends Notification<?>>)
- factory().getRuntimeContext().getClassForSchema((NotificationDefinition) stmt);
- return getNotification(clz);
+ final Class<?> cls = factory().getRuntimeContext().getClassForSchema(key);
+ checkArgument(Notification.class.isAssignableFrom(cls), "Path %s does not represent a notification",
+ key);
+ return getNotificationImpl(cls);
}
});
- private SchemaRootCodecContext(final DataContainerCodecPrototype<EffectiveModelContext> dataPrototype) {
- super(dataPrototype);
+ SchemaRootCodecContext(final CodecContextFactory factory) {
+ super(DataContainerCodecPrototype.rootPrototype(factory));
}
- /**
- * Creates RootNode from supplied CodecContextFactory.
- *
- * @param factory
- * CodecContextFactory
- * @return A new root node
- */
- static SchemaRootCodecContext<?> create(final CodecContextFactory factory) {
- return new SchemaRootCodecContext<>(DataContainerCodecPrototype.rootPrototype(factory));
+ @Override
+ public WithStatus getSchema() {
+ return getType().getEffectiveModelContext();
}
- @SuppressWarnings("unchecked")
@Override
+ @SuppressWarnings("unchecked")
public <C extends DataObject> DataContainerCodecContext<C, ?> streamChild(final Class<C> childClass) {
- return (DataContainerCodecContext<C, ?>) getOrRethrow(childrenByClass, childClass);
+ final var result = Notification.class.isAssignableFrom(childClass) ? getNotificationImpl(childClass)
+ : getOrRethrow(childrenByClass, childClass);
+ return (DataContainerCodecContext<C, ?>) result;
}
@Override
}
@Override
- public D deserialize(final NormalizedNode normalizedNode) {
+ public D deserialize(final NormalizedNode data) {
throw new UnsupportedOperationException("Could not create Binding data representation for root");
}
return getOrRethrow(actionsByClass, action);
}
+ NotificationCodecContext<?> getNotification(final Absolute notification) {
+ return getOrRethrow(notificationsByPath, notification);
+ }
+
NotificationCodecContext<?> getNotification(final Class<? extends Notification<?>> notification) {
- return (NotificationCodecContext<?>) streamChild((Class<? extends DataObject>)notification);
+ return getNotificationImpl(notification);
}
- NotificationCodecContext<?> getNotification(final Absolute notification) {
- return getOrRethrow(notificationsByPath, notification);
+ private NotificationCodecContext<?> getNotificationImpl(final Class<?> notification) {
+ return getOrRethrow(notificationsByClass, notification);
}
ContainerNodeCodecContext<?> getRpc(final Class<? extends DataContainer> rpcInputOrOutput) {
- return (ContainerNodeCodecContext<?>) streamChild((Class<? extends DataObject>)rpcInputOrOutput);
+ return getOrRethrow(rpcDataByClass, rpcInputOrOutput);
}
RpcInputCodec<?> getRpc(final Absolute containerPath) {
return getOrRethrow(rpcDataByPath, containerPath);
}
- DataContainerCodecContext<?,?> createDataTreeChildContext(final Class<?> key) {
- final QName qname = BindingReflections.findQName(key);
- final DataSchemaNode childSchema = childNonNull(getSchema().dataChildByName(qname), key,
+ DataContainerCodecContext<?, ?> createDataTreeChildContext(final Class<? extends DataObject> key) {
+ final RuntimeType childSchema = childNonNull(getType().bindingChild(JavaTypeName.create(key)), key,
"%s is not top-level item.", key);
- return DataContainerCodecPrototype.from(key, childSchema, factory()).get();
+ if (childSchema instanceof CompositeRuntimeType composite && childSchema instanceof DataRuntimeType) {
+ return DataContainerCodecPrototype.from(key, composite, factory()).get();
+ }
+ throw IncorrectNestingException.create("%s is not a valid data tree child of %s", key, this);
}
ActionCodecContext createActionContext(final Class<? extends Action<?, ?, ?>> action) {
final Optional<ParameterizedType> optParamType = ClassLoaderUtils.findParameterizedType(action, actionType);
checkState(optParamType.isPresent(), "%s does not specialize %s", action, actionType);
- final ParameterizedType paramType = optParamType.get();
+ final ParameterizedType paramType = optParamType.orElseThrow();
final Type[] args = paramType.getActualTypeArguments();
checkArgument(args.length == expectedArgsLength, "Unexpected (%s) Action generatic arguments", args.length);
- final ActionDefinition schema = factory().getRuntimeContext().getActionDefinition(action);
+ final ActionRuntimeType schema = factory().getRuntimeContext().getActionDefinition(action);
return new ActionCodecContext(
- DataContainerCodecPrototype.from(asClass(args[inputOffset], RpcInput.class), schema.getInput(),
- factory()).get(),
- DataContainerCodecPrototype.from(asClass(args[outputOffset], RpcOutput.class), schema.getOutput(),
- factory()).get());
+ DataContainerCodecPrototype.from(asClass(args[inputOffset], RpcInput.class), schema.input(),
+ factory()).get(),
+ DataContainerCodecPrototype.from(asClass(args[outputOffset], RpcOutput.class), schema.output(),
+ factory()).get());
}
private static <T extends DataObject> Class<? extends T> asClass(final Type type, final Class<T> target) {
return ((Class<?>) type).asSubclass(target);
}
- ContainerNodeCodecContext<?> createRpcDataContext(final Class<?> key) {
- checkArgument(DataContainer.class.isAssignableFrom(key));
- final QName qname = BindingReflections.findQName(key);
- final QNameModule qnameModule = qname.getModule();
- final Module module = getSchema().findModule(qnameModule)
- .orElseThrow(() -> new IllegalArgumentException("Failed to find module for " + qnameModule));
- final String className = BindingMapping.getClassName(qname);
-
- for (final RpcDefinition potential : module.getRpcs()) {
- final QName potentialQName = potential.getQName();
- /*
- * Check if rpc and class represents data from same module and then checks if rpc local name produces same
- * class name as class name appended with Input/Output based on QName associated with binding class.
- *
- * FIXME: Rework this to have more precise logic regarding Binding Specification.
- */
- if (key.getSimpleName().equals(BindingMapping.getClassName(potentialQName) + className)) {
- final ContainerLike schema = getRpcDataSchema(potential, qname);
- checkArgument(schema != null, "Schema for %s does not define input / output.", potential.getQName());
- return (ContainerNodeCodecContext<?>) DataContainerCodecPrototype.from(key, schema, factory()).get();
- }
- }
-
- throw new IllegalArgumentException("Supplied class " + key + " is not valid RPC class.");
- }
-
/**
* Returns RPC input or output schema based on supplied QName.
*
private static @Nullable ContainerLike getRpcDataSchema(final @NonNull RpcDefinition rpc,
final @NonNull QName qname) {
requireNonNull(rpc, "Rpc Schema must not be null");
- switch (requireNonNull(qname, "QName must not be null").getLocalName()) {
- case "input":
- return rpc.getInput();
- case "output":
- return rpc.getOutput();
- default:
- throw new IllegalArgumentException("Supplied qname " + qname
- + " does not represent rpc input or output.");
- }
+ return switch (requireNonNull(qname, "QName must not be null").getLocalName()) {
+ case "input" -> rpc.getInput();
+ case "output" -> rpc.getOutput();
+ default -> throw new IllegalArgumentException(
+ "Supplied qname " + qname + " does not represent rpc input or output.");
+ };
}
- /**
- * Returns RPC Input or Output Data container from RPC definition.
- *
- * @param schema SchemaContext in which lookup should be performed.
- * @param path Schema path of RPC input/output data container
- * @return Notification schema or null, if notification is not present in schema context.
- */
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
- private static @Nullable ContainerLike getRpcDataSchema(final @NonNull EffectiveModelContext schema,
- final @NonNull Absolute path) {
- requireNonNull(schema, "Schema context must not be null.");
- requireNonNull(path, "Schema path must not be null.");
- final Iterator<QName> it = path.getNodeIdentifiers().iterator();
- checkArgument(it.hasNext(), "Rpc must have QName.");
- final QName rpcName = it.next();
- checkArgument(it.hasNext(), "input or output must be part of path.");
- final QName inOrOut = it.next();
- for (final RpcDefinition potential : schema.getOperations()) {
- if (rpcName.equals(potential.getQName())) {
- return getRpcDataSchema(potential, inOrOut);
- }
+ ChoiceNodeCodecContext<?> createChoiceDataContext(final Class<? extends DataObject> caseType) {
+ final var choiceClass = findCaseChoice(caseType);
+ if (choiceClass == null) {
+ throw new IllegalArgumentException(caseType + " is not a valid case representation");
}
- return null;
- }
- NotificationCodecContext<?> createNotificationDataContext(final Class<?> notificationType) {
- checkArgument(Notification.class.isAssignableFrom(notificationType));
- checkArgument(notificationType.isInterface(), "Supplied class must be interface.");
- final QName qname = BindingReflections.findQName(notificationType);
- final NotificationDefinition schema = getSchema().findNotification(qname).orElseThrow(
- () -> new IllegalArgumentException("Supplied " + notificationType + " is not valid notification"));
- return new NotificationCodecContext<>(notificationType, schema, factory());
- }
+ final var runtimeType = factory().getRuntimeContext().getSchemaDefinition(choiceClass);
+ if (!(runtimeType instanceof ChoiceRuntimeType choiceType)) {
+ throw new IllegalArgumentException(caseType + " does not refer to a choice");
+ }
- ChoiceNodeCodecContext<?> createChoiceDataContext(final Class<? extends DataObject> caseType) {
- final Class<?> choiceClass = findCaseChoice(caseType);
- checkArgument(choiceClass != null, "Class %s is not a valid case representation", caseType);
- final DataSchemaNode schema = factory().getRuntimeContext().getSchemaDefinition(choiceClass);
- checkArgument(schema instanceof ChoiceSchemaNode, "Class %s does not refer to a choice", caseType);
-
- final DataContainerCodecContext<?, ChoiceSchemaNode> choice = DataContainerCodecPrototype.from(choiceClass,
- (ChoiceSchemaNode)schema, factory()).get();
- Verify.verify(choice instanceof ChoiceNodeCodecContext);
+ final var choice = DataContainerCodecPrototype.from(choiceClass, choiceType, factory()).get();
+ verify(choice instanceof ChoiceNodeCodecContext);
return (ChoiceNodeCodecContext<?>) choice;
}
@Override
public DataContainerCodecContext<?, ?> bindingPathArgumentChild(final InstanceIdentifier.PathArgument arg,
final List<PathArgument> builder) {
- final Optional<? extends Class<? extends DataObject>> caseType = arg.getCaseType();
+ final var caseType = arg.getCaseType();
if (caseType.isPresent()) {
final @NonNull Class<? extends DataObject> type = caseType.orElseThrow();
- final ChoiceNodeCodecContext<?> choice = choicesByClass.getUnchecked(type);
+ final var choice = choicesByClass.getUnchecked(type);
choice.addYangPathArgument(arg, builder);
- final DataContainerCodecContext<?, ?> caze = choice.streamChild(type);
+ final var caze = choice.streamChild(type);
caze.addYangPathArgument(arg, builder);
return caze.bindingPathArgumentChild(arg, builder);
}
}
private static Class<?> findCaseChoice(final Class<? extends DataObject> caseClass) {
- for (Type type : caseClass.getGenericInterfaces()) {
- if (type instanceof Class) {
- final Class<?> typeClass = (Class<?>) type;
- if (ChoiceIn.class.isAssignableFrom(typeClass)) {
- return typeClass.asSubclass(ChoiceIn.class);
- }
+ for (var type : caseClass.getGenericInterfaces()) {
+ if (type instanceof Class<?> typeClass && ChoiceIn.class.isAssignableFrom(typeClass)) {
+ return typeClass.asSubclass(ChoiceIn.class);
}
}
-
return null;
}
private static <K,V> V getOrRethrow(final LoadingCache<K, V> cache, final K key) {
try {
return cache.getUnchecked(key);
- } catch (final UncheckedExecutionException e) {
- final Throwable cause = e.getCause();
+ } catch (UncheckedExecutionException e) {
+ final var cause = e.getCause();
if (cause != null) {
Throwables.throwIfUnchecked(cause);
}