yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/UnknownEffectiveStatementImpl.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
   9 package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
  10
  11 import java.util.ArrayList;
  12 import java.util.List;
  13 import java.util.Objects;
  14 import org.opendaylight.yangtools.yang.common.QName;
  15 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
  16 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  17 import org.opendaylight.yangtools.yang.model.api.Status;
  18 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  19 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  20 import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
  21 import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
  22 import org.opendaylight.yangtools.yang.parser.spi.ExtensionNamespace;
  23 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  24 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.TypeOfCopy;
  25 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
  26
  27 public class UnknownEffectiveStatementImpl extends EffectiveStatementBase<QName, UnknownStatement<QName>> implements
  28         UnknownSchemaNode {
  29
  30     private boolean augmenting;
  31     private boolean addedByUses;
  32     private UnknownSchemaNode original;
  33
  34     private final QName qName;
  35     private final SchemaPath path;
  36     private ExtensionDefinition extension;
  37     private String description;
  38     private String reference;
  39     private Status status = Status.CURRENT;
  40     private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
  41     private QName nodeType;
  42     private String nodeParameter;
  43
  44     public UnknownEffectiveStatementImpl(final StmtContext<QName, UnknownStatement<QName>, ?> ctx) {
  45         super(ctx);
  46
  47         final StmtContext<?, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> extensionInit = ctx
  48                 .getAllFromNamespace(ExtensionNamespace.class).get(ctx.getPublicDefinition().getStatementName());
  49
  50         if (extensionInit == null) {
  51             extension = null;
  52             nodeType = ctx.getPublicDefinition().getArgumentName();
  53         } else {
  54             extension = (ExtensionEffectiveStatementImpl) extensionInit.buildEffective();
  55             nodeType = extension.getQName();
  56         }
  57
  58         qName = ctx.getStatementArgument();
  59         path = Utils.getSchemaPath(ctx);
  60
  61         nodeParameter = (ctx.rawStatementArgument() == null) ? "" : ctx.rawStatementArgument();
  62
  63         // TODO init other fields (see Bug1412Test)
  64
  65         for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
  66             if (effectiveStatement instanceof DescriptionEffectiveStatementImpl) {
  67                 description = ((DescriptionEffectiveStatementImpl) effectiveStatement).argument();
  68             }
  69             if (effectiveStatement instanceof ReferenceEffectiveStatementImpl) {
  70                 reference = ((ReferenceEffectiveStatementImpl) effectiveStatement).argument();
  71             }
  72             if (effectiveStatement instanceof UnknownEffectiveStatementImpl) {
  73                 unknownNodes.add((UnknownEffectiveStatementImpl) effectiveStatement);
  74             }
  75         }
  76
  77         initCopyType(ctx);
  78     }
  79
  80     private void initCopyType(final StmtContext<QName, UnknownStatement<QName>, ?> ctx) {
  81
  82         List<TypeOfCopy> copyTypesFromOriginal = ctx.getCopyHistory();
  83
  84         if (copyTypesFromOriginal.contains(TypeOfCopy.ADDED_BY_AUGMENTATION)) {
  85             augmenting = true;
  86         }
  87         if (copyTypesFromOriginal.contains(TypeOfCopy.ADDED_BY_USES)) {
  88             addedByUses = true;
  89         }
  90         if (copyTypesFromOriginal.contains(TypeOfCopy.ADDED_BY_USES_AUGMENTATION)) {
  91             addedByUses = augmenting = true;
  92         }
  93
  94         if (ctx.getOriginalCtx() != null) {
  95             original = (UnknownSchemaNode) ctx.getOriginalCtx().buildEffective();
  96         }
  97     }
  98
  99     @Override
 100     public QName getNodeType() {
 101         return nodeType;
 102     }
 103
 104     @Override
 105     public String getNodeParameter() {
 106         return nodeParameter;
 107     }
 108
 109     @Override
 110     public boolean isAddedByUses() {
 111         return addedByUses;
 112     }
 113
 114     @Override
 115     public ExtensionDefinition getExtensionDefinition() {
 116         return extension;
 117     }
 118
 119     @Override
 120     public QName getQName() {
 121         return qName;
 122     }
 123
 124     @Override
 125     public SchemaPath getPath() {
 126         return path;
 127     }
 128
 129     @Override
 130     public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 131         return unknownNodes;
 132     }
 133
 134     @Override
 135     public String getDescription() {
 136         return description;
 137     }
 138
 139     @Override
 140     public String getReference() {
 141         return reference;
 142     }
 143
 144     @Override
 145     public Status getStatus() {
 146         return status;
 147     }
 148
 149     @Override
 150     public int hashCode() {
 151         final int prime = 31;
 152         int result = 1;
 153         result = prime * result + Objects.hashCode(qName);
 154         result = prime * result + Objects.hashCode(path);
 155         result = prime * result + Objects.hashCode(nodeType);
 156         result = prime * result + Objects.hashCode(nodeParameter);
 157         return result;
 158     }
 159
 160     @Override
 161     public boolean equals(final Object obj) {
 162         if (this == obj) {
 163             return true;
 164         }
 165         if (obj == null) {
 166             return false;
 167         }
 168         if (getClass() != obj.getClass()) {
 169             return false;
 170         }
 171         UnknownEffectiveStatementImpl other = (UnknownEffectiveStatementImpl) obj;
 172         if (qName == null) {
 173             if (other.qName != null) {
 174                 return false;
 175             }
 176         } else if (!qName.equals(other.qName)) {
 177             return false;
 178         }
 179         if (path == null) {
 180             if (other.path != null) {
 181                 return false;
 182             }
 183         } else if (!path.equals(other.path)) {
 184             return false;
 185         }
 186         if (nodeType == null) {
 187             if (other.nodeType != null) {
 188                 return false;
 189             }
 190         } else if (!nodeType.equals(other.nodeType)) {
 191             return false;
 192         }
 193         if (nodeParameter == null) {
 194             if (other.nodeParameter != null) {
 195                 return false;
 196             }
 197         } else if (!nodeParameter.equals(other.nodeParameter)) {
 198             return false;
 199         }
 200         return true;
 201     }
 202
 203     @Override
 204     public String toString() {
 205         StringBuilder sb = new StringBuilder();
 206         sb.append(nodeType.getNamespace());
 207         sb.append(":");
 208         sb.append(nodeType.getLocalName());
 209         sb.append(" ");
 210         sb.append(nodeParameter);
 211         return sb.toString();
 212     }
 213 }