binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/BindingSchemaContextUtils.java

   1 /*
   2  * Copyright (c) 2014, 2015 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.mdsal.binding.generator.impl;
   9
  10 import com.google.common.base.Preconditions;
  11 import java.util.HashSet;
  12 import java.util.Iterator;
  13 import java.util.Optional;
  14 import java.util.Set;
  15 import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
  16 import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
  17 import org.opendaylight.yangtools.yang.binding.Augmentation;
  18 import org.opendaylight.yangtools.yang.binding.ChildOf;
  19 import org.opendaylight.yangtools.yang.binding.DataObject;
  20 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  21 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
  22 import org.opendaylight.yangtools.yang.common.QName;
  23 import org.opendaylight.yangtools.yang.common.QNameModule;
  24 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
  25 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
  26 import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
  27 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
  28 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  29 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  30 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  31 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  32 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  33 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  34 import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
  35 import org.slf4j.Logger;
  36 import org.slf4j.LoggerFactory;
  37
  38 public final class BindingSchemaContextUtils {
  39     private static final Logger LOG = LoggerFactory.getLogger(BindingSchemaContextUtils.class);
  40
  41     private BindingSchemaContextUtils() {
  42         throw new UnsupportedOperationException("Utility class should not be instantiated");
  43     }
  44
  45     // FIXME: This method does not search in case augmentations.
  46     public static Optional<DataNodeContainer> findDataNodeContainer(final SchemaContext ctx,
  47             final InstanceIdentifier<?> path) {
  48         Iterator<PathArgument> pathArguments = path.getPathArguments().iterator();
  49         PathArgument currentArg = pathArguments.next();
  50         Preconditions.checkArgument(currentArg != null);
  51         QName currentQName = BindingReflections.findQName(currentArg.getType());
  52
  53         Optional<DataNodeContainer> currentContainer = Optional.empty();
  54         if (BindingReflections.isNotification(currentArg.getType())) {
  55             currentContainer = findNotification(ctx, currentQName);
  56         } else if (BindingReflections.isRpcType(currentArg.getType())) {
  57             currentContainer = findFirstDataNodeContainerInRpc(ctx, currentArg.getType());
  58             if (currentQName == null && currentContainer.isPresent()) {
  59                 currentQName = ((DataSchemaNode) currentContainer.get()).getQName();
  60             }
  61         } else {
  62             currentContainer = findDataNodeContainer(ctx, currentQName);
  63         }
  64
  65         while (currentContainer.isPresent() && pathArguments.hasNext()) {
  66             currentArg = pathArguments.next();
  67             if (Augmentation.class.isAssignableFrom(currentArg.getType())) {
  68                 currentQName = BindingReflections.findQName(currentArg.getType());
  69                 if (pathArguments.hasNext()) {
  70                     currentArg = pathArguments.next();
  71                 } else {
  72                     return currentContainer;
  73                 }
  74             }
  75             if (ChildOf.class.isAssignableFrom(currentArg.getType())
  76                     && BindingReflections.isAugmentationChild(currentArg.getType())) {
  77                 currentQName = BindingReflections.findQName(currentArg.getType());
  78             } else {
  79                 currentQName = BindingReflections.findQName(currentArg.getType()).withModule(currentQName.getModule());
  80             }
  81             Optional<DataNodeContainer> potential = findDataNodeContainer(currentContainer.get(), currentQName);
  82             if (potential.isPresent()) {
  83                 currentContainer = potential;
  84             } else {
  85                 return Optional.empty();
  86             }
  87         }
  88         return currentContainer;
  89     }
  90
  91     private static Optional<DataNodeContainer> findDataNodeContainer(final DataNodeContainer ctx,
  92             final QName targetQName) {
  93
  94         for (DataSchemaNode child : ctx.getChildNodes()) {
  95             if (child instanceof ChoiceSchemaNode) {
  96                 DataNodeContainer potential = findInCases((ChoiceSchemaNode) child, targetQName);
  97                 if (potential != null) {
  98                     return Optional.of(potential);
  99                 }
 100             } else if (child instanceof DataNodeContainer && child.getQName().equals(targetQName)) {
 101                 return Optional.of((DataNodeContainer) child);
 102             } else if (child instanceof DataNodeContainer && child.isAddedByUses()
 103                     && child.getQName().getLocalName().equals(targetQName.getLocalName())) {
 104                 return Optional.of((DataNodeContainer) child);
 105             }
 106
 107         }
 108         return Optional.empty();
 109     }
 110
 111     private static Optional<DataNodeContainer> findNotification(final SchemaContext ctx,
 112             final QName notificationQName) {
 113         for (NotificationDefinition notification : ctx.getNotifications()) {
 114             if (notification.getQName().equals(notificationQName)) {
 115                 return Optional.of(notification);
 116             }
 117         }
 118         return Optional.empty();
 119     }
 120
 121     private static DataNodeContainer findInCases(final ChoiceSchemaNode choiceNode, final QName targetQName) {
 122         for (CaseSchemaNode caze : choiceNode.getCases().values()) {
 123             Optional<DataNodeContainer> potential = findDataNodeContainer(caze, targetQName);
 124             if (potential.isPresent()) {
 125                 return potential.get();
 126             }
 127         }
 128         return null;
 129     }
 130
 131     @SuppressWarnings("checkstyle:illegalCatch")
 132     private static Optional<DataNodeContainer> findFirstDataNodeContainerInRpc(final SchemaContext ctx,
 133             final Class<? extends DataObject> targetType) {
 134         final QNameModule targetModule;
 135         try {
 136             targetModule = BindingReflections.getModuleInfo(targetType).getName().getModule();
 137         } catch (Exception e) {
 138             throw new IllegalArgumentException(
 139                     String.format("Failed to load module information for class %s", targetType), e);
 140         }
 141
 142         for (RpcDefinition rpc : ctx.getOperations()) {
 143             if (targetModule.equals(rpc.getQName().getModule())) {
 144                 final Optional<DataNodeContainer> potential = findInputOutput(rpc,targetType.getSimpleName());
 145                 if (potential.isPresent()) {
 146                     return potential;
 147                 }
 148             }
 149         }
 150         return Optional.empty();
 151     }
 152
 153     private static Optional<DataNodeContainer> findInputOutput(final RpcDefinition rpc, final String targetType) {
 154         final String rpcName = BindingMapping.getClassName(rpc.getQName());
 155         final String rpcInputName = rpcName + BindingMapping.RPC_INPUT_SUFFIX;
 156         if (targetType.equals(rpcInputName)) {
 157             return Optional.of(rpc.getInput());
 158         }
 159         final String rpcOutputName = rpcName + BindingMapping.RPC_OUTPUT_SUFFIX;
 160         if (targetType.equals(rpcOutputName)) {
 161             return Optional.of(rpc.getOutput());
 162         }
 163         return Optional.empty();
 164     }
 165
 166     public static Set<AugmentationSchemaNode> collectAllAugmentationDefinitions(final SchemaContext currentSchema,
 167             final AugmentationTarget ctxNode) {
 168         HashSet<AugmentationSchemaNode> augmentations = new HashSet<>();
 169         augmentations.addAll(ctxNode.getAvailableAugmentations());
 170         if (ctxNode instanceof DataSchemaNode && ((DataSchemaNode) ctxNode).isAddedByUses()) {
 171             LOG.info("DataSchemaNode target added by uses {}", ctxNode);
 172         }
 173
 174         return augmentations;
 175     }
 176
 177     public static Optional<ChoiceSchemaNode> findInstantiatedChoice(final DataNodeContainer parent,
 178             final Class<?> choiceClass) {
 179         return findInstantiatedChoice(parent, BindingReflections.findQName(choiceClass));
 180     }
 181
 182     public static Optional<ChoiceSchemaNode> findInstantiatedChoice(final DataNodeContainer ctxNode,
 183             final QName choiceName) {
 184         DataSchemaNode potential = ctxNode.getDataChildByName(choiceName);
 185         if (potential instanceof ChoiceSchemaNode) {
 186             return Optional.of((ChoiceSchemaNode) potential);
 187         }
 188
 189         return Optional.empty();
 190     }
 191
 192     public static Optional<CaseSchemaNode> findInstantiatedCase(final ChoiceSchemaNode instantiatedChoice,
 193             final CaseSchemaNode originalDefinition) {
 194         CaseSchemaNode potential = instantiatedChoice.getCaseNodeByName(originalDefinition.getQName());
 195         if (originalDefinition.equals(potential)) {
 196             return Optional.of(potential);
 197         }
 198         if (potential != null) {
 199             SchemaNode potentialRoot = SchemaNodeUtils.getRootOriginalIfPossible(potential);
 200             if (originalDefinition.equals(potentialRoot)) {
 201                 return Optional.of(potential);
 202             }
 203         }
 204
 205         // We try to find case by name, then lookup its root definition
 206         // and compare it with original definition
 207         // This solves case, if choice was inside grouping
 208         // which was used in different module and thus namespaces are
 209         // different, but local names are still same.
 210         //
 211         // Still we need to check equality of definition, because local name is not
 212         // sufficient to uniquelly determine equality of cases
 213         //
 214         for (CaseSchemaNode caze : instantiatedChoice.findCaseNodes(originalDefinition.getQName().getLocalName())) {
 215             if (originalDefinition.equals(SchemaNodeUtils.getRootOriginalIfPossible(caze))) {
 216                 return Optional.of(caze);
 217             }
 218         }
 219         return Optional.empty();
 220     }
 221
 222 }