yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ExtensionEffectiveStatementImpl.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.stmt.rfc6020.effective;
   9
  10 import com.google.common.collect.ImmutableList;
  11 import java.util.ArrayDeque;
  12 import java.util.ArrayList;
  13 import java.util.Collection;
  14 import java.util.Deque;
  15 import java.util.List;
  16 import java.util.Objects;
  17 import javax.annotation.Nonnull;
  18 import org.opendaylight.yangtools.yang.common.QName;
  19 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
  20 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  21 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  22 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  23 import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
  24 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  25 import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
  26 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.RecursiveObjectLeaker;
  27
  28 public class ExtensionEffectiveStatementImpl extends AbstractEffectiveDocumentedNode<QName, ExtensionStatement>
  29         implements ExtensionDefinition {
  30     private static final class RecursionDetector extends ThreadLocal<Deque<ExtensionEffectiveStatementImpl>> {
  31         boolean check(final ExtensionEffectiveStatementImpl current) {
  32             final Deque<ExtensionEffectiveStatementImpl> stack = get();
  33             if (stack != null) {
  34                 for (ExtensionEffectiveStatementImpl s : stack) {
  35                     if (s == current) {
  36                         return true;
  37                     }
  38                 }
  39             }
  40             return false;
  41         }
  42
  43         void push(final ExtensionEffectiveStatementImpl current) {
  44             Deque<ExtensionEffectiveStatementImpl> stack = get();
  45             if (stack == null) {
  46                 stack = new ArrayDeque<>(1);
  47                 set(stack);
  48             }
  49
  50             stack.push(current);
  51         }
  52
  53         void pop() {
  54             Deque<ExtensionEffectiveStatementImpl> stack = get();
  55             stack.pop();
  56             if (stack.isEmpty()) {
  57                 remove();
  58             }
  59         }
  60     }
  61
  62     private static final RecursionDetector TOSTRING_DETECTOR = new RecursionDetector();
  63
  64     private final QName qname;
  65     private final String argument;
  66     private final SchemaPath schemaPath;
  67
  68     private final List<UnknownSchemaNode> unknownNodes;
  69     private final boolean yin;
  70
  71     private ExtensionEffectiveStatementImpl(
  72             final StmtContext<QName, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> ctx) {
  73         super(ctx);
  74         this.qname = ctx.getStatementArgument();
  75         this.schemaPath = ctx.getSchemaPath().get();
  76
  77         final List<UnknownSchemaNode> unknownNodesInit = new ArrayList<>();
  78         for (EffectiveStatement<?, ?> unknownNode : effectiveSubstatements()) {
  79             if (unknownNode instanceof UnknownSchemaNode) {
  80                 unknownNodesInit.add((UnknownSchemaNode) unknownNode);
  81             }
  82         }
  83         this.unknownNodes = ImmutableList.copyOf(unknownNodesInit);
  84
  85         // initFields
  86         ArgumentEffectiveStatementImpl argumentSubstatement = firstEffective(ArgumentEffectiveStatementImpl.class);
  87         if (argumentSubstatement != null) {
  88             this.argument = argumentSubstatement.argument().getLocalName();
  89
  90             YinElementEffectiveStatementImpl yinElement = argumentSubstatement
  91                     .firstEffective(YinElementEffectiveStatementImpl.class);
  92             if (yinElement != null) {
  93                 this.yin = yinElement.argument();
  94             } else {
  95                 this.yin = false;
  96             }
  97         } else {
  98             this.argument = null;
  99             this.yin = false;
 100         }
 101     }
 102
 103     /**
 104      * Create a new ExtensionEffectiveStatement, dealing with potential recursion
 105      *
 106      * @param ctx Statement context
 107      * @return A potentially under-initialized instance
 108      */
 109     public static EffectiveStatement<QName, ExtensionStatement> create(
 110             final StmtContext<QName, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> ctx) {
 111         // Look at the thread-local leak in case we are invoked recursively
 112         final ExtensionEffectiveStatementImpl existing = RecursiveObjectLeaker.lookup(ctx,
 113             ExtensionEffectiveStatementImpl.class);
 114         if (existing != null) {
 115             // Careful! this not fully initialized!
 116             return existing;
 117         }
 118
 119         RecursiveObjectLeaker.beforeConstructor(ctx);
 120         try {
 121             // This result is fine, we know it has been completely initialized
 122             return new ExtensionEffectiveStatementImpl(ctx);
 123         } finally {
 124             RecursiveObjectLeaker.afterConstructor(ctx);
 125         }
 126     }
 127
 128     @Override
 129     Collection<? extends EffectiveStatement<?, ?>> initSubstatements(
 130             final Collection<StatementContextBase<?, ?, ?>> substatementsInit) {
 131         // WARNING: this leaks an incompletely-initialized object
 132         RecursiveObjectLeaker.inConstructor(this);
 133
 134         return super.initSubstatements(substatementsInit);
 135     }
 136
 137     @Nonnull
 138     @Override
 139     public QName getQName() {
 140         return qname;
 141     }
 142
 143     @Nonnull
 144     @Override
 145     public SchemaPath getPath() {
 146         return schemaPath;
 147     }
 148
 149     @Nonnull
 150     @Override
 151     public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 152         return unknownNodes;
 153     }
 154
 155     @Override
 156     public String getArgument() {
 157         return argument;
 158     }
 159
 160     @Override
 161     public boolean isYinElement() {
 162         return yin;
 163     }
 164
 165     @Override
 166     public int hashCode() {
 167         final int prime = 31;
 168         int result = 1;
 169         result = prime * result + Objects.hashCode(qname);
 170         result = prime * result + Objects.hashCode(schemaPath);
 171         return result;
 172     }
 173
 174     @Override
 175     public boolean equals(final Object obj) {
 176         if (this == obj) {
 177             return true;
 178         }
 179         if (obj == null) {
 180             return false;
 181         }
 182         if (getClass() != obj.getClass()) {
 183             return false;
 184         }
 185         ExtensionEffectiveStatementImpl other = (ExtensionEffectiveStatementImpl) obj;
 186         return Objects.equals(qname, other.qname) && Objects.equals(schemaPath, other.schemaPath);
 187     }
 188
 189     @Override
 190     public String toString() {
 191         if (TOSTRING_DETECTOR.check(this)) {
 192             return recursedToString();
 193         }
 194
 195         TOSTRING_DETECTOR.push(this);
 196         try {
 197             return ExtensionEffectiveStatementImpl.class.getSimpleName() + "[" +
 198                     "argument=" + argument +
 199                     ", qname=" + qname +
 200                     ", schemaPath=" + schemaPath +
 201                     ", extensionSchemaNodes=" + unknownNodes +
 202                     ", yin=" + yin +
 203                     "]";
 204         } finally {
 205             TOSTRING_DETECTOR.pop();
 206         }
 207     }
 208
 209     private String recursedToString() {
 210         return ExtensionEffectiveStatementImpl.class.getSimpleName() + "[" +
 211                 "argument=" + argument +
 212                 ", qname=" + qname +
 213                 ", schemaPath=" + schemaPath +
 214                 ", yin=" + yin +
 215                 " <RECURSIVE> ]";
 216     }
 217 }