X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-binding-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fbinding%2Fimpl%2FBindingToNormalizedNodeCodec.java;h=3f9d5c78546af7b0f40111b745fe89c8fefc5c91;hb=d206d27042eef2185c875f85cf6eac61a1bd77c4;hp=6329637dd01cfdad2470345e4c8433a07fe62ebf;hpb=325258bd8ecb1345ebf98fa038389908a26dff09;p=controller.git 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 6329637dd0..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,27 +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; @@ -37,11 +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; @@ -57,10 +67,11 @@ 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 path + // Used instance-identifier codec do not support serialization of last + // path // argument if it is Augmentation (behaviour expected by old datastore) // in this case, we explicitly check if last argument is augmentation // to process it separately @@ -70,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); } } @@ -103,13 +113,24 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { } - public InstanceIdentifier toBinding( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) - throws DeserializationException { - - PathArgument lastArgument = Iterables.getLast(normalized.getPath()); - // Used instance-identifier codec do not support serialization of last path - // argument if it is AugmentationIdentifier (behaviour expected by old datastore) + /** + * + * Returns a Binding-Aware instance identifier from normalized + * instance-identifier if it is possible to create representation. + * + * Returns Optional.absent for cases where target is mixin node except + * augmentation. + * + */ + public Optional> toBinding( + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) + throws DeserializationException { + + 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 + // datastore) // in this case, we explicitly check if last argument is augmentation // to process it separately if (lastArgument instanceof AugmentationIdentifier) { @@ -118,59 +139,113 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { return toBindingImpl(normalized); } - private InstanceIdentifier toBindingAugmented( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) throws DeserializationException { - InstanceIdentifier potential = toBindingImpl(normalized); + private Optional> toBindingAugmented( + 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 - if(isAugmentationIdentifier(potential)) { + if (potential.isPresent() && isAugmentationIdentifier(potential.get())) { return potential; } - AugmentationIdentifier lastArgument = (AugmentationIdentifier) Iterables.getLast(normalized.getPath()); + int normalizedCount = getAugmentationCount(normalized); + AugmentationIdentifier lastArgument = (AugmentationIdentifier) Iterables.getLast(normalized.getPathArguments()); - // Here we employ small trick - Binding-aware Codec injects an pointer to augmentation class - // if child is referenced - so we will reference child and then shorten path. + // Here we employ small trick - Binding-aware Codec injects an pointer + // to augmentation class + // if child is referenced - so we will reference child and then shorten + // 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); + continue; + } + } catch (DataNormalizationException e) { + LOG.warn("Failed to denormalize path {}, skipping it", childPath, e); + continue; + } + + Optional> baId = toBindingImpl(childPath); + if (!baId.isPresent()) { + LOG.debug("No binding-aware identifier found for path {}, skipping it", childPath); + continue; + } - InstanceIdentifier potentialPath = shortenToLastAugment(toBindingImpl(childPath)); - return potentialPath; - } catch (Exception e) { - LOG.trace("Unable to deserialize aug. child path for {}",childPath,e); + InstanceIdentifier potentialPath = shortenToLastAugment(baId.get()); + int potentialAugmentCount = getAugmentationCount(potentialPath); + if (potentialAugmentCount == normalizedCount) { + LOG.trace("Found matching path {}", potentialPath); + return Optional.> of(potentialPath); } + + LOG.trace("Skipping mis-matched potential path {}", potentialPath); } - return toBindingImpl(normalized); + + LOG.trace("Failed to find augmentation matching {}", normalized); + return Optional.absent(); } - private InstanceIdentifier toBindingImpl( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) - throws DeserializationException { - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath; + private Optional> toBindingImpl( + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) + throws DeserializationException { + org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier legacyPath; + try { + if (isNotRepresentable(normalized)) { + return Optional.absent(); + } legacyPath = legacyToNormalized.toLegacy(normalized); } catch (DataNormalizationException e) { throw new IllegalStateException("Could not denormalize path.", e); } LOG.trace("InstanceIdentifier Path Deserialization: Legacy representation {}, Normalized representation: {}", legacyPath, normalized); - return bindingToLegacy.fromDataDom(legacyPath); + return Optional.> of(bindingToLegacy.fromDataDom(legacyPath)); + } + + 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) { + return true; + } + if (op.isLeaf()) { + return true; + } + return false; } - private static final Entry, DataObject> toEntry( + private DataNormalizationOperation findNormalizationOperation( + final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized) + throws DataNormalizationException { + DataNormalizationOperation current = legacyToNormalized.getRootOperation(); + for (PathArgument arg : normalized.getPathArguments()) { + current = current.getChild(arg); + } + return current; + } + + 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; - if(isAugmentationIdentifier(path) && normalizedNode instanceof AugmentationNode) { + if (isAugmentationIdentifier(path) && normalizedNode instanceof AugmentationNode) { QName augIdentifier = BindingReflections.findQName(path.getTargetType()); ContainerNode virtualNode = Builders.containerBuilder() // .withNodeIdentifier(new NodeIdentifier(augIdentifier)) // @@ -188,12 +263,20 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { return legacyToNormalized; } - public Entry, DataObject> toBinding( - final Entry> normalized) - throws DeserializationException { - InstanceIdentifier bindingPath = toBinding(normalized.getKey()); - DataObject bindingData = toBinding(bindingPath, normalized.getValue()); - return toEntry(bindingPath, bindingData); + public Optional, DataObject>> toBinding( + final Entry> normalized) + throws DeserializationException { + Optional> potentialPath = toBinding(normalized.getKey()); + if (potentialPath.isPresent()) { + InstanceIdentifier bindingPath = potentialPath.get(); + DataObject bindingData = toBinding(bindingPath, normalized.getValue()); + if (bindingData == null) { + LOG.warn("Failed to deserialize {} to Binding format. Binding path is: {}", normalized, bindingPath); + } + return Optional.of(toBindingEntry(bindingPath, bindingData)); + } else { + return Optional.absent(); + } } @Override @@ -201,45 +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)) { + if (isAugmentationIdentifier(processed)) { return processed; } - // Here we employ small trick - DataNormalizer injecst 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()); + } + }); + } - private org.opendaylight.yangtools.yang.data.api.InstanceIdentifier shortenToLastAugmentation( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) { + 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; + } + + /** + * + * 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; } @@ -248,7 +459,7 @@ public class BindingToNormalizedNodeCodec implements SchemaContextListener { final InstanceIdentifier binding) { int position = 0; int foundPosition = -1; - for(org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : binding.getPathArguments()) { + for (org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : binding.getPathArguments()) { position++; if (isAugmentation(arg.getType())) { foundPosition = position; @@ -257,85 +468,102 @@ 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; + private static boolean isAugmentation(final Class type) { + return Augmentation.class.isAssignableFrom(type); } - @SuppressWarnings({ "rawtypes", "unchecked" }) - private Class getYangModeledType(final Method method) { - if (method.getName().equals("getClass") || !method.getName().startsWith("get") - || method.getParameterTypes().length > 0) { - return null; - } + private static boolean isAugmentationIdentifier(final InstanceIdentifier potential) { + return Augmentation.class.isAssignableFrom(potential.getTargetType()); + } - 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() { - - @SuppressWarnings("rawtypes") - @Override - public Class call() throws Exception { - 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; + 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())) { + count++; } } - return null; + return count; } - @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())); + private static int getAugmentationCount(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier potential) { + int count = 0; + for (PathArgument arg : potential.getPathArguments()) { + if (arg instanceof AugmentationIdentifier) { + count++; + } } - return InstanceIdentifier.create(wildArgs); + return count; } - - private static boolean isAugmentation(final Class type) { - return Augmentation.class.isAssignableFrom(type); + @SuppressWarnings({ "rawtypes", "unchecked" }) + public Function>, Optional> deserializeFunction(final InstanceIdentifier path) { + return new DeserializeFunction(this, path); } - private static boolean isAugmentationIdentifier(final InstanceIdentifier path) { - return Augmentation.class.isAssignableFrom(path.getTargetType()); + 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(); + } } - private boolean isAugmentationIdentifier(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier processed) { - return Iterables.getLast(processed.getPath()) instanceof AugmentationIdentifier; + /** + * 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()); } }