restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/restconf/impl/DataNormalizationOperation.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.netconf.sal.restconf.impl;
   9
  10 import static com.google.common.base.Verify.verifyNotNull;
  11
  12 import com.google.common.collect.ImmutableMap;
  13 import com.google.common.collect.ImmutableSet;
  14 import com.google.common.collect.Iterables;
  15 import java.util.Map;
  16 import java.util.Set;
  17 import java.util.concurrent.ConcurrentHashMap;
  18 import org.eclipse.jdt.annotation.Nullable;
  19 import org.opendaylight.yangtools.concepts.Identifiable;
  20 import org.opendaylight.yangtools.yang.common.Empty;
  21 import org.opendaylight.yangtools.yang.common.QName;
  22 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  23 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  27 import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
  28 import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
  29 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
  30 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
  31 import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
  32 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
  33 import org.opendaylight.yangtools.yang.model.api.ContainerLike;
  34 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  35 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  36 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  37 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  38 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
  39 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  40 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  41 import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
  42 import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
  43
  44 abstract class DataNormalizationOperation<T extends PathArgument> implements Identifiable<T> {
  45     private final T identifier;
  46
  47     DataNormalizationOperation(final T identifier) {
  48         this.identifier = identifier;
  49     }
  50
  51     static DataNormalizationOperation<?> from(final EffectiveModelContext ctx) {
  52         return new ContainerNormalization(ctx);
  53     }
  54
  55     @Override
  56     public T getIdentifier() {
  57         return identifier;
  58     }
  59
  60     boolean isMixin() {
  61         return false;
  62     }
  63
  64     Set<QName> getQNameIdentifiers() {
  65         return ImmutableSet.of(identifier.getNodeType());
  66     }
  67
  68     abstract DataNormalizationOperation<?> getChild(PathArgument child) throws DataNormalizationException;
  69
  70     abstract DataNormalizationOperation<?> getChild(QName child) throws DataNormalizationException;
  71
  72     abstract DataNormalizationOperation<?> enterChild(QName child, SchemaInferenceStack stack)
  73         throws DataNormalizationException;
  74
  75     abstract DataNormalizationOperation<?> enterChild(PathArgument child, SchemaInferenceStack stack)
  76         throws DataNormalizationException;
  77
  78     void pushToStack(final SchemaInferenceStack stack) {
  79         // Accurate for most subclasses
  80         stack.enterSchemaTree(getIdentifier().getNodeType());
  81     }
  82
  83     private abstract static class SimpleTypeNormalization<T extends PathArgument>
  84             extends DataNormalizationOperation<T> {
  85         SimpleTypeNormalization(final T identifier) {
  86             super(identifier);
  87         }
  88
  89         @Override
  90         final DataNormalizationOperation<?> getChild(final PathArgument child) {
  91             return null;
  92         }
  93
  94         @Override
  95         final DataNormalizationOperation<?> getChild(final QName child) {
  96             return null;
  97         }
  98
  99         @Override
 100         final DataNormalizationOperation<?> enterChild(final QName child, final SchemaInferenceStack stack) {
 101             return null;
 102         }
 103
 104         @Override
 105         final DataNormalizationOperation<?> enterChild(final PathArgument child, final SchemaInferenceStack stack) {
 106             return null;
 107         }
 108     }
 109
 110     private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
 111         LeafNormalization(final LeafSchemaNode potential) {
 112             super(new NodeIdentifier(potential.getQName()));
 113         }
 114     }
 115
 116     private static final class LeafListEntryNormalization extends SimpleTypeNormalization<NodeWithValue> {
 117         LeafListEntryNormalization(final LeafListSchemaNode potential) {
 118             super(new NodeWithValue<>(potential.getQName(), Empty.value()));
 119         }
 120
 121         @Override
 122         protected void pushToStack(final SchemaInferenceStack stack) {
 123             // No-op
 124         }
 125     }
 126
 127     private abstract static class DataContainerNormalizationOperation<T extends PathArgument>
 128             extends DataNormalizationOperation<T> {
 129         private final DataNodeContainer schema;
 130         private final Map<QName, DataNormalizationOperation<?>> byQName = new ConcurrentHashMap<>();
 131         private final Map<PathArgument, DataNormalizationOperation<?>> byArg = new ConcurrentHashMap<>();
 132
 133         DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema) {
 134             super(identifier);
 135             this.schema = schema;
 136         }
 137
 138         @Override
 139         DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException {
 140             DataNormalizationOperation<?> potential = byArg.get(child);
 141             if (potential != null) {
 142                 return potential;
 143             }
 144             potential = fromLocalSchema(child);
 145             return register(potential);
 146         }
 147
 148         @Override
 149         DataNormalizationOperation<?> getChild(final QName child) throws DataNormalizationException {
 150             DataNormalizationOperation<?> potential = byQName.get(child);
 151             if (potential != null) {
 152                 return potential;
 153             }
 154             potential = fromLocalSchemaAndQName(schema, child);
 155             return register(potential);
 156         }
 157
 158         @Override
 159         final DataNormalizationOperation<?> enterChild(final QName child, final SchemaInferenceStack stack)
 160                 throws DataNormalizationException {
 161             return pushToStack(getChild(child), stack);
 162         }
 163
 164         @Override
 165         final DataNormalizationOperation<?> enterChild(final PathArgument child, final SchemaInferenceStack stack)
 166                 throws DataNormalizationException {
 167             return pushToStack(getChild(child), stack);
 168         }
 169
 170         private static DataNormalizationOperation<?> pushToStack(final DataNormalizationOperation<?> child,
 171                 final SchemaInferenceStack stack) {
 172             if (child != null) {
 173                 child.pushToStack(stack);
 174             }
 175             return child;
 176         }
 177
 178         private DataNormalizationOperation<?> fromLocalSchema(final PathArgument child)
 179                 throws DataNormalizationException {
 180             if (child instanceof AugmentationIdentifier) {
 181                 return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
 182                         .iterator().next());
 183             }
 184             return fromSchemaAndQNameChecked(schema, child.getNodeType());
 185         }
 186
 187         DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema2,
 188                 final QName child) throws DataNormalizationException {
 189             return fromSchemaAndQNameChecked(schema2, child);
 190         }
 191
 192         private DataNormalizationOperation<?> register(final DataNormalizationOperation<?> potential) {
 193             if (potential != null) {
 194                 byArg.put(potential.getIdentifier(), potential);
 195                 for (final QName qname : potential.getQNameIdentifiers()) {
 196                     byQName.put(qname, potential);
 197                 }
 198             }
 199             return potential;
 200         }
 201
 202         private static DataNormalizationOperation<?> fromSchemaAndQNameChecked(final DataNodeContainer schema,
 203                 final QName child) throws DataNormalizationException {
 204
 205             final DataSchemaNode result = findChildSchemaNode(schema, child);
 206             if (result == null) {
 207                 throw new DataNormalizationException(String.format(
 208                         "Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child,
 209                         schema,schema.getChildNodes()));
 210             }
 211
 212             // We try to look up if this node was added by augmentation
 213             if (schema instanceof DataSchemaNode && result.isAugmenting()) {
 214                 return fromAugmentation(schema, (AugmentationTarget) schema, result);
 215             }
 216             return fromDataSchemaNode(result);
 217         }
 218     }
 219
 220     private static final class ListItemNormalization extends
 221             DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
 222         ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
 223             super(identifier, schema);
 224         }
 225
 226         @Override
 227         protected void pushToStack(final SchemaInferenceStack stack) {
 228             // No-op
 229         }
 230     }
 231
 232     private static final class UnkeyedListItemNormalization
 233             extends DataContainerNormalizationOperation<NodeIdentifier> {
 234         UnkeyedListItemNormalization(final ListSchemaNode schema) {
 235             super(new NodeIdentifier(schema.getQName()), schema);
 236         }
 237
 238         @Override
 239         protected void pushToStack(final SchemaInferenceStack stack) {
 240             // No-op
 241         }
 242     }
 243
 244     private static final class ContainerNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
 245         ContainerNormalization(final ContainerLike schema) {
 246             super(new NodeIdentifier(schema.getQName()), schema);
 247         }
 248     }
 249
 250     private abstract static class MixinNormalizationOp<T extends PathArgument> extends DataNormalizationOperation<T> {
 251         MixinNormalizationOp(final T identifier) {
 252             super(identifier);
 253         }
 254
 255         @Override
 256         final boolean isMixin() {
 257             return true;
 258         }
 259     }
 260
 261     private abstract static class ListLikeNormalizationOp<T extends PathArgument> extends MixinNormalizationOp<T> {
 262         ListLikeNormalizationOp(final T identifier) {
 263             super(identifier);
 264         }
 265
 266         @Override
 267         protected final DataNormalizationOperation<?> enterChild(final QName child, final SchemaInferenceStack stack)
 268                 throws DataNormalizationException {
 269             // Stack is already pointing to the corresponding statement, now we are just working with the child
 270             return getChild(child);
 271         }
 272
 273         @Override
 274         protected final DataNormalizationOperation<?> enterChild(final PathArgument child,
 275                 final SchemaInferenceStack stack) throws DataNormalizationException {
 276             return getChild(child);
 277         }
 278     }
 279
 280     private static final class LeafListMixinNormalization extends ListLikeNormalizationOp<NodeIdentifier> {
 281         private final DataNormalizationOperation<?> innerOp;
 282
 283         LeafListMixinNormalization(final LeafListSchemaNode potential) {
 284             super(new NodeIdentifier(potential.getQName()));
 285             innerOp = new LeafListEntryNormalization(potential);
 286         }
 287
 288         @Override
 289         DataNormalizationOperation<?> getChild(final PathArgument child) {
 290             if (child instanceof NodeWithValue) {
 291                 return innerOp;
 292             }
 293             return null;
 294         }
 295
 296         @Override
 297         DataNormalizationOperation<?> getChild(final QName child) {
 298             if (getIdentifier().getNodeType().equals(child)) {
 299                 return innerOp;
 300             }
 301             return null;
 302         }
 303     }
 304
 305     private static final class AugmentationNormalization
 306             extends DataContainerNormalizationOperation<AugmentationIdentifier> {
 307
 308         AugmentationNormalization(final AugmentationSchemaNode augmentation, final DataNodeContainer schema) {
 309             super(DataSchemaContextNode.augmentationIdentifierFrom(augmentation),
 310                 new EffectiveAugmentationSchema(augmentation, schema));
 311         }
 312
 313         @Override
 314         boolean isMixin() {
 315             return true;
 316         }
 317
 318         @Override
 319         DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema, final QName child) {
 320             final DataSchemaNode result = findChildSchemaNode(schema, child);
 321             if (result == null) {
 322                 return null;
 323             }
 324
 325             // We try to look up if this node was added by augmentation
 326             if (schema instanceof DataSchemaNode && result.isAugmenting()) {
 327                 return fromAugmentation(schema, (AugmentationTarget) schema, result);
 328             }
 329             return fromDataSchemaNode(result);
 330         }
 331
 332         @Override
 333         Set<QName> getQNameIdentifiers() {
 334             return getIdentifier().getPossibleChildNames();
 335         }
 336
 337         @Override
 338         void pushToStack(final SchemaInferenceStack stack) {
 339             // No-op
 340         }
 341     }
 342
 343     private static final class MapMixinNormalization extends ListLikeNormalizationOp<NodeIdentifier> {
 344         private final ListItemNormalization innerNode;
 345
 346         MapMixinNormalization(final ListSchemaNode list) {
 347             super(new NodeIdentifier(list.getQName()));
 348             innerNode = new ListItemNormalization(NodeIdentifierWithPredicates.of(list.getQName()), list);
 349         }
 350
 351         @Override
 352         DataNormalizationOperation<?> getChild(final PathArgument child) {
 353             if (child.getNodeType().equals(getIdentifier().getNodeType())) {
 354                 return innerNode;
 355             }
 356             return null;
 357         }
 358
 359         @Override
 360         DataNormalizationOperation<?> getChild(final QName child) {
 361             if (getIdentifier().getNodeType().equals(child)) {
 362                 return innerNode;
 363             }
 364             return null;
 365         }
 366     }
 367
 368     private static final class UnkeyedListMixinNormalization extends ListLikeNormalizationOp<NodeIdentifier> {
 369         private final UnkeyedListItemNormalization innerNode;
 370
 371         UnkeyedListMixinNormalization(final ListSchemaNode list) {
 372             super(new NodeIdentifier(list.getQName()));
 373             innerNode = new UnkeyedListItemNormalization(list);
 374         }
 375
 376         @Override
 377         DataNormalizationOperation<?> getChild(final PathArgument child) {
 378             if (child.getNodeType().equals(getIdentifier().getNodeType())) {
 379                 return innerNode;
 380             }
 381             return null;
 382         }
 383
 384         @Override
 385         DataNormalizationOperation<?> getChild(final QName child) {
 386             if (getIdentifier().getNodeType().equals(child)) {
 387                 return innerNode;
 388             }
 389             return null;
 390         }
 391     }
 392
 393     private static final class ChoiceNodeNormalization extends MixinNormalizationOp<NodeIdentifier> {
 394         private final ImmutableMap<QName, DataNormalizationOperation<?>> byQName;
 395         private final ImmutableMap<PathArgument, DataNormalizationOperation<?>> byArg;
 396         private final ImmutableMap<DataNormalizationOperation<?>, QName> childToCase;
 397
 398         ChoiceNodeNormalization(final ChoiceSchemaNode schema) {
 399             super(new NodeIdentifier(schema.getQName()));
 400             ImmutableMap.Builder<DataNormalizationOperation<?>, QName> childToCaseBuilder = ImmutableMap.builder();
 401             final ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
 402             final ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder =
 403                     ImmutableMap.builder();
 404
 405             for (final CaseSchemaNode caze : schema.getCases()) {
 406                 for (final DataSchemaNode cazeChild : caze.getChildNodes()) {
 407                     final DataNormalizationOperation<?> childOp = fromDataSchemaNode(cazeChild);
 408                     byArgBuilder.put(childOp.getIdentifier(), childOp);
 409                     childToCaseBuilder.put(childOp, caze.getQName());
 410                     for (final QName qname : childOp.getQNameIdentifiers()) {
 411                         byQNameBuilder.put(qname, childOp);
 412                     }
 413                 }
 414             }
 415             childToCase = childToCaseBuilder.build();
 416             byQName = byQNameBuilder.build();
 417             byArg = byArgBuilder.build();
 418         }
 419
 420         @Override
 421         DataNormalizationOperation<?> getChild(final PathArgument child) {
 422             return byArg.get(child);
 423         }
 424
 425         @Override
 426         DataNormalizationOperation<?> getChild(final QName child) {
 427             return byQName.get(child);
 428         }
 429
 430         @Override
 431         Set<QName> getQNameIdentifiers() {
 432             return byQName.keySet();
 433         }
 434
 435         @Override
 436         DataNormalizationOperation<?> enterChild(final QName child, final SchemaInferenceStack stack) {
 437             return pushToStack(getChild(child), stack);
 438         }
 439
 440         @Override
 441         DataNormalizationOperation<?> enterChild(final PathArgument child, final SchemaInferenceStack stack) {
 442             return pushToStack(getChild(child), stack);
 443         }
 444
 445         @Override
 446         void pushToStack(final SchemaInferenceStack stack) {
 447             stack.enterChoice(getIdentifier().getNodeType());
 448         }
 449
 450         private DataNormalizationOperation<?> pushToStack(final DataNormalizationOperation<?> child,
 451                 final SchemaInferenceStack stack) {
 452             if (child != null) {
 453                 final var caseName = verifyNotNull(childToCase.get(child), "No case statement for %s in %s", child,
 454                     this);
 455                 stack.enterSchemaTree(caseName);
 456                 child.pushToStack(stack);
 457             }
 458             return child;
 459         }
 460     }
 461
 462     private static final class AnyxmlNormalization extends SimpleTypeNormalization<NodeIdentifier> {
 463         AnyxmlNormalization(final AnyxmlSchemaNode schema) {
 464             super(new NodeIdentifier(schema.getQName()));
 465         }
 466     }
 467
 468     private static @Nullable DataSchemaNode findChildSchemaNode(final DataNodeContainer parent, final QName child) {
 469         final DataSchemaNode potential = parent.dataChildByName(child);
 470         return potential != null ? potential : findChoice(parent, child);
 471     }
 472
 473     private static @Nullable ChoiceSchemaNode findChoice(final DataNodeContainer parent, final QName child) {
 474         for (final ChoiceSchemaNode choice : Iterables.filter(parent.getChildNodes(), ChoiceSchemaNode.class)) {
 475             for (final CaseSchemaNode caze : choice.getCases()) {
 476                 if (findChildSchemaNode(caze, child) != null) {
 477                     return choice;
 478                 }
 479             }
 480         }
 481         return null;
 482     }
 483
 484     /**
 485      * Returns a DataNormalizationOperation for provided child node.
 486      *
 487      * <p>
 488      * If supplied child is added by Augmentation this operation returns
 489      * a DataNormalizationOperation for augmentation,
 490      * otherwise returns a DataNormalizationOperation for child as
 491      * call for {@link #fromDataSchemaNode(DataSchemaNode)}.
 492      */
 493     private static DataNormalizationOperation<?> fromAugmentation(final DataNodeContainer parent,
 494             final AugmentationTarget parentAug, final DataSchemaNode child) {
 495         for (final AugmentationSchemaNode aug : parentAug.getAvailableAugmentations()) {
 496             if (aug.dataChildByName(child.getQName()) != null) {
 497                 return new AugmentationNormalization(aug, parent);
 498             }
 499         }
 500         return fromDataSchemaNode(child);
 501     }
 502
 503     static DataNormalizationOperation<?> fromDataSchemaNode(final DataSchemaNode potential) {
 504         if (potential instanceof ContainerSchemaNode) {
 505             return new ContainerNormalization((ContainerSchemaNode) potential);
 506         } else if (potential instanceof ListSchemaNode) {
 507             return fromListSchemaNode((ListSchemaNode) potential);
 508         } else if (potential instanceof LeafSchemaNode) {
 509             return new LeafNormalization((LeafSchemaNode) potential);
 510         } else if (potential instanceof ChoiceSchemaNode) {
 511             return new ChoiceNodeNormalization((ChoiceSchemaNode) potential);
 512         } else if (potential instanceof LeafListSchemaNode) {
 513             return new LeafListMixinNormalization((LeafListSchemaNode) potential);
 514         } else if (potential instanceof AnyxmlSchemaNode) {
 515             return new AnyxmlNormalization((AnyxmlSchemaNode) potential);
 516         }
 517         return null;
 518     }
 519
 520     private static DataNormalizationOperation<?> fromListSchemaNode(final ListSchemaNode potential) {
 521         if (potential.getKeyDefinition().isEmpty()) {
 522             return new UnkeyedListMixinNormalization(potential);
 523         }
 524         return new MapMixinNormalization(potential);
 525     }
 526 }