yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/ContainerSchemaNodes.java

   1 /*
   2  * Copyright (c) 2016 ZTE, 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.yangtools.yang.data.util;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.annotations.Beta;
  13 import com.google.common.collect.ImmutableList;
  14 import com.google.common.collect.ImmutableMap;
  15 import com.google.common.collect.ImmutableSet;
  16 import com.google.common.collect.Maps;
  17 import java.util.Collection;
  18 import java.util.Optional;
  19 import java.util.Set;
  20 import org.opendaylight.yangtools.yang.common.QName;
  21 import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
  22 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
  23 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  24 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  25 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  26 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
  27 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  28 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
  29 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  30 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  31 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  32 import org.opendaylight.yangtools.yang.model.api.Status;
  33 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  34 import org.opendaylight.yangtools.yang.model.api.UsesNode;
  35
  36 /**
  37  * yang-data-util
  38  * org.opendaylight.yangtools.yang.data.util
  39  * Utility class for taking notification or rpc as ContainerSchemaNode.
  40  * @author <a href="mailto:geng.xingyuan@zte.com.cn">Geng Xingyuan</a>
  41  */
  42 public final class ContainerSchemaNodes {
  43
  44     private ContainerSchemaNodes() {
  45     }
  46
  47     @Beta
  48     public static ContainerSchemaNode forNotification(final NotificationDefinition notification) {
  49         return new NotificationContainerSchemaNode(notification);
  50     }
  51
  52     @Beta
  53     public static ContainerSchemaNode forRPC(final RpcDefinition rpc) {
  54         return new RpcContainerSchemaNode(rpc);
  55     }
  56
  57     private abstract static class AbstractContainerSchemaNode implements ContainerSchemaNode {
  58
  59         private final SchemaNode schemaNode;
  60
  61         private AbstractContainerSchemaNode(final SchemaNode schemaNode) {
  62             this.schemaNode = schemaNode;
  63         }
  64
  65         @Override
  66         public boolean isPresenceContainer() {
  67             return false;
  68         }
  69
  70         @Override
  71         public Set<UsesNode> getUses() {
  72             return ImmutableSet.of();
  73         }
  74
  75         @Override
  76         public boolean isAugmenting() {
  77             return false;
  78         }
  79
  80         @Override
  81         public boolean isConfiguration() {
  82             return false;
  83         }
  84
  85         @Override
  86         public QName getQName() {
  87             return schemaNode.getQName();
  88         }
  89
  90         @Override
  91         public SchemaPath getPath() {
  92             return schemaNode.getPath();
  93         }
  94
  95         @Override
  96         public Optional<String> getDescription() {
  97             return schemaNode.getDescription();
  98         }
  99
 100         @Override
 101         public Optional<String> getReference() {
 102             return schemaNode.getReference();
 103         }
 104
 105         @Override
 106         public Status getStatus() {
 107             return schemaNode.getStatus();
 108         }
 109
 110         @Override
 111         public Collection<MustDefinition> getMustConstraints() {
 112             return ImmutableList.of();
 113         }
 114
 115         @Override
 116         public Optional<RevisionAwareXPath> getWhenCondition() {
 117             return Optional.empty();
 118         }
 119     }
 120
 121     private static final class RpcContainerSchemaNode extends AbstractContainerSchemaNode {
 122
 123         private final RpcDefinition rpcDefinition;
 124
 125         private RpcContainerSchemaNode(final RpcDefinition rpcDefinition) {
 126             super(rpcDefinition);
 127             this.rpcDefinition = rpcDefinition;
 128         }
 129
 130         @Override
 131         public Set<GroupingDefinition> getGroupings() {
 132             return rpcDefinition.getGroupings();
 133         }
 134
 135         @Override
 136         public Set<TypeDefinition<?>> getTypeDefinitions() {
 137             return rpcDefinition.getTypeDefinitions();
 138         }
 139
 140         @Override
 141         public Set<AugmentationSchemaNode> getAvailableAugmentations() {
 142             return ImmutableSet.of();
 143         }
 144
 145         @Override
 146         public Collection<DataSchemaNode> getChildNodes() {
 147             final ContainerSchemaNode input = rpcDefinition.getInput();
 148             final ContainerSchemaNode output = rpcDefinition.getOutput();
 149             if (input == null && output == null) {
 150                 return ImmutableList.of();
 151             } else if (input != null && output != null) {
 152                 return ImmutableList.of(input,output);
 153             } else if (input != null) {
 154                 return ImmutableList.of(input);
 155             } else {
 156                 return ImmutableList.of(output);
 157             }
 158         }
 159
 160         @Override
 161         public Optional<DataSchemaNode> findDataChildByName(final QName name) {
 162             switch (name.getLocalName()) {
 163                 case "input":
 164                     return Optional.of(rpcDefinition.getInput());
 165                 case "output":
 166                     return Optional.of(rpcDefinition.getOutput());
 167                 default:
 168                     return Optional.empty();
 169             }
 170         }
 171
 172         @Deprecated
 173         @Override
 174         public boolean isAddedByUses() {
 175             return false;
 176         }
 177
 178         @Override
 179         public Set<ActionDefinition> getActions() {
 180             return ImmutableSet.of();
 181         }
 182
 183         @Override
 184         public Set<NotificationDefinition> getNotifications() {
 185             return ImmutableSet.of();
 186         }
 187     }
 188
 189     private static final class NotificationContainerSchemaNode extends AbstractContainerSchemaNode {
 190
 191         private final NotificationDefinition notification;
 192         private final ImmutableMap<QName, DataSchemaNode> mapNodes;
 193
 194         private NotificationContainerSchemaNode(final NotificationDefinition notification) {
 195             super(notification);
 196             this.notification = notification;
 197             mapNodes = Maps.uniqueIndex(notification.getChildNodes(), DataSchemaNode::getQName);
 198         }
 199
 200         @Override
 201         public Set<NotificationDefinition> getNotifications() {
 202             return ImmutableSet.of(notification);
 203         }
 204
 205         @Override
 206         public Set<AugmentationSchemaNode> getAvailableAugmentations() {
 207             return notification.getAvailableAugmentations();
 208         }
 209
 210         @Override
 211         public Set<TypeDefinition<?>> getTypeDefinitions() {
 212             return notification.getTypeDefinitions();
 213         }
 214
 215         @Override
 216         public Collection<DataSchemaNode> getChildNodes() {
 217             return notification.getChildNodes();
 218         }
 219
 220         @Override
 221         public Set<GroupingDefinition> getGroupings() {
 222             return notification.getGroupings();
 223         }
 224
 225         @Override
 226         public Optional<DataSchemaNode> findDataChildByName(final QName name) {
 227             return Optional.ofNullable(mapNodes.get(requireNonNull(name)));
 228         }
 229
 230         @Override
 231         @Deprecated
 232         public boolean isAddedByUses() {
 233             //FIXME: reference to https://bugs.opendaylight.org/show_bug.cgi?id=6897
 234             return false;
 235         }
 236
 237         @Override
 238         public Set<ActionDefinition> getActions() {
 239             return ImmutableSet.of();
 240         }
 241     }
 242 }