yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/TypeDefEffectiveStatementImpl.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 java.util.Collection;
  11 import java.util.Map;
  12 import org.opendaylight.yangtools.yang.common.QName;
  13 import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
  14 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  15 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  16 import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
  17 import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
  18 import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
  19 import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
  20 import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
  21 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
  22 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
  23 import org.opendaylight.yangtools.yang.model.util.type.DerivedTypeBuilder;
  24 import org.opendaylight.yangtools.yang.model.util.type.DerivedTypes;
  25 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  26 import org.slf4j.Logger;
  27 import org.slf4j.LoggerFactory;
  28
  29 public final class TypeDefEffectiveStatementImpl extends AbstractEffectiveSchemaNode<TypedefStatement> implements
  30         TypedefEffectiveStatement {
  31     private static final Logger LOG = LoggerFactory.getLogger(TypeDefEffectiveStatementImpl.class);
  32     private final TypeDefinition<?> typeDefinition;
  33     private TypeEffectiveStatement<TypeStatement> typeStatement;
  34
  35     public TypeDefEffectiveStatementImpl(final StmtContext<QName, TypedefStatement, ?> ctx) {
  36         super(ctx);
  37
  38         final TypeEffectiveStatement<?> typeEffectiveStmt = firstSubstatementOfType(TypeEffectiveStatement.class);
  39         final DerivedTypeBuilder<?> builder = DerivedTypes.derivedTypeBuilder(typeEffectiveStmt.getTypeDefinition(),
  40             ctx.getSchemaPath().get());
  41         for (EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
  42             if (stmt instanceof DefaultEffectiveStatementImpl) {
  43                 builder.setDefaultValue(stmt.argument());
  44             } else if (stmt instanceof DescriptionEffectiveStatementImpl) {
  45                 builder.setDescription(((DescriptionEffectiveStatementImpl)stmt).argument());
  46             } else if (stmt instanceof ReferenceEffectiveStatementImpl) {
  47                 builder.setReference(((ReferenceEffectiveStatementImpl)stmt).argument());
  48             } else if (stmt instanceof StatusEffectiveStatementImpl) {
  49                 builder.setStatus(((StatusEffectiveStatementImpl)stmt).argument());
  50             } else if (stmt instanceof UnitsEffectiveStatementImpl) {
  51                 builder.setUnits(((UnitsEffectiveStatementImpl)stmt).argument());
  52             } else if (stmt instanceof UnknownEffectiveStatementImpl) {
  53                 // FIXME: should not directly implement, I think
  54                 builder.addUnknownSchemaNode((UnknownEffectiveStatementImpl)stmt);
  55             } else {
  56                 if (!(stmt instanceof TypeEffectiveStatement)) {
  57                     LOG.debug("Ignoring statement {}", stmt);
  58                 }
  59             }
  60         }
  61
  62         typeDefinition = builder.build();
  63     }
  64
  65     @Override
  66     public TypeDefinition<?> getTypeDefinition() {
  67         return typeDefinition;
  68     }
  69
  70     public TypeEffectiveStatement<TypeStatement> asTypeEffectiveStatement() {
  71         TypeEffectiveStatement<TypeStatement> ret = typeStatement;
  72         if (ret == null) {
  73             synchronized (this) {
  74                 ret = typeStatement;
  75                 if (ret == null) {
  76                     ret = new ProxyTypeEffectiveStatement();
  77                     typeStatement = ret;
  78                 }
  79             }
  80         }
  81
  82         return ret;
  83     }
  84
  85     private final class ProxyTypeEffectiveStatement implements TypeEffectiveStatement<TypeStatement> {
  86         @Override
  87         public TypeStatement getDeclared() {
  88             return null;
  89         }
  90
  91         @Override
  92         public <K, V, N extends IdentifierNamespace<K, V>> V get(final Class<N> namespace, final K identifier) {
  93             return TypeDefEffectiveStatementImpl.this.get(namespace, identifier);
  94         }
  95
  96         @Override
  97         public <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(final Class<N> namespace) {
  98             return TypeDefEffectiveStatementImpl.this.getAll(namespace);
  99         }
 100
 101         @Override
 102         public Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
 103             // FIXME: this is tricky
 104             throw new UnsupportedOperationException("Not implemented yet");
 105         }
 106
 107         @Override
 108         public StatementDefinition statementDefinition() {
 109             return Rfc6020Mapping.TYPE;
 110         }
 111
 112         @Override
 113         public String argument() {
 114             return getQName().getLocalName();
 115         }
 116
 117         @Override
 118         public StatementSource getStatementSource() {
 119             return StatementSource.CONTEXT;
 120         }
 121
 122         @Override
 123         public TypeDefinition<?> getTypeDefinition() {
 124             return TypeDefEffectiveStatementImpl.this.getTypeDefinition();
 125         }
 126     }
 127 }