yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/choice/ImplicitChoiceCaseNode.java

   1 /*
   2  * Copyright (c) 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.yangtools.yang.parser.rfc7950.stmt.choice;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.collect.ImmutableList;
  13 import com.google.common.collect.ImmutableSet;
  14 import java.util.Collection;
  15 import java.util.List;
  16 import java.util.Objects;
  17 import java.util.Optional;
  18 import java.util.Set;
  19 import javax.annotation.Nonnull;
  20 import org.opendaylight.yangtools.yang.common.QName;
  21 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
  22 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  23 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  24 import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
  25 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  26 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
  27 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  28 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  29 import org.opendaylight.yangtools.yang.model.api.Status;
  30 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  31 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  32 import org.opendaylight.yangtools.yang.model.api.UsesNode;
  33
  34 // FIXME: hide this somewhere
  35 public final class ImplicitChoiceCaseNode implements ChoiceCaseNode, DerivableSchemaNode {
  36
  37     private final DataSchemaNode caseShorthandNode;
  38     private final ChoiceCaseNode original;
  39     private final SchemaPath path;
  40     private final boolean augmenting;
  41
  42     public ImplicitChoiceCaseNode(final DataSchemaNode caseShorthandNode) {
  43         this.caseShorthandNode = requireNonNull(caseShorthandNode);
  44         this.path = requireNonNull(caseShorthandNode.getPath().getParent());
  45         this.original = getOriginalIfPresent(caseShorthandNode);
  46
  47         // We need to cache this, as it will be reset
  48         this.augmenting = caseShorthandNode.isAugmenting();
  49     }
  50
  51     @Override
  52     public boolean isAugmenting() {
  53         return augmenting;
  54     }
  55
  56     @Override
  57     public boolean isAddedByUses() {
  58         return caseShorthandNode.isAddedByUses();
  59     }
  60
  61     @Override
  62     public boolean isConfiguration() {
  63         return caseShorthandNode.isConfiguration();
  64     }
  65
  66     @Nonnull
  67     @Override
  68     public QName getQName() {
  69         return caseShorthandNode.getQName();
  70     }
  71
  72     @Nonnull
  73     @Override
  74     public SchemaPath getPath() {
  75         return path;
  76     }
  77
  78     @Nonnull
  79     @Override
  80     public List<UnknownSchemaNode> getUnknownSchemaNodes() {
  81         return ImmutableList.of();
  82     }
  83
  84     @Override
  85     public Optional<String> getDescription() {
  86         return caseShorthandNode.getDescription();
  87     }
  88
  89     @Override
  90     public Optional<String> getReference() {
  91         return caseShorthandNode.getReference();
  92     }
  93
  94     @Nonnull
  95     @Override
  96     public Status getStatus() {
  97         return caseShorthandNode.getStatus();
  98     }
  99
 100     @Override
 101     public Set<TypeDefinition<?>> getTypeDefinitions() {
 102         return ImmutableSet.of();
 103     }
 104
 105     @Override
 106     public Collection<DataSchemaNode> getChildNodes() {
 107         return ImmutableList.of(caseShorthandNode);
 108     }
 109
 110     @Override
 111     public Set<GroupingDefinition> getGroupings() {
 112         return ImmutableSet.of();
 113     }
 114
 115     @Override
 116     public Optional<DataSchemaNode> findDataChildByName(final QName name) {
 117         return name.equals(getQName()) ? Optional.of(caseShorthandNode) : Optional.empty();
 118     }
 119
 120     @Override
 121     public Set<UsesNode> getUses() {
 122         return ImmutableSet.of();
 123     }
 124
 125     @Override
 126     public Set<AugmentationSchemaNode> getAvailableAugmentations() {
 127         return ImmutableSet.of();
 128     }
 129
 130     @Override
 131     public Optional<? extends SchemaNode> getOriginal() {
 132         return Optional.ofNullable(original);
 133     }
 134
 135     @Override
 136     public Optional<RevisionAwareXPath> getWhenCondition() {
 137         return caseShorthandNode.getWhenCondition();
 138     }
 139
 140     @Override
 141     public int hashCode() {
 142         final int prime = 31;
 143         int result = 1;
 144         result = prime * result + Objects.hashCode(getQName());
 145         result = prime * result + Objects.hashCode(path);
 146         return result;
 147     }
 148
 149     @Override
 150     public boolean equals(final Object obj) {
 151         if (this == obj) {
 152             return true;
 153         }
 154         if (obj == null) {
 155             return false;
 156         }
 157         if (getClass() != obj.getClass()) {
 158             return false;
 159         }
 160         ImplicitChoiceCaseNode other = (ImplicitChoiceCaseNode) obj;
 161         return Objects.equals(getQName(), other.getQName()) && Objects.equals(path, other.path);
 162     }
 163
 164     @Override
 165     public String toString() {
 166         return ImplicitChoiceCaseNode.class.getSimpleName() + "[" + "qname=" + getQName() + "]";
 167     }
 168
 169     private static ChoiceCaseNode getOriginalIfPresent(final SchemaNode caseShorthandNode) {
 170         if (caseShorthandNode instanceof DerivableSchemaNode) {
 171             final Optional<? extends SchemaNode> original = ((DerivableSchemaNode) caseShorthandNode).getOriginal();
 172             if (original.isPresent()) {
 173                 return new ImplicitChoiceCaseNode((DataSchemaNode) original.get());
 174             }
 175         }
 176         return null;
 177     }
 178 }