X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-binding-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fbinding%2Fimpl%2FBindingToNormalizedNodeCodec.java;h=8723fdf82a931b846482914fd5e85e69e8c10cf1;hp=3f9d5c78546af7b0f40111b745fe89c8fefc5c91;hb=a9533db1d57a2729772ee192a2f96d358c71bede;hpb=478ce1fa1dc30974b7cf23fd5258f1af5366d547 diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java index 3f9d5c7854..8723fdf82a 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/BindingToNormalizedNodeCodec.java @@ -10,21 +10,23 @@ package org.opendaylight.controller.md.sal.binding.impl; import java.lang.reflect.Method; import java.lang.reflect.Type; import java.util.AbstractMap.SimpleEntry; +import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Map.Entry; -import java.util.concurrent.Callable; + +import javax.annotation.Nullable; import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationException; import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationOperation; import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizer; -import org.opendaylight.yangtools.concepts.util.ClassLoaderUtils; import org.opendaylight.yangtools.yang.binding.Augmentation; 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.InstanceIdentifier.Item; import org.opendaylight.yangtools.yang.binding.util.BindingReflections; +import org.opendaylight.yangtools.yang.binding.util.ClassLoaderUtils; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.CompositeNode; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier; @@ -43,7 +45,10 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContextListener; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import com.google.common.base.Function; import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.base.Supplier; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; @@ -75,7 +80,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { public Entry> toNormalizedNode( final InstanceIdentifier bindingPath, final DataObject bindingObject) { - return toNormalizedNode(toEntry(bindingPath, bindingObject)); + return toNormalizedNode(toBindingEntry(bindingPath, bindingObject)); } @@ -87,17 +92,16 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { .toNormalized(legacyEntry); LOG.trace("Serialization of {}, Legacy Representation: {}, Normalized Representation: {}", binding, legacyEntry, normalizedEntry); - if (Augmentation.class.isAssignableFrom(binding.getKey().getTargetType())) { + if (isAugmentation(binding.getKey().getTargetType())) { for (DataContainerChild child : ((DataContainerNode) normalizedEntry .getValue()).getValue()) { if (child instanceof AugmentationNode) { ImmutableList childArgs = ImmutableList. builder() - .addAll(normalizedEntry.getKey().getPath()).add(child.getIdentifier()).build(); - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = new org.opendaylight.yangtools.yang.data.api.InstanceIdentifier( + .addAll(normalizedEntry.getKey().getPathArguments()).add(child.getIdentifier()).build(); + org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create( childArgs); - return new SimpleEntry>( - childPath, child); + return toDOMEntry(childPath, child); } } @@ -117,9 +121,9 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { */ public Optional> toBinding( final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) - throws DeserializationException { + throws DeserializationException { - PathArgument lastArgument = Iterables.getLast(normalized.getPath()); + PathArgument lastArgument = Iterables.getLast(normalized.getPathArguments()); // Used instance-identifier codec do not support serialization of last // path // argument if it is AugmentationIdentifier (behaviour expected by old @@ -134,7 +138,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { private Optional> toBindingAugmented( final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) - throws DeserializationException { + throws DeserializationException { Optional> potential = toBindingImpl(normalized); // Shorthand check, if codec already supports deserialization // of AugmentationIdentifier we will return @@ -143,7 +147,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { } int normalizedCount = getAugmentationCount(normalized); - AugmentationIdentifier lastArgument = (AugmentationIdentifier) Iterables.getLast(normalized.getPath()); + AugmentationIdentifier lastArgument = (AugmentationIdentifier) Iterables.getLast(normalized.getPathArguments()); // Here we employ small trick - Binding-aware Codec injects an pointer // to augmentation class @@ -151,9 +155,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { // path. LOG.trace("Looking for candidates to match {}", normalized); for (QName child : lastArgument.getPossibleChildNames()) { - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = new org.opendaylight.yangtools.yang.data.api.InstanceIdentifier( - ImmutableList. builder().addAll(normalized.getPath()).add(new NodeIdentifier(child)) - .build()); + org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = normalized.node(child); try { if (isNotRepresentable(childPath)) { LOG.trace("Path {} is not BI-representable, skipping it", childPath); @@ -186,7 +188,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { private Optional> toBindingImpl( final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) - throws DeserializationException { + throws DeserializationException { org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath; try { @@ -216,21 +218,28 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { private DataNormalizationOperation findNormalizationOperation( final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) - throws DataNormalizationException { + throws DataNormalizationException { DataNormalizationOperation current = legacyToNormalized.getRootOperation(); - for (PathArgument arg : normalized.getPath()) { + for (PathArgument arg : normalized.getPathArguments()) { current = current.getChild(arg); } return current; } - private static final Entry, DataObject> toEntry( + private static final Entry, DataObject> toBindingEntry( final org.opendaylight.yangtools.yang.binding.InstanceIdentifier key, final DataObject value) { return new SimpleEntry, DataObject>( key, value); } + private static final Entry> toDOMEntry( + final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier key, + final NormalizedNode value) { + return new SimpleEntry>( + key, value); + } + public DataObject toBinding(final InstanceIdentifier path, final NormalizedNode normalizedNode) throws DeserializationException { CompositeNode legacy = null; @@ -254,7 +263,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { public Optional, DataObject>> toBinding( final Entry> normalized) - throws DeserializationException { + throws DeserializationException { Optional> potentialPath = toBinding(normalized.getKey()); if (potentialPath.isPresent()) { InstanceIdentifier bindingPath = potentialPath.get(); @@ -262,7 +271,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { if (bindingData == null) { LOG.warn("Failed to deserialize {} to Binding format. Binding path is: {}", normalized, bindingPath); } - return Optional.of(toEntry(bindingPath, bindingData)); + return Optional.of(toBindingEntry(bindingPath, bindingData)); } else { return Optional.absent(); } @@ -304,15 +313,15 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) { int position = 0; int foundPosition = -1; - for (PathArgument arg : normalized.getPath()) { + for (PathArgument arg : normalized.getPathArguments()) { position++; if (arg instanceof AugmentationIdentifier) { foundPosition = position; } } if (foundPosition > 0) { - return new org.opendaylight.yangtools.yang.data.api.InstanceIdentifier(normalized.getPath().subList(0, - foundPosition)); + Iterable shortened = Iterables.limit(normalized.getPathArguments(), foundPosition); + return org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create(shortened); } return null; } @@ -364,19 +373,19 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { } else if (List.class.isAssignableFrom(returnType)) { try { return ClassLoaderUtils.withClassLoader(method.getDeclaringClass().getClassLoader(), - new Callable() { - @Override - public Class call() { - Type listResult = ClassLoaderUtils.getFirstGenericParameter(method - .getGenericReturnType()); - if (listResult instanceof Class - && DataObject.class.isAssignableFrom((Class) listResult)) { - return (Class) listResult; - } - return null; - } - - }); + new Supplier() { + @Override + public Class get() { + Type listResult = ClassLoaderUtils.getFirstGenericParameter(method + .getGenericReturnType()); + if (listResult instanceof Class + && DataObject.class.isAssignableFrom((Class) listResult)) { + return (Class) listResult; + } + return null; + } + + }); } catch (Exception e) { LOG.debug("Could not get YANG modeled entity for {}", method, e); return null; @@ -404,7 +413,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { } private boolean isAugmentationIdentifier(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier processed) { - return Iterables.getLast(processed.getPath()) instanceof AugmentationIdentifier; + return Iterables.getLast(processed.getPathArguments()) instanceof AugmentationIdentifier; } private static int getAugmentationCount(final InstanceIdentifier potential) { @@ -420,11 +429,66 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { private static int getAugmentationCount(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier potential) { int count = 0; - for(PathArgument arg : potential.getPath()) { + for(PathArgument arg : potential.getPathArguments()) { if(arg instanceof AugmentationIdentifier) { count++; } } return count; } + + public Function>, Optional> deserializeFunction(final InstanceIdentifier path) { + return new DeserializeFunction(this, path); + } + + private static class DeserializeFunction implements Function>, Optional> { + + private final BindingToNormalizedNodeCodec codec; + private final InstanceIdentifier path; + + public DeserializeFunction(final BindingToNormalizedNodeCodec codec, final InstanceIdentifier path) { + super(); + this.codec = Preconditions.checkNotNull(codec, "Codec must not be null"); + this.path = Preconditions.checkNotNull(path, "Path must not be null"); + } + + @Nullable + @Override + public Optional apply(@Nullable final Optional> normalizedNode) { + if (normalizedNode.isPresent()) { + final DataObject dataObject; + try { + dataObject = codec.toBinding(path, normalizedNode.get()); + } catch (DeserializationException e) { + LOG.warn("Failed to create dataobject from node {}", normalizedNode.get(), e); + throw new IllegalStateException("Failed to create dataobject", e); + } + + if (dataObject != null) { + return Optional.of(dataObject); + } + } + return Optional.absent(); + } + } + + /** + * Returns an default object according to YANG schema for supplied path. + * + * @param path DOM Path + * @return Node with defaults set on. + */ + public NormalizedNode getDefaultNodeFor(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier path) { + Iterator iterator = path.getPathArguments().iterator(); + DataNormalizationOperation currentOp = legacyToNormalized.getRootOperation(); + while (iterator.hasNext()) { + PathArgument currentArg = iterator.next(); + try { + currentOp = currentOp.getChild(currentArg); + } catch (DataNormalizationException e) { + throw new IllegalArgumentException(String.format("Invalid child encountered in path %s", path), e); + } + } + return currentOp.createDefault(path.getLastPathArgument()); + } }