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=66caaea7083af18f1ffaedc3113f4e35d167b4ff;hp=3f9d5c78546af7b0f40111b745fe89c8fefc5c91;hb=d206d27042eef2185c875f85cf6eac61a1bd77c4;hpb=5109d42de3cfd06bb3834b7f6fc9e4ab6e8bb3d2 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..66caaea708 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 @@ -8,28 +8,30 @@ 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.LinkedList; -import java.util.List; +import java.util.Collection; +import java.util.HashSet; +import java.util.Iterator; import java.util.Map.Entry; -import java.util.concurrent.Callable; +import java.util.Set; + +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.BindingMapping; 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.YangModuleInfo; import org.opendaylight.yangtools.yang.binding.util.BindingReflections; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.data.api.CompositeNode; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode; import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; @@ -38,12 +40,18 @@ import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService; import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException; import org.opendaylight.yangtools.yang.data.impl.schema.Builders; +import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; +import org.opendaylight.yangtools.yang.model.api.AugmentationTarget; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaContext; 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.Predicate; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; @@ -59,7 +67,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { this.bindingToLegacy = mappingService; } - public org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalized( + public org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier toNormalized( final InstanceIdentifier binding) { // Used instance-identifier codec do not support serialization of last @@ -73,31 +81,30 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { return toNormalizedImpl(binding); } - public Entry> toNormalizedNode( + public Entry> toNormalizedNode( final InstanceIdentifier bindingPath, final DataObject bindingObject) { - return toNormalizedNode(toEntry(bindingPath, bindingObject)); + return toNormalizedNode(toBindingEntry(bindingPath, bindingObject)); } - public Entry> toNormalizedNode( + public Entry> toNormalizedNode( final Entry, DataObject> binding) { - Entry legacyEntry = bindingToLegacy + Entry legacyEntry = bindingToLegacy .toDataDom(binding); - Entry> normalizedEntry = legacyToNormalized + Entry> normalizedEntry = legacyToNormalized .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( - childArgs); - return new SimpleEntry>( - childPath, child); + .addAll(normalizedEntry.getKey().getPathArguments()).add(child.getIdentifier()).build(); + org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier childPath = org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier + .create(childArgs); + return toDOMEntry(childPath, child); } } @@ -116,10 +123,10 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { * */ public Optional> toBinding( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) - throws DeserializationException { + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) + 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 @@ -133,8 +140,8 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { } private Optional> toBindingAugmented( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) - throws DeserializationException { + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) + throws DeserializationException { Optional> potential = toBindingImpl(normalized); // Shorthand check, if codec already supports deserialization // of AugmentationIdentifier we will return @@ -143,7 +150,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 +158,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.YangInstanceIdentifier childPath = normalized.node(child); try { if (isNotRepresentable(childPath)) { LOG.trace("Path {} is not BI-representable, skipping it", childPath); @@ -185,9 +190,9 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { } private Optional> toBindingImpl( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) - throws DeserializationException { - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath; + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) + throws DeserializationException { + org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier legacyPath; try { if (isNotRepresentable(normalized)) { @@ -202,35 +207,41 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { return Optional.> of(bindingToLegacy.fromDataDom(legacyPath)); } - private boolean isNotRepresentable(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) + private boolean isNotRepresentable(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) throws DataNormalizationException { DataNormalizationOperation op = findNormalizationOperation(normalized); - if( op.isMixin() && op.getIdentifier() instanceof NodeIdentifier) { + if (op.isMixin() && op.getIdentifier() instanceof NodeIdentifier) { return true; } - if(op.isLeaf()) { + if (op.isLeaf()) { return true; } return false; } private DataNormalizationOperation findNormalizationOperation( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) - throws DataNormalizationException { + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) + 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.YangInstanceIdentifier key, final NormalizedNode value) { + return new SimpleEntry>(key, + value); + } + public DataObject toBinding(final InstanceIdentifier path, final NormalizedNode normalizedNode) throws DeserializationException { CompositeNode legacy = null; @@ -253,8 +264,8 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { } public Optional, DataObject>> toBinding( - final Entry> normalized) - throws DeserializationException { + final Entry> normalized) + throws DeserializationException { Optional> potentialPath = toBinding(normalized.getKey()); if (potentialPath.isPresent()) { InstanceIdentifier bindingPath = potentialPath.get(); @@ -262,7 +273,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(); } @@ -273,46 +284,173 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { legacyToNormalized = new DataNormalizer(arg0); } - private org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalizedAugmented( + private org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier toNormalizedAugmented( final InstanceIdentifier augPath) { - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier processed = toNormalizedImpl(augPath); + org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier processed = toNormalizedImpl(augPath); // If used instance identifier codec added supports for deserialization // of last AugmentationIdentifier we will just reuse it if (isAugmentationIdentifier(processed)) { return processed; } - // Here we employ small trick - DataNormalizer injects augmentation - // identifier if child is - // also part of the path (since using a child we can safely identify - // augmentation) - // so, we scan augmentation for children add it to path - // and use original algorithm, then shorten it to last augmentation - for (@SuppressWarnings("rawtypes") - Class augChild : getAugmentationChildren(augPath.getTargetType())) { + Optional additionalSerialized; + additionalSerialized = toNormalizedAugmentedUsingChildContainers(augPath, processed); + + if (additionalSerialized.isPresent()) { + return additionalSerialized.get(); + } + additionalSerialized = toNormalizedAugmentedUsingChildLeafs(augPath, processed); + if (additionalSerialized.isPresent()) { + return additionalSerialized.get(); + } + throw new IllegalStateException("Unabled to construct augmentation identfier for " + augPath); + } + + /** + * Tries to find correct augmentation identifier using children leafs + * + * This method uses normalized Instance Identifier of parent node to fetch + * schema and {@link BindingReflections#getModuleInfo(Class)} to learn about + * augmentation namespace, specificly, in which module it was defined. + * + * Then it uses it to filter all available augmentations for parent by + * module. After that it walks augmentations in particular module and + * pick-up first which at least one leaf name matches supplied augmentation. + * We could do this safely since YANG explicitly states that no any existing + * augmentations must differ in leaf fully qualified names. + * + * + * @param augPath + * Binding Aware Path which ends with augment + * @param parentPath + * Processed path + * @return + */ + private Optional toNormalizedAugmentedUsingChildLeafs( + final InstanceIdentifier augPath, + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier parentPath) { + try { + DataNormalizationOperation parentOp = legacyToNormalized.getOperation(parentPath); + if(!parentOp.getDataSchemaNode().isPresent()) { + return Optional.absent(); + } + DataSchemaNode parentSchema = parentOp.getDataSchemaNode().get(); + if (parentSchema instanceof AugmentationTarget) { + Set augmentations = ((AugmentationTarget) parentSchema).getAvailableAugmentations(); + LOG.info("Augmentations for {}, {}", augPath, augmentations); + Optional schema = findAugmentation(augPath.getTargetType(), augmentations); + if (schema.isPresent()) { + AugmentationIdentifier augmentationIdentifier = DataNormalizationOperation + .augmentationIdentifierFrom(schema.get()); + return Optional.of(parentPath.node(augmentationIdentifier)); + } + } + } catch (DataNormalizationException e) { + throw new IllegalArgumentException(e); + } + return Optional.absent(); + } + + /** + * Creates instance identifier for augmentation child, tries to serialize it + * Instance Identifier is then shortened to last augmentation. + * + * This is for situations, where underlying codec is implementing hydrogen + * style DOM APIs (which did not supported {@link AugmentationIdentifier}.) + * + * @param augPath + * @param parentPath + * Path to parent node + * @return + */ + @SuppressWarnings("rawtypes") + private Optional toNormalizedAugmentedUsingChildContainers( + final InstanceIdentifier augPath, + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier parentPath) { + for (Class augChild : BindingReflections.getChildrenClasses(augPath.getTargetType())) { @SuppressWarnings("unchecked") InstanceIdentifier childPath = augPath.child(augChild); - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized = toNormalizedImpl(childPath); - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier potentialDiscovered = shortenToLastAugmentation(normalized); + org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized = toNormalizedImpl(childPath); + org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier potentialDiscovered = shortenToLastAugmentation( + normalized, parentPath); if (potentialDiscovered != null) { - return potentialDiscovered; + return Optional.of(potentialDiscovered); } } - return processed; + return Optional.absent(); + } + + private Optional findAugmentation(final Class targetType, + final Set augmentations) { + YangModuleInfo moduleInfo; + try { + moduleInfo = BindingReflections.getModuleInfo(targetType); + } catch (Exception e) { + throw new IllegalStateException(e); + } + Iterable filtered = filteredByModuleInfo(augmentations, + BindingReflections.getModuleQName(moduleInfo).getModule()); + filtered.toString(); + Set targetTypeGetters = getYangModeledGetters(targetType); + for (AugmentationSchema schema : filtered) { + for (DataSchemaNode child : schema.getChildNodes()) { + String getterName = "get" + BindingMapping.getClassName(child.getQName()); + if (targetTypeGetters.contains(getterName)) { + return Optional.of(schema); + } + } + } + return Optional.absent(); + } + + private static Iterable filteredByModuleInfo(final Iterable augmentations, + final QNameModule module) { + return Iterables.filter(augmentations, new Predicate() { + @Override + public boolean apply(final AugmentationSchema schema) { + final Collection childNodes = schema.getChildNodes(); + return !childNodes.isEmpty() && module.equals(Iterables.get(childNodes, 0).getQName().getModule()); + } + }); + } + + public static final Set getYangModeledGetters(final Class targetType) { + HashSet ret = new HashSet(); + for (Method method : targetType.getMethods()) { + if (isYangModeledGetter(method)) { + ret.add(method.getName()); + } + } + return ret; } - private org.opendaylight.yangtools.yang.data.api.InstanceIdentifier shortenToLastAugmentation( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) { + /** + * + * Returns true if supplied method represent getter for YANG modeled value + * + * @param method + * Method to be tested + * @return true if method represent getter for YANG Modeled value. + */ + private static final boolean isYangModeledGetter(final Method method) { + return !method.getName().equals("getClass") && !method.getName().equals("getImplementedInterface") + && method.getName().startsWith("get") && method.getParameterTypes().length == 0; + } + + private org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier shortenToLastAugmentation( + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized, + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier parentPath) { + int parentSize = Iterables.size(parentPath.getPathArguments()); 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)); + if (foundPosition > 0 && foundPosition > parentSize) { + Iterable shortened = Iterables.limit(normalized.getPathArguments(), foundPosition); + return org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.create(shortened); } return null; } @@ -330,71 +468,15 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { return InstanceIdentifier.create(Iterables.limit(binding.getPathArguments(), foundPosition)); } - private org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalizedImpl( + private org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier toNormalizedImpl( final InstanceIdentifier binding) { - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath = bindingToLegacy + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier legacyPath = bindingToLegacy .toDataDom(binding); - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized = legacyToNormalized + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized = legacyToNormalized .toNormalized(legacyPath); return normalized; } - @SuppressWarnings("unchecked") - private Iterable> getAugmentationChildren(final Class targetType) { - List> ret = new LinkedList<>(); - for (Method method : targetType.getMethods()) { - Class entity = getYangModeledType(method); - if (entity != null) { - ret.add((Class) entity); - } - } - return ret; - } - - @SuppressWarnings({ "rawtypes", "unchecked" }) - private Class getYangModeledType(final Method method) { - if (method.getName().equals("getClass") || !method.getName().startsWith("get") - || method.getParameterTypes().length > 0) { - return null; - } - - Class returnType = method.getReturnType(); - if (DataContainer.class.isAssignableFrom(returnType)) { - return (Class) returnType; - } 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; - } - - }); - } catch (Exception e) { - LOG.debug("Could not get YANG modeled entity for {}", method, e); - return null; - } - - } - return null; - } - - @SuppressWarnings({ "unchecked", "rawtypes" }) - private static InstanceIdentifier toWildcarded(final InstanceIdentifier orig) { - List wildArgs = new LinkedList<>(); - for (org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : orig.getPathArguments()) { - wildArgs.add(new Item(arg.getType())); - } - return InstanceIdentifier.create(wildArgs); - } - private static boolean isAugmentation(final Class type) { return Augmentation.class.isAssignableFrom(type); } @@ -403,14 +485,14 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { return Augmentation.class.isAssignableFrom(potential.getTargetType()); } - private boolean isAugmentationIdentifier(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier processed) { - return Iterables.getLast(processed.getPath()) instanceof AugmentationIdentifier; + private boolean isAugmentationIdentifier(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier processed) { + return Iterables.getLast(processed.getPathArguments()) instanceof AugmentationIdentifier; } private static int getAugmentationCount(final InstanceIdentifier potential) { int count = 0; - for(org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : potential.getPathArguments()) { - if(isAugmentation(arg.getType())) { + for (org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : potential.getPathArguments()) { + if (isAugmentation(arg.getType())) { count++; } @@ -418,13 +500,70 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { return count; } - private static int getAugmentationCount(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier potential) { + private static int getAugmentationCount(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier potential) { int count = 0; - for(PathArgument arg : potential.getPath()) { - if(arg instanceof AugmentationIdentifier) { + for (PathArgument arg : potential.getPathArguments()) { + if (arg instanceof AugmentationIdentifier) { count++; } } return count; } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + 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"); + } + + @SuppressWarnings("rawtypes") + @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.YangInstanceIdentifier 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()); + } }