binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/DataContainerCodecContext.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 com.google.common.base.Preconditions.checkArgument;
  11 import static java.util.Objects.requireNonNull;
  12
  13 import com.google.common.collect.ImmutableCollection;
  14 import com.google.common.collect.ImmutableSet;
  15 import java.io.IOException;
  16 import java.lang.invoke.MethodHandles;
  17 import java.lang.invoke.VarHandle;
  18 import java.util.List;
  19 import java.util.Optional;
  20 import java.util.Set;
  21 import org.eclipse.jdt.annotation.NonNull;
  22 import org.eclipse.jdt.annotation.Nullable;
  23 import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
  24 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeCachingCodec;
  25 import org.opendaylight.mdsal.binding.dom.codec.api.BindingStreamEventWriter;
  26 import org.opendaylight.mdsal.binding.dom.codec.api.IncorrectNestingException;
  27 import org.opendaylight.mdsal.binding.dom.codec.api.MissingClassInLoadingStrategyException;
  28 import org.opendaylight.mdsal.binding.dom.codec.api.MissingSchemaException;
  29 import org.opendaylight.mdsal.binding.dom.codec.api.MissingSchemaForClassException;
  30 import org.opendaylight.mdsal.binding.model.api.Type;
  31 import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeContext;
  32 import org.opendaylight.mdsal.binding.runtime.api.CompositeRuntimeType;
  33 import org.opendaylight.mdsal.binding.runtime.api.RuntimeTypeContainer;
  34 import org.opendaylight.yangtools.yang.binding.Augmentation;
  35 import org.opendaylight.yangtools.yang.binding.BindingObject;
  36 import org.opendaylight.yangtools.yang.binding.DataObject;
  37 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
  38 import org.opendaylight.yangtools.yang.common.QName;
  39 import org.opendaylight.yangtools.yang.common.QNameModule;
  40 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  41 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  42 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  43 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  44 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
  45 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
  46
  47 abstract class DataContainerCodecContext<D extends DataObject, T extends RuntimeTypeContainer> extends NodeCodecContext
  48         implements BindingDataObjectCodecTreeNode<D>  {
  49     private static final VarHandle EVENT_STREAM_SERIALIZER;
  50
  51     static {
  52         try {
  53             EVENT_STREAM_SERIALIZER = MethodHandles.lookup().findVarHandle(DataContainerCodecContext.class,
  54                 "eventStreamSerializer", DataObjectSerializer.class);
  55         } catch (NoSuchFieldException | IllegalAccessException e) {
  56             throw new ExceptionInInitializerError(e);
  57         }
  58     }
  59
  60     private final @NonNull DataContainerCodecPrototype<T> prototype;
  61
  62     // Accessed via a VarHandle
  63     @SuppressWarnings("unused")
  64     private volatile DataObjectSerializer eventStreamSerializer;
  65
  66     DataContainerCodecContext(final DataContainerCodecPrototype<T> prototype) {
  67         this.prototype = requireNonNull(prototype);
  68     }
  69
  70     public final @NonNull T getType() {
  71         return prototype.getType();
  72     }
  73
  74     @Override
  75     public final ChildAddressabilitySummary getChildAddressabilitySummary() {
  76         return prototype.getChildAddressabilitySummary();
  77     }
  78
  79     protected final QNameModule namespace() {
  80         return prototype.getNamespace();
  81     }
  82
  83     protected final CodecContextFactory factory() {
  84         return prototype.getFactory();
  85     }
  86
  87     @Override
  88     protected YangInstanceIdentifier.PathArgument getDomPathArgument() {
  89         return prototype.getYangArg();
  90     }
  91
  92     /**
  93      * Returns nested node context using supplied YANG Instance Identifier.
  94      *
  95      * @param arg Yang Instance Identifier Argument
  96      * @return Context of child
  97      * @throws IllegalArgumentException If supplied argument does not represent valid child.
  98      */
  99     @Override
 100     public abstract NodeCodecContext yangPathArgumentChild(YangInstanceIdentifier.PathArgument arg);
 101
 102     /**
 103      * Returns nested node context using supplied Binding Instance Identifier
 104      * and adds YANG instance identifiers to supplied list.
 105      *
 106      * @param arg Binding Instance Identifier Argument
 107      * @return Context of child or null if supplied {@code arg} does not represent valid child.
 108      * @throws IllegalArgumentException If supplied argument does not represent valid child.
 109      */
 110     @Override
 111     public DataContainerCodecContext<?, ?> bindingPathArgumentChild(final PathArgument arg,
 112             final List<YangInstanceIdentifier.PathArgument> builder) {
 113         final DataContainerCodecContext<?,?> child = streamChild(arg.getType());
 114         if (builder != null) {
 115             child.addYangPathArgument(arg,builder);
 116         }
 117         return child;
 118     }
 119
 120     /**
 121      * Returns deserialized Binding Path Argument from YANG instance identifier.
 122      */
 123     protected PathArgument getBindingPathArgument(final YangInstanceIdentifier.PathArgument domArg) {
 124         return bindingArg();
 125     }
 126
 127     protected final PathArgument bindingArg() {
 128         return prototype.getBindingArg();
 129     }
 130
 131     @SuppressWarnings("unchecked")
 132     @Override
 133     public final Class<D> getBindingClass() {
 134         return Class.class.cast(prototype.getBindingClass());
 135     }
 136
 137     @Override
 138     public abstract <C extends DataObject> DataContainerCodecContext<C, ?> streamChild(Class<C> childClass);
 139
 140     /**
 141      * Returns child context as if it was walked by {@link BindingStreamEventWriter}. This means that to enter case, one
 142      * must issue getChild(ChoiceClass).getChild(CaseClass).
 143      *
 144      * @param childClass child class
 145      * @return Context of child or Optional.empty is supplied class is not applicable in context.
 146      */
 147     @Override
 148     public abstract <C extends DataObject> Optional<DataContainerCodecContext<C,?>> possibleStreamChild(
 149             Class<C> childClass);
 150
 151     @Override
 152     public String toString() {
 153         return getClass().getSimpleName() + " [" + prototype.getBindingClass() + "]";
 154     }
 155
 156     @Override
 157     public BindingNormalizedNodeCachingCodec<D> createCachingCodec(
 158             final ImmutableCollection<Class<? extends BindingObject>> cacheSpecifier) {
 159         if (cacheSpecifier.isEmpty()) {
 160             return new NonCachingCodec<>(this);
 161         }
 162         return new CachingNormalizedNodeCodec<>(this, ImmutableSet.copyOf(cacheSpecifier));
 163     }
 164
 165     @NonNull BindingStreamEventWriter createWriter(final NormalizedNodeStreamWriter domWriter) {
 166         return BindingToNormalizedStreamWriter.create(this, domWriter);
 167     }
 168
 169     protected final <V> @NonNull V childNonNull(final @Nullable V nullable,
 170             final YangInstanceIdentifier.PathArgument child, final String message, final Object... args) {
 171         if (nullable == null) {
 172             throw childNullException(extractName(child), message, args);
 173         }
 174         return nullable;
 175     }
 176
 177     protected final <V> @NonNull V childNonNull(final @Nullable V nullable, final QName child, final String message,
 178             final Object... args) {
 179         if (nullable == null) {
 180             throw childNullException(child, message, args);
 181         }
 182         return nullable;
 183     }
 184
 185     protected final <V> @NonNull V childNonNull(final @Nullable V nullable, final Class<?> childClass,
 186             final String message, final Object... args) {
 187         if (nullable == null) {
 188             throw childNullException(childClass, message, args);
 189         }
 190         return nullable;
 191     }
 192
 193     private IllegalArgumentException childNullException(final QName child, final String message, final Object... args) {
 194         final QNameModule module = child.getModule();
 195         if (!factory().getRuntimeContext().getEffectiveModelContext().findModule(module).isPresent()) {
 196             throw new MissingSchemaException("Module " + module + " is not present in current schema context.");
 197         }
 198         throw IncorrectNestingException.create(message, args);
 199     }
 200
 201     private IllegalArgumentException childNullException(final Class<?> childClass, final String message,
 202             final Object... args) {
 203         final BindingRuntimeContext runtimeContext = factory().getRuntimeContext();
 204         final CompositeRuntimeType schema;
 205         if (Augmentation.class.isAssignableFrom(childClass)) {
 206             schema = runtimeContext.getAugmentationDefinition(childClass.asSubclass(Augmentation.class));
 207         } else {
 208             schema = runtimeContext.getSchemaDefinition(childClass);
 209         }
 210         if (schema == null) {
 211             throw new MissingSchemaForClassException(childClass);
 212         }
 213
 214         try {
 215             runtimeContext.loadClass(Type.of(childClass));
 216         } catch (final ClassNotFoundException e) {
 217             throw new MissingClassInLoadingStrategyException(
 218                 "User supplied class " + childClass.getName() + " is not available in " + runtimeContext, e);
 219         }
 220
 221         throw IncorrectNestingException.create(message, args);
 222     }
 223
 224     private static QName extractName(final YangInstanceIdentifier.PathArgument child) {
 225         if (child instanceof AugmentationIdentifier) {
 226             final Set<QName> children = ((AugmentationIdentifier) child).getPossibleChildNames();
 227             checkArgument(!children.isEmpty(), "Augmentation without childs must not be used in data");
 228             return children.iterator().next();
 229         }
 230         return child.getNodeType();
 231     }
 232
 233     final DataObjectSerializer eventStreamSerializer() {
 234         final DataObjectSerializer existing = (DataObjectSerializer) EVENT_STREAM_SERIALIZER.getAcquire(this);
 235         return existing != null ? existing : loadEventStreamSerializer();
 236     }
 237
 238     // Split out to aid inlining
 239     private DataObjectSerializer loadEventStreamSerializer() {
 240         final DataObjectSerializer loaded = factory().getEventStreamSerializer(getBindingClass());
 241         final Object witness = EVENT_STREAM_SERIALIZER.compareAndExchangeRelease(this, null, loaded);
 242         return witness == null ? loaded : (DataObjectSerializer) witness;
 243     }
 244
 245     @Override
 246     public NormalizedNode serialize(final D data) {
 247         final NormalizedNodeResult result = new NormalizedNodeResult();
 248         // We create DOM stream writer which produces normalized nodes
 249         final NormalizedNodeStreamWriter domWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 250         writeAsNormalizedNode(data, domWriter);
 251         return result.getResult();
 252     }
 253
 254     @Override
 255     public void writeAsNormalizedNode(final D data, final NormalizedNodeStreamWriter writer) {
 256         try {
 257             eventStreamSerializer().serialize(data, createWriter(writer));
 258         } catch (final IOException e) {
 259             throw new IllegalStateException("Failed to serialize Binding DTO",e);
 260         }
 261     }
 262 }