From: Robert Varga Date: Sun, 26 Jan 2020 13:05:42 +0000 (+0100) Subject: Optimize simple declared statements X-Git-Tag: v3.0.10~54 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=e938c422ef0287416c350d53987354ec29ff6d88;p=yangtools.git Optimize simple declared statements Our declared statements weigh in at 32/56 bytes each, which is a bit wasteful for what they are doing -- and it all boils down to class hierarchy. Introduce AbstractDeclaredStatement, which provides structural base to implement them with minimal footprint. Initial conversion includes simple statements, which can be implemented in 16/24 bytes. OrderedBy statement also takes advantage of low cardinality of its argument to further eliminate footprint in regular YANG use. JIRA: YANGTOOLS-1065 Change-Id: I6ea57a7260d3e33108c6c77c1ce120937181796f Signed-off-by: Robert Varga (cherry picked from commit ab3c2696f4b6ebc62529570ba39110876c3a3c98) --- diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredStatement.java new file mode 100644 index 0000000000..5b319d39c4 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredStatement.java @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt; + +import com.google.common.annotations.Beta; +import com.google.common.collect.ImmutableList; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.meta.StatementSource; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +/** + * An abstract base class for {@link DeclaredStatement} implementations. This is a direct competition to + * {@link org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement}, providing lower-footprint + * implementations. + */ +@Beta +public abstract class AbstractDeclaredStatement implements DeclaredStatement { + protected AbstractDeclaredStatement() { + } + + @Override + public final StatementSource getStatementSource() { + return StatementSource.DECLARATION; + } + + @Override + public Collection> declaredSubstatements() { + // Default to reduce load on subclasses and keep the number of implementations down + return ImmutableList.of(); + } + + /** + * Utility method for squashing singleton lists into single objects. This is a CPU/mem trade-off, which we are + * usually willing to make: for the cost of an instanceof check we can save one object and re-create it when needed. + * The inverse operation is #unmaskSubstatements(Object)}. + * + * @param substatements substatements to mask + * @return Masked substatements + * @throws NullPointerException if substatements is null + */ + protected static final @NonNull Object maskSubstatements( + final ImmutableList> substatements) { + // Note: ImmutableList guarantees non-null content + return substatements.size() == 1 ? substatements.get(0) : substatements; + } + + /** + * Utility method for recovering singleton lists squashed by {@link #maskSubstatements(ImmutableList)}. + * + * @param masked substatements to unmask + * @return List of substatements + * @throws NullPointerException if masked is null + * @throws ClassCastException if masked object was not produced by {@link #maskSubstatements(ImmutableList)} + */ + @SuppressWarnings("unchecked") + protected static final @NonNull ImmutableList> unmaskSubstatements( + final @NonNull Object masked) { + return masked instanceof ImmutableList ? (ImmutableList>) masked + // Yes, this is ugly code, which could use an explicit verify, that would just change the what sort + // of exception we throw. ClassCastException is as good as VerifyException. + : ImmutableList.of((DeclaredStatement) masked); + } + + public abstract static class WithRawArgument extends AbstractDeclaredStatement { + private final String rawArgument; + + protected WithRawArgument(final StmtContext context) { + rawArgument = context.rawStatementArgument(); + } + + @Override + public final String rawArgument() { + return rawArgument; + } + } + + public abstract static class WithRawStringArgument extends WithRawArgument { + protected WithRawStringArgument(final StmtContext context) { + super(context); + } + + @Override + public final String argument() { + return rawArgument(); + } + } + + public abstract static class WithArgument extends WithRawArgument { + private final A argument; + + protected WithArgument(final StmtContext context) { + super(context); + argument = context.getStatementArgument(); + } + + @Override + public final A argument() { + return argument; + } + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseStatementSupport.java index ffb357c4e6..c7650293fc 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseStatementSupport.java @@ -38,6 +38,19 @@ public abstract class BaseStatementSupport, super(publicDefinition); } + @Override + public final D createDeclared(final StmtContext ctx) { + final ImmutableList> substatements = ctx.declaredSubstatements().stream() + .map(StmtContext::buildDeclared) + .collect(ImmutableList.toImmutableList()); + return substatements.isEmpty() ? createEmptyDeclared(ctx) : createDeclared(ctx, substatements); + } + + protected abstract @NonNull D createDeclared(@NonNull StmtContext ctx, + @NonNull ImmutableList> substatements); + + protected abstract @NonNull D createEmptyDeclared(@NonNull StmtContext ctx); + @Override public final E createEffective(final StmtContext ctx) { final D declared = buildDeclared(ctx); diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/AbstractBelongsToStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/AbstractBelongsToStatement.java new file mode 100644 index 0000000000..1f475dc2dc --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/AbstractBelongsToStatement.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.belongs_to; + +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawStringArgument; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +abstract class AbstractBelongsToStatement extends WithRawStringArgument implements BelongsToStatement { + AbstractBelongsToStatement(final StmtContext context) { + super(context); + } + + @Override + public final StatementDefinition statementDefinition() { + return YangStmtMapping.BELONGS_TO; + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/BelongsToStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/BelongsToStatementImpl.java deleted file mode 100644 index 64959136b5..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/BelongsToStatementImpl.java +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.belongs_to; - -import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; - -final class BelongsToStatementImpl extends AbstractDeclaredStatement - implements BelongsToStatement { - BelongsToStatementImpl(final StmtContext context) { - super(context); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/BelongsToStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/BelongsToStatementSupport.java index 6ee915e34e..7979f3f473 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/BelongsToStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/BelongsToStatementSupport.java @@ -12,6 +12,7 @@ import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.f import com.google.common.collect.ImmutableList; import java.util.Collection; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.BelongsToEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement; @@ -51,11 +52,6 @@ public final class BelongsToStatementSupport return value; } - @Override - public BelongsToStatement createDeclared(final StmtContext ctx) { - return new BelongsToStatementImpl(ctx); - } - @Override public void onPreLinkageDeclared(final Mutable ctx) { ctx.addRequiredSource(getSourceIdentifier(ctx)); @@ -91,6 +87,17 @@ public final class BelongsToStatementSupport }); } + @Override + protected BelongsToStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularBelongsToStatement(ctx, substatements); + } + + @Override + protected BelongsToStatement createEmptyDeclared(final StmtContext ctx) { + return new EmptyBelongsToStatement(ctx); + } + @Override protected BelongsToEffectiveStatement createEffective( final StmtContext ctx, diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/EmptyBelongsToStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/EmptyBelongsToStatement.java new file mode 100644 index 0000000000..11d12cf9c6 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/EmptyBelongsToStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.belongs_to; + +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class EmptyBelongsToStatement extends AbstractBelongsToStatement { + EmptyBelongsToStatement(final StmtContext context) { + super(context); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToStatement.java new file mode 100644 index 0000000000..2227403e94 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToStatement.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.belongs_to; + +import com.google.common.collect.ImmutableList; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class RegularBelongsToStatement extends AbstractBelongsToStatement { + private final @NonNull Object substatements; + + RegularBelongsToStatement(final StmtContext context, + final ImmutableList> substatements) { + super(context); + this.substatements = maskSubstatements(substatements); + } + + @Override + public Collection> declaredSubstatements() { + return unmaskSubstatements(substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/AbstractContactStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/AbstractContactStatement.java new file mode 100644 index 0000000000..6ca681e8bd --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/AbstractContactStatement.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.contact; + +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawStringArgument; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +abstract class AbstractContactStatement extends WithRawStringArgument implements ContactStatement { + AbstractContactStatement(final StmtContext context) { + super(context); + } + + @Override + public final StatementDefinition statementDefinition() { + return YangStmtMapping.CONTACT; + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/ContactStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/ContactStatementImpl.java deleted file mode 100644 index be618e6fe8..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/ContactStatementImpl.java +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.contact; - -import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; - -final class ContactStatementImpl extends AbstractDeclaredStatement implements ContactStatement { - ContactStatementImpl(final StmtContext context) { - super(context); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/ContactStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/ContactStatementSupport.java index 4d464adc8e..452558effd 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/ContactStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/ContactStatementSupport.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.contact; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.ContactEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement; @@ -36,13 +37,19 @@ public final class ContactStatementSupport } @Override - public ContactStatement createDeclared(final StmtContext ctx) { - return new ContactStatementImpl(ctx); + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; } @Override - protected SubstatementValidator getSubstatementValidator() { - return SUBSTATEMENT_VALIDATOR; + protected ContactStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularContactStatement(ctx, substatements); + } + + @Override + protected ContactStatement createEmptyDeclared(final StmtContext ctx) { + return new EmptyContactStatement(ctx); } @Override diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/EmptyContactStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/EmptyContactStatement.java new file mode 100644 index 0000000000..5c8a08d8c4 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/EmptyContactStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.contact; + +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class EmptyContactStatement extends AbstractContactStatement { + EmptyContactStatement(final StmtContext context) { + super(context); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/RegularContactStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/RegularContactStatement.java new file mode 100644 index 0000000000..f490af4296 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/contact/RegularContactStatement.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.contact; + +import com.google.common.collect.ImmutableList; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class RegularContactStatement extends AbstractContactStatement { + private final @NonNull Object substatements; + + RegularContactStatement(final StmtContext context, + final ImmutableList> substatements) { + super(context); + this.substatements = maskSubstatements(substatements); + } + + @Override + public Collection> declaredSubstatements() { + return unmaskSubstatements(substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/AbstractDefaultStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/AbstractDefaultStatement.java new file mode 100644 index 0000000000..17e2ec4ad0 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/AbstractDefaultStatement.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.default_; + +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawStringArgument; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +abstract class AbstractDefaultStatement extends WithRawStringArgument implements DefaultStatement { + AbstractDefaultStatement(final StmtContext context) { + super(context); + } + + @Override + public final StatementDefinition statementDefinition() { + return YangStmtMapping.DEFAULT; + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/DefaultStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/DefaultStatementImpl.java deleted file mode 100644 index 2ad75aa8cd..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/DefaultStatementImpl.java +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.default_; - -import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; - -final class DefaultStatementImpl extends AbstractDeclaredStatement implements - DefaultStatement { - DefaultStatementImpl(final StmtContext context) { - super(context); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/DefaultStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/DefaultStatementSupport.java index a038934eb9..43ad0acf68 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/DefaultStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/DefaultStatementSupport.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.default_; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.DefaultEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement; @@ -36,13 +37,19 @@ public final class DefaultStatementSupport } @Override - public DefaultStatement createDeclared(final StmtContext ctx) { - return new DefaultStatementImpl(ctx); + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; } @Override - protected SubstatementValidator getSubstatementValidator() { - return SUBSTATEMENT_VALIDATOR; + protected DefaultStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularDefaultStatement(ctx, substatements); + } + + @Override + protected DefaultStatement createEmptyDeclared(final StmtContext ctx) { + return new EmptyDefaultStatement(ctx); } @Override diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/EmptyDefaultStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/EmptyDefaultStatement.java new file mode 100644 index 0000000000..ea09ba75bc --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/EmptyDefaultStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.default_; + +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class EmptyDefaultStatement extends AbstractDefaultStatement { + EmptyDefaultStatement(final StmtContext context) { + super(context); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/RegularDefaultStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/RegularDefaultStatement.java new file mode 100644 index 0000000000..259a17e154 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/default_/RegularDefaultStatement.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.default_; + +import com.google.common.collect.ImmutableList; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class RegularDefaultStatement extends AbstractDefaultStatement { + private final @NonNull Object substatements; + + RegularDefaultStatement(final StmtContext context, + final ImmutableList> substatements) { + super(context); + this.substatements = maskSubstatements(substatements); + } + + @Override + public Collection> declaredSubstatements() { + return unmaskSubstatements(substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/AbstractDescriptionStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/AbstractDescriptionStatement.java new file mode 100644 index 0000000000..5853b800c7 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/AbstractDescriptionStatement.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.description; + +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawStringArgument; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +abstract class AbstractDescriptionStatement extends WithRawStringArgument implements DescriptionStatement { + AbstractDescriptionStatement(final StmtContext context) { + super(context); + } + + @Override + public final StatementDefinition statementDefinition() { + return YangStmtMapping.DESCRIPTION; + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/DescriptionStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/DescriptionStatementImpl.java deleted file mode 100644 index a61f7a823c..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/DescriptionStatementImpl.java +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.description; - -import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; - -final class DescriptionStatementImpl extends AbstractDeclaredStatement implements DescriptionStatement { - DescriptionStatementImpl(final StmtContext context) { - super(context); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/DescriptionStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/DescriptionStatementSupport.java index c7d7a65613..f83401f7de 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/DescriptionStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/DescriptionStatementSupport.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.description; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.DescriptionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement; @@ -36,13 +37,19 @@ public final class DescriptionStatementSupport } @Override - public DescriptionStatement createDeclared(final StmtContext ctx) { - return new DescriptionStatementImpl(ctx); + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; } @Override - protected SubstatementValidator getSubstatementValidator() { - return SUBSTATEMENT_VALIDATOR; + protected DescriptionStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularDescriptionStatement(ctx, substatements); + } + + @Override + protected DescriptionStatement createEmptyDeclared(final StmtContext ctx) { + return new EmptyDescriptionStatement(ctx); } @Override diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/EmptyDescriptionStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/EmptyDescriptionStatement.java new file mode 100644 index 0000000000..d516aac707 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/EmptyDescriptionStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.description; + +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class EmptyDescriptionStatement extends AbstractDescriptionStatement { + EmptyDescriptionStatement(final StmtContext context) { + super(context); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/RegularDescriptionStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/RegularDescriptionStatement.java new file mode 100644 index 0000000000..a504d1fa3d --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/description/RegularDescriptionStatement.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.description; + +import com.google.common.collect.ImmutableList; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class RegularDescriptionStatement extends AbstractDescriptionStatement { + private final @NonNull Object substatements; + + RegularDescriptionStatement(final StmtContext context, + final ImmutableList> substatements) { + super(context); + this.substatements = maskSubstatements(substatements); + } + + @Override + public Collection> declaredSubstatements() { + return unmaskSubstatements(substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/AbstractErrorAppTagStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/AbstractErrorAppTagStatement.java new file mode 100644 index 0000000000..52993ec1d6 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/AbstractErrorAppTagStatement.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_app_tag; + +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawStringArgument; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +abstract class AbstractErrorAppTagStatement extends WithRawStringArgument implements ErrorAppTagStatement { + AbstractErrorAppTagStatement(final StmtContext context) { + super(context); + } + + @Override + public final StatementDefinition statementDefinition() { + return YangStmtMapping.ERROR_APP_TAG; + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/EmptyErrorAppTagStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/EmptyErrorAppTagStatement.java new file mode 100644 index 0000000000..4954725702 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/EmptyErrorAppTagStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_app_tag; + +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class EmptyErrorAppTagStatement extends AbstractErrorAppTagStatement { + EmptyErrorAppTagStatement(final StmtContext context) { + super(context); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/ErrorAppTagStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/ErrorAppTagStatementImpl.java deleted file mode 100644 index c60f1de30b..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/ErrorAppTagStatementImpl.java +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_app_tag; - -import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; - -final class ErrorAppTagStatementImpl extends AbstractDeclaredStatement implements ErrorAppTagStatement { - ErrorAppTagStatementImpl(final StmtContext context) { - super(context); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/ErrorAppTagStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/ErrorAppTagStatementSupport.java index e5c0fe5763..195080cee8 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/ErrorAppTagStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/ErrorAppTagStatementSupport.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_app_tag; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.ErrorAppTagEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement; @@ -36,13 +37,19 @@ public final class ErrorAppTagStatementSupport } @Override - public ErrorAppTagStatement createDeclared(final StmtContext ctx) { - return new ErrorAppTagStatementImpl(ctx); + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; } @Override - protected SubstatementValidator getSubstatementValidator() { - return SUBSTATEMENT_VALIDATOR; + protected ErrorAppTagStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularErrorAppTagStatement(ctx, substatements); + } + + @Override + protected ErrorAppTagStatement createEmptyDeclared(final StmtContext ctx) { + return new EmptyErrorAppTagStatement(ctx); } @Override diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagStatement.java new file mode 100644 index 0000000000..2cefb67f41 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagStatement.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_app_tag; + +import com.google.common.collect.ImmutableList; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class RegularErrorAppTagStatement extends AbstractErrorAppTagStatement { + private final @NonNull Object substatements; + + RegularErrorAppTagStatement(final StmtContext context, + final ImmutableList> substatements) { + super(context); + this.substatements = maskSubstatements(substatements); + } + + @Override + public Collection> declaredSubstatements() { + return unmaskSubstatements(substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/AbstractErrorMessageStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/AbstractErrorMessageStatement.java new file mode 100644 index 0000000000..bb6c50b5ab --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/AbstractErrorMessageStatement.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_message; + +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawStringArgument; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +abstract class AbstractErrorMessageStatement extends WithRawStringArgument implements ErrorMessageStatement { + AbstractErrorMessageStatement(final StmtContext context) { + super(context); + } + + @Override + public final StatementDefinition statementDefinition() { + return YangStmtMapping.ERROR_MESSAGE; + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/EmptyErrorMessageStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/EmptyErrorMessageStatement.java new file mode 100644 index 0000000000..17595df678 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/EmptyErrorMessageStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_message; + +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class EmptyErrorMessageStatement extends AbstractErrorMessageStatement { + EmptyErrorMessageStatement(final StmtContext context) { + super(context); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/ErrorMessageStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/ErrorMessageStatementImpl.java deleted file mode 100644 index b7916464ed..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/ErrorMessageStatementImpl.java +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_message; - -import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; - -final class ErrorMessageStatementImpl extends AbstractDeclaredStatement implements ErrorMessageStatement { - ErrorMessageStatementImpl(final StmtContext context) { - super(context); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/ErrorMessageStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/ErrorMessageStatementSupport.java index 7e561c1480..75f20aad96 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/ErrorMessageStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/ErrorMessageStatementSupport.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_message; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.ErrorMessageEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement; @@ -36,13 +37,19 @@ public final class ErrorMessageStatementSupport } @Override - public ErrorMessageStatement createDeclared(final StmtContext ctx) { - return new ErrorMessageStatementImpl(ctx); + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; } @Override - protected SubstatementValidator getSubstatementValidator() { - return SUBSTATEMENT_VALIDATOR; + protected ErrorMessageStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularErrorMessageStatement(ctx, substatements); + } + + @Override + protected ErrorMessageStatement createEmptyDeclared(final StmtContext ctx) { + return new EmptyErrorMessageStatement(ctx); } @Override diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageStatement.java new file mode 100644 index 0000000000..54a591d726 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageStatement.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_message; + +import com.google.common.collect.ImmutableList; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class RegularErrorMessageStatement extends AbstractErrorMessageStatement { + private final @NonNull Object substatements; + + RegularErrorMessageStatement(final StmtContext context, + final ImmutableList> substatements) { + super(context); + this.substatements = maskSubstatements(substatements); + } + + @Override + public Collection> declaredSubstatements() { + return unmaskSubstatements(substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/AbstractKeyStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/AbstractKeyStatement.java new file mode 100644 index 0000000000..d050fa35a3 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/AbstractKeyStatement.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.key; + +import java.util.Collection; +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +abstract class AbstractKeyStatement extends AbstractDeclaredStatement.WithArgument> + implements KeyStatement { + AbstractKeyStatement(final StmtContext, ?, ?> context) { + super(context); + } + + @Override + public final StatementDefinition statementDefinition() { + return YangStmtMapping.KEY; + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/KeyStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/EmptyKeyStatement.java similarity index 52% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/KeyStatementImpl.java rename to yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/EmptyKeyStatement.java index 99648fd50f..b8a0bcfcf3 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/KeyStatementImpl.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/EmptyKeyStatement.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v1.0 which accompanies this distribution, @@ -8,14 +8,11 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.key; import java.util.Collection; -import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; -final class KeyStatementImpl extends AbstractDeclaredStatement> - implements KeyStatement { - KeyStatementImpl(final StmtContext, KeyStatement, ?> context) { +final class EmptyKeyStatement extends AbstractKeyStatement { + EmptyKeyStatement(final StmtContext, ?, ?> context) { super(context); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/KeyStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/KeyStatementSupport.java index 1d94bd07f2..522e81511c 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/KeyStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/KeyStatementSupport.java @@ -15,6 +15,7 @@ import java.util.Collection; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.KeyEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement; @@ -81,13 +82,20 @@ public final class KeyStatementSupport } @Override - public KeyStatement createDeclared(final StmtContext, KeyStatement, ?> ctx) { - return new KeyStatementImpl(ctx); + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; } @Override - protected SubstatementValidator getSubstatementValidator() { - return SUBSTATEMENT_VALIDATOR; + protected KeyStatement createDeclared(final StmtContext, KeyStatement, ?> ctx, + final ImmutableList> substatements) { + return new RegularKeyStatement(ctx, substatements); + } + + @Override + protected KeyStatement createEmptyDeclared( + final StmtContext, KeyStatement, ?> ctx) { + return new EmptyKeyStatement(ctx); } @Override diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularKeyStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularKeyStatement.java new file mode 100644 index 0000000000..de5948d49c --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/key/RegularKeyStatement.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.key; + +import com.google.common.collect.ImmutableList; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class RegularKeyStatement extends AbstractKeyStatement { + private final @NonNull Object substatements; + + RegularKeyStatement(final StmtContext, ?, ?> context, + final ImmutableList> substatements) { + super(context); + this.substatements = maskSubstatements(substatements); + } + + @Override + public Collection> declaredSubstatements() { + return unmaskSubstatements(substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/AbstractOrderedByStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/AbstractOrderedByStatement.java new file mode 100644 index 0000000000..1ba1451e41 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/AbstractOrderedByStatement.java @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ordered_by; + +import static java.util.Objects.requireNonNull; + +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement; + +abstract class AbstractOrderedByStatement extends AbstractDeclaredStatement implements OrderedByStatement { + private final @NonNull String argument; + + AbstractOrderedByStatement(final String argument) { + this.argument = requireNonNull(argument); + } + + @Override + public final @NonNull String argument() { + return argument; + } + + @Override + public final @NonNull String rawArgument() { + return argument; + } + + @Override + public final StatementDefinition statementDefinition() { + return YangStmtMapping.ORDERED_BY; + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/EmptyOrderedByStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/EmptyOrderedByStatement.java new file mode 100644 index 0000000000..617ebf433c --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/EmptyOrderedByStatement.java @@ -0,0 +1,14 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ordered_by; + +final class EmptyOrderedByStatement extends AbstractOrderedByStatement { + EmptyOrderedByStatement(final String argument) { + super(argument); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementImpl.java deleted file mode 100644 index 266b2558f0..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementImpl.java +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ordered_by; - -import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; - -final class OrderedByStatementImpl extends AbstractDeclaredStatement implements OrderedByStatement { - OrderedByStatementImpl(final StmtContext context) { - super(context); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementSupport.java index aeefa3bccc..7a43729653 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementSupport.java @@ -8,7 +8,9 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ordered_by; import com.google.common.collect.ImmutableList; +import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.OrderedByEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement; @@ -22,6 +24,13 @@ public final class OrderedByStatementSupport SubstatementValidator.builder(YangStmtMapping.ORDERED_BY).build(); private static final OrderedByStatementSupport INSTANCE = new OrderedByStatementSupport(); + /* + * Ordered-by has low argument cardinality, hence we can reuse them in case declaration does not have any + * substatements (which is the usual case). + */ + private static final @NonNull EmptyOrderedByStatement EMPTY_SYSTEM_DECL = new EmptyOrderedByStatement("system"); + private static final @NonNull EmptyOrderedByStatement EMPTY_USER_DECL = new EmptyOrderedByStatement("user"); + private OrderedByStatementSupport() { super(YangStmtMapping.ORDERED_BY); } @@ -36,8 +45,14 @@ public final class OrderedByStatementSupport } @Override - public OrderedByStatement createDeclared(final StmtContext ctx) { - return new OrderedByStatementImpl(ctx); + public String internArgument(final String rawArgument) { + if ("user".equals(rawArgument)) { + return "user"; + } else if ("system".equals(rawArgument)) { + return "system"; + } else { + return rawArgument; + } } @Override @@ -45,6 +60,25 @@ public final class OrderedByStatementSupport return SUBSTATEMENT_VALIDATOR; } + @Override + protected OrderedByStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularOrderedByStatement(ctx.coerceStatementArgument(), substatements); + } + + @Override + protected OrderedByStatement createEmptyDeclared(final StmtContext ctx) { + final String argument = ctx.coerceStatementArgument(); + switch (argument) { + case "system": + return EMPTY_SYSTEM_DECL; + case "user": + return EMPTY_USER_DECL; + default: + throw new IllegalStateException("Unhandled argument " + argument); + } + } + @Override protected OrderedByEffectiveStatement createEffective( final StmtContext ctx, @@ -59,15 +93,4 @@ public final class OrderedByStatementSupport final OrderedByStatement declared) { return new EmptyOrderedByEffectiveStatement(declared); } - - @Override - public String internArgument(final String rawArgument) { - if ("user".equals(rawArgument)) { - return "user"; - } else if ("system".equals(rawArgument)) { - return "system"; - } else { - return rawArgument; - } - } -} \ No newline at end of file +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByStatement.java new file mode 100644 index 0000000000..6055be42f5 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByStatement.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ordered_by; + +import com.google.common.collect.ImmutableList; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; + +final class RegularOrderedByStatement extends AbstractOrderedByStatement { + private final @NonNull Object substatements; + + RegularOrderedByStatement(final String argument, + final ImmutableList> substatements) { + super(argument); + this.substatements = maskSubstatements(substatements); + } + + @Override + public Collection> declaredSubstatements() { + return unmaskSubstatements(substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/AbstractPrefixStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/AbstractPrefixStatement.java new file mode 100644 index 0000000000..10d06f0155 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/AbstractPrefixStatement.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.prefix; + +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawStringArgument; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +abstract class AbstractPrefixStatement extends WithRawStringArgument implements PrefixStatement { + AbstractPrefixStatement(final StmtContext context) { + super(context); + } + + @Override + public final StatementDefinition statementDefinition() { + return YangStmtMapping.PREFIX; + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/EmptyPrefixStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/EmptyPrefixStatement.java new file mode 100644 index 0000000000..5f2cb57e4d --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/EmptyPrefixStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.prefix; + +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class EmptyPrefixStatement extends AbstractPrefixStatement { + EmptyPrefixStatement(final StmtContext context) { + super(context); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/PrefixStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/PrefixStatementImpl.java deleted file mode 100644 index 4c1816e639..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/PrefixStatementImpl.java +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.prefix; - -import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; - -final class PrefixStatementImpl extends AbstractDeclaredStatement implements PrefixStatement { - PrefixStatementImpl(final StmtContext context) { - super(context); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/PrefixStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/PrefixStatementSupport.java index 09b8d59073..2516cae680 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/PrefixStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/PrefixStatementSupport.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.prefix; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.PrefixEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement; @@ -36,13 +37,19 @@ public final class PrefixStatementSupport } @Override - public PrefixStatement createDeclared(final StmtContext ctx) { - return new PrefixStatementImpl(ctx); + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; } @Override - protected SubstatementValidator getSubstatementValidator() { - return SUBSTATEMENT_VALIDATOR; + protected PrefixStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularPrefixStatement(ctx, substatements); + } + + @Override + protected PrefixStatement createEmptyDeclared(final StmtContext ctx) { + return new EmptyPrefixStatement(ctx); } @Override diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/RegularPrefixStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/RegularPrefixStatement.java new file mode 100644 index 0000000000..621c387c41 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/prefix/RegularPrefixStatement.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.prefix; + +import com.google.common.collect.ImmutableList; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class RegularPrefixStatement extends AbstractPrefixStatement { + private final @NonNull Object substatements; + + RegularPrefixStatement(final StmtContext context, + final ImmutableList> substatements) { + super(context); + this.substatements = maskSubstatements(substatements); + } + + @Override + public Collection> declaredSubstatements() { + return unmaskSubstatements(substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/AbstractPresenceStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/AbstractPresenceStatement.java new file mode 100644 index 0000000000..068b7f2d56 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/AbstractPresenceStatement.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.presence; + +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawStringArgument; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +abstract class AbstractPresenceStatement extends WithRawStringArgument implements PresenceStatement { + AbstractPresenceStatement(final StmtContext context) { + super(context); + } + + @Override + public final StatementDefinition statementDefinition() { + return YangStmtMapping.PRESENCE; + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/EmptyPresenceStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/EmptyPresenceStatement.java new file mode 100644 index 0000000000..16e734b337 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/EmptyPresenceStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.presence; + +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class EmptyPresenceStatement extends AbstractPresenceStatement { + EmptyPresenceStatement(final StmtContext context) { + super(context); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/PresenceStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/PresenceStatementImpl.java deleted file mode 100644 index 12e06f008b..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/PresenceStatementImpl.java +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.presence; - -import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; - -final class PresenceStatementImpl extends AbstractDeclaredStatement implements PresenceStatement { - PresenceStatementImpl(final StmtContext context) { - super(context); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/PresenceStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/PresenceStatementSupport.java index 2fd845bf93..ae73d61e12 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/PresenceStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/PresenceStatementSupport.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.presence; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.PresenceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement; @@ -36,13 +37,19 @@ public final class PresenceStatementSupport } @Override - public PresenceStatement createDeclared(final StmtContext ctx) { - return new PresenceStatementImpl(ctx); + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; } @Override - protected SubstatementValidator getSubstatementValidator() { - return SUBSTATEMENT_VALIDATOR; + protected PresenceStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularPresenceStatement(ctx, substatements); + } + + @Override + protected PresenceStatement createEmptyDeclared(final StmtContext ctx) { + return new EmptyPresenceStatement(ctx); } @Override diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/RegularPresenceStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/RegularPresenceStatement.java new file mode 100644 index 0000000000..5e97171d68 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/presence/RegularPresenceStatement.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.presence; + +import com.google.common.collect.ImmutableList; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class RegularPresenceStatement extends AbstractPresenceStatement { + private final @NonNull Object substatements; + + RegularPresenceStatement(final StmtContext context, + final ImmutableList> substatements) { + super(context); + this.substatements = maskSubstatements(substatements); + } + + @Override + public Collection> declaredSubstatements() { + return unmaskSubstatements(substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/AbstractReferenceStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/AbstractReferenceStatement.java new file mode 100644 index 0000000000..5f08d05c02 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/AbstractReferenceStatement.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.reference; + +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawStringArgument; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +abstract class AbstractReferenceStatement extends WithRawStringArgument implements ReferenceStatement { + AbstractReferenceStatement(final StmtContext context) { + super(context); + } + + @Override + public final StatementDefinition statementDefinition() { + return YangStmtMapping.REFERENCE; + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/EmptyReferenceStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/EmptyReferenceStatement.java new file mode 100644 index 0000000000..7a762fc94c --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/EmptyReferenceStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.reference; + +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class EmptyReferenceStatement extends AbstractReferenceStatement { + EmptyReferenceStatement(final StmtContext context) { + super(context); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/ReferenceStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/ReferenceStatementSupport.java index e73ef12f60..28ba59ab0f 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/ReferenceStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/ReferenceStatementSupport.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.reference; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.ReferenceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement; @@ -37,13 +38,19 @@ public final class ReferenceStatementSupport } @Override - public ReferenceStatement createDeclared(final StmtContext ctx) { - return new ReferenceStatementImpl(ctx); + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; } @Override - protected SubstatementValidator getSubstatementValidator() { - return SUBSTATEMENT_VALIDATOR; + protected ReferenceStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularReferenceStatement(ctx, substatements); + } + + @Override + protected ReferenceStatement createEmptyDeclared(final StmtContext ctx) { + return new EmptyReferenceStatement(ctx); } @Override diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceStatement.java new file mode 100644 index 0000000000..abc2989ba5 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceStatement.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.reference; + +import com.google.common.collect.ImmutableList; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class RegularReferenceStatement extends AbstractReferenceStatement { + private final @NonNull Object substatements; + + RegularReferenceStatement(final StmtContext context, + final ImmutableList> substatements) { + super(context); + this.substatements = maskSubstatements(substatements); + } + + @Override + public Collection> declaredSubstatements() { + return unmaskSubstatements(substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/AbstractUnitsStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/AbstractUnitsStatement.java new file mode 100644 index 0000000000..ec231e7655 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/AbstractUnitsStatement.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.units; + +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawStringArgument; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +abstract class AbstractUnitsStatement extends WithRawStringArgument implements UnitsStatement { + AbstractUnitsStatement(final StmtContext context) { + super(context); + } + + @Override + public final StatementDefinition statementDefinition() { + return YangStmtMapping.UNITS; + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/EmptyUnitsStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/EmptyUnitsStatement.java new file mode 100644 index 0000000000..88630698b8 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/EmptyUnitsStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.units; + +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class EmptyUnitsStatement extends AbstractUnitsStatement { + EmptyUnitsStatement(final StmtContext context) { + super(context); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/RegularUnitsStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/RegularUnitsStatement.java new file mode 100644 index 0000000000..b6d278f054 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/RegularUnitsStatement.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.units; + +import com.google.common.collect.ImmutableList; +import java.util.Collection; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class RegularUnitsStatement extends AbstractUnitsStatement { + private final @NonNull Object substatements; + + RegularUnitsStatement(final StmtContext context, + final ImmutableList> substatements) { + super(context); + this.substatements = maskSubstatements(substatements); + } + + @Override + public Collection> declaredSubstatements() { + return unmaskSubstatements(substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/UnitsStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/UnitsStatementImpl.java deleted file mode 100644 index b0ca5d7ee6..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/UnitsStatementImpl.java +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.units; - -import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; - -final class UnitsStatementImpl extends AbstractDeclaredStatement implements UnitsStatement { - UnitsStatementImpl(final StmtContext context) { - super(context); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/UnitsStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/UnitsStatementSupport.java index fcf4914498..3a1fb84363 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/UnitsStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/units/UnitsStatementSupport.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.units; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.UnitsEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement; @@ -37,13 +38,19 @@ public final class UnitsStatementSupport } @Override - public UnitsStatement createDeclared(final StmtContext ctx) { - return new UnitsStatementImpl(ctx); + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; } @Override - protected SubstatementValidator getSubstatementValidator() { - return SUBSTATEMENT_VALIDATOR; + protected UnitsStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularUnitsStatement(ctx, substatements); + } + + @Override + protected UnitsStatement createEmptyDeclared(final StmtContext ctx) { + return new EmptyUnitsStatement(ctx); } @Override @@ -59,4 +66,4 @@ public final class UnitsStatementSupport final UnitsStatement declared) { return new EmptyUnitsEffectiveStatement(declared); } -} \ No newline at end of file +}