X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding%2Fmdsal-binding-dom-codec%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fbinding%2Fdom%2Fcodec%2Fimpl%2FBindingCodecContext.java;h=57426e2e42e27fe92bf577034e1f22b925110d50;hb=c4d4ec8b44becb12d2ea0c2a2be8f24994c2b58d;hp=99dee6fda3a74d0957b8671ce7c34efce768a891;hpb=6dc0dbb76325cf16bc6980fe474eba00370a5703;p=mdsal.git diff --git a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/BindingCodecContext.java b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/BindingCodecContext.java index 99dee6fda3..57426e2e42 100644 --- a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/BindingCodecContext.java +++ b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/BindingCodecContext.java @@ -23,8 +23,8 @@ import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; +import java.lang.reflect.WildcardType; import java.time.Instant; -import java.util.AbstractMap.SimpleEntry; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; @@ -51,14 +51,15 @@ import org.opendaylight.mdsal.binding.dom.codec.loader.CodecClassLoader; import org.opendaylight.mdsal.binding.dom.codec.spi.AbstractBindingNormalizedNodeSerializer; import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices; import org.opendaylight.mdsal.binding.dom.codec.spi.BindingSchemaMapping; -import org.opendaylight.mdsal.binding.model.api.GeneratedType; import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeContext; +import org.opendaylight.mdsal.binding.runtime.api.ListRuntimeType; import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections; import org.opendaylight.yangtools.concepts.Delegator; import org.opendaylight.yangtools.concepts.IllegalArgumentCodec; import org.opendaylight.yangtools.concepts.Immutable; import org.opendaylight.yangtools.util.ClassLoaderUtils; import org.opendaylight.yangtools.yang.binding.Action; +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; @@ -83,15 +84,15 @@ import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeS import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult; import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode; import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode; -import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; -import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus; import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; -import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; +import org.opendaylight.yangtools.yang.model.api.TypeAware; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute; +import org.opendaylight.yangtools.yang.model.api.stmt.TypeDefinitionAware; import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition; @@ -156,9 +157,9 @@ public final class BindingCodecContext extends AbstractBindingNormalizedNodeSeri @Inject public BindingCodecContext(final BindingRuntimeContext context) { this.context = requireNonNull(context, "Binding Runtime Context is required."); - this.root = SchemaRootCodecContext.create(this); - this.identityCodec = new IdentityCodec(context); - this.instanceIdentifierCodec = new InstanceIdentifierCodec(this); + root = SchemaRootCodecContext.create(this); + identityCodec = new IdentityCodec(context); + instanceIdentifierCodec = new InstanceIdentifierCodec(this); } @Override @@ -201,7 +202,7 @@ public final class BindingCodecContext extends AbstractBindingNormalizedNodeSeri final InstanceIdentifier path, final NormalizedNodeStreamWriter domWriter) { final List yangArgs = new LinkedList<>(); final DataContainerCodecContext codecContext = getCodecContextNode(path, yangArgs); - return new SimpleEntry<>(YangInstanceIdentifier.create(yangArgs), codecContext.createWriter(domWriter)); + return Map.entry(YangInstanceIdentifier.create(yangArgs), codecContext.createWriter(domWriter)); } @Override @@ -217,7 +218,7 @@ public final class BindingCodecContext extends AbstractBindingNormalizedNodeSeri } @Override - public BindingStreamEventWriter newNotificationWriter(final Class notification, + public BindingStreamEventWriter newNotificationWriter(final Class> notification, final NormalizedNodeStreamWriter domWriter) { return root.getNotification(notification).createWriter(domWriter); } @@ -343,29 +344,39 @@ public final class BindingCodecContext extends AbstractBindingNormalizedNodeSeri } @Override - public ImmutableMap getLeafNodes(final Class parentClass, - final DataNodeContainer childSchema) { + public ImmutableMap getLeafNodes(final Class type, + final EffectiveStatement schema) { final Map getterToLeafSchema = new HashMap<>(); - for (final DataSchemaNode leaf : childSchema.getChildNodes()) { - if (leaf instanceof TypedDataSchemaNode || leaf instanceof AnyxmlSchemaNode - || leaf instanceof AnydataSchemaNode) { - getterToLeafSchema.put(BindingSchemaMapping.getGetterMethodName(leaf), leaf); + for (var stmt : schema.effectiveSubstatements()) { + if (stmt instanceof TypedDataSchemaNode) { + putLeaf(getterToLeafSchema, (TypedDataSchemaNode) stmt); + } else if (stmt instanceof AnydataSchemaNode) { + putLeaf(getterToLeafSchema, (AnydataSchemaNode) stmt); + } else if (stmt instanceof AnyxmlSchemaNode) { + putLeaf(getterToLeafSchema, (AnyxmlSchemaNode) stmt); } } - return getLeafNodesUsingReflection(parentClass, getterToLeafSchema); + return getLeafNodesUsingReflection(type, getterToLeafSchema); + } + + private static void putLeaf(final Map map, final DataSchemaNode leaf) { + map.put(BindingSchemaMapping.getGetterMethodName(leaf), leaf); } private ImmutableMap getLeafNodesUsingReflection( final Class parentClass, final Map getterToLeafSchema) { final Map leaves = new HashMap<>(); for (final Method method : parentClass.getMethods()) { - if (method.getParameterCount() == 0) { + // Only consider non-bridge methods with no arguments + if (method.getParameterCount() == 0 && !method.isBridge()) { final DataSchemaNode schema = getterToLeafSchema.get(method.getName()); final ValueNodeCodecContext valueNode; if (schema instanceof LeafSchemaNode) { final LeafSchemaNode leafSchema = (LeafSchemaNode) schema; + // FIXME: MDSAL-670: this is not right as we need to find a concrete type, but this may return + // Object.class final Class valueType = method.getReturnType(); final IllegalArgumentCodec codec = getCodec(valueType, leafSchema.getType()); valueNode = LeafNodeCodecContext.of(leafSchema, codec, method.getName(), valueType, @@ -381,6 +392,9 @@ public final class BindingCodecContext extends AbstractBindingNormalizedNodeSeri valueType = (Class) genericType; } else if (genericType instanceof ParameterizedType) { valueType = (Class) ((ParameterizedType) genericType).getRawType(); + } else if (genericType instanceof WildcardType) { + // FIXME: MDSAL-670: this is not right as we need to find a concrete type + valueType = Object.class; } else { throw new IllegalStateException("Unexpected return type " + genericType); } @@ -419,7 +433,9 @@ public final class BindingCodecContext extends AbstractBindingNormalizedNodeSeri } else if (BindingReflections.isBindingClass(valueType)) { return getCodecForBindingClass(valueType, instantiatedType); } - return ValueTypeCodec.NOOP_CODEC; + // FIXME: MDSAL-670: this is right for most situations, but we must never return NOOP_CODEC for + // valueType=Object.class + return SchemaUnawareCodec.NOOP_CODEC; } @SuppressWarnings("checkstyle:illegalCatch") @@ -439,31 +455,43 @@ public final class BindingCodecContext extends AbstractBindingNormalizedNodeSeri throw new IllegalStateException("Unable to load codec for " + valueType, e); } } else if (typeDef instanceof LeafrefTypeDefinition) { - final Entry typeWithSchema = context.getTypeWithSchema(valueType); - final WithStatus schema = typeWithSchema.getValue(); - checkState(schema instanceof TypeDefinition); - return getCodec(valueType, (TypeDefinition) schema); + final var typeWithSchema = context.getTypeWithSchema(valueType); + final var schema = typeWithSchema.statement(); + final TypeDefinition def; + if (schema instanceof TypeDefinitionAware) { + def = ((TypeDefinitionAware) schema).getTypeDefinition(); + } else if (schema instanceof TypeAware) { + def = ((TypeAware) schema).getType(); + } else { + throw new IllegalStateException("Unexpected schema " + schema); + } + return getCodec(valueType, def); } - return ValueTypeCodec.getCodecFor(valueType, typeDef); + return SchemaUnawareCodec.of(valueType, typeDef); } @Override - public IdentifiableItemCodec getPathArgumentCodec(final Class listClz, final ListSchemaNode schema) { + public IdentifiableItemCodec getPathArgumentCodec(final Class listClz, final ListRuntimeType type) { final Optional>> optIdentifier = ClassLoaderUtils.findFirstGenericArgument(listClz, Identifiable.class); checkState(optIdentifier.isPresent(), "Failed to find identifier for %s", listClz); final Class> identifier = optIdentifier.get(); final Map valueCtx = new HashMap<>(); - for (final ValueNodeCodecContext leaf : getLeafNodes(identifier, schema).values()) { + for (final ValueNodeCodecContext leaf : getLeafNodes(identifier, type.statement()).values()) { final QName name = leaf.getDomPathArgument().getNodeType(); valueCtx.put(name, new ValueContext(identifier, leaf)); } - return IdentifiableItemCodec.of(schema, identifier, listClz, valueCtx); + return IdentifiableItemCodec.of(type.statement(), identifier, listClz, valueCtx); + } + + @Override + public BindingDataObjectCodecTreeNode streamChild(final Class childClass) { + return root.streamChild(childClass); } - @SuppressWarnings("unchecked") @Override + @SuppressWarnings("unchecked") public BindingDataObjectCodecTreeNode getSubtreeCodec(final InstanceIdentifier path) { // TODO Do we need defensive check here? return (BindingDataObjectCodecTreeNode) getCodecContextNode(path, null); @@ -490,7 +518,7 @@ public final class BindingCodecContext extends AbstractBindingNormalizedNodeSeri } @Override - public Entry> toNormalizedNode( + public Entry toNormalizedNode( final InstanceIdentifier path, final T data) { final NormalizedNodeResult result = new NormalizedNodeResult(); // We create DOM stream writer which produces normalized nodes @@ -507,12 +535,12 @@ public final class BindingCodecContext extends AbstractBindingNormalizedNodeSeri LOG.error("Unexpected failure while serializing path {} data {}", path, data, e); throw new IllegalStateException("Failed to create normalized node", e); } - return new SimpleEntry<>(writeCtx.getKey(),result.getResult()); + return Map.entry(writeCtx.getKey(), result.getResult()); } @Override public Entry, DataObject> fromNormalizedNode(final YangInstanceIdentifier path, - final NormalizedNode data) { + final NormalizedNode data) { if (notBindingRepresentable(data)) { return null; } @@ -528,21 +556,20 @@ public final class BindingCodecContext extends AbstractBindingNormalizedNodeSeri } final DataObject lazyObj = codec.deserialize(data); - final InstanceIdentifier bindingPath = InstanceIdentifier.create(builder); - return new SimpleEntry<>(bindingPath, lazyObj); + final InstanceIdentifier bindingPath = InstanceIdentifier.unsafeOf(builder); + return Map.entry(bindingPath, lazyObj); } @Override - public Notification fromNormalizedNodeNotification(final Absolute path, final ContainerNode data) { + public BaseNotification fromNormalizedNodeNotification(final Absolute path, final ContainerNode data) { return getNotificationContext(path).deserialize(data); } @Override - public Notification fromNormalizedNodeNotification(final Absolute path, final ContainerNode data, + public BaseNotification fromNormalizedNodeNotification(final Absolute path, final ContainerNode data, final Instant eventInstant) { return eventInstant == null ? fromNormalizedNodeNotification(path, data) : getNotificationContext(path).deserialize(data, eventInstant); - } @Override @@ -564,10 +591,22 @@ public final class BindingCodecContext extends AbstractBindingNormalizedNodeSeri @Override @SuppressFBWarnings("BC_UNCONFIRMED_CAST") - public ContainerNode toNormalizedNodeNotification(@NonNull final Notification data) { + public ContainerNode toNormalizedNodeNotification(final Notification data) { // FIXME: Should the cast to DataObject be necessary? return serializeDataObject((DataObject) data, - (ctx, iface, domWriter) -> ctx.newNotificationWriter(iface.asSubclass(Notification.class), domWriter)); + (ctx, iface, domWriter) -> ctx.newNotificationWriter( + (Class>) iface.asSubclass(Notification.class), domWriter)); + } + + @Override + public ContainerNode toNormalizedNodeNotification(final Absolute path, final BaseNotification data) { + checkArgument(data instanceof DataObject, "Unexpected data %s", data); + @SuppressWarnings("rawtypes") + final NotificationCodecContext notifContext = getNotificationContext(path); + @SuppressWarnings("unchecked") + final var result = notifContext.serialize((DataObject) data); + verify(result instanceof ContainerNode, "Unexpected result %s from %s", result, data); + return (ContainerNode) result; } @Override @@ -607,7 +646,7 @@ public final class BindingCodecContext extends AbstractBindingNormalizedNodeSeri } - private static boolean notBindingRepresentable(final NormalizedNode data) { + private static boolean notBindingRepresentable(final NormalizedNode data) { // ValueNode covers LeafNode and LeafSetEntryNode return data instanceof ValueNode || data instanceof MapNode || data instanceof UnkeyedListNode