--- /dev/null
+/*
+ * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.yangtools.sal.binding.generator.impl;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+import org.opendaylight.yangtools.yang.binding.Augmentation;
+import org.opendaylight.yangtools.yang.binding.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.ChildOf;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
+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.model.api.AugmentationSchema;
+import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
+import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
+import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
+import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
+
+public final class BindingSchemaContextUtils {
+
+ private BindingSchemaContextUtils() {
+ throw new UnsupportedOperationException("Utility class should not be instantiated");
+ }
+
+ // FIXME: THis method does not search in case augmentations.
+ public static Optional<DataNodeContainer> findDataNodeContainer(final SchemaContext ctx,
+ final InstanceIdentifier<?> path) {
+ Iterator<PathArgument> pathArguments = path.getPathArguments().iterator();
+ PathArgument currentArg = pathArguments.next();
+ Preconditions.checkArgument(currentArg != null);
+ QName currentQName = BindingReflections.findQName(currentArg.getType());
+
+ Optional<DataNodeContainer> currentContainer = Optional.absent();
+ if (BindingReflections.isNotification(currentArg.getType())) {
+ currentContainer = findNotification(ctx, currentQName);
+ } else if (BindingReflections.isRpcType(currentArg.getType())) {
+ currentContainer = findFirstDataNodeContainerInRpc(ctx, currentArg.getType());
+ if(currentQName == null && currentContainer.isPresent()) {
+ currentQName = ((DataSchemaNode) currentContainer.get()).getQName();
+ }
+ } else {
+ currentContainer = findDataNodeContainer(ctx, currentQName);
+ }
+
+ while (currentContainer.isPresent() && pathArguments.hasNext()) {
+ currentArg = pathArguments.next();
+ if (Augmentation.class.isAssignableFrom(currentArg.getType())) {
+ currentQName = BindingReflections.findQName(currentArg.getType());
+ if(pathArguments.hasNext()) {
+ currentArg = pathArguments.next();
+ } else {
+ return currentContainer;
+ }
+ }
+ if(ChildOf.class.isAssignableFrom(currentArg.getType()) && BindingReflections.isAugmentationChild(currentArg.getType())) {
+ currentQName = BindingReflections.findQName(currentArg.getType());
+ } else {
+ currentQName = QName.create(currentQName, BindingReflections.findQName(currentArg.getType()).getLocalName());
+ }
+ Optional<DataNodeContainer> potential = findDataNodeContainer(currentContainer.get(), currentQName);
+ if (potential.isPresent()) {
+ currentContainer = potential;
+ } else {
+ return Optional.absent();
+ }
+ }
+ return currentContainer;
+ }
+
+ private static Optional<DataNodeContainer> findNotification(final SchemaContext ctx, final QName notificationQName) {
+ for (NotificationDefinition notification : ctx.getNotifications()) {
+ if (notification.getQName().equals(notificationQName)) {
+ return Optional.<DataNodeContainer> of(notification);
+ }
+ }
+ return Optional.absent();
+ }
+
+ private static Optional<DataNodeContainer> findDataNodeContainer(final DataNodeContainer ctx,
+ final QName targetQName) {
+
+ for (DataSchemaNode child : ctx.getChildNodes()) {
+ if (child instanceof ChoiceSchemaNode) {
+ DataNodeContainer potential = findInCases(((ChoiceSchemaNode) child), targetQName);
+ if (potential != null) {
+ return Optional.of(potential);
+ }
+ } else if (child instanceof DataNodeContainer && child.getQName().equals(targetQName)) {
+ return Optional.of((DataNodeContainer) child);
+ } else if (child instanceof DataNodeContainer //
+ && child.isAddedByUses() //
+ && child.getQName().getLocalName().equals(targetQName.getLocalName())) {
+ return Optional.of((DataNodeContainer) child);
+ }
+
+ }
+ return Optional.absent();
+ }
+
+ private static DataNodeContainer findInCases(final ChoiceSchemaNode choiceNode, final QName targetQName) {
+ for (ChoiceCaseNode caze : choiceNode.getCases()) {
+ Optional<DataNodeContainer> potential = findDataNodeContainer(caze, targetQName);
+ if (potential.isPresent()) {
+ return potential.get();
+ }
+ }
+ return null;
+ }
+
+ private static Optional<DataNodeContainer> findFirstDataNodeContainerInRpc(final SchemaContext ctx,
+ final Class<? extends DataObject> targetType) {
+ final YangModuleInfo moduleInfo;
+ try {
+ moduleInfo = BindingReflections.getModuleInfo(targetType);
+ } catch (Exception e) {
+ throw new IllegalArgumentException(
+ String.format("Failed to load module information for class %s", targetType), e);
+ }
+
+ for(RpcDefinition rpc : ctx.getOperations()) {
+ String rpcNamespace = rpc.getQName().getNamespace().toString();
+ String rpcRevision = rpc.getQName().getFormattedRevision();
+ if(moduleInfo.getNamespace().equals(rpcNamespace) && moduleInfo.getRevision().equals(rpcRevision)) {
+ Optional<DataNodeContainer> potential = findInputOutput(rpc,targetType.getSimpleName());
+ if(potential.isPresent()) {
+ return potential;
+ }
+ }
+ }
+ return Optional.absent();
+ }
+
+ private static Optional<DataNodeContainer> findInputOutput(final RpcDefinition rpc, final String targetType) {
+ String rpcName = BindingMapping.getClassName(rpc.getQName());
+ String rpcInputName = rpcName + BindingMapping.RPC_INPUT_SUFFIX;
+ String rpcOutputName = rpcName + BindingMapping.RPC_OUTPUT_SUFFIX;
+ if(targetType.equals(rpcInputName)) {
+ return Optional.<DataNodeContainer>of(rpc.getInput());
+ } else if (targetType.equals(rpcOutputName)) {
+ return Optional.<DataNodeContainer>of(rpc.getOutput());
+ }
+ return Optional.absent();
+ }
+
+ public static Set<AugmentationSchema> collectAllAugmentationDefinitions(final SchemaContext currentSchema, final AugmentationTarget ctxNode) {
+ HashSet<AugmentationSchema> augmentations = new HashSet<>();
+ augmentations.addAll(ctxNode.getAvailableAugmentations());
+ if(ctxNode instanceof DataSchemaNode && ((DataSchemaNode) ctxNode).isAddedByUses()) {
+
+ System.out.println(ctxNode);
+
+ }
+
+ // TODO Auto-generated method stub
+ return augmentations;
+ }
+
+ public static Optional<ChoiceSchemaNode> findInstantiatedChoice(final DataNodeContainer parent, final Class<?> choiceClass) {
+ return findInstantiatedChoice(parent, BindingReflections.findQName(choiceClass));
+ }
+
+ public static Optional<ChoiceSchemaNode> findInstantiatedChoice(final DataNodeContainer ctxNode, final QName choiceName) {
+ DataSchemaNode potential = ctxNode.getDataChildByName(choiceName);
+ if (potential == null) {
+ potential = ctxNode.getDataChildByName(choiceName.getLocalName());
+ }
+
+ if (potential instanceof ChoiceSchemaNode) {
+ return Optional.of((ChoiceSchemaNode) potential);
+ }
+
+ return Optional.absent();
+ }
+
+ public static Optional<ChoiceCaseNode> findInstantiatedCase(final ChoiceSchemaNode instantiatedChoice, final ChoiceCaseNode originalDefinition) {
+ ChoiceCaseNode potential = instantiatedChoice.getCaseNodeByName(originalDefinition.getQName());
+ if(originalDefinition.equals(potential)) {
+ return Optional.of(potential);
+ }
+ if (potential != null) {
+ SchemaNode potentialRoot = SchemaNodeUtils.getRootOriginalIfPossible(potential);
+ if (originalDefinition.equals(potentialRoot)) {
+ return Optional.of(potential);
+ }
+ }
+ // We try to find case by name, then lookup its root definition
+ // and compare it with original definition
+ // This solves case, if choice was inside grouping
+ // which was used in different module and thus namespaces are
+ // different, but local names are still same.
+ //
+ // Still we need to check equality of definition, because local name is not
+ // sufficient to uniquelly determine equality of cases
+ //
+ potential = instantiatedChoice.getCaseNodeByName(originalDefinition.getQName().getLocalName());
+ if(potential != null && (originalDefinition.equals(SchemaNodeUtils.getRootOriginalIfPossible(potential)))) {
+ return Optional.of(potential);
+ }
+ return Optional.absent();
+ }
+
+}
Code Review / mdsal.git / blobdiff