package org.opendaylight.mdsal.binding.dom.codec.impl;
import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
import static com.google.common.base.Verify.verify;
-import static java.util.Objects.requireNonNull;
import com.google.common.base.Throwables;
import com.google.common.base.Verify;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.util.ClassLoaderUtils;
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.ContainerSchemaNode;
+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.Module;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
final class SchemaRootCodecContext<D extends DataObject> extends DataContainerCodecContext<D,SchemaContext> {
- private final LoadingCache<Class<?>, DataContainerCodecContext<?,?>> childrenByClass = CacheBuilder.newBuilder()
- .build(new CacheLoader<Class<?>, DataContainerCodecContext<?,?>>() {
- @Override
- public DataContainerCodecContext<?,?> load(final Class<?> key) {
- return createDataTreeChildContext(key);
- }
- });
-
- private final LoadingCache<Class<? extends Action<?, ?, ?>>, ActionCodecContext> actionsByClass = CacheBuilder
- .newBuilder().build(new CacheLoader<Class<? extends Action<?, ?, ?>>, ActionCodecContext>() {
- @Override
- public ActionCodecContext load(final Class<? extends Action<?, ?, ?>> key) {
- return createActionContext(key);
+ 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);
}
- });
-
- private final LoadingCache<Class<?>, ContainerNodeCodecContext<?>> rpcDataByClass = CacheBuilder.newBuilder().build(
- new CacheLoader<Class<?>, ContainerNodeCodecContext<?>>() {
- @Override
- public ContainerNodeCodecContext<?> load(final Class<?> 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) {
- return createNotificationDataContext(key);
- }
- });
+ private final LoadingCache<Class<? extends Action<?, ?, ?>>, ActionCodecContext> actionsByClass =
+ CacheBuilder.newBuilder().build(new CacheLoader<>() {
+ @Override
+ public ActionCodecContext load(final Class<? extends Action<?, ?, ?>> key) {
+ return createActionContext(key);
+ }
+ });
private final LoadingCache<Class<? extends DataObject>, ChoiceNodeCodecContext<?>> choicesByClass =
- CacheBuilder.newBuilder().build(new CacheLoader<Class<? extends DataObject>, ChoiceNodeCodecContext<?>>() {
- @Override
- public ChoiceNodeCodecContext<?> load(final Class<? extends DataObject> key) {
- return createChoiceDataContext(key);
- }
- });
-
- private final LoadingCache<QName, DataContainerCodecContext<?,?>> childrenByQName = CacheBuilder.newBuilder().build(
- new CacheLoader<QName, DataContainerCodecContext<?,?>>() {
- @Override
- public DataContainerCodecContext<?,?> load(final QName qname) {
- final DataSchemaNode childSchema = getSchema().getDataChildByName(qname);
- childNonNull(childSchema, qname,"Argument %s is not valid child of %s", qname,getSchema());
- if (childSchema instanceof DataNodeContainer || childSchema instanceof ChoiceSchemaNode) {
- @SuppressWarnings("unchecked")
- final Class<? extends DataObject> childCls = (Class<? extends DataObject>)
- factory().getRuntimeContext().getClassForSchema(childSchema);
- return streamChild(childCls);
- }
-
- throw new UnsupportedOperationException("Unsupported child type " + childSchema.getClass());
+ CacheBuilder.newBuilder().build(new CacheLoader<>() {
+ @Override
+ public ChoiceNodeCodecContext<?> load(final Class<? extends DataObject> key) {
+ return createChoiceDataContext(key);
+ }
+ });
+
+ private final LoadingCache<QName, DataContainerCodecContext<?,?>> childrenByQName =
+ CacheBuilder.newBuilder().build(new CacheLoader<>() {
+ @Override
+ public DataContainerCodecContext<?, ?> load(final QName qname) {
+ final DataSchemaNode childSchema = getSchema().getDataChildByName(qname);
+ childNonNull(childSchema, qname, "Argument %s is not valid child of %s", qname, getSchema());
+ if (childSchema instanceof DataNodeContainer || childSchema instanceof ChoiceSchemaNode) {
+ @SuppressWarnings("unchecked")
+ final Class<? extends DataObject> childCls = (Class<? extends DataObject>)
+ factory().getRuntimeContext().getClassForSchema(childSchema);
+ return streamChild(childCls);
}
- });
- private final LoadingCache<SchemaPath, RpcInputCodec<?>> rpcDataByPath = CacheBuilder.newBuilder().build(
- new CacheLoader<SchemaPath, RpcInputCodec<?>>() {
+ throw new UnsupportedOperationException("Unsupported child type " + childSchema.getClass());
+ }
+ });
+
+ private final LoadingCache<Absolute, RpcInputCodec<?>> rpcDataByPath =
+ CacheBuilder.newBuilder().build(new CacheLoader<>() {
@Override
- public RpcInputCodec<?> load(final SchemaPath key) {
- final ContainerSchemaNode schema = SchemaContextUtil.getRpcDataSchema(getSchema(), key);
+ public RpcInputCodec<?> load(final Absolute key) {
+ final ContainerLike schema = SchemaContextUtil.getRpcDataSchema(getSchema(), key.asSchemaPath());
@SuppressWarnings("unchecked")
final Class<? extends DataContainer> cls = (Class<? extends DataContainer>)
- factory().getRuntimeContext().getClassForSchema(schema);
+ factory().getRuntimeContext().getClassForSchema(schema);
return getRpc(cls);
}
});
- private final LoadingCache<SchemaPath, NotificationCodecContext<?>> notificationsByPath = CacheBuilder.newBuilder()
- .build(new CacheLoader<SchemaPath, NotificationCodecContext<?>>() {
- @Override
- public NotificationCodecContext<?> load(final SchemaPath key) {
- final NotificationDefinition schema = SchemaContextUtil.getNotificationSchema(getSchema(), key);
- @SuppressWarnings("unchecked")
- final Class<? extends Notification> clz = (Class<? extends Notification>)
- factory().getRuntimeContext().getClassForSchema(schema);
- return getNotification(clz);
- }
- });
+ private final LoadingCache<Absolute, NotificationCodecContext<?>> notificationsByPath =
+ CacheBuilder.newBuilder().build(new CacheLoader<>() {
+ @Override
+ public NotificationCodecContext<?> load(final Absolute key) {
+ final NotificationDefinition schema = SchemaContextUtil.getNotificationSchema(getSchema(),
+ // FIXME: do not convert here!
+ key.asSchemaPath());
+ @SuppressWarnings("unchecked")
+ final Class<? extends Notification> clz = (Class<? extends Notification>)
+ factory().getRuntimeContext().getClassForSchema(schema);
+ return getNotification(clz);
+ }
+ });
private SchemaRootCodecContext(final DataContainerCodecPrototype<SchemaContext> dataPrototype) {
super(dataPrototype);
@SuppressWarnings("unchecked")
@Override
public <C extends DataObject> DataContainerCodecContext<C, ?> streamChild(final Class<C> childClass) {
- /* FIXME: This is still not solved for RPCs
- * TODO: Probably performance wise RPC, Data and Notification loading cache
- * should be merge for performance resons. Needs microbenchmark to
- * determine which is faster (keeping them separate or in same cache).
- */
- if (Notification.class.isAssignableFrom(childClass)) {
- return (DataContainerCodecContext<C, ?>) getNotification((Class<? extends Notification>)childClass);
- }
- return (DataContainerCodecContext<C, ?>) getOrRethrow(childrenByClass,childClass);
+ return (DataContainerCodecContext<C, ?>) getOrRethrow(childrenByClass, childClass);
}
@Override
}
NotificationCodecContext<?> getNotification(final Class<? extends Notification> notification) {
- return getOrRethrow(notificationsByClass, notification);
+ return (NotificationCodecContext<?>) streamChild((Class<? extends DataObject>)notification);
}
- NotificationCodecContext<?> getNotification(final SchemaPath notification) {
+ NotificationCodecContext<?> getNotification(final Absolute notification) {
return getOrRethrow(notificationsByPath, notification);
}
ContainerNodeCodecContext<?> getRpc(final Class<? extends DataContainer> rpcInputOrOutput) {
- return getOrRethrow(rpcDataByClass, rpcInputOrOutput);
+ return (ContainerNodeCodecContext<?>) streamChild((Class<? extends DataObject>)rpcInputOrOutput);
}
- RpcInputCodec<?> getRpc(final SchemaPath notification) {
- return getOrRethrow(rpcDataByPath, notification);
+ RpcInputCodec<?> getRpc(final Absolute containerPath) {
+ return getOrRethrow(rpcDataByPath, containerPath);
}
DataContainerCodecContext<?,?> createDataTreeChildContext(final Class<?> key) {
private ActionCodecContext prepareActionContext(final int inputOffset, final int outputOffset,
final int expectedArgsLength, final Class<? extends Action<?, ?, ?>> action, final Class<?> actionType) {
- final ParameterizedType paramType = requireNonNull(ClassLoaderUtils.findParameterizedType(action, actionType),
- () -> "There does not exist any ParameterType in " + 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 Type[] args = paramType.getActualTypeArguments();
checkArgument(args.length == expectedArgsLength, "Unexpected (%s) Action generatic arguments", args.length);
final ActionDefinition schema = factory().getRuntimeContext().getActionDefinition(action);
* FIXME: Rework this to have more precise logic regarding Binding Specification.
*/
if (key.getSimpleName().equals(BindingMapping.getClassName(potentialQName) + className)) {
- final ContainerSchemaNode schema = SchemaNodeUtils.getRpcDataSchema(potential, qname);
+ final ContainerLike schema = SchemaNodeUtils.getRpcDataSchema(potential, qname);
checkArgument(schema != null, "Schema for %s does not define input / output.", potential.getQName());
return (ContainerNodeCodecContext<?>) DataContainerCodecPrototype.from(key, schema, factory()).get();
}
checkArgument(Notification.class.isAssignableFrom(notificationType));
checkArgument(notificationType.isInterface(), "Supplied class must be interface.");
final QName qname = BindingReflections.findQName(notificationType);
- /**
- * FIXME: After Lithium cleanup of yang-model-api, use direct call on schema context
- * to retrieve notification via index.
- */
- final NotificationDefinition schema = SchemaContextUtil.getNotificationSchema(getSchema(),
- SchemaPath.create(true, qname));
- checkArgument(schema != null, "Supplied %s is not valid notification", notificationType);
-
+ final NotificationDefinition schema = getSchema().findNotification(qname).orElseThrow(
+ () -> new IllegalArgumentException("Supplied " + notificationType + " is not valid notification"));
return new NotificationCodecContext<>(notificationType, schema, factory());
}
final List<PathArgument> builder) {
final Optional<? extends Class<? extends DataObject>> caseType = arg.getCaseType();
if (caseType.isPresent()) {
- // XXX: we use two caseType.get()s because of https://bugs.openjdk.java.net/browse/JDK-8144185,
- // which makes JaCoCo blow up if we try using @NonNull on the local variable.
- final ChoiceNodeCodecContext<?> choice = choicesByClass.getUnchecked(caseType.get());
+ final @NonNull Class<? extends DataObject> type = caseType.orElseThrow();
+ final ChoiceNodeCodecContext<?> choice = choicesByClass.getUnchecked(type);
choice.addYangPathArgument(arg, builder);
- final DataContainerCodecContext<?, ?> caze = choice.streamChild(caseType.get());
+ final DataContainerCodecContext<?, ?> caze = choice.streamChild(type);
caze.addYangPathArgument(arg, builder);
return caze.bindingPathArgumentChild(arg, builder);
}
Code Review / mdsal.git / blobdiff