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=53615ad7dedc6c7d751554fb7f28bf446b96f1ee;hb=5ae1ab641771c896ca06467928b4e970303a8043;hp=35ebe76499f51e6bb5b629c4cf42a944fe727ea8;hpb=0afde20cdabcedb2bd8ddd1d59d12d3a5669600b;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 35ebe76499..1e2d2b17f0 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 @@ -7,19 +7,20 @@ */ package org.opendaylight.controller.md.sal.binding.impl; +import com.google.common.base.Function; +import com.google.common.base.Optional; import java.util.AbstractMap.SimpleEntry; +import java.util.Iterator; import java.util.Map.Entry; - 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.yang.binding.Augmentation; +import org.opendaylight.yangtools.binding.data.codec.impl.BindingNormalizedNodeCodecRegistry; +import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy; +import org.opendaylight.yangtools.sal.binding.generator.util.BindingRuntimeContext; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.opendaylight.yangtools.yang.data.api.CompositeNode; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument; -import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode; -import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; -import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; 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; @@ -28,99 +29,120 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContextListener; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.google.common.collect.ImmutableList; - -public class BindingToNormalizedNodeCodec implements SchemaContextListener { +public class BindingToNormalizedNodeCodec implements SchemaContextListener,AutoCloseable { private static final Logger LOG = LoggerFactory.getLogger(BindingToNormalizedNodeCodec.class); private final BindingIndependentMappingService bindingToLegacy; + private final BindingNormalizedNodeCodecRegistry codecRegistry; private DataNormalizer legacyToNormalized; + private final GeneratedClassLoadingStrategy classLoadingStrategy; - public BindingToNormalizedNodeCodec(final BindingIndependentMappingService mappingService) { + public BindingToNormalizedNodeCodec(final GeneratedClassLoadingStrategy classLoadingStrategy, final BindingIndependentMappingService mappingService, final BindingNormalizedNodeCodecRegistry codecRegistry) { super(); this.bindingToLegacy = mappingService; + this.classLoadingStrategy = classLoadingStrategy; + this.codecRegistry = codecRegistry; + } - public org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalized( + public org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier toNormalized( final InstanceIdentifier binding) { - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath = bindingToLegacy.toDataDom(binding); - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized = legacyToNormalized.toNormalized(legacyPath); - LOG.trace("InstanceIdentifier Path {} Serialization: Legacy representation {}, Normalized representation: {}",binding,legacyPath,normalized); - return normalized; + return codecRegistry.toYangInstanceIdentifier(binding); } - public Entry> toNormalizedNode( + @SuppressWarnings({ "unchecked", "rawtypes" }) + public Entry> toNormalizedNode( final InstanceIdentifier bindingPath, final DataObject bindingObject) { - return toNormalizedNode(toEntry(bindingPath, bindingObject)); + return codecRegistry.toNormalizedNode((InstanceIdentifier) bindingPath, bindingObject); } - public Entry> toNormalizedNode( + public Entry> toNormalizedNode( final Entry, DataObject> binding) { - Entry legacyEntry = bindingToLegacy.toDataDom(binding); - Entry> normalizedEntry = legacyToNormalized.toNormalized(legacyEntry); - LOG.trace("Serialization of {}, Legacy Representation: {}, Normalized Representation: {}",binding,legacyEntry,normalizedEntry); - if(Augmentation.class.isAssignableFrom(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); - } - } - - } - return normalizedEntry; - - + return toNormalizedNode(binding.getKey(),binding.getValue()); } - public InstanceIdentifier toBinding( - final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized) - throws DeserializationException { - - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath; + /** + * + * 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 { try { - legacyPath = legacyToNormalized.toLegacy(normalized); - } catch (DataNormalizationException e) { - throw new IllegalStateException("Could not denormalize path.",e); + return Optional.>of(codecRegistry.fromYangInstanceIdentifier(normalized)); + } catch (IllegalArgumentException e) { + return Optional.absent(); } - LOG.trace("InstanceIdentifier Path Deserialization: Legacy representation {}, Normalized representation: {}",legacyPath,normalized); - return bindingToLegacy.fromDataDom(legacyPath); } - 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); } - public DataObject toBinding(final InstanceIdentifier path, final NormalizedNode normalizedNode) - throws DeserializationException { - return bindingToLegacy.dataObjectFromDataDom(path, (CompositeNode) DataNormalizer.toLegacy(normalizedNode)); - } - public DataNormalizer getDataNormalizer() { 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); + @SuppressWarnings("unchecked") + public Optional, DataObject>> toBinding( + final Entry> normalized) + throws DeserializationException { + try { + @SuppressWarnings("rawtypes") + Entry binding = codecRegistry.fromNormalizedNode(normalized.getKey(), normalized.getValue()); + return Optional., DataObject>>fromNullable(binding); + } catch (IllegalArgumentException e) { + return Optional.absent(); + } } @Override public void onGlobalContextUpdated(final SchemaContext arg0) { legacyToNormalized = new DataNormalizer(arg0); + codecRegistry.onBindingRuntimeContextUpdated(BindingRuntimeContext.create(classLoadingStrategy, arg0)); + } + + public Function>, Optional> deserializeFunction(final InstanceIdentifier path) { + return codecRegistry.deserializeFunction(path); + } + + /** + * 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()); + } + + public BindingIndependentMappingService getLegacy() { + return bindingToLegacy; } + @Override + public void close() throws Exception { + // NOOP Intentionally + } }