*/
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 javax.annotation.Nonnull;
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.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
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.spi.source.SourceException;
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<QName, TypedefStatement> implements
- TypeDefinition<TypeDefinition<?>>, TypeDefinitionEffectiveBuilder {
+public final class TypeDefEffectiveStatementImpl extends AbstractEffectiveSchemaNode<TypedefStatement> implements
+ TypedefEffectiveStatement {
+ private static final Logger LOG = LoggerFactory.getLogger(TypeDefEffectiveStatementImpl.class);
+ private final TypeDefinition<?> typeDefinition;
+ private TypeEffectiveStatement<TypeStatement> 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<RangeConstraint> ranges;
- private final List<LengthConstraint> lengths;
- private final List<PatternConstraint> patterns;
- private final Integer fractionDigits;
-
- private ExtendedType extendedType = null;
-
- public TypeDefEffectiveStatementImpl(StmtContext<QName, TypedefStatement, ?> ctx) {
+ public TypeDefEffectiveStatementImpl(final StmtContext<QName, TypedefStatement, ?> 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();
+ final TypeEffectiveStatement<?> typeEffectiveStmt = firstSubstatementOfType(TypeEffectiveStatement.class);
+ final DerivedTypeBuilder<?> builder = DerivedTypes.derivedTypeBuilder(typeEffectiveStmt.getTypeDefinition(),
+ ctx.getSchemaPath().get());
+ String defaultValue = null;
+ for (final EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
+ if (stmt instanceof DefaultEffectiveStatementImpl) {
+ defaultValue = ((DefaultEffectiveStatementImpl) stmt).argument();
+ builder.setDefaultValue(defaultValue);
+ } 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 (effectiveStatement instanceof ReferenceEffectiveStatementImpl) {
- reference = ((ReferenceEffectiveStatementImpl) effectiveStatement).argument();
- }
- if (effectiveStatement instanceof StatusEffectiveStatementImpl) {
- status = ((StatusEffectiveStatementImpl) effectiveStatement).argument();
- }
- }
-
- if (type != null) {
-
- ranges = ImmutableList.copyOf(type.getRangeConstraints());
- lengths = ImmutableList.copyOf(type.getLengthConstraints());
- patterns = ImmutableList.copyOf(type.getPatternConstraints());
- fractionDigits = type.getFractionDigits();
- } else {
-
- ranges = Collections.emptyList();
- lengths = Collections.emptyList();
- patterns = Collections.emptyList();
- fractionDigits = null;
- }
-
- baseType = parseBaseTypeFromCtx(ctx);
- }
-
- private TypeDefinition<?> parseBaseTypeFromCtx(final StmtContext<QName, TypedefStatement, ?> 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<?, TypedefStatement, EffectiveStatement<QName, TypedefStatement>> baseTypeCtx = ctx
- .getParentContext().getFromNamespace(TypeNamespace.class, baseTypeQName);
- baseType = (TypeDefEffectiveStatementImpl) baseTypeCtx.buildEffective();
}
- if (baseType == null) {
- baseType = firstSubstatementOfType(TypeDefinition.class);
+ try {
+ SourceException
+ .throwIf(TypeUtils.hasDefaultValueMarkedWithIfFeature(ctx.getRootVersion(), typeEffectiveStmt,
+ defaultValue), ctx.getStatementSourceReference(),
+ "Typedef '%s' has default value '%s' marked with an if-feature statement.", ctx
+ .getStatementArgument(), defaultValue);
+ } catch (final IllegalStateException e) {
+ throw new SourceException(ctx.getStatementSourceReference(), e,
+ "Unable to find a default value for typedef '%s'", ctx.getStatementArgument());
}
- 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<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.emptyList();
- }
-
- @Override
- public String getDescription() {
- return description;
- }
-
- @Override
- public String getReference() {
- return reference;
+ typeDefinition = builder.build();
}
+ @Nonnull
@Override
- public Status getStatus() {
- return status;
- }
-
- public List<RangeConstraint> getRangeConstraints() {
- return ranges;
- }
-
- public List<LengthConstraint> getLengthConstraints() {
- return lengths;
- }
+ public TypeDefinition<?> getTypeDefinition() {
+ return typeDefinition;
+ }
+
+ public TypeEffectiveStatement<TypeStatement> asTypeEffectiveStatement() {
+ TypeEffectiveStatement<TypeStatement> ret = typeStatement;
+ if (ret == null) {
+ synchronized (this) {
+ ret = typeStatement;
+ if (ret == null) {
+ ret = new ProxyTypeEffectiveStatement();
+ typeStatement = ret;
+ }
+ }
+ }
- public List<PatternConstraint> getPatternConstraints() {
- return patterns;
+ return ret;
}
- public Integer getFractionDigits() {
- return fractionDigits;
- }
+ private final class ProxyTypeEffectiveStatement implements TypeEffectiveStatement<TypeStatement> {
+ @Override
+ public TypeStatement getDeclared() {
+ return null;
+ }
- @Override
- public ExtendedType buildType() {
+ @Override
+ public <K, V, N extends IdentifierNamespace<K, V>> V get(@Nonnull final Class<N> namespace, @Nonnull final K identifier) {
+ return TypeDefEffectiveStatementImpl.this.get(namespace, identifier);
+ }
- if (extendedType != null) {
- return extendedType;
+ @Override
+ public <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(@Nonnull final Class<N> 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);
+ @Nonnull
+ @Override
+ public Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+ return TypeDefEffectiveStatementImpl.this.effectiveSubstatements();
}
- extendedTypeBuilder.defaultValue(defaultValue);
- extendedTypeBuilder.units(units);
+ @Nonnull
+ @Override
+ public StatementDefinition statementDefinition() {
+ return YangStmtMapping.TYPE;
+ }
- extendedTypeBuilder.fractionDigits(fractionDigits);
- extendedTypeBuilder.ranges(ranges);
- extendedTypeBuilder.lengths(lengths);
- extendedTypeBuilder.patterns(patterns);
+ @Override
+ public String argument() {
+ return getQName().getLocalName();
+ }
- extendedType = extendedTypeBuilder.build();
+ @Nonnull
+ @Override
+ public StatementSource getStatementSource() {
+ return StatementSource.CONTEXT;
+ }
- return extendedType;
+ @Nonnull
+ @Override
+ public TypeDefinition<?> getTypeDefinition() {
+ return TypeDefEffectiveStatementImpl.this.getTypeDefinition();
+ }
}
}
Code Review / yangtools.git / blobdiff