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 com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import com.google.common.base.Strings;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.File;
import java.io.IOException;
-import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
@MetaInfServices(value = BindingDOMCodecServices.class)
public final class BindingCodecContext extends AbstractBindingNormalizedNodeSerializer
- implements BindingDOMCodecServices, Immutable, CodecContextFactory, DataObjectSerializerRegistry {
+ implements BindingDOMCodecServices, Immutable, CodecContextFactory, DataContainerSerializerRegistry {
private static final Logger LOG = LoggerFactory.getLogger(BindingCodecContext.class);
private static final @NonNull NodeIdentifier FAKE_NODEID = new NodeIdentifier(QName.create("fake", "fake"));
private static final File BYTECODE_DIRECTORY;
BYTECODE_DIRECTORY = Strings.isNullOrEmpty(dir) ? null : new File(dir);
}
- private final LoadingCache<Class<?>, DataObjectStreamer<?>> streamers = CacheBuilder.newBuilder().build(
- new CacheLoader<Class<?>, DataObjectStreamer<?>>() {
+ private final LoadingCache<Class<?>, DataContainerStreamer<?>> streamers = CacheBuilder.newBuilder().build(
+ new CacheLoader<>() {
@Override
- public DataObjectStreamer<?> load(final Class<?> key) throws ReflectiveOperationException {
- final Class<?> streamer = DataObjectStreamerGenerator.generateStreamer(loader, BindingCodecContext.this,
+ public DataContainerStreamer<?> load(final Class<?> key) throws ReflectiveOperationException {
+ final var streamer = DataContainerStreamerGenerator.generateStreamer(loader, BindingCodecContext.this,
key);
- final Field instance = streamer.getDeclaredField(DataObjectStreamerGenerator.INSTANCE_FIELD);
- return (DataObjectStreamer<?>) instance.get(null);
+ final var instance = streamer.getDeclaredField(DataContainerStreamerGenerator.INSTANCE_FIELD);
+ return (DataContainerStreamer<?>) instance.get(null);
}
});
- private final LoadingCache<Class<?>, DataObjectSerializer> serializers = CacheBuilder.newBuilder().build(
- new CacheLoader<Class<?>, DataObjectSerializer>() {
+ private final LoadingCache<Class<?>, DataContainerSerializer> serializers = CacheBuilder.newBuilder().build(
+ new CacheLoader<>() {
@Override
- public DataObjectSerializer load(final Class<?> key) throws ExecutionException {
- return new DataObjectSerializer(BindingCodecContext.this, streamers.get(key));
+ public DataContainerSerializer load(final Class<?> key) throws ExecutionException {
+ return new DataContainerSerializer(BindingCodecContext.this, streamers.get(key));
}
});
}
@Override
- public DataObjectSerializer getEventStreamSerializer(final Class<?> type) {
+ public DataContainerSerializer getEventStreamSerializer(final Class<?> type) {
return serializers.getUnchecked(type);
}
@Override
- public DataObjectStreamer<?> getDataObjectSerializer(final Class<?> type) {
+ public DataContainerStreamer<?> getDataContainerStreamer(final Class<?> type) {
return streamers.getUnchecked(type);
}
@Override
- public DataObjectSerializer getSerializer(final Class<? extends DataObject> type) {
+ public DataContainerSerializer getSerializer(final Class<? extends DataContainer> type) {
return serializers.getUnchecked(type);
}
@Nullable BindingDataObjectCodecTreeNode<?> getCodecContextNode(final @NonNull YangInstanceIdentifier dom,
final @Nullable Collection<InstanceIdentifier.PathArgument> bindingArguments) {
CodecContext currentNode = root;
- ListNodeCodecContext<?> currentList = null;
+ ListCodecContext<?> currentList = null;
for (var domArg : dom.getPathArguments()) {
checkArgument(currentNode instanceof DataContainerCodecContext,
}
currentList = null;
currentNode = nextNode;
- } else if (nextNode instanceof ListNodeCodecContext<?> listNode) {
+ } else if (nextNode instanceof ListCodecContext<?> listNode) {
// We enter list, we do not update current Node yet,
// since we need to verify
currentList = listNode;
LOG.debug("Instance identifier targeting a choice is not representable ({})", dom);
return null;
}
- if (currentNode instanceof CaseNodeCodecContext) {
+ if (currentNode instanceof CaseCodecContext) {
LOG.debug("Instance identifier targeting a case is not representable ({})", dom);
return null;
}
final ValueCodec<Object, Object> codec = getCodec(valueType, leafListSchema.getType());
valueNode = new LeafSetNodeCodecContext(leafListSchema, codec, method.getName());
} else if (schema instanceof AnyxmlSchemaNode anyxmlSchema) {
- valueNode = new OpaqueNodeCodecContext.Anyxml<>(anyxmlSchema, method.getName(),
- opaqueReturnType(method), loader);
+ valueNode = new AnyxmlCodecContext<>(anyxmlSchema, method.getName(), opaqueReturnType(method),
+ loader);
} else if (schema instanceof AnydataSchemaNode anydataSchema) {
- valueNode = new OpaqueNodeCodecContext.Anydata<>(anydataSchema, method.getName(),
- opaqueReturnType(method), loader);
+ valueNode = new AnydataCodecContext<>(anydataSchema, method.getName(), opaqueReturnType(method),
+ loader);
} else {
verify(schema == null, "Unhandled schema %s for method %s", schema, method);
// We do not have schema for leaf, so we will ignore it (e.g. getClass).
return serializeDataObject(output, (ctx, iface, domWriter) -> ctx.newActionOutputWriter(action, domWriter));
}
+ @Override
+ protected NodeIdentifier actionInputName(final Class<? extends Action<?, ?, ?>> action) {
+ return verifyNotNull(getActionCodec(action).input().getDomPathArgument());
+ }
+
+ @Override
+ protected NodeIdentifier actionOutputName(final Class<? extends Action<?, ?, ?>> action) {
+ return verifyNotNull(getActionCodec(action).output().getDomPathArgument());
+ }
+
private <T extends DataContainer> @NonNull ContainerNode serializeDataObject(final DataObject data,
final WriterFactoryMethod<T> newWriter) {
final var result = new NormalizationResultHolder();
return (ContainerNode) result.getResult().data();
}
-
private static boolean notBindingRepresentable(final NormalizedNode data) {
// ValueNode covers LeafNode and LeafSetEntryNode
return data instanceof ValueNode
Code Review / yangtools.git / blobdiff