import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeAwareEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.DataNodeContainerMixin;
/**
* Base stateless superclass for statements which (logically) always have an associated {@link DeclaredStatement}. This
}
/**
- * Indexing support for {@link DataNodeContainer#findDataChildByName(QName)}.
+ * Indexing support for {@link DataNodeContainer#dataChildByName(QName)}.
*/
- protected final Optional<DataSchemaNode> findDataSchemaNode(final QName name) {
+ protected final @Nullable DataSchemaNode dataSchemaNode(final QName name) {
// Only DataNodeContainer subclasses should be calling this method
verify(this instanceof DataNodeContainer);
final SchemaTreeEffectiveStatement<?> child = schemaTreeNamespace().get(requireNonNull(name));
- return child instanceof DataSchemaNode ? Optional.of((DataSchemaNode) child) : Optional.empty();
+ return child instanceof DataSchemaNode ? (DataSchemaNode) child : null;
}
protected abstract Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace();
this.declared = requireNonNull(declared);
}
+ protected Default(final Default<A, D> original) {
+ this.declared = original.declared;
+ }
+
@Override
public final D getDeclared() {
return declared;
}
}
+ /**
+ * Utility class for implementing DataNodeContainer-type statements.
+ */
+ public abstract static class DefaultDataNodeContainer<A, D extends DeclaredStatement<A>> extends Default<A, D>
+ implements DataNodeContainerMixin<A, D> {
+ private final @NonNull ImmutableMap<QName, DataSchemaNode> dataChildren;
+ private final @NonNull Object substatements;
+
+ protected DefaultDataNodeContainer(final D declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(declared);
+ this.substatements = maskList(substatements);
+
+ // Note: we do not leak this map, so iteration order does not matter
+ final Map<QName, DataSchemaNode> tmp = new HashMap<>();
+
+ for (EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
+ if (stmt instanceof DataSchemaNode) {
+ final DataSchemaNode node = (DataSchemaNode) stmt;
+ final QName id = node.getQName();
+ final DataSchemaNode prev = tmp.put(id, node);
+ if (prev != null) {
+ throw new SubstatementIndexingException(
+ "Cannot add child with name " + id + ", a conflicting child already exists");
+ }
+ }
+ }
+
+ dataChildren = ImmutableMap.copyOf(tmp);
+ }
+
+ @Override
+ public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+ return unmaskList(substatements);
+ }
+
+ @Override
+ public final DataSchemaNode dataChildByName(final QName name) {
+ return dataChildren.get(requireNonNull(name));
+ }
+ }
+
/**
* An extra building block on top of {@link Default}, which is wiring {@link #argument()} to the declared statement.
* This is mostly useful for arguments that are not subject to inference transformation -- for example Strings in
this.substatements = maskList(substatements);
}
+ protected WithSubstatements(final WithSubstatements<A, D> original) {
+ super(original);
+ this.substatements = original.substatements;
+ }
+
@Override
public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
return unmaskList(substatements);
super(declared);
}
+ protected DefaultArgument(final DefaultArgument<A, D> original) {
+ super(original);
+ }
+
@Override
- public final @Nullable A argument() {
+ public final A argument() {
return getDeclared().argument();
}
}
+ /**
+ * A building block on top of {@link Default}, which adds an explicit argument value, which is not related to the
+ * context. This is mostly useful when the effective argument value reflects additional statements and similar.
+ *
+ * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <D> Class representing declared version of this statement.
+ */
+ public abstract static class DefaultWithArgument<A, D extends DeclaredStatement<A>> extends Default<A, D> {
+ public abstract static class WithSubstatements<A, D extends DeclaredStatement<A>>
+ extends DefaultWithArgument<A, D> {
+ private final @NonNull Object substatements;
+
+ protected WithSubstatements(final D declared, final A argument,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(declared, argument);
+ this.substatements = maskList(substatements);
+ }
+
+ @Override
+ public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+ return unmaskList(substatements);
+ }
+ }
+
+ private final A argument;
+
+ protected DefaultWithArgument(final D declared, final A argument) {
+ super(declared);
+ this.argument = argument;
+ }
+
+ @Override
+ public final A argument() {
+ return argument;
+ }
+ }
+
/**
* Stateful version of {@link WithSchemaTree}. Schema tree namespace is eagerly instantiated (and checked).
*
*/
public abstract static class DefaultWithSchemaTree<A, D extends DeclaredStatement<A>,
E extends SchemaTreeAwareEffectiveStatement<A, D>> extends WithSchemaTree<A, D, E> {
- private final @NonNull Map<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
+ public abstract static class WithSubstatements<A, D extends DeclaredStatement<A>,
+ E extends SchemaTreeAwareEffectiveStatement<A, D>> extends DefaultWithSchemaTree<A, D, E> {
+ private final @NonNull Object substatements;
+
+ protected WithSubstatements(final D declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(declared, substatements);
+ this.substatements = maskList(substatements);
+ }
+
+ protected WithSubstatements(final WithSubstatements<A, D, E> original) {
+ super(original);
+ this.substatements = original.substatements;
+ }
+
+ @Override
+ public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+ return unmaskList(substatements);
+ }
+ }
+
+ private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
private final @NonNull D declared;
- protected DefaultWithSchemaTree(final D declared, final StmtContext<?, ?, ?> ctx,
+ protected DefaultWithSchemaTree(final D declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
this.declared = requireNonNull(declared);
- this.schemaTree = AbstractSchemaEffectiveDocumentedNode.createSchemaTreeNamespace(
- ctx.getStatementSourceReference(), substatements);
+ this.schemaTree = ImmutableMap.copyOf(createSchemaTreeNamespace(substatements));
+ }
+
+ protected DefaultWithSchemaTree(final DefaultWithSchemaTree<A, D, E> original) {
+ this.declared = original.declared;
+ this.schemaTree = original.schemaTree;
}
@Override
*/
public abstract static class DefaultWithDataTree<A, D extends DeclaredStatement<A>,
E extends DataTreeAwareEffectiveStatement<A, D>> extends WithDataTree<A, D, E> {
- private final @NonNull Map<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
- private final @NonNull Map<QName, DataTreeEffectiveStatement<?>> dataTree;
+ public abstract static class WithSubstatements<A, D extends DeclaredStatement<A>,
+ E extends DataTreeAwareEffectiveStatement<A, D>> extends DefaultWithDataTree<A, D, E> {
+ private final @NonNull Object substatements;
+
+ protected WithSubstatements(final D declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(declared, substatements);
+ this.substatements = maskList(substatements);
+ }
+
+ protected WithSubstatements(final WithSubstatements<A, D, E> original) {
+ super(original);
+ this.substatements = original.substatements;
+ }
+
+ @Override
+ public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+ return unmaskList(substatements);
+ }
+ }
+
+ private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
+ private final @NonNull ImmutableMap<QName, DataTreeEffectiveStatement<?>> dataTree;
private final @NonNull D declared;
- protected DefaultWithDataTree(final D declared, final StmtContext<?, ?, ?> ctx,
+ protected DefaultWithDataTree(final D declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
this.declared = requireNonNull(declared);
- final StatementSourceReference ref = ctx.getStatementSourceReference();
- this.schemaTree = AbstractSchemaEffectiveDocumentedNode.createSchemaTreeNamespace(ref, substatements);
- this.dataTree = AbstractSchemaEffectiveDocumentedNode.createDataTreeNamespace(ref, schemaTree);
+ final Map<QName, SchemaTreeEffectiveStatement<?>> schema = createSchemaTreeNamespace(substatements);
+ this.schemaTree = ImmutableMap.copyOf(schema);
+ this.dataTree = createDataTreeNamespace(schema.values(), schemaTree);
+ }
+
+ protected DefaultWithDataTree(final DefaultWithDataTree<A, D, E> original) {
+ this.declared = original.declared;
+ this.schemaTree = original.schemaTree;
+ this.dataTree = original.dataTree;
}
@Override
Code Review / yangtools.git / blobdiff