yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredStatement.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.parser.rfc7950.stmt;
   9
  10 import static com.google.common.base.Verify.verifyNotNull;
  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.Collection;
  16 import org.eclipse.jdt.annotation.NonNull;
  17 import org.opendaylight.yangtools.yang.common.Empty;
  18 import org.opendaylight.yangtools.yang.common.QName;
  19 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
  20 import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
  21
  22 /**
  23  * An abstract base class for {@link DeclaredStatement} implementations. This is a direct competition to
  24  * {@link org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement}, providing lower-footprint
  25  * implementations.
  26  */
  27 @Beta
  28 // FIXME: 7.0.0: we should be able to promote this to model.spi.meta package.
  29 public abstract class AbstractDeclaredStatement<A> extends AbstractModelStatement<A> implements DeclaredStatement<A> {
  30     protected AbstractDeclaredStatement() {
  31     }
  32
  33     @Override
  34     public StatementSource getStatementSource() {
  35         return StatementSource.DECLARATION;
  36     }
  37
  38     @Override
  39     public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
  40         // Default to reduce load on subclasses and keep the number of implementations down
  41         return ImmutableList.of();
  42     }
  43
  44     /**
  45      * Utility method for recovering singleton lists squashed by {@link #maskList(ImmutableList)}.
  46      *
  47      * @param masked list to unmask
  48      * @return Unmasked list
  49      * @throws NullPointerException if masked is null
  50      * @throws ClassCastException if masked object does not match DeclaredStatement
  51      */
  52     @SuppressWarnings({ "rawtypes", "unchecked" })
  53     protected static final @NonNull ImmutableList<? extends DeclaredStatement<?>> unmaskList(
  54             final @NonNull Object masked) {
  55         return (ImmutableList) unmaskList(masked, DeclaredStatement.class);
  56     }
  57
  58     public abstract static class WithRawArgument<A> extends AbstractDeclaredStatement<A> {
  59         public abstract static class WithSubstatements<A> extends WithRawArgument<A> {
  60             private final @NonNull Object substatements;
  61
  62             protected WithSubstatements(final String rawArgument,
  63                     final ImmutableList<? extends DeclaredStatement<?>> substatements) {
  64                 super(rawArgument);
  65                 this.substatements = maskList(substatements);
  66             }
  67
  68             @Override
  69             public final Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
  70                 return unmaskList(substatements);
  71             }
  72         }
  73
  74         private final String rawArgument;
  75
  76         protected WithRawArgument(final String rawArgument) {
  77             this.rawArgument = rawArgument;
  78         }
  79
  80         @Override
  81         public final String rawArgument() {
  82             return rawArgument;
  83         }
  84     }
  85
  86     public abstract static class WithQNameArgument extends AbstractDeclaredStatement<QName> {
  87         public abstract static class WithSubstatements extends WithQNameArgument {
  88             private final @NonNull Object substatements;
  89
  90             protected WithSubstatements(final QName argument,
  91                     final ImmutableList<? extends DeclaredStatement<?>> substatements) {
  92                 super(argument);
  93                 this.substatements = maskList(substatements);
  94             }
  95
  96             @Override
  97             public final Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
  98                 return unmaskList(substatements);
  99             }
 100         }
 101
 102         private final @NonNull QName argument;
 103
 104         protected WithQNameArgument(final QName argument) {
 105             this.argument = requireNonNull(argument);
 106         }
 107
 108         @Override
 109         public final QName argument() {
 110             return argument;
 111         }
 112
 113         @Override
 114         public final String rawArgument() {
 115             return argument.getLocalName();
 116         }
 117     }
 118
 119     public abstract static class WithRawStringArgument extends WithRawArgument<String> {
 120         public abstract static class WithSubstatements extends WithRawStringArgument {
 121             private final @NonNull Object substatements;
 122
 123             protected WithSubstatements(final String rawArgument,
 124                     final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 125                 super(rawArgument);
 126                 this.substatements = maskList(substatements);
 127             }
 128
 129             @Override
 130             public final Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
 131                 return unmaskList(substatements);
 132             }
 133         }
 134
 135         protected WithRawStringArgument(final String rawArgument) {
 136             super(verifyNotNull(rawArgument));
 137         }
 138
 139         @Override
 140         public final String argument() {
 141             return verifyNotNull(rawArgument());
 142         }
 143     }
 144
 145     public abstract static class WithArgument<A> extends WithRawArgument<A> {
 146         public abstract static class WithSubstatements<A> extends WithArgument<A> {
 147             private final @NonNull Object substatements;
 148
 149             protected WithSubstatements(final String rawArgument, final A argument,
 150                     final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 151                 super(rawArgument, argument);
 152                 this.substatements = maskList(substatements);
 153             }
 154
 155             @Override
 156             public final Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
 157                 return unmaskList(substatements);
 158             }
 159         }
 160
 161         private final @NonNull A argument;
 162
 163         protected WithArgument(final String rawArgument, final A argument) {
 164             super(rawArgument);
 165             this.argument = requireNonNull(argument);
 166         }
 167
 168         @Override
 169         public final A argument() {
 170             return argument;
 171         }
 172     }
 173
 174     public abstract static class ArgumentToString<A> extends AbstractDeclaredStatement<A> {
 175         public abstract static class WithSubstatements<A> extends ArgumentToString<A> {
 176             private final @NonNull Object substatements;
 177
 178             protected WithSubstatements(final A argument,
 179                     final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 180                 super(argument);
 181                 this.substatements = maskList(substatements);
 182             }
 183
 184             @Override
 185             public final Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
 186                 return unmaskList(substatements);
 187             }
 188         }
 189
 190         private final @NonNull A argument;
 191
 192         protected ArgumentToString(final @NonNull A argument) {
 193             this.argument = requireNonNull(argument);
 194         }
 195
 196         @Override
 197         public final A argument() {
 198             return argument;
 199         }
 200
 201         @Override
 202         public final String rawArgument() {
 203             return argument.toString();
 204         }
 205     }
 206
 207     public abstract static class WithoutArgument extends AbstractDeclaredStatement<Empty> {
 208         public abstract static class WithSubstatements extends WithoutArgument {
 209             private final @NonNull Object substatements;
 210
 211             protected WithSubstatements(final ImmutableList<? extends DeclaredStatement<?>> substatements) {
 212                 this.substatements = maskList(substatements);
 213             }
 214
 215             @Override
 216             public final Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
 217                 return unmaskList(substatements);
 218             }
 219         }
 220
 221         @Override
 222         public final Empty argument() {
 223             return Empty.getInstance();
 224         }
 225
 226         @Override
 227         public final String rawArgument() {
 228             return null;
 229         }
 230     }
 231 }