X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Fstmt%2Frfc6020%2Feffective%2FTypeDefEffectiveStatementImpl.java;h=576441fa53d06ef7bd712ac51b1392a5e5afe87d;hb=2ad7b79d5a61b540afca3ce37ab81738bbb699b7;hp=ee0ec2007a91e7ca7f39fd9f7476266bd7b1f7c5;hpb=30c67c4d780e897d972d60bb79d546b512516f90;p=yangtools.git diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/TypeDefEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/TypeDefEffectiveStatementImpl.java index ee0ec2007a..576441fa53 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/TypeDefEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/TypeDefEffectiveStatementImpl.java @@ -7,209 +7,121 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective; -import com.google.common.base.Optional; -import com.google.common.collect.ImmutableList; -import java.util.Collections; -import java.util.List; +import java.util.Collection; +import java.util.Map; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.model.api.SchemaPath; -import org.opendaylight.yangtools.yang.model.api.Status; +import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; -import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.meta.StatementSource; +import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement; -import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint; -import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; -import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint; -import org.opendaylight.yangtools.yang.model.util.ExtendedType; -import org.opendaylight.yangtools.yang.model.util.ExtendedType.Builder; -import org.opendaylight.yangtools.yang.parser.spi.TypeNamespace; +import org.opendaylight.yangtools.yang.model.util.type.DerivedTypeBuilder; +import org.opendaylight.yangtools.yang.model.util.type.DerivedTypes; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.TypeDefinitionEffectiveBuilder; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; -public class TypeDefEffectiveStatementImpl extends EffectiveStatementBase implements - TypeDefinition>, TypeDefinitionEffectiveBuilder { +public final class TypeDefEffectiveStatementImpl extends AbstractEffectiveSchemaNode implements + TypedefEffectiveStatement { + private static final Logger LOG = LoggerFactory.getLogger(TypeDefEffectiveStatementImpl.class); + private final TypeDefinition typeDefinition; + private TypeEffectiveStatement typeStatement; - private final QName qName; - private final SchemaPath path; - - private final TypeDefinition baseType; - - private String defaultValue; - private String units; - - private String description; - private String reference; - - private Status status; - - private final List ranges; - private final List lengths; - private final List patterns; - private final Integer fractionDigits; - - private ExtendedType extendedType = null; - - public TypeDefEffectiveStatementImpl(StmtContext ctx) { + public TypeDefEffectiveStatementImpl(final StmtContext ctx) { super(ctx); - qName = ctx.getStatementArgument(); - path = Utils.getSchemaPath(ctx); - - ExtendedTypeEffectiveStatementImpl type = null; - - for (final EffectiveStatement effectiveStatement : effectiveSubstatements()) { - if (effectiveStatement instanceof ExtendedTypeEffectiveStatementImpl) { - type = ((ExtendedTypeEffectiveStatementImpl) effectiveStatement); - } - if (effectiveStatement instanceof DefaultEffectiveStatementImpl) { - defaultValue = ((DefaultEffectiveStatementImpl) effectiveStatement).argument(); - } - if (effectiveStatement instanceof UnitsEffectiveStatementImpl) { - units = ((UnitsEffectiveStatementImpl) effectiveStatement).argument(); - } - if (effectiveStatement instanceof DescriptionEffectiveStatementImpl) { - description = ((DescriptionEffectiveStatementImpl) effectiveStatement).argument(); - } - if (effectiveStatement instanceof ReferenceEffectiveStatementImpl) { - reference = ((ReferenceEffectiveStatementImpl) effectiveStatement).argument(); - } - if (effectiveStatement instanceof StatusEffectiveStatementImpl) { - status = ((StatusEffectiveStatementImpl) effectiveStatement).argument(); + final TypeEffectiveStatement typeEffectiveStmt = firstSubstatementOfType(TypeEffectiveStatement.class); + final DerivedTypeBuilder builder = DerivedTypes.derivedTypeBuilder(typeEffectiveStmt.getTypeDefinition(), + ctx.getSchemaPath().get()); + for (EffectiveStatement stmt : effectiveSubstatements()) { + if (stmt instanceof DefaultEffectiveStatementImpl) { + builder.setDefaultValue(stmt.argument()); + } else if (stmt instanceof DescriptionEffectiveStatementImpl) { + builder.setDescription(((DescriptionEffectiveStatementImpl)stmt).argument()); + } else if (stmt instanceof ReferenceEffectiveStatementImpl) { + builder.setReference(((ReferenceEffectiveStatementImpl)stmt).argument()); + } else if (stmt instanceof StatusEffectiveStatementImpl) { + builder.setStatus(((StatusEffectiveStatementImpl)stmt).argument()); + } else if (stmt instanceof UnitsEffectiveStatementImpl) { + builder.setUnits(((UnitsEffectiveStatementImpl)stmt).argument()); + } else if (stmt instanceof UnknownEffectiveStatementImpl) { + // FIXME: should not directly implement, I think + builder.addUnknownSchemaNode((UnknownEffectiveStatementImpl)stmt); + } else { + if (!(stmt instanceof TypeEffectiveStatement)) { + LOG.debug("Ignoring statement {}", stmt); + } } } - if (type != null) { - - ranges = ImmutableList.copyOf(type.getRangeConstraints()); - lengths = ImmutableList.copyOf(type.getLengthConstraints()); - patterns = ImmutableList.copyOf(type.getPatternConstraints()); - fractionDigits = type.getFractionDigits(); - } else { + typeDefinition = builder.build(); + } - ranges = Collections.emptyList(); - lengths = Collections.emptyList(); - patterns = Collections.emptyList(); - fractionDigits = null; + @Override + public TypeDefinition getTypeDefinition() { + return typeDefinition; + } + + public TypeEffectiveStatement asTypeEffectiveStatement() { + TypeEffectiveStatement ret = typeStatement; + if (ret == null) { + synchronized (this) { + ret = typeStatement; + if (ret == null) { + ret = new ProxyTypeEffectiveStatement(); + typeStatement = ret; + } + } } - baseType = parseBaseTypeFromCtx(ctx); + return ret; } - private TypeDefinition parseBaseTypeFromCtx(final StmtContext ctx) { - - TypeDefinition baseType; - - QName baseTypeQName = Utils.qNameFromArgument(ctx, - StmtContextUtils.firstAttributeOf(ctx.declaredSubstatements(), TypeStatement.class)); - - if (TypeUtils.isYangBaseTypeString(baseTypeQName.getLocalName())) { - baseType = TypeUtils.getYangBaseTypeFromString(baseTypeQName.getLocalName()); - } else { - StmtContext> baseTypeCtx = ctx - .getParentContext().getFromNamespace(TypeNamespace.class, baseTypeQName); - baseType = (TypeDefEffectiveStatementImpl) baseTypeCtx.buildEffective(); + private final class ProxyTypeEffectiveStatement implements TypeEffectiveStatement { + @Override + public TypeStatement getDeclared() { + return null; } - if (baseType == null) { - baseType = firstSubstatementOfType(TypeDefinition.class); + @Override + public > V get(final Class namespace, final K identifier) { + return TypeDefEffectiveStatementImpl.this.get(namespace, identifier); } - return baseType; - } - - @Override - public TypeDefinition getBaseType() { - return baseType; - } - - @Override - public String getUnits() { - return units; - } - - @Override - public Object getDefaultValue() { - return defaultValue; - } - - @Override - public QName getQName() { - return qName; - } - - @Override - public SchemaPath getPath() { - return path; - } - - @Override - public List getUnknownSchemaNodes() { - return Collections.emptyList(); - } - - @Override - public String getDescription() { - return description; - } - - @Override - public String getReference() { - return reference; - } - - @Override - public Status getStatus() { - return status; - } - - public List getRangeConstraints() { - return ranges; - } - - public List getLengthConstraints() { - return lengths; - } - - public List getPatternConstraints() { - return patterns; - } - - public Integer getFractionDigits() { - return fractionDigits; - } - - @Override - public ExtendedType buildType() { - - if (extendedType != null) { - return extendedType; + @Override + public > Map getAll(final Class namespace) { + return TypeDefEffectiveStatementImpl.this.getAll(namespace); } - Builder extendedTypeBuilder; - if (baseType instanceof TypeDefinitionEffectiveBuilder) { - TypeDefinitionEffectiveBuilder typeDefBaseType = (TypeDefinitionEffectiveBuilder) baseType; - extendedTypeBuilder = ExtendedType.builder(qName, typeDefBaseType.buildType(), - Optional.fromNullable(description), Optional.fromNullable(reference), path); - } else { - extendedTypeBuilder = ExtendedType.builder(qName, baseType, Optional.fromNullable(description), - Optional.fromNullable(reference), path); + @Override + public Collection> effectiveSubstatements() { + // FIXME: this is tricky + throw new UnsupportedOperationException("Not implemented yet"); } - extendedTypeBuilder.defaultValue(defaultValue); - extendedTypeBuilder.units(units); + @Override + public StatementDefinition statementDefinition() { + return Rfc6020Mapping.TYPE; + } - extendedTypeBuilder.fractionDigits(fractionDigits); - extendedTypeBuilder.ranges(ranges); - extendedTypeBuilder.lengths(lengths); - extendedTypeBuilder.patterns(patterns); + @Override + public String argument() { + return getQName().getLocalName(); + } - extendedType = extendedTypeBuilder.build(); + @Override + public StatementSource getStatementSource() { + return StatementSource.CONTEXT; + } - return extendedType; + @Override + public TypeDefinition getTypeDefinition() { + return TypeDefEffectiveStatementImpl.this.getTypeDefinition(); + } } }