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