import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
+import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
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.stmt.DataTreeAwareEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeAwareEffectiveStatement.DataTreeNamespace;
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.SchemaTreeAwareEffectiveStatement.SchemaTreeNamespace;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefNamespace;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefAwareEffectiveStatement;
/**
* Base stateless superclass for statements which (logically) always have an associated {@link DeclaredStatement}. This
* @param <D> Class representing declared version of this statement.
*/
public abstract static class WithSchemaTree<A, D extends DeclaredStatement<A>>
- extends AbstractDeclaredEffectiveStatement<A, D> {
- @Override
- @SuppressWarnings("unchecked")
- protected <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends Map<K, V>> getNamespaceContents(
- final Class<N> namespace) {
- if (SchemaTreeNamespace.class.equals(namespace)) {
- return Optional.of((Map<K, V>) schemaTreeNamespace());
- }
- return super.getNamespaceContents(namespace);
- }
-
+ extends AbstractDeclaredEffectiveStatement<A, D> implements SchemaTreeAwareEffectiveStatement<A, D> {
/**
* Indexing support for {@link DataNodeContainer#dataChildByName(QName)}.
*/
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 ? (DataSchemaNode) child : null;
+ return filterOptional(findSchemaTreeNode(name), DataSchemaNode.class).orElse(null);
}
-
- protected abstract Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace();
}
/**
* @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
- public abstract static class WithDataTree<A, D extends DeclaredStatement<A>> extends WithSchemaTree<A, D> {
- @Override
- @SuppressWarnings("unchecked")
- protected <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends Map<K, V>> getNamespaceContents(
- final Class<N> namespace) {
- if (DataTreeNamespace.class.equals(namespace)) {
- return Optional.of((Map<K, V>) dataTreeNamespace());
- }
- return super.getNamespaceContents(namespace);
- }
-
- protected abstract Map<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace();
+ public abstract static class WithDataTree<A, D extends DeclaredStatement<A>> extends WithSchemaTree<A, D>
+ implements DataTreeAwareEffectiveStatement<A, D> {
+ // Nothing else
}
/**
}
@Override
- protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
- return schemaTree;
+ public final Collection<SchemaTreeEffectiveStatement<?>> schemaTreeNodes() {
+ return schemaTree.values();
+ }
+
+ @Override
+ public final Optional<SchemaTreeEffectiveStatement<?>> findSchemaTreeNode(final QName qname) {
+ return findValue(schemaTree, requireNonNull(qname));
}
}
*/
public abstract static class DefaultWithDataTree<A, D extends DeclaredStatement<A>> extends WithDataTree<A, D> {
public abstract static class WithTypedefNamespace<A, D extends DeclaredStatement<A>>
- extends DefaultWithDataTree<A, D> {
+ extends DefaultWithDataTree<A, D> implements TypedefAwareEffectiveStatement<A, D> {
protected WithTypedefNamespace(final D declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(declared, substatements);
protected WithTypedefNamespace(final WithTypedefNamespace<A, D> original) {
super(original);
}
-
- @Override
- @SuppressWarnings("unchecked")
- protected <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends Map<K, V>> getNamespaceContents(
- final Class<N> namespace) {
- if (TypedefNamespace.class.equals(namespace)) {
- return Optional.of((Map<K, V>) new LinearTypedefNamespace(effectiveSubstatements()));
- }
- return super.getNamespaceContents(namespace);
- }
}
private final @NonNull Map<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
}
@Override
- protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
- return schemaTree;
+ public final Collection<SchemaTreeEffectiveStatement<?>> schemaTreeNodes() {
+ return schemaTree.values();
+ }
+
+ @Override
+ public final Optional<SchemaTreeEffectiveStatement<?>> findSchemaTreeNode(final QName qname) {
+ return findValue(schemaTree, qname);
+ }
+
+ @Override
+ public final Collection<DataTreeEffectiveStatement<?>> dataTreeNodes() {
+ return dataTree.values();
}
@Override
- protected final Map<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace() {
- return dataTree;
+ public final Optional<DataTreeEffectiveStatement<?>> findDataTreeNode(final QName qname) {
+ return findValue(dataTree, qname);
}
}
}