model/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractDeclaredEffectiveStatement.java

   1 /*
   2  * Copyright (c) 2020 PANTHEON.tech, s.r.o. 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.model.spi.meta;
   9
  10 import static com.google.common.base.Verify.verify;
  11 import static java.util.Objects.requireNonNull;
  12
  13 import com.google.common.annotations.Beta;
  14 import com.google.common.collect.ImmutableList;
  15 import java.util.Map;
  16 import java.util.Optional;
  17 import org.eclipse.jdt.annotation.NonNull;
  18 import org.eclipse.jdt.annotation.Nullable;
  19 import org.opendaylight.yangtools.yang.common.Empty;
  20 import org.opendaylight.yangtools.yang.common.QName;
  21 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  22 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  23 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
  24 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  25 import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
  26 import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeAwareEffectiveStatement;
  27 import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeAwareEffectiveStatement.DataTreeNamespace;
  28 import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement;
  29 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeAwareEffectiveStatement;
  30 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeAwareEffectiveStatement.SchemaTreeNamespace;
  31 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
  32 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefNamespace;
  33
  34 /**
  35  * Base stateless superclass for statements which (logically) always have an associated {@link DeclaredStatement}. This
  36  * is notably not true for all {@code case} statements, some of which may actually be implied.
  37  *
  38  * <p>
  39  * Note implementations are not strictly required to make the declared statement available, they are free to throw
  40  * {@link UnsupportedOperationException} from {@link #getDeclared()}, rendering any services relying on declared
  41  * statement to be not available.
  42  *
  43  * @param <A> Argument type ({@link Empty} if statement does not have argument.)
  44  * @param <D> Class representing declared version of this statement.
  45  */
  46 @Beta
  47 public abstract class AbstractDeclaredEffectiveStatement<A, D extends DeclaredStatement<A>>
  48         extends AbstractEffectiveStatement<A, D> {
  49     @Override
  50     public abstract @NonNull D getDeclared();
  51
  52     /**
  53      * Base stateless superclass form {@link SchemaTreeAwareEffectiveStatement}s. It maintains the contents of schema
  54      * tree namespace based of effective substatements.
  55      *
  56      * @param <A> Argument type ({@link Empty} if statement does not have argument.)
  57      * @param <D> Class representing declared version of this statement.
  58      */
  59     public abstract static class WithSchemaTree<A, D extends DeclaredStatement<A>>
  60             extends AbstractDeclaredEffectiveStatement<A, D> {
  61         @Override
  62         @SuppressWarnings("unchecked")
  63         protected <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends Map<K, V>> getNamespaceContents(
  64                 final Class<N> namespace) {
  65             if (SchemaTreeNamespace.class.equals(namespace)) {
  66                 return Optional.of((Map<K, V>) schemaTreeNamespace());
  67             }
  68             return super.getNamespaceContents(namespace);
  69         }
  70
  71         /**
  72          * Indexing support for {@link DataNodeContainer#dataChildByName(QName)}.
  73          */
  74         protected final @Nullable DataSchemaNode dataSchemaNode(final QName name) {
  75             // Only DataNodeContainer subclasses should be calling this method
  76             verify(this instanceof DataNodeContainer);
  77             final SchemaTreeEffectiveStatement<?> child = schemaTreeNamespace().get(requireNonNull(name));
  78             return child instanceof DataSchemaNode ? (DataSchemaNode) child : null;
  79         }
  80
  81         protected abstract Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace();
  82     }
  83
  84     /**
  85      * Base stateless superclass for {@link DataTreeAwareEffectiveStatement}s. It maintains the contents of data tree
  86      * namespace based of effective substatements.
  87      *
  88      * @param <A> Argument type ({@link Empty} if statement does not have argument.)
  89      * @param <D> Class representing declared version of this statement.
  90      */
  91     public abstract static class WithDataTree<A, D extends DeclaredStatement<A>> extends WithSchemaTree<A, D> {
  92         @Override
  93         @SuppressWarnings("unchecked")
  94         protected <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends Map<K, V>> getNamespaceContents(
  95                 final Class<N> namespace) {
  96             if (DataTreeNamespace.class.equals(namespace)) {
  97                 return Optional.of((Map<K, V>) dataTreeNamespace());
  98             }
  99             return super.getNamespaceContents(namespace);
 100         }
 101
 102         protected abstract Map<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace();
 103     }
 104
 105     /**
 106      * A stateful version of {@link AbstractDeclaredEffectiveStatement}, which holds (and requires) a declared
 107      * statement.
 108      *
 109      * @param <A> Argument type ({@link Empty} if statement does not have argument.)
 110      * @param <D> Class representing declared version of this statement.
 111      */
 112     public abstract static class Default<A, D extends DeclaredStatement<A>>
 113             extends AbstractDeclaredEffectiveStatement<A, D> {
 114         private final @NonNull D declared;
 115
 116         protected Default(final D declared) {
 117             this.declared = requireNonNull(declared);
 118         }
 119
 120         protected Default(final Default<A, D> original) {
 121             this.declared = original.declared;
 122         }
 123
 124         @Override
 125         public final @NonNull D getDeclared() {
 126             return declared;
 127         }
 128     }
 129
 130     /**
 131      * An extra building block on top of {@link Default}, which is wiring {@link #argument()} to the declared statement.
 132      * This is mostly useful for arguments that are not subject to inference transformation -- for example Strings in
 133      * {@code description}, etc. This explicitly is not true of statements which underwent namespace binding via
 134      * {@code uses} or similar.
 135      *
 136      * @param <A> Argument type ({@link Empty} if statement does not have argument.)
 137      * @param <D> Class representing declared version of this statement.
 138      */
 139     public abstract static class DefaultArgument<A, D extends DeclaredStatement<A>> extends Default<A, D> {
 140         public abstract static class WithSubstatements<A, D extends DeclaredStatement<A>>
 141                 extends DefaultArgument<A, D> {
 142             private final @NonNull Object substatements;
 143
 144             protected WithSubstatements(final D declared,
 145                     final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 146                 super(declared);
 147                 this.substatements = maskList(substatements);
 148             }
 149
 150             protected WithSubstatements(final WithSubstatements<A, D> original) {
 151                 super(original);
 152                 this.substatements = original.substatements;
 153             }
 154
 155             @Override
 156             public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
 157                 return unmaskList(substatements);
 158             }
 159         }
 160
 161         protected DefaultArgument(final D declared) {
 162             super(declared);
 163         }
 164
 165         protected DefaultArgument(final DefaultArgument<A, D> original) {
 166             super(original);
 167         }
 168
 169         @Override
 170         public final A argument() {
 171             return getDeclared().argument();
 172         }
 173     }
 174
 175     /**
 176      * A building block on top of {@link Default}, which adds an explicit argument value, which is not related to the
 177      * context. This is mostly useful when the effective argument value reflects additional statements and similar.
 178      *
 179      * @param <A> Argument type ({@link Empty} if statement does not have argument.)
 180      * @param <D> Class representing declared version of this statement.
 181      */
 182     public abstract static class DefaultWithArgument<A, D extends DeclaredStatement<A>> extends Default<A, D> {
 183         public abstract static class WithSubstatements<A, D extends DeclaredStatement<A>>
 184                 extends DefaultWithArgument<A, D> {
 185             private final @NonNull Object substatements;
 186
 187             protected WithSubstatements(final D declared, final A argument,
 188                     final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 189                 super(declared, argument);
 190                 this.substatements = maskList(substatements);
 191             }
 192
 193             @Override
 194             public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
 195                 return unmaskList(substatements);
 196             }
 197         }
 198
 199         private final A argument;
 200
 201         protected DefaultWithArgument(final D declared, final A argument) {
 202             super(declared);
 203             this.argument = argument;
 204         }
 205
 206         @Override
 207         public final A argument() {
 208             return argument;
 209         }
 210     }
 211
 212     /**
 213      * Stateful version of {@link WithSchemaTree}. Schema tree namespace is eagerly instantiated (and checked).
 214      *
 215      * @param <A> Argument type ({@link Empty} if statement does not have argument.)
 216      * @param <D> Class representing declared version of this statement.
 217      */
 218     public abstract static class DefaultWithSchemaTree<A, D extends DeclaredStatement<A>> extends WithSchemaTree<A, D> {
 219         private final @NonNull Map<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
 220         private final @NonNull Object substatements;
 221         private final @NonNull D declared;
 222
 223         protected DefaultWithSchemaTree(final D declared,
 224                 final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 225             this.declared = requireNonNull(declared);
 226             this.substatements = maskList(substatements);
 227             this.schemaTree = immutableNamespaceOf(createSchemaTreeNamespace(substatements));
 228         }
 229
 230         protected DefaultWithSchemaTree(final DefaultWithSchemaTree<A, D> original) {
 231             this.declared = original.declared;
 232             this.schemaTree = original.schemaTree;
 233             this.substatements = original.substatements;
 234         }
 235
 236         @Override
 237         public final D getDeclared() {
 238             return declared;
 239         }
 240
 241         @Override
 242         public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
 243             return unmaskList(substatements);
 244         }
 245
 246         @Override
 247         protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
 248             return schemaTree;
 249         }
 250     }
 251
 252     /**
 253      * Stateful version of {@link WithDataTree}. Schema tree and data tree namespaces are eagerly instantiated
 254      * (and checked).
 255      *
 256      * @param <A> Argument type ({@link Empty} if statement does not have argument.)
 257      * @param <D> Class representing declared version of this statement.
 258      */
 259     public abstract static class DefaultWithDataTree<A, D extends DeclaredStatement<A>> extends WithDataTree<A, D> {
 260         public abstract static class WithTypedefNamespace<A, D extends DeclaredStatement<A>>
 261                 extends DefaultWithDataTree<A, D> {
 262             protected WithTypedefNamespace(final D declared,
 263                 final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 264                 super(declared, substatements);
 265                 // Consistency check only
 266                 createTypedefNamespace(substatements);
 267             }
 268
 269             protected WithTypedefNamespace(final WithTypedefNamespace<A, D> original) {
 270                 super(original);
 271             }
 272
 273             @Override
 274             @SuppressWarnings("unchecked")
 275             protected <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends Map<K, V>> getNamespaceContents(
 276                     final Class<N> namespace) {
 277                 if (TypedefNamespace.class.equals(namespace)) {
 278                     return Optional.of((Map<K, V>) new LinearTypedefNamespace(effectiveSubstatements()));
 279                 }
 280                 return super.getNamespaceContents(namespace);
 281             }
 282         }
 283
 284         private final @NonNull Map<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
 285         private final @NonNull Map<QName, DataTreeEffectiveStatement<?>> dataTree;
 286         private final @NonNull Object substatements;
 287         private final @NonNull D declared;
 288
 289         protected DefaultWithDataTree(final D declared,
 290                 final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
 291             this.declared = requireNonNull(declared);
 292             this.substatements = maskList(substatements);
 293
 294             // Note we call schema.values() so we do not retain them, as that is just pure memory overhead
 295             final Map<QName, SchemaTreeEffectiveStatement<?>> schema = createSchemaTreeNamespace(substatements);
 296             this.schemaTree = immutableNamespaceOf(schema);
 297             this.dataTree = createDataTreeNamespace(schema.values(), schemaTree);
 298         }
 299
 300         protected DefaultWithDataTree(final DefaultWithDataTree<A, D> original) {
 301             this.declared = original.declared;
 302             this.schemaTree = original.schemaTree;
 303             this.dataTree = original.dataTree;
 304             this.substatements = original.substatements;
 305         }
 306
 307         @Override
 308         public final D getDeclared() {
 309             return declared;
 310         }
 311
 312         @Override
 313         public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
 314             return unmaskList(substatements);
 315         }
 316
 317         @Override
 318         protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
 319             return schemaTree;
 320         }
 321
 322         @Override
 323         protected final Map<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace() {
 324             return dataTree;
 325         }
 326     }
 327 }