git.opendaylight Code Review - yangtools.git/blob

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.binding.data.codec.impl;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11 import static com.google.common.base.Preconditions.checkState;
  12 import static com.google.common.base.Verify.verify;
  13 import static com.google.common.base.Verify.verifyNotNull;
  14 import static java.util.Objects.requireNonNull;
  15
  16 import com.google.common.annotations.VisibleForTesting;
  17 import com.google.common.base.Strings;
  18 import com.google.common.base.Throwables;
  19 import com.google.common.base.VerifyException;
  20 import com.google.common.cache.CacheBuilder;
  21 import com.google.common.cache.CacheLoader;
  22 import com.google.common.cache.LoadingCache;
  23 import com.google.common.collect.ImmutableList;
  24 import com.google.common.collect.ImmutableMap;
  25 import com.google.common.util.concurrent.UncheckedExecutionException;
  26 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  27 import java.io.File;
  28 import java.io.IOException;
  29 import java.lang.reflect.Method;
  30 import java.lang.reflect.ParameterizedType;
  31 import java.lang.reflect.Type;
  32 import java.lang.reflect.WildcardType;
  33 import java.time.Instant;
  34 import java.util.ArrayList;
  35 import java.util.HashMap;
  36 import java.util.Iterator;
  37 import java.util.List;
  38 import java.util.Map;
  39 import java.util.Map.Entry;
  40 import java.util.Optional;
  41 import java.util.ServiceLoader;
  42 import java.util.concurrent.ExecutionException;
  43 import org.eclipse.jdt.annotation.NonNull;
  44 import org.eclipse.jdt.annotation.Nullable;
  45 import org.kohsuke.MetaInfServices;
  46 import org.opendaylight.yangtools.binding.Action;
  47 import org.opendaylight.yangtools.binding.Augmentation;
  48 import org.opendaylight.yangtools.binding.BaseIdentity;
  49 import org.opendaylight.yangtools.binding.BaseNotification;
  50 import org.opendaylight.yangtools.binding.BindingInstanceIdentifier;
  51 import org.opendaylight.yangtools.binding.ChoiceIn;
  52 import org.opendaylight.yangtools.binding.DataContainer;
  53 import org.opendaylight.yangtools.binding.DataObject;
  54 import org.opendaylight.yangtools.binding.DataObjectReference;
  55 import org.opendaylight.yangtools.binding.DataObjectStep;
  56 import org.opendaylight.yangtools.binding.EntryObject;
  57 import org.opendaylight.yangtools.binding.Key;
  58 import org.opendaylight.yangtools.binding.KeyedListAction;
  59 import org.opendaylight.yangtools.binding.Notification;
  60 import org.opendaylight.yangtools.binding.OpaqueObject;
  61 import org.opendaylight.yangtools.binding.RpcInput;
  62 import org.opendaylight.yangtools.binding.RpcOutput;
  63 import org.opendaylight.yangtools.binding.YangData;
  64 import org.opendaylight.yangtools.binding.contract.BuiltInType;
  65 import org.opendaylight.yangtools.binding.data.codec.api.BindingAugmentationCodecTreeNode;
  66 import org.opendaylight.yangtools.binding.data.codec.api.BindingCodecTree;
  67 import org.opendaylight.yangtools.binding.data.codec.api.BindingCodecTreeNode;
  68 import org.opendaylight.yangtools.binding.data.codec.api.BindingDataCodec;
  69 import org.opendaylight.yangtools.binding.data.codec.api.BindingDataObjectCodecTreeNode;
  70 import org.opendaylight.yangtools.binding.data.codec.api.BindingInstanceIdentifierCodec;
  71 import org.opendaylight.yangtools.binding.data.codec.api.BindingNormalizedNodeSerializer;
  72 import org.opendaylight.yangtools.binding.data.codec.api.BindingNormalizedNodeWriterFactory;
  73 import org.opendaylight.yangtools.binding.data.codec.api.BindingStreamEventWriter;
  74 import org.opendaylight.yangtools.binding.data.codec.api.BindingYangDataCodecTreeNode;
  75 import org.opendaylight.yangtools.binding.data.codec.api.CommonDataObjectCodecTreeNode;
  76 import org.opendaylight.yangtools.binding.data.codec.api.IncorrectNestingException;
  77 import org.opendaylight.yangtools.binding.data.codec.api.MissingSchemaException;
  78 import org.opendaylight.yangtools.binding.data.codec.dynamic.DynamicBindingDataCodec;
  79 import org.opendaylight.yangtools.binding.data.codec.spi.AbstractBindingNormalizedNodeSerializer;
  80 import org.opendaylight.yangtools.binding.data.codec.spi.BindingDOMCodecServices;
  81 import org.opendaylight.yangtools.binding.data.codec.spi.BindingSchemaMapping;
  82 import org.opendaylight.yangtools.binding.loader.BindingClassLoader;
  83 import org.opendaylight.yangtools.binding.model.api.JavaTypeName;
  84 import org.opendaylight.yangtools.binding.reflect.BindingReflections;
  85 import org.opendaylight.yangtools.binding.runtime.api.ActionRuntimeType;
  86 import org.opendaylight.yangtools.binding.runtime.api.BindingRuntimeContext;
  87 import org.opendaylight.yangtools.binding.runtime.api.ChoiceRuntimeType;
  88 import org.opendaylight.yangtools.binding.runtime.api.ContainerLikeRuntimeType;
  89 import org.opendaylight.yangtools.binding.runtime.api.ContainerRuntimeType;
  90 import org.opendaylight.yangtools.binding.runtime.api.DataRuntimeType;
  91 import org.opendaylight.yangtools.binding.runtime.api.InputRuntimeType;
  92 import org.opendaylight.yangtools.binding.runtime.api.ListRuntimeType;
  93 import org.opendaylight.yangtools.binding.runtime.api.NotificationRuntimeType;
  94 import org.opendaylight.yangtools.binding.runtime.api.OutputRuntimeType;
  95 import org.opendaylight.yangtools.concepts.Immutable;
  96 import org.opendaylight.yangtools.util.ClassLoaderUtils;
  97 import org.opendaylight.yangtools.yang.common.QName;
  98 import org.opendaylight.yangtools.yang.common.YangDataName;
  99 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 100 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 101 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
 102 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
 103 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
 104 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 105 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
 106 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
 107 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 108 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
 109 import org.opendaylight.yangtools.yang.data.api.schema.ValueNode;
 110 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
 111 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
 112 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
 113 import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
 114 import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
 115 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
 116 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
 117 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
 118 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
 119 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
 120 import org.opendaylight.yangtools.yang.model.api.TypeAware;
 121 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
 122 import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
 123 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 124 import org.opendaylight.yangtools.yang.model.api.stmt.PresenceEffectiveStatement;
 125 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
 126 import org.opendaylight.yangtools.yang.model.api.stmt.TypeDefinitionAware;
 127 import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
 128 import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
 129 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
 130 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
 131 import org.slf4j.Logger;
 132 import org.slf4j.LoggerFactory;
 133
 134 @MetaInfServices(value = { BindingDataCodec.class, DynamicBindingDataCodec.class, BindingDOMCodecServices.class })
 135 public final class BindingCodecContext extends AbstractBindingNormalizedNodeSerializer
 136         implements DynamicBindingDataCodec, CodecContextFactory, DataContainerSerializerRegistry, Immutable,
 137                    BindingDOMCodecServices {
 138     private static final Logger LOG = LoggerFactory.getLogger(BindingCodecContext.class);
 139     private static final @NonNull NodeIdentifier FAKE_NODEID = new NodeIdentifier(QName.create("fake", "fake"));
 140     private static final File BYTECODE_DIRECTORY;
 141
 142     static {
 143         final String dir = System.getProperty("org.opendaylight.mdsal.binding.dom.codec.loader.bytecodeDumpDirectory");
 144         BYTECODE_DIRECTORY = Strings.isNullOrEmpty(dir) ? null : new File(dir);
 145     }
 146
 147     /**
 148      * A simple codec that just verifies against possible {@link BuiltInType}s.
 149      */
 150     // FIXME: YANGTOOLS-1602: this codec should not be needed
 151     @VisibleForTesting
 152     static final @NonNull SchemaUnawareCodec NOOP_CODEC = new SchemaUnawareCodec() {
 153         @Override
 154         protected Object serializeImpl(final Object input) {
 155             return BuiltInType.checkValue(input);
 156         }
 157
 158         @Override
 159         protected Object deserializeImpl(final Object input) {
 160             return BuiltInType.checkValue(input);
 161         }
 162     };
 163
 164     private final LoadingCache<Class<?>, DataContainerStreamer<?>> streamers = CacheBuilder.newBuilder()
 165         .build(new CacheLoader<>() {
 166             @Override
 167             public DataContainerStreamer<?> load(final Class<?> key) throws ReflectiveOperationException {
 168                 final var streamer = DataContainerStreamerGenerator.generateStreamer(loader, BindingCodecContext.this,
 169                     key);
 170                 final var instance = streamer.getDeclaredField(DataContainerStreamerGenerator.INSTANCE_FIELD);
 171                 return (DataContainerStreamer<?>) instance.get(null);
 172             }
 173         });
 174     private final LoadingCache<Class<?>, DataContainerSerializer> serializers = CacheBuilder.newBuilder()
 175         .build(new CacheLoader<>() {
 176             @Override
 177             public DataContainerSerializer load(final Class<?> key) throws ExecutionException {
 178                 return new DataContainerSerializer(BindingCodecContext.this, streamers.get(key));
 179             }
 180         });
 181     private final LoadingCache<Class<? extends DataObject>, DataContainerCodecContext<?, ?, ?>> childrenByClass =
 182         CacheBuilder.newBuilder().build(new CacheLoader<>() {
 183             @Override
 184             public DataContainerCodecContext<?, ?, ?> load(final Class<? extends DataObject> key) {
 185                 final var childSchema = context.getTypes().bindingChild(JavaTypeName.create(key));
 186                 if (childSchema instanceof ContainerLikeRuntimeType containerLike) {
 187                     if (childSchema instanceof ContainerRuntimeType container
 188                         && container.statement().findFirstEffectiveSubstatement(PresenceEffectiveStatement.class)
 189                             .isEmpty()) {
 190                         return new StructuralContainerCodecContext<>(key, container, BindingCodecContext.this);
 191                     }
 192                     return new ContainerLikeCodecContext<>(key, containerLike, BindingCodecContext.this);
 193                 } else if (childSchema instanceof ListRuntimeType list) {
 194                     return list.keyType() == null ? new ListCodecContext<>(key, list, BindingCodecContext.this)
 195                         : MapCodecContext.of(key, list, BindingCodecContext.this);
 196                 } else if (childSchema instanceof ChoiceRuntimeType choice) {
 197                     return new ChoiceCodecContext<>(key.asSubclass(ChoiceIn.class), choice, BindingCodecContext.this);
 198                 } else if (childSchema == null) {
 199                     throw DataContainerCodecContext.childNullException(context, key, "%s is not top-level item.", key);
 200                 } else {
 201                     throw new IncorrectNestingException("%s is not a valid data tree child of %s", key, this);
 202                 }
 203             }
 204         });
 205
 206     private final LoadingCache<@NonNull QName, CodecContext> childrenByDomArg =
 207         CacheBuilder.newBuilder().build(new CacheLoader<>() {
 208             @Override
 209             public CodecContext load(final QName qname) throws ClassNotFoundException {
 210                 final var type = context.getTypes();
 211                 final var child = type.schemaTreeChild(qname);
 212                 if (child == null) {
 213                     final var module = qname.getModule();
 214                     if (type.findModule(module).isEmpty()) {
 215                         throw new MissingSchemaException(
 216                             "Module " + module + " is not present in current schema context.");
 217                     }
 218                     throw new IncorrectNestingException("Argument %s is not valid child of %s", qname, type);
 219                 }
 220
 221                 if (!(child instanceof DataRuntimeType)) {
 222                     throw new IncorrectNestingException("Argument %s is not valid data tree child of %s", qname, type);
 223                 }
 224
 225                 // TODO: improve this check?
 226                 final var childSchema = child.statement();
 227                 if (childSchema instanceof DataNodeContainer || childSchema instanceof ChoiceSchemaNode) {
 228                     return getStreamChild(context.loadClass(child.javaType()));
 229                 } else if (childSchema instanceof AnydataSchemaNode || childSchema instanceof AnyxmlSchemaNode
 230                     || childSchema instanceof LeafSchemaNode || childSchema instanceof LeafListSchemaNode) {
 231                     final var module = type.findModule(qname.getModule()).orElseThrow();
 232                     final var moduleChildren = getLeafNodes(context.loadClass(module.javaType()), module.statement());
 233                     for (var moduleChild : moduleChildren.values()) {
 234                         if (qname.equals(moduleChild.getDomPathArgument().getNodeType())) {
 235                             return moduleChild;
 236                         }
 237                     }
 238                     throw new IllegalArgumentException("Failed to resolve " + child + " in " + module);
 239                 } else {
 240                     throw new UnsupportedOperationException("Unsupported child type " + childSchema.getClass());
 241                 }
 242             }
 243         });
 244
 245     private final LoadingCache<Class<? extends DataObject>, ChoiceCodecContext<?>> choicesByClass =
 246         CacheBuilder.newBuilder().build(new CacheLoader<>() {
 247             @Override
 248             public ChoiceCodecContext<?> load(final Class<? extends DataObject> caseType) {
 249                 final var choiceClass = findCaseChoice(caseType);
 250                 if (choiceClass == null) {
 251                     throw new IllegalArgumentException(caseType + " is not a valid case representation");
 252                 }
 253                 if (context.getSchemaDefinition(choiceClass) instanceof ChoiceRuntimeType choiceType) {
 254                     // FIXME: accurate type!
 255                     return new ChoiceCodecContext(choiceClass, choiceType, BindingCodecContext.this);
 256                 }
 257                 throw new IllegalArgumentException(caseType + " does not refer to a choice");
 258             }
 259
 260             private static Class<?> findCaseChoice(final Class<? extends DataObject> caseClass) {
 261                 for (var type : caseClass.getGenericInterfaces()) {
 262                     if (type instanceof Class<?> typeClass && ChoiceIn.class.isAssignableFrom(typeClass)) {
 263                         return typeClass.asSubclass(ChoiceIn.class);
 264                     }
 265                 }
 266                 return null;
 267             }
 268         });
 269
 270     private final LoadingCache<Class<? extends Action<?, ?, ?>>, ActionCodecContext> actionsByClass =
 271         CacheBuilder.newBuilder().build(new CacheLoader<>() {
 272             @Override
 273             public ActionCodecContext load(final Class<? extends Action<?, ?, ?>> action) {
 274                 if (KeyedListAction.class.isAssignableFrom(action)) {
 275                     return prepareActionContext(2, 3, 4, action, KeyedListAction.class);
 276                 } else if (Action.class.isAssignableFrom(action)) {
 277                     return prepareActionContext(1, 2, 3, action, Action.class);
 278                 }
 279                 throw new IllegalArgumentException("The specific action type does not exist for action "
 280                     + action.getName());
 281             }
 282
 283             private ActionCodecContext prepareActionContext(final int inputOffset, final int outputOffset,
 284                     final int expectedArgsLength, final Class<? extends Action<?, ?, ?>> action,
 285                     final Class<?> actionType) {
 286                 final var args = ClassLoaderUtils.findParameterizedType(action, actionType)
 287                     .orElseThrow(() -> new IllegalStateException(action + " does not specialize " + actionType))
 288                     .getActualTypeArguments();
 289                 checkArgument(args.length == expectedArgsLength, "Unexpected (%s) Action generatic arguments",
 290                     args.length);
 291                 final ActionRuntimeType schema = context.getActionDefinition(action);
 292                 return new ActionCodecContext(
 293                     new ContainerLikeCodecContext(asClass(args[inputOffset], RpcInput.class), schema.input(),
 294                         BindingCodecContext.this),
 295                     new ContainerLikeCodecContext(asClass(args[outputOffset], RpcOutput.class), schema.output(),
 296                         BindingCodecContext.this));
 297             }
 298
 299             private static <T extends DataObject> Class<? extends T> asClass(final Type type, final Class<T> target) {
 300                 verify(type instanceof Class, "Type %s is not a class", type);
 301                 return ((Class<?>) type).asSubclass(target);
 302             }
 303         });
 304
 305     private final LoadingCache<Class<?>, NotificationCodecContext<?>> notificationsByClass = CacheBuilder.newBuilder()
 306         .build(new CacheLoader<>() {
 307             @Override
 308             public NotificationCodecContext<?> load(final Class<?> key) {
 309                 final var runtimeType = context.getTypes().bindingChild(JavaTypeName.create(key));
 310                 if (runtimeType instanceof NotificationRuntimeType notification) {
 311                     return new NotificationCodecContext<>(key, notification, BindingCodecContext.this);
 312                 } if (runtimeType != null) {
 313                     throw new IllegalArgumentException(key + " maps to unexpected " + runtimeType);
 314                 }
 315                 throw new IllegalArgumentException(key + " is not a known class");
 316             }
 317         });
 318     private final LoadingCache<Absolute, NotificationCodecContext<?>> notificationsByPath =
 319         CacheBuilder.newBuilder().build(new CacheLoader<>() {
 320             @Override
 321             public NotificationCodecContext<?> load(final Absolute key) {
 322                 final var cls = context.getClassForSchema(key);
 323                 try {
 324                     return getNotificationContext(cls.asSubclass(Notification.class));
 325                 } catch (ClassCastException e) {
 326                     throw new IllegalArgumentException("Path " + key + " does not represent a notification", e);
 327                 }
 328             }
 329         });
 330
 331     private final LoadingCache<Class<?>, ContainerLikeCodecContext<?>> rpcDataByClass =
 332         CacheBuilder.newBuilder().build(new CacheLoader<>() {
 333             @Override
 334             public ContainerLikeCodecContext<?> load(final Class<?> key) {
 335                 final var runtimeType = context.getTypes().findSchema(JavaTypeName.create(key))
 336                     .orElseThrow(() -> new IllegalArgumentException(key + " is not a known class"));
 337                 if (RpcInput.class.isAssignableFrom(key) && runtimeType instanceof InputRuntimeType input) {
 338                     // FIXME: accurate type
 339                     return new ContainerLikeCodecContext(key, input, BindingCodecContext.this);
 340                 } else if (RpcOutput.class.isAssignableFrom(key) && runtimeType instanceof OutputRuntimeType output) {
 341                     // FIXME: accurate type
 342                     return new ContainerLikeCodecContext(key, output, BindingCodecContext.this);
 343                 } else {
 344                     throw new IllegalArgumentException(key + " maps to unexpected " + runtimeType);
 345                 }
 346             }
 347         });
 348     private final LoadingCache<Absolute, ContainerLikeCodecContext<?>> rpcDataByPath =
 349         CacheBuilder.newBuilder().build(new CacheLoader<>() {
 350             @Override
 351             public ContainerLikeCodecContext<?> load(final Absolute key) {
 352                 final var rpcName = key.firstNodeIdentifier();
 353
 354                 final Class<? extends DataContainer> container = switch (key.lastNodeIdentifier().getLocalName()) {
 355                     case "input" -> context.getRpcInput(rpcName);
 356                     case "output" -> context.getRpcOutput(rpcName);
 357                     default -> throw new IllegalArgumentException("Unhandled path " + key);
 358                 };
 359
 360                 return getRpc(container);
 361             }
 362         });
 363
 364     private final @NonNull BindingClassLoader loader =
 365         BindingClassLoader.create(BindingCodecContext.class, BYTECODE_DIRECTORY);
 366     private final @NonNull InstanceIdentifierCodec instanceIdentifierCodec;
 367     private final @NonNull IdentityCodec identityCodec;
 368     private final @NonNull BindingRuntimeContext context;
 369
 370     public BindingCodecContext() {
 371         this(ServiceLoader.load(BindingRuntimeContext.class).findFirst()
 372             .orElseThrow(() -> new IllegalStateException("Failed to load BindingRuntimeContext")));
 373     }
 374
 375     public BindingCodecContext(final BindingRuntimeContext context) {
 376         this.context = requireNonNull(context, "Binding Runtime Context is required.");
 377         identityCodec = new IdentityCodec(context);
 378         instanceIdentifierCodec = new InstanceIdentifierCodec(this);
 379     }
 380
 381     @Override
 382     @Deprecated(since = "14.0.2", forRemoval = true)
 383     public BindingRuntimeContext getRuntimeContext() {
 384         return context;
 385     }
 386
 387     @Override
 388     public BindingRuntimeContext runtimeContext() {
 389         return context;
 390     }
 391
 392     @Override
 393     public BindingNormalizedNodeSerializer nodeSerializer() {
 394         return this;
 395     }
 396
 397     @Override
 398     public BindingCodecTree tree() {
 399         return this;
 400     }
 401
 402     @Override
 403     public BindingNormalizedNodeWriterFactory writerFactory() {
 404         return this;
 405     }
 406
 407     @Override
 408     public BindingClassLoader getLoader() {
 409         return loader;
 410     }
 411
 412     @Override
 413     public IdentityCodec getIdentityCodec() {
 414         return identityCodec;
 415     }
 416
 417     @Override
 418     public BindingInstanceIdentifierCodec getInstanceIdentifierCodec() {
 419         return instanceIdentifierCodec;
 420     }
 421
 422     @Override
 423     public <T extends YangData<T>> BindingYangDataCodecTreeNode<T> getYangDataCodec(final Class<T> yangDataClass) {
 424         throw new UnsupportedOperationException("Not implemented yet");
 425     }
 426
 427     @Override
 428     public BindingYangDataCodecTreeNode<?> getYangDataCodec(final YangDataName yangDataName) {
 429         throw new UnsupportedOperationException("Not implemented yet");
 430     }
 431
 432     @Override
 433     public DataContainerSerializer getEventStreamSerializer(final Class<?> type) {
 434         return serializers.getUnchecked(type);
 435     }
 436
 437     @Override
 438     public DataContainerStreamer<?> getDataContainerStreamer(final Class<?> type) {
 439         return streamers.getUnchecked(type);
 440     }
 441
 442     @Override
 443     public DataContainerSerializer getSerializer(final Class<? extends DataContainer> type) {
 444         return serializers.getUnchecked(type);
 445     }
 446
 447     @Override
 448     public Entry<YangInstanceIdentifier, BindingStreamEventWriter> newWriterAndIdentifier(
 449             final DataObjectReference<?> path, final NormalizedNodeStreamWriter domWriter) {
 450         final var yangArgs = new ArrayList<PathArgument>();
 451         final var codecContext = getCodecContextNode(path, yangArgs);
 452         return Map.entry(YangInstanceIdentifier.of(yangArgs),
 453             new BindingToNormalizedStreamWriter(codecContext, domWriter));
 454     }
 455
 456     @Override
 457     public BindingStreamEventWriter newWriter(final DataObjectReference<?> path,
 458             final NormalizedNodeStreamWriter domWriter) {
 459         return new BindingToNormalizedStreamWriter(getCodecContextNode(path, null), domWriter);
 460     }
 461
 462     @Override
 463     public BindingStreamEventWriter newRpcWriter(final Class<? extends DataContainer> rpcInputOrOutput,
 464             final NormalizedNodeStreamWriter domWriter) {
 465         return new BindingToNormalizedStreamWriter(getRpc(rpcInputOrOutput), domWriter);
 466     }
 467
 468     @Override
 469     public BindingStreamEventWriter newNotificationWriter(final Class<? extends Notification<?>> notification,
 470             final NormalizedNodeStreamWriter domWriter) {
 471         return new BindingToNormalizedStreamWriter(getNotificationContext(notification), domWriter);
 472     }
 473
 474     @Override
 475     public BindingStreamEventWriter newActionInputWriter(final Class<? extends Action<?, ?, ?>> action,
 476             final NormalizedNodeStreamWriter domWriter) {
 477         return new BindingToNormalizedStreamWriter(getActionCodec(action).input(), domWriter);
 478     }
 479
 480     @Override
 481     public BindingStreamEventWriter newActionOutputWriter(final Class<? extends Action<?, ?, ?>> action,
 482             final NormalizedNodeStreamWriter domWriter) {
 483         return new BindingToNormalizedStreamWriter(getActionCodec(action).output(), domWriter);
 484     }
 485
 486     @NonNull DataContainerCodecContext<?, ?, ?> getCodecContextNode(final DataObjectReference<?> binding,
 487             final List<PathArgument> builder) {
 488         final var it = binding.steps().iterator();
 489         final var step = it.next();
 490
 491         final DataContainerCodecContext<?, ?, ?> start;
 492         final var caseType = step.caseType();
 493         if (caseType != null) {
 494             final var choice = choicesByClass.getUnchecked(caseType);
 495             choice.addYangPathArgument(step, builder);
 496             final var caze = choice.getStreamChild(caseType);
 497             caze.addYangPathArgument(step, builder);
 498             start = caze.bindingPathArgumentChild(step, builder);
 499         } else {
 500             final var child = getStreamChild(step.type());
 501             child.addYangPathArgument(step, builder);
 502             start = child;
 503         }
 504
 505         var current = start;
 506         while (it.hasNext()) {
 507             current = current.bindingPathArgumentChild(it.next(), builder);
 508         }
 509         return current;
 510     }
 511
 512     /**
 513      * Multi-purpose utility function. Traverse the codec tree, looking for the appropriate codec for the specified
 514      * {@link YangInstanceIdentifier}. As a side-effect, gather all traversed binding {@link DataObjectStep}s into the
 515      * supplied collection.
 516      *
 517      * @param dom {@link YangInstanceIdentifier} which is to be translated
 518      * @param bindingArguments Collection for traversed path arguments
 519      * @return Codec for target node, or {@code null} if the node does not have a binding representation (choice, case,
 520      *         leaf).
 521      * @throws IllegalArgumentException if {@code dom} is empty
 522      */
 523     @Nullable BindingDataObjectCodecTreeNode<?> getCodecContextNode(final @NonNull YangInstanceIdentifier dom,
 524             final @Nullable List<DataObjectStep<?>> bindingArguments) {
 525         final var codec = lookupCodecContext(dom, bindingArguments);
 526         if (!(codec instanceof BindingDataObjectCodecTreeNode<?> dataObjectCodec)) {
 527             return null;
 528         }
 529         if (dataObjectCodec instanceof CaseCodecContext) {
 530             LOG.debug("Instance identifier targeting a case is not representable ({})", dom);
 531             return null;
 532         }
 533         return dataObjectCodec;
 534     }
 535
 536     @Nullable CodecContext lookupCodecContext(final @NonNull YangInstanceIdentifier path,
 537             final @Nullable List<DataObjectStep<?>> bindingArguments) {
 538         final var it = path.getPathArguments().iterator();
 539         if (!it.hasNext()) {
 540             throw new IllegalArgumentException("Path may not be empty");
 541         }
 542
 543         // First item is somewhat special:
 544         // 1. it has to be a NodeIdentifier, otherwise it is a malformed identifier and we do not find it
 545         var domArg = it.next();
 546         if (!(domArg instanceof NodeIdentifier)) {
 547             return null;
 548         }
 549         CodecContext nextNode = getOrRethrow(childrenByDomArg, domArg.getNodeType());
 550
 551         CodecContext currentNode;
 552         switch (nextNode) {
 553             case ListCodecContext<?> listNode -> {
 554                 // 2. if it is a list, we need to see if we are consuming another item.
 555                 if (!it.hasNext()) {
 556                     // 2a: not further items: it boils down to a wildcard
 557                     if (bindingArguments != null) {
 558                         bindingArguments.add(listNode.getBindingPathArgument(null));
 559                     }
 560                     return listNode;
 561                 }
 562
 563                 // 2b: there is a next item: it should either be a NodeIdentifier or a NodeIdentifierWithPredicates, but
 564                 //     it has to have the same node type
 565                 final var nextArg = it.next();
 566                 if (nextArg instanceof NodeWithValue || !nextArg.getNodeType().equals(domArg.getNodeType())) {
 567                     throw new IllegalArgumentException("List should be referenced twice in " + path);
 568                 }
 569                 if (bindingArguments != null) {
 570                     bindingArguments.add(listNode.getBindingPathArgument(nextArg));
 571                 }
 572                 currentNode = listNode;
 573             }
 574             case ChoiceCodecContext<?> choiceNode -> {
 575                 currentNode = choiceNode;
 576             }
 577             case CommonDataObjectCodecContext<?, ?> firstContainer -> {
 578                 if (bindingArguments != null) {
 579                     bindingArguments.add(firstContainer.getBindingPathArgument(domArg));
 580                 }
 581                 currentNode = firstContainer;
 582             }
 583             case ValueNodeCodecContext valueNode -> {
 584                 return checkValueCodec(valueNode, it);
 585             }
 586         }
 587
 588         ListCodecContext<?> currentList = null;
 589         while (it.hasNext()) {
 590             domArg = it.next();
 591             if (!(currentNode instanceof DataContainerCodecContext previous)) {
 592                 throw new IllegalArgumentException("Unexpected child of non-container node " + currentNode);
 593             }
 594
 595             nextNode = previous.yangPathArgumentChild(domArg);
 596
 597             /**
 598              * Compatibility case: if it's determined the node belongs to augmentation
 599              * then insert augmentation path argument in between.
 600              */
 601             if (nextNode instanceof AugmentationCodecContext<?> augmContext) {
 602                 if (bindingArguments != null) {
 603                     bindingArguments.add(augmContext.bindingArg());
 604                 }
 605                 currentNode = nextNode;
 606                 nextNode = augmContext.yangPathArgumentChild(domArg);
 607             }
 608
 609             /*
 610              * List representation in YANG Instance Identifier consists of two arguments: first is list as a whole,
 611              * second is list as an item so if it is /list it means list as whole, if it is /list/list - it is
 612              * wildcarded and if it is /list/list[key] it is concrete item, all these variations are expressed in
 613              * DataObjectReference as am ExactDataObjectStep.
 614              */
 615             if (currentList != null) {
 616                 checkArgument(currentList == nextNode, "List should be referenced two times in %s", path);
 617
 618                 // We entered list, so now we have all information to emit
 619                 // list path using second list argument.
 620                 if (bindingArguments != null) {
 621                     bindingArguments.add(currentList.getBindingPathArgument(domArg));
 622                 }
 623                 currentList = null;
 624                 currentNode = nextNode;
 625             } else if (nextNode instanceof ListCodecContext<?> listNode) {
 626                 // We enter list, we do not update current Node yet,
 627                 // since we need to verify
 628                 currentList = listNode;
 629             } else if (nextNode instanceof ChoiceCodecContext) {
 630                 // We do not add path argument for choice, since
 631                 // it is not supported by binding instance identifier.
 632                 currentNode = nextNode;
 633             } else if (nextNode instanceof CommonDataObjectCodecContext<?, ?> containerNode) {
 634                 if (bindingArguments != null) {
 635                     bindingArguments.add(containerNode.getBindingPathArgument(domArg));
 636                 }
 637                 currentNode = nextNode;
 638             } else if (nextNode instanceof ValueNodeCodecContext valueNode) {
 639                 return checkValueCodec(valueNode, it);
 640             }
 641         }
 642
 643         // Algorithm ended in list as whole representation, we still need to emit identifier for list
 644         if (currentList != null) {
 645             if (bindingArguments != null) {
 646                 bindingArguments.add(currentList.getBindingPathArgument(null));
 647             }
 648             return currentList;
 649         }
 650         return currentNode;
 651     }
 652
 653     private static ValueNodeCodecContext checkValueCodec(final ValueNodeCodecContext codec,
 654             final Iterator<PathArgument> it) {
 655         if (codec instanceof LeafSetNodeCodecContext leafSet && it.hasNext()) {
 656             final var nextArg = it.next();
 657             if (!(nextArg instanceof NodeWithValue)) {
 658                 throw new IllegalArgumentException(nextArg + " should be a NodeWithValue matching " + leafSet);
 659             }
 660         }
 661         if (it.hasNext()) {
 662             throw new IllegalArgumentException(
 663                 "Attempted to step " + ImmutableList.copyOf(it) + " past " + codec);
 664         }
 665         return codec;
 666     }
 667
 668     NotificationCodecContext<?> getNotificationContext(final Absolute notification) {
 669         return getOrRethrow(notificationsByPath, notification);
 670     }
 671
 672     private NotificationCodecContext<?> getNotificationContext(final Class<?> notification) {
 673         return getOrRethrow(notificationsByClass, notification);
 674     }
 675
 676     ContainerLikeCodecContext<?> getRpc(final Class<? extends DataContainer> rpcInputOrOutput) {
 677         return getOrRethrow(rpcDataByClass, rpcInputOrOutput);
 678     }
 679
 680     ContainerLikeCodecContext<?> getRpcInputCodec(final Absolute containerPath) {
 681         return getOrRethrow(rpcDataByPath, containerPath);
 682     }
 683
 684     ActionCodecContext getActionCodec(final Class<? extends Action<?, ?, ?>> action) {
 685         return getOrRethrow(actionsByClass, action);
 686     }
 687
 688     @Override
 689     public ImmutableMap<Method, ValueNodeCodecContext> getLeafNodes(final Class<?> type,
 690             final EffectiveStatement<?, ?> schema) {
 691         final var getterToLeafSchema = new HashMap<String, DataSchemaNode>();
 692         for (var stmt : schema.effectiveSubstatements()) {
 693             if (stmt instanceof TypedDataSchemaNode typedSchema) {
 694                 putLeaf(getterToLeafSchema, typedSchema);
 695             } else if (stmt instanceof AnydataSchemaNode anydataSchema) {
 696                 putLeaf(getterToLeafSchema, anydataSchema);
 697             } else if (stmt instanceof AnyxmlSchemaNode anyxmlSchema) {
 698                 putLeaf(getterToLeafSchema, anyxmlSchema);
 699             }
 700         }
 701         return getLeafNodesUsingReflection(type, getterToLeafSchema);
 702     }
 703
 704     private static void putLeaf(final Map<String, DataSchemaNode> map, final DataSchemaNode leaf) {
 705         map.put(BindingSchemaMapping.getGetterMethodName(leaf), leaf);
 706     }
 707
 708     private ImmutableMap<Method, ValueNodeCodecContext> getLeafNodesUsingReflection(
 709             final Class<?> parentClass, final Map<String, DataSchemaNode> getterToLeafSchema) {
 710         final var leaves = new HashMap<Method, ValueNodeCodecContext>();
 711         for (var method : parentClass.getMethods()) {
 712             // Only consider non-bridge methods with no arguments
 713             if (method.getParameterCount() == 0 && !method.isBridge()) {
 714                 final DataSchemaNode schema = getterToLeafSchema.get(method.getName());
 715
 716                 final ValueNodeCodecContext valueNode;
 717                 if (schema instanceof LeafSchemaNode leafSchema) {
 718                     // FIXME: YANGTOOLS-1602: this is not right as we need to find a concrete type, but this may return
 719                     //                   Object.class
 720                     final Class<?> valueType = method.getReturnType();
 721                     final ValueCodec<Object, Object> codec = getCodec(valueType, leafSchema.getType());
 722                     valueNode = LeafNodeCodecContext.of(leafSchema, codec, method.getName(), valueType,
 723                         context.modelContext());
 724                 } else if (schema instanceof LeafListSchemaNode leafListSchema) {
 725                     final Optional<Type> optType = ClassLoaderUtils.getFirstGenericParameter(
 726                         method.getGenericReturnType());
 727                     checkState(optType.isPresent(), "Failed to find return type for %s", method);
 728
 729                     final Class<?> valueType;
 730                     final Type genericType = optType.orElseThrow();
 731                     if (genericType instanceof Class<?> clazz) {
 732                         valueType = clazz;
 733                     } else if (genericType instanceof ParameterizedType parameterized) {
 734                         valueType = (Class<?>) parameterized.getRawType();
 735                     } else if (genericType instanceof WildcardType) {
 736                         // FIXME: YANGTOOLS-1602: this is not right as we need to find a concrete type
 737                         valueType = Object.class;
 738                     } else {
 739                         throw new IllegalStateException("Unexpected return type " + genericType);
 740                     }
 741
 742                     final ValueCodec<Object, Object> codec = getCodec(valueType, leafListSchema.getType());
 743                     valueNode = new LeafSetNodeCodecContext(leafListSchema, codec, method.getName(), valueType);
 744                 } else if (schema instanceof AnyxmlSchemaNode anyxmlSchema) {
 745                     valueNode = new AnyxmlCodecContext<>(anyxmlSchema, method.getName(), opaqueReturnType(method),
 746                         loader);
 747                 } else if (schema instanceof AnydataSchemaNode anydataSchema) {
 748                     valueNode = new AnydataCodecContext<>(anydataSchema, method.getName(), opaqueReturnType(method),
 749                         loader);
 750                 } else {
 751                     verify(schema == null, "Unhandled schema %s for method %s", schema, method);
 752                     // We do not have schema for leaf, so we will ignore it (e.g. getClass).
 753                     continue;
 754                 }
 755
 756                 leaves.put(method, valueNode);
 757             }
 758         }
 759         return ImmutableMap.copyOf(leaves);
 760     }
 761
 762     // FIXME: this is probably not right w.r.t. nulls
 763     ValueCodec<Object, Object> getCodec(final Class<?> valueType, final TypeDefinition<?> instantiatedType) {
 764         if (BaseIdentity.class.isAssignableFrom(valueType)) {
 765             @SuppressWarnings({ "unchecked", "rawtypes" })
 766             final ValueCodec<Object, Object> casted = (ValueCodec) identityCodec;
 767             return casted;
 768         } else if (BindingInstanceIdentifier.class.equals(valueType)) {
 769             @SuppressWarnings({ "unchecked", "rawtypes" })
 770             final ValueCodec<Object, Object> casted = (ValueCodec) instanceIdentifierCodec;
 771             return casted;
 772         } else if (BindingReflections.isBindingClass(valueType)) {
 773             return getCodecForBindingClass(valueType, instantiatedType);
 774         } else {
 775             final var codec = BuiltInValueCodec.forValueType(valueType);
 776             if (codec != null) {
 777                 return codec;
 778             }
 779
 780             // FIXME: YANGTOOLS-1602: we must never return NOOP_CODEC for valueType=Object.class
 781             if (Object.class.equals(valueType)) {
 782                 return NOOP_CODEC;
 783             }
 784
 785             throw new VerifyException("Unsupported type " + valueType.getName());
 786         }
 787     }
 788
 789     @SuppressWarnings("checkstyle:illegalCatch")
 790     // FIXME: this is probably not right w.r.t. nulls
 791     private ValueCodec<Object, Object> getCodecForBindingClass(final Class<?> valueType,
 792             final TypeDefinition<?> typeDef) {
 793         if (typeDef instanceof IdentityrefTypeDefinition) {
 794             return new CompositeValueCodec.OfIdentity(valueType, identityCodec);
 795         } else if (typeDef instanceof InstanceIdentifierTypeDefinition) {
 796             return new CompositeValueCodec.OfInstanceIdentifier(valueType, instanceIdentifierCodec);
 797         } else if (typeDef instanceof UnionTypeDefinition unionType) {
 798             try {
 799                 return UnionTypeCodec.of(valueType, unionType, this);
 800             } catch (Exception e) {
 801                 throw new IllegalStateException("Unable to load codec for " + valueType, e);
 802             }
 803         } else if (typeDef instanceof LeafrefTypeDefinition) {
 804             final var schema = context.getTypeWithSchema(valueType).statement();
 805             return getCodec(valueType, switch (schema) {
 806                 case TypeDefinitionAware typeDefAware -> typeDefAware.getTypeDefinition();
 807                 case TypeAware typeAware -> typeAware.getType();
 808                 default -> throw new IllegalStateException("Unexpected schema " + schema);
 809             });
 810         }
 811
 812         final var cached = SchemaUnawareCodec.of(valueType, typeDef);
 813         if (cached != null) {
 814             return cached;
 815         }
 816         final var codec = BuiltInValueCodec.forValueType(valueType);
 817         if (codec != null) {
 818             return codec;
 819         }
 820
 821         throw new VerifyException("Unsupported type " + valueType.getName());
 822     }
 823
 824     @Override
 825     public IdentifiableItemCodec getPathArgumentCodec(final Class<?> listClz, final ListRuntimeType type) {
 826         @SuppressWarnings("unchecked")
 827         final Class<? extends Key<?>> identifier = (Class<? extends Key<?>>)
 828             ClassLoaderUtils.findGenericArgument(listClz, EntryObject.class, 1)
 829                 .orElseThrow(() -> new IllegalStateException("Failed to find identifier for " + listClz))
 830                 .asSubclass(Key.class);
 831
 832         final var valueCtx = new HashMap<QName, ValueContext>();
 833         for (var leaf : getLeafNodes(identifier, type.statement()).values()) {
 834             final var name = leaf.getDomPathArgument().getNodeType();
 835             valueCtx.put(name, new ValueContext(identifier, leaf));
 836         }
 837         return IdentifiableItemCodec.of(type.statement(), identifier, listClz, valueCtx);
 838     }
 839
 840     @Override
 841     @SuppressWarnings("unchecked")
 842     public <E extends DataObject> DataContainerCodecContext<E, ?, ?> getStreamChild(final Class<E> childClass) {
 843         final var result = Notification.class.isAssignableFrom(childClass) ? getNotificationContext(childClass)
 844             : getOrRethrow(childrenByClass, childClass);
 845         return (DataContainerCodecContext<E, ?, ?>) result;
 846     }
 847
 848     @Override
 849     @SuppressWarnings("unchecked")
 850     public <A extends Augmentation<?>> BindingAugmentationCodecTreeNode<A> getAugmentationCodec(
 851             final DataObjectReference<A> path) {
 852         final var codecContext = getCodecContextNode(path, null);
 853         if (codecContext instanceof BindingAugmentationCodecTreeNode) {
 854             return (BindingAugmentationCodecTreeNode<A>) codecContext;
 855         }
 856         throw new IllegalArgumentException(path + " does not refer to an Augmentation");
 857     }
 858
 859     @Override
 860     @SuppressWarnings("unchecked")
 861     public <T extends DataObject> BindingDataObjectCodecTreeNode<T> getDataObjectCodec(
 862             final DataObjectReference<T> path) {
 863         final var codecContext = getCodecContextNode(path, null);
 864         if (codecContext instanceof BindingDataObjectCodecTreeNode) {
 865             return (BindingDataObjectCodecTreeNode<T>) codecContext;
 866         }
 867         throw new IllegalArgumentException(path + " does not refer to a plain DataObject");
 868     }
 869
 870     @Override
 871     @SuppressWarnings("unchecked")
 872     public <T extends DataObject> CodecWithPath<T> getSubtreeCodecWithPath(final DataObjectReference<T> path) {
 873         final var yangArgs = new ArrayList<PathArgument>();
 874         final var codecContext = getCodecContextNode(path, yangArgs);
 875
 876         // TODO Do we need defensive check here?
 877         return new CodecWithPath<>((CommonDataObjectCodecTreeNode<T>) codecContext,
 878             YangInstanceIdentifier.of(yangArgs));
 879     }
 880
 881     @Override
 882     @SuppressWarnings("unchecked")
 883     public <T extends DataObject> CommonDataObjectCodecTreeNode<T> getSubtreeCodec(final DataObjectReference<T> path) {
 884         // TODO Do we need defensive check here?
 885         return (CommonDataObjectCodecTreeNode<T>) getCodecContextNode(path, null);
 886     }
 887
 888     @Override
 889     public BindingCodecTreeNode getSubtreeCodec(final YangInstanceIdentifier path) {
 890         return lookupCodecContext(requireNonNull(path), null);
 891     }
 892
 893     @Override
 894     public BindingCodecTreeNode getSubtreeCodec(final Absolute path) {
 895         throw new UnsupportedOperationException("Not implemented yet.");
 896     }
 897
 898     @Override
 899     public YangInstanceIdentifier toYangInstanceIdentifier(final DataObjectReference<?> binding) {
 900         return instanceIdentifierCodec.fromBinding(binding);
 901     }
 902
 903     @Override
 904     public <T extends DataObject> DataObjectReference<T> fromYangInstanceIdentifier(final YangInstanceIdentifier dom) {
 905         return instanceIdentifierCodec.toBinding(dom);
 906     }
 907
 908     @Override
 909     public <A extends Augmentation<?>> AugmentationResult toNormalizedAugmentation(final DataObjectReference<A> path,
 910             final A data) {
 911         final var result = toNormalizedNode(path, data);
 912         if (result instanceof AugmentationResult augment) {
 913             return augment;
 914         }
 915         throw new IllegalArgumentException(path + " does not identify an Augmentation");
 916     }
 917
 918     @Override
 919     public <T extends DataObject> NodeResult toNormalizedDataObject(final DataObjectReference<T> path, final T data) {
 920         final var result = toNormalizedNode(path, data);
 921         if (result instanceof NodeResult node) {
 922             return node;
 923         }
 924         throw new IllegalArgumentException(path + " does not identify a plain DataObject");
 925     }
 926
 927     @Override
 928     public <T extends DataObject> NormalizedResult toNormalizedNode(final DataObjectReference<T> path, final T data) {
 929         // We create Binding Stream Writer which translates from Binding to Normalized Nodes
 930         final var yangArgs = new ArrayList<PathArgument>();
 931         final var codecContext = getCodecContextNode(path, yangArgs);
 932         final var yangPath = YangInstanceIdentifier.of(yangArgs);
 933
 934         // We create DOM stream writer which produces normalized nodes
 935         final var result = new NormalizationResultHolder();
 936         final var domWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 937         final var bindingWriter = new BindingToNormalizedStreamWriter(codecContext, domWriter);
 938         final var augment = codecContext instanceof BindingAugmentationCodecTreeNode<?> augmentNode ? augmentNode
 939             : null;
 940
 941         try {
 942             // Augmentations do not have a representation, so we are faking a ContainerNode as the parent and we will be
 943             // extracting the resulting children.
 944             if (augment != null) {
 945                 domWriter.startContainerNode(FAKE_NODEID, NormalizedNodeStreamWriter.UNKNOWN_SIZE);
 946             }
 947
 948             // We get serializer which reads binding data and uses Binding To Normalized Node writer to write result
 949             getSerializer(path.lastStep().type()).serialize(data, bindingWriter);
 950
 951             if (augment != null) {
 952                 domWriter.endNode();
 953             }
 954         } catch (final IOException e) {
 955             LOG.error("Unexpected failure while serializing path {} data {}", path, data, e);
 956             throw new IllegalStateException("Failed to create normalized node", e);
 957         }
 958
 959         // Terminate the fake container and extract it to the result
 960         if (augment != null) {
 961             return new AugmentationResult(yangPath, augment.childPathArguments(),
 962                 ImmutableList.copyOf(((ContainerNode) result.getResult().data()).body()));
 963         }
 964         return new NodeResult(yangPath, result.getResult().data());
 965     }
 966
 967     @Override
 968     public Entry<DataObjectReference<?>, DataObject> fromNormalizedNode(final YangInstanceIdentifier path,
 969             final NormalizedNode data) {
 970         if (notBindingRepresentable(data)) {
 971             return null;
 972         }
 973
 974         final var builder = new ArrayList<DataObjectStep<?>>();
 975         final var codec = getCodecContextNode(path, builder);
 976         if (codec == null) {
 977             if (data != null) {
 978                 LOG.warn("Path {} does not have a binding equivalent, should have been caught earlier ({})", path,
 979                     data.getClass());
 980             }
 981             return null;
 982         }
 983
 984         final DataObject lazyObj = codec.deserialize(data);
 985         return Map.entry(DataObjectReference.ofUnsafeSteps(builder), lazyObj);
 986     }
 987
 988     @Override
 989     public BaseNotification fromNormalizedNodeNotification(final Absolute path, final ContainerNode data) {
 990         return getNotificationContext(path).deserialize(data);
 991     }
 992
 993     @Override
 994     public BaseNotification fromNormalizedNodeNotification(final Absolute path, final ContainerNode data,
 995             final Instant eventInstant) {
 996         return eventInstant == null ? fromNormalizedNodeNotification(path, data)
 997                 : getNotificationContext(path).deserialize(data, eventInstant);
 998     }
 999
1000     @Override
1001     public DataObject fromNormalizedNodeRpcData(final Absolute containerPath, final ContainerNode data) {
1002         return getRpcInputCodec(containerPath).deserialize(data);
1003     }
1004
1005     @Override
1006     public <T extends RpcInput> T fromNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
1007             final ContainerNode input) {
1008         return (T) requireNonNull(getActionCodec(action).input().deserialize(requireNonNull(input)));
1009     }
1010
1011     @Override
1012     public <T extends RpcOutput> T fromNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
1013             final ContainerNode output) {
1014         return (T) requireNonNull(getActionCodec(action).output().deserialize(requireNonNull(output)));
1015     }
1016
1017     @Override
1018     @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
1019     public ContainerNode toNormalizedNodeNotification(final Notification<?> data) {
1020         // FIXME: Should the cast to DataObject be necessary?
1021         return serializeDataObject((DataObject) data,
1022             (ctx, iface, domWriter) -> ctx.newNotificationWriter(
1023                 (Class<? extends Notification<?>>) iface.asSubclass(Notification.class), domWriter));
1024     }
1025
1026     @Override
1027     public ContainerNode toNormalizedNodeNotification(final Absolute path, final BaseNotification data) {
1028         checkArgument(data instanceof DataObject, "Unexpected data %s", data);
1029         @SuppressWarnings("rawtypes")
1030         final NotificationCodecContext notifContext = getNotificationContext(path);
1031         @SuppressWarnings("unchecked")
1032         final var result = notifContext.serialize((DataObject) data);
1033         verify(result instanceof ContainerNode, "Unexpected result %s from %s", result, data);
1034         return (ContainerNode) result;
1035     }
1036
1037     @Override
1038     @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
1039     public ContainerNode toNormalizedNodeRpcData(final DataContainer data) {
1040         // FIXME: Should the cast to DataObject be necessary?
1041         return serializeDataObject((DataObject) data, BindingNormalizedNodeWriterFactory::newRpcWriter);
1042     }
1043
1044     @Override
1045     public ContainerNode toNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
1046             final RpcInput input) {
1047         return serializeDataObject(input,(ctx, iface, domWriter) -> ctx.newActionInputWriter(action, domWriter));
1048     }
1049
1050     @Override
1051     public ContainerNode toNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
1052             final RpcOutput output) {
1053         return serializeDataObject(output, (ctx, iface, domWriter) -> ctx.newActionOutputWriter(action, domWriter));
1054     }
1055
1056     @Override
1057     protected NodeIdentifier actionInputName(final Class<? extends Action<?, ?, ?>> action) {
1058         return verifyNotNull(getActionCodec(action).input().getDomPathArgument());
1059     }
1060
1061     @Override
1062     protected NodeIdentifier actionOutputName(final Class<? extends Action<?, ?, ?>> action) {
1063         return verifyNotNull(getActionCodec(action).output().getDomPathArgument());
1064     }
1065
1066     private <T extends DataContainer> @NonNull ContainerNode serializeDataObject(final DataObject data,
1067             final WriterFactoryMethod<T> newWriter) {
1068         final var result = new NormalizationResultHolder();
1069         // We create DOM stream writer which produces normalized nodes
1070         final var domWriter = ImmutableNormalizedNodeStreamWriter.from(result);
1071         final Class<? extends DataObject> type = data.implementedInterface();
1072         @SuppressWarnings("unchecked")
1073         final BindingStreamEventWriter writer = newWriter.createWriter(this, (Class<T>) type, domWriter);
1074         try {
1075             getSerializer(type).serialize(data, writer);
1076         } catch (final IOException e) {
1077             LOG.error("Unexpected failure while serializing data {}", data, e);
1078             throw new IllegalStateException("Failed to create normalized node", e);
1079         }
1080         return (ContainerNode) result.getResult().data();
1081     }
1082
1083     private static boolean notBindingRepresentable(final NormalizedNode data) {
1084         // ValueNode covers LeafNode and LeafSetEntryNode
1085         return data instanceof ValueNode
1086             || data instanceof MapNode || data instanceof UnkeyedListNode
1087             || data instanceof ChoiceNode
1088             || data instanceof LeafSetNode;
1089     }
1090
1091     private static <K,V> V getOrRethrow(final LoadingCache<K, V> cache, final K key) {
1092         try {
1093             return cache.getUnchecked(key);
1094         } catch (UncheckedExecutionException e) {
1095             final var cause = e.getCause();
1096             if (cause != null) {
1097                 Throwables.throwIfUnchecked(cause);
1098             }
1099             throw e;
1100         }
1101     }
1102
1103     @SuppressWarnings("rawtypes")
1104     private static Class<? extends OpaqueObject> opaqueReturnType(final Method method) {
1105         final Class<?> valueType = method.getReturnType();
1106         verify(OpaqueObject.class.isAssignableFrom(valueType), "Illegal value type %s", valueType);
1107         return valueType.asSubclass(OpaqueObject.class);
1108     }
1109
1110     @FunctionalInterface
1111     private interface WriterFactoryMethod<T extends DataContainer> {
1112         BindingStreamEventWriter createWriter(@NonNull BindingNormalizedNodeWriterFactory factory,
1113                 @NonNull Class<? extends T> bindingClass, @NonNull NormalizedNodeStreamWriter domWriter);
1114     }
1115 }