binding/binding-data-codec-dynamic/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/MapCodecContext.java

   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.mdsal.binding.dom.codec.impl;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import java.lang.reflect.Method;
  13 import java.util.List;
  14 import java.util.Map;
  15 import org.eclipse.jdt.annotation.NonNull;
  16 import org.opendaylight.mdsal.binding.runtime.api.ListRuntimeType;
  17 import org.opendaylight.yangtools.binding.lib.DataObject;
  18 import org.opendaylight.yangtools.binding.lib.DataObjectStep;
  19 import org.opendaylight.yangtools.binding.lib.Key;
  20 import org.opendaylight.yangtools.binding.lib.KeyAware;
  21 import org.opendaylight.yangtools.binding.lib.KeyStep;
  22 import org.opendaylight.yangtools.binding.lib.KeylessStep;
  23 import org.opendaylight.yangtools.binding.lib.contract.Naming;
  24 import org.opendaylight.yangtools.yang.common.Ordering;
  25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  27 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  28
  29 abstract sealed class MapCodecContext<I extends Key<D>, D extends DataObject & KeyAware<I>>
  30         extends ListCodecContext<D> {
  31     private static final class Ordered<I extends Key<D>, D extends DataObject & KeyAware<I>>
  32             extends MapCodecContext<I, D> {
  33         Ordered(final MapCodecPrototype prototype, final Method keyMethod, final IdentifiableItemCodec codec) {
  34             super(prototype, keyMethod, codec);
  35         }
  36     }
  37
  38     static final class Unordered<I extends Key<D>, D extends DataObject & KeyAware<I>>
  39             extends MapCodecContext<I, D> {
  40         private Unordered(final MapCodecPrototype prototype, final Method keyMethod,
  41                 final IdentifiableItemCodec codec) {
  42             super(prototype, keyMethod, codec);
  43         }
  44
  45         @Override
  46         Map<I, D> fromMap(final MapNode map, final int size) {
  47             return LazyBindingMap.of(this, map, size);
  48         }
  49     }
  50
  51     private final IdentifiableItemCodec codec;
  52
  53     private MapCodecContext(final MapCodecPrototype prototype, final Method keyMethod,
  54             final IdentifiableItemCodec codec) {
  55         super(prototype, keyMethod);
  56         this.codec = requireNonNull(codec);
  57     }
  58
  59     static @NonNull MapCodecContext<?, ?> of(final Class<? extends DataObject> cls, final ListRuntimeType type,
  60             final CodecContextFactory factory) {
  61         return of(new MapCodecPrototype(new KeylessStep(cls), type, factory));
  62     }
  63
  64     static @NonNull MapCodecContext<?, ?> of(final MapCodecPrototype prototype) {
  65         final var bindingClass = prototype.javaClass();
  66         final Method keyMethod;
  67         try {
  68             keyMethod = bindingClass.getMethod(Naming.KEY_AWARE_KEY_NAME);
  69         } catch (NoSuchMethodException e) {
  70             throw new IllegalStateException("Required method not available", e);
  71         }
  72
  73         final var type = prototype.runtimeType();
  74         final var codec = prototype.contextFactory().getPathArgumentCodec(bindingClass, type);
  75
  76         return type.statement().ordering() == Ordering.SYSTEM ? new Unordered<>(prototype, keyMethod, codec)
  77             : new Ordered<>(prototype, keyMethod, codec);
  78     }
  79
  80     @Override
  81     void addYangPathArgument(final List<PathArgument> builder, final DataObjectStep<?> step) {
  82         /*
  83          * DOM Instance Identifier for list is always represent by two entries one for map and one for children. This
  84          * is also true for wildcarded instance identifiers
  85          */
  86         final var yangArg = getDomPathArgument();
  87         builder.add(yangArg);
  88
  89         if (step instanceof KeyStep<?, ?> keyStep) {
  90             builder.add(codec.bindingToDom(keyStep));
  91         } else {
  92             // Adding wildcarded
  93             builder.add(yangArg);
  94         }
  95     }
  96
  97     @Override
  98     protected final DataObjectStep<?> getBindingPathArgument(final PathArgument domArg) {
  99         return domArg instanceof NodeIdentifierWithPredicates nip ? codec.domToBinding(nip)
 100             : super.getBindingPathArgument(domArg);
 101     }
 102
 103     @SuppressWarnings({ "rawtypes", "unchecked" })
 104     final NodeIdentifierWithPredicates serialize(final Key<?> key) {
 105         return codec.bindingToDom(new KeyStep(getBindingClass(), key));
 106     }
 107
 108     final @NonNull Key<?> deserialize(final @NonNull NodeIdentifierWithPredicates arg) {
 109         return codec.deserializeIdentifier(arg);
 110     }
 111
 112     @Override
 113     public final PathArgument serializePathArgument(final DataObjectStep<?> step) {
 114         return step instanceof KeyStep<?, ?> keyStep ? codec.bindingToDom(keyStep) : super.serializePathArgument(step);
 115     }
 116
 117     @Override
 118     public final DataObjectStep<?> deserializePathArgument(final PathArgument arg) {
 119         return arg instanceof NodeIdentifierWithPredicates nip ? codec.domToBinding(nip)
 120             : super.deserializePathArgument(arg);
 121     }
 122 }