summary |
shortlog |
log |
commit | commitdiff |
review |
tree
raw |
patch |
inline | side by side (from parent 1:
66249d6)
Improved extraction of Instance Identifiers from
DOM Data Change Event.
Logs in console are poluted with DeserializationException,
which fails to deserialize DOM Instance Identifier
to Binding Instance Identifier.
Added explicit check against schema context to
see if Instance Identifier is representable
in Binding Format, if not we will not report
is as part of subtree Data Change event.
Change-Id: Iaee2390fd089e0a2d66ec658aab4e7dab2a93a46
Signed-off-by: Tony Tkacik <ttkacik@cisco.com>
+ int normalizedCount = getAugmentationCount(normalized);
AugmentationIdentifier lastArgument = (AugmentationIdentifier) Iterables.getLast(normalized.getPath());
// Here we employ small trick - Binding-aware Codec injects an pointer
AugmentationIdentifier lastArgument = (AugmentationIdentifier) Iterables.getLast(normalized.getPath());
// Here we employ small trick - Binding-aware Codec injects an pointer
ImmutableList.<PathArgument> builder().addAll(normalized.getPath()).add(new NodeIdentifier(child))
.build());
try {
ImmutableList.<PathArgument> builder().addAll(normalized.getPath()).add(new NodeIdentifier(child))
.build());
try {
- if (!isChoiceOrCasePath(childPath)) {
+ if (!isNotRepresentable(childPath)) {
InstanceIdentifier<? extends DataObject> potentialPath = shortenToLastAugment(toBindingImpl(
childPath).get());
InstanceIdentifier<? extends DataObject> potentialPath = shortenToLastAugment(toBindingImpl(
childPath).get());
- return Optional.<InstanceIdentifier<? extends DataObject>> of(potentialPath);
+ int potentialAugmentCount = getAugmentationCount(potentialPath);
+ if(potentialAugmentCount == normalizedCount) {
+ return Optional.<InstanceIdentifier<? extends DataObject>> of(potentialPath);
+ }
}
} catch (Exception e) {
LOG.trace("Unable to deserialize aug. child path for {}", childPath, e);
}
}
}
} catch (Exception e) {
LOG.trace("Unable to deserialize aug. child path for {}", childPath, e);
}
}
- return toBindingImpl(normalized);
+ return Optional.absent();
}
private Optional<InstanceIdentifier<? extends DataObject>> toBindingImpl(
}
private Optional<InstanceIdentifier<? extends DataObject>> toBindingImpl(
org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath;
try {
org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath;
try {
- if (isChoiceOrCasePath(normalized)) {
+ if (isNotRepresentable(normalized)) {
return Optional.absent();
}
legacyPath = legacyToNormalized.toLegacy(normalized);
return Optional.absent();
}
legacyPath = legacyToNormalized.toLegacy(normalized);
return Optional.<InstanceIdentifier<? extends DataObject>> of(bindingToLegacy.fromDataDom(legacyPath));
}
return Optional.<InstanceIdentifier<? extends DataObject>> of(bindingToLegacy.fromDataDom(legacyPath));
}
- private boolean isChoiceOrCasePath(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized)
+ private boolean isNotRepresentable(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized)
throws DataNormalizationException {
DataNormalizationOperation<?> op = findNormalizationOperation(normalized);
throws DataNormalizationException {
DataNormalizationOperation<?> op = findNormalizationOperation(normalized);
- return op.isMixin() && op.getIdentifier() instanceof NodeIdentifier;
+ if( op.isMixin() && op.getIdentifier() instanceof NodeIdentifier) {
+ return true;
+ }
+ if(op.isLeaf()) {
+ return true;
+ }
+ return false;
}
private DataNormalizationOperation<?> findNormalizationOperation(
}
private DataNormalizationOperation<?> findNormalizationOperation(
if (isAugmentationIdentifier(processed)) {
return processed;
}
if (isAugmentationIdentifier(processed)) {
return processed;
}
- // Here we employ small trick - DataNormalizer injecst augmentation
+ // 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)
// identifier if child is
// also part of the path (since using a child we can safely identify
// augmentation)
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.InstanceIdentifier processed) {
return Iterables.getLast(processed.getPath()) 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 count;
+ }
+
+ private static int getAugmentationCount(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier potential) {
+ int count = 0;
+ for(PathArgument arg : potential.getPath()) {
+ if(arg instanceof AugmentationIdentifier) {
+ count++;
+ }
+ }
+ return count;
+ }
public abstract NormalizedNode<?, ?> normalize(Node<?> legacyData);
public abstract NormalizedNode<?, ?> normalize(Node<?> legacyData);
+ public abstract boolean isLeaf();
+
private static abstract class SimpleTypeNormalization<T extends PathArgument> extends DataNormalizationOperation<T> {
protected SimpleTypeNormalization(final T identifier) {
private static abstract class SimpleTypeNormalization<T extends PathArgument> extends DataNormalizationOperation<T> {
protected SimpleTypeNormalization(final T identifier) {
+ @Override
+ public boolean isLeaf() {
+ return true;
+ }
+
}
private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
}
private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
return builder.build();
}
return builder.build();
}
+ @Override
+ public boolean isLeaf() {
+ return false;
+ }
+
@SuppressWarnings("rawtypes")
protected abstract NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode);
@SuppressWarnings("rawtypes")
protected abstract NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode);