yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ListEffectiveStatementImpl.java

   1 package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
   2
   3 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.TypeOfCopy;
   4
   5 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
   6 import java.util.Collection;
   7 import java.util.HashSet;
   8 import java.util.LinkedList;
   9 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
  10 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  11 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  12 import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
  13 import com.google.common.base.Optional;
  14 import com.google.common.collect.ImmutableList;
  15 import com.google.common.collect.ImmutableSet;
  16 import java.util.List;
  17 import java.util.Set;
  18 import org.opendaylight.yangtools.yang.common.QName;
  19 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  20 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
  21 import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
  22 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  23 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  24 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  25
  26 public class ListEffectiveStatementImpl extends
  27         AbstractEffectiveDocumentedDataNodeContainer<QName, ListStatement>
  28         implements ListSchemaNode, DerivableSchemaNode {
  29     private final QName qname;
  30     private final SchemaPath path;
  31
  32     boolean augmenting;
  33     boolean addedByUses;
  34     ListSchemaNode original;
  35     boolean configuration;
  36     ConstraintDefinition constraints;
  37     boolean userOrdered;
  38
  39     ImmutableList<QName> keyDefinition;
  40     ImmutableSet<AugmentationSchema> augmentations;
  41     ImmutableList<UnknownSchemaNode> unknownNodes;
  42
  43     public ListEffectiveStatementImpl(
  44             StmtContext<QName, ListStatement, EffectiveStatement<QName, ListStatement>> ctx) {
  45         super(ctx);
  46         this.qname = ctx.getStatementArgument();
  47         this.path = Utils.getSchemaPath(ctx);
  48         // :TODO init other fields
  49
  50         initKeyDefinition();
  51         initSubstatementCollections();
  52         initCopyType(ctx);
  53     }
  54
  55     private void initCopyType(
  56             StmtContext<QName, ListStatement, EffectiveStatement<QName, ListStatement>> ctx) {
  57
  58         TypeOfCopy typeOfCopy = ctx.getTypeOfCopy();
  59         switch (typeOfCopy) {
  60         case ADDED_BY_AUGMENTATION:
  61             augmenting = true;
  62             original = (ListSchemaNode) ctx.getOriginalCtx().buildEffective();
  63             break;
  64         case ADDED_BY_USES:
  65             addedByUses = true;
  66             original = (ListSchemaNode) ctx.getOriginalCtx().buildEffective();
  67             break;
  68         default:
  69             break;
  70         }
  71     }
  72
  73     /**
  74      *
  75      */
  76     private void initKeyDefinition() {
  77         List<QName> keyDefinitionInit = new LinkedList<QName>();
  78         KeyEffectiveStatementImpl key = firstEffective(KeyEffectiveStatementImpl.class);
  79
  80         if (key != null) {
  81             Collection<SchemaNodeIdentifier> keyParts = key.argument();
  82             for (SchemaNodeIdentifier keyPart : keyParts) {
  83                 keyDefinitionInit.add(keyPart.getLastComponent());
  84             }
  85         }
  86
  87         this.keyDefinition = ImmutableList.copyOf(keyDefinitionInit);
  88     }
  89
  90     private void initSubstatementCollections() {
  91         Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements = effectiveSubstatements();
  92
  93         List<UnknownSchemaNode> unknownNodesInit = new LinkedList<UnknownSchemaNode>();
  94         Set<AugmentationSchema> augmentationsInit = new HashSet<AugmentationSchema>();
  95
  96         for (EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements) {
  97             if (effectiveStatement instanceof UnknownSchemaNode) {
  98                 UnknownSchemaNode unknownNode = (UnknownSchemaNode) effectiveStatement;
  99                 unknownNodesInit.add(unknownNode);
 100             }
 101             if (effectiveStatement instanceof AugmentationSchema) {
 102                 AugmentationSchema augmentationSchema = (AugmentationSchema) effectiveStatement;
 103                 augmentationsInit.add(augmentationSchema);
 104             }
 105         }
 106
 107         this.unknownNodes = ImmutableList.copyOf(unknownNodesInit);
 108         this.augmentations = ImmutableSet.copyOf(augmentationsInit);
 109     }
 110
 111     @Override
 112     public QName getQName() {
 113         return qname;
 114     }
 115
 116     @Override
 117     public SchemaPath getPath() {
 118         return path;
 119     }
 120
 121     @Override
 122     public List<QName> getKeyDefinition() {
 123         return keyDefinition;
 124     }
 125
 126     @Override
 127     public boolean isAugmenting() {
 128         return augmenting;
 129     }
 130
 131     @Override
 132     public boolean isAddedByUses() {
 133         return addedByUses;
 134     }
 135
 136     @Override
 137     public Optional<ListSchemaNode> getOriginal() {
 138         return Optional.fromNullable(original);
 139     }
 140
 141     @Override
 142     public boolean isConfiguration() {
 143         return configuration;
 144     }
 145
 146     @Override
 147     public ConstraintDefinition getConstraints() {
 148         return constraints;
 149     }
 150
 151     @Override
 152     public Set<AugmentationSchema> getAvailableAugmentations() {
 153         return augmentations;
 154     }
 155
 156     @Override
 157     public boolean isUserOrdered() {
 158         return userOrdered;
 159     }
 160
 161     @Override
 162     public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 163         return unknownNodes;
 164     }
 165
 166     @Override
 167     public int hashCode() {
 168         final int prime = 31;
 169         int result = 1;
 170         result = prime * result + ((qname == null) ? 0 : qname.hashCode());
 171         result = prime * result + ((path == null) ? 0 : path.hashCode());
 172         return result;
 173     }
 174
 175     @Override
 176     public boolean equals(final Object obj) {
 177         if (this == obj) {
 178             return true;
 179         }
 180         if (obj == null) {
 181             return false;
 182         }
 183         if (getClass() != obj.getClass()) {
 184             return false;
 185         }
 186         final ListEffectiveStatementImpl other = (ListEffectiveStatementImpl) obj;
 187         if (qname == null) {
 188             if (other.qname != null) {
 189                 return false;
 190             }
 191         } else if (!qname.equals(other.qname)) {
 192             return false;
 193         }
 194         if (path == null) {
 195             if (other.path != null) {
 196                 return false;
 197             }
 198         } else if (!path.equals(other.path)) {
 199             return false;
 200         }
 201         return true;
 202     }
 203
 204     @Override
 205     public String toString() {
 206         return "list " + qname.getLocalName();
 207     }
 208 }