*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Verify.verify;
+
import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
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 java.lang.reflect.Type;
+import java.util.List;
+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.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.ChoiceIn;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.Notification;
-import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
+import org.opendaylight.yangtools.yang.binding.RpcInput;
+import org.opendaylight.yangtools.yang.binding.RpcOutput;
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.ContainerSchemaNode;
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.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
}
});
+ 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<?>, ContainerNodeCodecContext<?>> rpcDataByClass = CacheBuilder.newBuilder().build(
new CacheLoader<Class<?>, ContainerNodeCodecContext<?>>() {
@Override
}
});
+ 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<?,?>>() {
- @SuppressWarnings("unchecked")
@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("rawtypes")
- final Class childCls = factory().getRuntimeContext().getClassForSchema(childSchema);
+ @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<?>>() {
- @SuppressWarnings({ "rawtypes", "unchecked" })
@Override
- public RpcInputCodec load(final SchemaPath key) {
+ public RpcInputCodec<?> load(final SchemaPath key) {
final ContainerSchemaNode schema = SchemaContextUtil.getRpcDataSchema(getSchema(), key);
- if (schema instanceof EffectiveStatement
- && ((EffectiveStatement) schema).getDeclared().getStatementSource()
- != StatementSource.DECLARATION) {
- // This is an implicitly-defined input or output statement. We do not have a corresponding
- // data representation, so we hard-wire it to null.
- return UnmappedRpcInputCodec.getInstance();
- }
-
- final Class cls = factory().getRuntimeContext().getClassForSchema(schema);
+ @SuppressWarnings("unchecked")
+ final Class<? extends DataContainer> cls = (Class<? extends DataContainer>)
+ factory().getRuntimeContext().getClassForSchema(schema);
return getRpc(cls);
}
});
private final LoadingCache<SchemaPath, NotificationCodecContext<?>> notificationsByPath = CacheBuilder.newBuilder()
.build(new CacheLoader<SchemaPath, NotificationCodecContext<?>>() {
-
- @SuppressWarnings({ "rawtypes", "unchecked" })
@Override
- public NotificationCodecContext load(final SchemaPath key) throws Exception {
+ public NotificationCodecContext<?> load(final SchemaPath key) {
final NotificationDefinition schema = SchemaContextUtil.getNotificationSchema(getSchema(), key);
- final Class clz = factory().getRuntimeContext().getClassForSchema(schema);
+ @SuppressWarnings("unchecked")
+ final Class<? extends Notification> clz = (Class<? extends Notification>)
+ factory().getRuntimeContext().getClassForSchema(schema);
return getNotification(clz);
}
});
throw new UnsupportedOperationException("Could not create Binding data representation for root");
}
+ ActionCodecContext getAction(final Class<? extends Action<?, ?, ?>> action) {
+ return getOrRethrow(actionsByClass, action);
+ }
+
NotificationCodecContext<?> getNotification(final Class<? extends Notification> notification) {
return getOrRethrow(notificationsByClass, notification);
}
return DataContainerCodecPrototype.from(key, childSchema, factory()).get();
}
+ ActionCodecContext createActionContext(final Class<? extends Action<?, ?, ?>> action) {
+ final Type[] args = ClassLoaderUtils.findParameterizedType(action, Action.class).getActualTypeArguments();
+ checkArgument(args.length == 3, "Unexpected (%s) Action generatic arguments", args.length);
+
+ final ActionDefinition schema = factory().getRuntimeContext().getActionDefinition(action);
+ return new ActionCodecContext(
+ DataContainerCodecPrototype.from(asClass(args[1], RpcInput.class), schema.getInput(), factory()).get(),
+ DataContainerCodecPrototype.from(asClass(args[2], RpcOutput.class), schema.getOutput(), factory()).get());
+ }
+
+ private static <T extends DataObject> Class<? extends T> asClass(final Type type, final Class<T> target) {
+ verify(type instanceof Class, "Type %s is not a class", type);
+ return ((Class<?>) type).asSubclass(target);
+ }
+
ContainerNodeCodecContext<?> createRpcDataContext(final Class<?> key) {
- Preconditions.checkArgument(DataContainer.class.isAssignableFrom(key));
+ checkArgument(DataContainer.class.isAssignableFrom(key));
final QName qname = BindingReflections.findQName(key);
- final QNameModule module = qname.getModule();
+ 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);
+
RpcDefinition rpc = null;
- for (final RpcDefinition potential : getSchema().getOperations()) {
+ for (final RpcDefinition potential : module.getRpcs()) {
final QName potentialQName = potential.getQName();
/*
* Check if rpc and class represents data from same module and then
* FIXME: Rework this to have more precise logic regarding Binding
* Specification.
*/
- if (module.equals(potentialQName.getModule())
- && key.getSimpleName().equals(
- BindingMapping.getClassName(potentialQName) + BindingMapping.getClassName(qname))) {
+ if (key.getSimpleName().equals(BindingMapping.getClassName(potentialQName) + className)) {
rpc = potential;
break;
}
}
- Preconditions.checkArgument(rpc != null, "Supplied class %s is not valid RPC class.", key);
+ checkArgument(rpc != null, "Supplied class %s is not valid RPC class.", key);
final ContainerSchemaNode schema = SchemaNodeUtils.getRpcDataSchema(rpc, qname);
- Preconditions.checkArgument(schema != null, "Schema for %s does not define input / output.", rpc.getQName());
+ checkArgument(schema != null, "Schema for %s does not define input / output.", rpc.getQName());
return (ContainerNodeCodecContext<?>) DataContainerCodecPrototype.from(key, schema, factory()).get();
}
NotificationCodecContext<?> createNotificationDataContext(final Class<?> notificationType) {
- Preconditions.checkArgument(Notification.class.isAssignableFrom(notificationType));
- Preconditions.checkArgument(notificationType.isInterface(), "Supplied class must be interface.");
+ 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
*/
final NotificationDefinition schema = SchemaContextUtil.getNotificationSchema(getSchema(),
SchemaPath.create(true, qname));
- Preconditions.checkArgument(schema != null, "Supplied %s is not valid notification", notificationType);
+ checkArgument(schema != null, "Supplied %s is not valid notification", notificationType);
return new NotificationCodecContext<>(notificationType, schema, factory());
}
+ 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);
+ return (ChoiceNodeCodecContext<?>) choice;
+ }
+
@Override
protected Object deserializeObject(final NormalizedNode<?, ?> normalizedNode) {
throw new UnsupportedOperationException("Unable to deserialize root");
@Override
public InstanceIdentifier.PathArgument deserializePathArgument(final YangInstanceIdentifier.PathArgument arg) {
- Preconditions.checkArgument(arg == null);
+ checkArgument(arg == null);
return null;
}
@Override
public YangInstanceIdentifier.PathArgument serializePathArgument(final InstanceIdentifier.PathArgument arg) {
- Preconditions.checkArgument(arg == null);
+ checkArgument(arg == null);
+ return null;
+ }
+
+ @Override
+ public DataContainerCodecContext<?, ?> bindingPathArgumentChild(final InstanceIdentifier.PathArgument arg,
+ final List<PathArgument> builder) {
+ final java.util.Optional<? extends Class<? extends DataObject>> caseType = arg.getCaseType();
+ if (caseType.isPresent()) {
+ final Class<? extends DataObject> type = caseType.get();
+ final ChoiceNodeCodecContext<?> choice = choicesByClass.getUnchecked(type);
+ choice.addYangPathArgument(arg, builder);
+ final DataContainerCodecContext<?, ?> caze = choice.streamChild(type);
+ caze.addYangPathArgument(arg, builder);
+ return caze.bindingPathArgumentChild(arg, builder);
+ }
+
+ return super.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);
+ }
+ }
+ }
+
return null;
}
throw e;
}
}
-}
\ No newline at end of file
+}
Code Review / mdsal.git / blobdiff