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