From dadc9aa0a7f3af000b4205f94cf86dba7e908d75 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Thu, 22 Apr 2021 13:51:42 +0200 Subject: [PATCH] All StatementSupports must support DeclarationReference Make sure we force all StatementSupport classes to implement attachDeclarationReference(), without a default no-op implementation. Also fix all implementation to comply with this requirement. JIRA: YANGTOOLS-1193 Change-Id: I06d1de989dc967d27477dbf49111f792706a4799 Signed-off-by: Robert Varga --- .../AugmentIdentifierStatementSupport.java | 7 ++ .../ContextInstanceStatementSupport.java | 7 ++ .../ContextReferenceStatementSupport.java | 7 ++ .../InstanceTargetStatementSupport.java | 7 ++ .../parser/RefAugmentIdentifierStatement.java | 20 +++++ .../parser/RefContextInstanceStatement.java | 20 +++++ .../parser/RefContextReferenceStatement.java | 20 +++++ .../parser/RefInstanceTargetStatement.java | 19 ++++ .../RefRpcContextReferenceStatement.java | 19 ++++ .../RpcContextReferenceStatementSupport.java | 7 ++ .../AbstractHashedValueStatementSupport.java | 73 ++-------------- ...nfigHashedValueEffectiveStatementImpl.java | 59 +++++++++++++ .../OpenConfigHashedValueStatementImpl.java | 32 +++++++ .../RefOpenConfigHashedValueStatement.java | 20 +++++ ...ementAttributesEffectiveStatementImpl.java | 52 +++++++++++ ...tFilterElementAttributesStatementImpl.java | 24 +++++ ...lterElementAttributesStatementSupport.java | 59 +++---------- ...efGetFilterElementAttributesStatement.java | 22 +++++ .../DefaultDenyAllEffectiveStatementImpl.java | 51 +++++++++++ .../parser/DefaultDenyAllStatementImpl.java | 22 +++++ .../DefaultDenyAllStatementSupport.java | 57 +++--------- ...efaultDenyWriteEffectiveStatementImpl.java | 52 +++++++++++ .../parser/DefaultDenyWriteStatementImpl.java | 22 +++++ .../DefaultDenyWriteStatementSupport.java | 57 +++--------- .../parser/RefDefaultDenyAllStatement.java | 20 +++++ .../parser/RefDefaultDenyWriteStatement.java | 20 +++++ .../rfc6643/parser/AliasStatementSupport.java | 7 ++ .../parser/DefValStatementSupport.java | 7 ++ .../parser/DisplayHintStatementSupport.java | 7 ++ .../parser/ImpliedStatementSupport.java | 7 ++ .../parser/MaxAccessStatementSupport.java | 7 ++ ...atementImpl.java => OidStatementImpl.java} | 4 +- .../rfc6643/parser/OidStatementSupport.java | 8 +- .../rfc6643/parser/RefAliasStatement.java | 18 ++++ .../rfc6643/parser/RefDefValStatement.java | 18 ++++ .../parser/RefDisplayHintStatement.java | 19 ++++ .../rfc6643/parser/RefImpliedStatement.java | 18 ++++ .../rfc6643/parser/RefMaxAccessStatement.java | 20 +++++ .../rfc6643/parser/RefOidStatement.java | 19 ++++ .../rfc6643/parser/RefSubIdStatement.java | 19 ++++ .../rfc6643/parser/SubIdStatementSupport.java | 7 ++ .../AnnotationEffectiveStatementImpl.java | 83 ++++++++++++++++++ .../parser/AnnotationStatementImpl.java | 20 +++++ .../parser/AnnotationStatementSupport.java | 87 ++----------------- .../parser/RefAnnotationStatement.java | 20 +++++ .../rfc8040/parser/RefYangDataStatement.java | 18 ++++ .../rfc8040/parser/YangDataStatementImpl.java | 23 +++++ .../parser/YangDataStatementSupport.java | 20 ++--- .../parser/MountPointStatementSupport.java | 7 ++ .../parser/RefMountPointStatement.java | 20 +++++ .../model/spi/meta/AbstractRefStatement.java | 8 +- .../spi/meta/AbstractStatementSupport.java | 6 +- 52 files changed, 966 insertions(+), 306 deletions(-) create mode 100644 yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefAugmentIdentifierStatement.java create mode 100644 yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefContextInstanceStatement.java create mode 100644 yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefContextReferenceStatement.java create mode 100644 yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefInstanceTargetStatement.java create mode 100644 yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefRpcContextReferenceStatement.java create mode 100644 yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/OpenConfigHashedValueEffectiveStatementImpl.java create mode 100644 yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/OpenConfigHashedValueStatementImpl.java create mode 100644 yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/RefOpenConfigHashedValueStatement.java create mode 100644 yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/GetFilterElementAttributesEffectiveStatementImpl.java create mode 100644 yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/GetFilterElementAttributesStatementImpl.java create mode 100644 yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/RefGetFilterElementAttributesStatement.java create mode 100644 yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyAllEffectiveStatementImpl.java create mode 100644 yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyAllStatementImpl.java create mode 100644 yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyWriteEffectiveStatementImpl.java create mode 100644 yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyWriteStatementImpl.java create mode 100644 yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/RefDefaultDenyAllStatement.java create mode 100644 yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/RefDefaultDenyWriteStatement.java rename yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/{OidIdStatementImpl.java => OidStatementImpl.java} (84%) create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefAliasStatement.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefDefValStatement.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefDisplayHintStatement.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefImpliedStatement.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefMaxAccessStatement.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefOidStatement.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefSubIdStatement.java create mode 100644 yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/AnnotationEffectiveStatementImpl.java create mode 100644 yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/AnnotationStatementImpl.java create mode 100644 yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/RefAnnotationStatement.java create mode 100644 yang/rfc8040-parser-support/src/main/java/org/opendaylight/yangtools/rfc8040/parser/RefYangDataStatement.java create mode 100644 yang/rfc8040-parser-support/src/main/java/org/opendaylight/yangtools/rfc8040/parser/YangDataStatementImpl.java create mode 100644 yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/RefMountPointStatement.java diff --git a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/AugmentIdentifierStatementSupport.java b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/AugmentIdentifierStatementSupport.java index 3b6ff34844..dc1077901f 100644 --- a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/AugmentIdentifierStatementSupport.java +++ b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/AugmentIdentifierStatementSupport.java @@ -13,6 +13,7 @@ import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierEffectiveSta import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierStatement; import org.opendaylight.yangtools.odlext.model.api.OpenDaylightExtensionsStatements; import org.opendaylight.yangtools.yang.common.UnqualifiedQName; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; @@ -54,6 +55,12 @@ public final class AugmentIdentifierStatementSupport return new AugmentIdentifierStatementImpl(ctx.getArgument(), substatements); } + @Override + protected AugmentIdentifierStatement attachDeclarationReference(final AugmentIdentifierStatement stmt, + final DeclarationReference reference) { + return new RefAugmentIdentifierStatement(stmt, reference); + } + @Override protected AugmentIdentifierEffectiveStatement createEffective( final Current stmt, diff --git a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/ContextInstanceStatementSupport.java b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/ContextInstanceStatementSupport.java index a10211e35d..d135f8ed62 100644 --- a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/ContextInstanceStatementSupport.java +++ b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/ContextInstanceStatementSupport.java @@ -13,6 +13,7 @@ import org.opendaylight.yangtools.odlext.model.api.ContextInstanceEffectiveState import org.opendaylight.yangtools.odlext.model.api.ContextInstanceStatement; import org.opendaylight.yangtools.odlext.model.api.OpenDaylightExtensionsStatements; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; 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.IdentityEffectiveStatement; @@ -32,6 +33,12 @@ public final class ContextInstanceStatementSupport return new ContextInstanceStatementImpl(ctx.getRawArgument(), ctx.getArgument(), substatements); } + @Override + protected ContextInstanceStatement attachDeclarationReference(final ContextInstanceStatement stmt, + final DeclarationReference reference) { + return new RefContextInstanceStatement(stmt, reference); + } + @Override ContextInstanceEffectiveStatement createEffective(final ContextInstanceStatement declared, final IdentityEffectiveStatement identity, diff --git a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/ContextReferenceStatementSupport.java b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/ContextReferenceStatementSupport.java index a898cd5470..4792cdca22 100644 --- a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/ContextReferenceStatementSupport.java +++ b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/ContextReferenceStatementSupport.java @@ -13,6 +13,7 @@ import org.opendaylight.yangtools.odlext.model.api.ContextReferenceEffectiveStat import org.opendaylight.yangtools.odlext.model.api.ContextReferenceStatement; import org.opendaylight.yangtools.odlext.model.api.OpenDaylightExtensionsStatements; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; 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.IdentityEffectiveStatement; @@ -32,6 +33,12 @@ public final class ContextReferenceStatementSupport return new ContextReferenceStatementImpl(ctx.rawArgument(), ctx.getArgument(), substatements); } + @Override + protected ContextReferenceStatement attachDeclarationReference(final ContextReferenceStatement stmt, + final DeclarationReference reference) { + return new RefContextReferenceStatement(stmt, reference); + } + @Override ContextReferenceEffectiveStatement createEffective(final ContextReferenceStatement declared, final IdentityEffectiveStatement identity, diff --git a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/InstanceTargetStatementSupport.java b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/InstanceTargetStatementSupport.java index e93f899922..f94cb00d2c 100644 --- a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/InstanceTargetStatementSupport.java +++ b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/InstanceTargetStatementSupport.java @@ -12,6 +12,7 @@ import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.odlext.model.api.InstanceTargetEffectiveStatement; import org.opendaylight.yangtools.odlext.model.api.InstanceTargetStatement; import org.opendaylight.yangtools.odlext.model.api.OpenDaylightExtensionsStatements; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; @@ -41,6 +42,12 @@ public final class InstanceTargetStatementSupport return new InstanceTargetStatementImpl(ctx.getArgument(), substatements); } + @Override + protected InstanceTargetStatement attachDeclarationReference(final InstanceTargetStatement stmt, + final DeclarationReference reference) { + return new RefInstanceTargetStatement(stmt, reference); + } + @Override protected InstanceTargetEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { diff --git a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefAugmentIdentifierStatement.java b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefAugmentIdentifierStatement.java new file mode 100644 index 0000000000..befe367d4c --- /dev/null +++ b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefAugmentIdentifierStatement.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2021 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.odlext.parser; + +import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierStatement; +import org.opendaylight.yangtools.yang.common.UnqualifiedQName; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefAugmentIdentifierStatement extends AbstractRefStatement + implements AugmentIdentifierStatement { + RefAugmentIdentifierStatement(final AugmentIdentifierStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefContextInstanceStatement.java b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefContextInstanceStatement.java new file mode 100644 index 0000000000..693f399103 --- /dev/null +++ b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefContextInstanceStatement.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2021 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.odlext.parser; + +import org.opendaylight.yangtools.odlext.model.api.ContextInstanceStatement; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefContextInstanceStatement extends AbstractRefStatement + implements ContextInstanceStatement { + RefContextInstanceStatement(final ContextInstanceStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefContextReferenceStatement.java b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefContextReferenceStatement.java new file mode 100644 index 0000000000..e0f1f84b75 --- /dev/null +++ b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefContextReferenceStatement.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2021 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.odlext.parser; + +import org.opendaylight.yangtools.odlext.model.api.ContextReferenceStatement; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefContextReferenceStatement extends AbstractRefStatement + implements ContextReferenceStatement { + RefContextReferenceStatement(final ContextReferenceStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefInstanceTargetStatement.java b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefInstanceTargetStatement.java new file mode 100644 index 0000000000..bc6375e00b --- /dev/null +++ b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefInstanceTargetStatement.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2021 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.odlext.parser; + +import org.opendaylight.yangtools.odlext.model.api.InstanceTargetStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefInstanceTargetStatement extends AbstractRefStatement + implements InstanceTargetStatement { + RefInstanceTargetStatement(final InstanceTargetStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefRpcContextReferenceStatement.java b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefRpcContextReferenceStatement.java new file mode 100644 index 0000000000..9fc66e913b --- /dev/null +++ b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RefRpcContextReferenceStatement.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2021 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.odlext.parser; + +import org.opendaylight.yangtools.odlext.model.api.RpcContextReferenceStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefRpcContextReferenceStatement extends AbstractRefStatement + implements RpcContextReferenceStatement { + RefRpcContextReferenceStatement(final RpcContextReferenceStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RpcContextReferenceStatementSupport.java b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RpcContextReferenceStatementSupport.java index d61e24e64c..df421544ef 100644 --- a/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RpcContextReferenceStatementSupport.java +++ b/yang/odlext-parser-support/src/main/java/org/opendaylight/yangtools/odlext/parser/RpcContextReferenceStatementSupport.java @@ -12,6 +12,7 @@ import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.odlext.model.api.OpenDaylightExtensionsStatements; import org.opendaylight.yangtools.odlext.model.api.RpcContextReferenceEffectiveStatement; import org.opendaylight.yangtools.odlext.model.api.RpcContextReferenceStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; @@ -42,6 +43,12 @@ public final class RpcContextReferenceStatementSupport return new RpcContextReferenceStatementImpl(ctx.getArgument(), substatements); } + @Override + protected RpcContextReferenceStatement attachDeclarationReference(final RpcContextReferenceStatement stmt, + final DeclarationReference reference) { + return new RefRpcContextReferenceStatement(stmt, reference); + } + @Override protected RpcContextReferenceEffectiveStatement createEffective( final Current stmt, diff --git a/yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/AbstractHashedValueStatementSupport.java b/yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/AbstractHashedValueStatementSupport.java index 8e792ebd98..768e1eea4f 100644 --- a/yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/AbstractHashedValueStatementSupport.java +++ b/yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/AbstractHashedValueStatementSupport.java @@ -7,83 +7,22 @@ */ package org.opendaylight.yangtools.openconfig.parser; -import static java.util.Objects.requireNonNull; - import com.google.common.collect.ImmutableList; -import org.eclipse.jdt.annotation.NonNull; -import org.opendaylight.yangtools.concepts.Immutable; import org.opendaylight.yangtools.openconfig.model.api.OpenConfigHashedValueEffectiveStatement; import org.opendaylight.yangtools.openconfig.model.api.OpenConfigHashedValueStatement; import org.opendaylight.yangtools.yang.common.Empty; -import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults; -import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; 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.meta.StatementDefinition; -import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithoutArgument.WithSubstatements; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; -import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractEmptyStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; -import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; abstract class AbstractHashedValueStatementSupport extends AbstractEmptyStatementSupport { - - private static final class Declared extends WithSubstatements implements OpenConfigHashedValueStatement { - private final @NonNull StatementDefinition definition; - - Declared(final StatementDefinition definition, - final ImmutableList> substatements) { - super(substatements); - this.definition = requireNonNull(definition); - } - - @Override - public StatementDefinition statementDefinition() { - return definition; - } - } - - private static final class Effective - extends UnknownEffectiveStatementBase - implements OpenConfigHashedValueEffectiveStatement { - private final @NonNull StatementDefinition definition; - private final @NonNull Immutable path; - - Effective(final Current stmt, - final ImmutableList> substatements) { - super(stmt, substatements); - definition = stmt.publicDefinition(); - path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath() - .createChild(stmt.publicDefinition().getStatementName())); - } - - @Override - public QName getQName() { - return SchemaNodeDefaults.extractQName(path); - } - - @Override - @Deprecated - public SchemaPath getPath() { - return SchemaNodeDefaults.extractPath(this, path); - } - - @Override - public StatementDefinition statementDefinition() { - return definition; - } - - @Override - public OpenConfigHashedValueEffectiveStatement asEffectiveStatement() { - return this; - } - } - private final SubstatementValidator validator; AbstractHashedValueStatementSupport(final StatementDefinition definition, final YangParserConfiguration config) { @@ -100,13 +39,19 @@ abstract class AbstractHashedValueStatementSupport protected final OpenConfigHashedValueStatement createDeclared( final StmtContext ctx, final ImmutableList> substatements) { - return new Declared(getPublicView(), substatements); + return new OpenConfigHashedValueStatementImpl(getPublicView(), substatements); + } + + @Override + protected final OpenConfigHashedValueStatement attachDeclarationReference( + final OpenConfigHashedValueStatement stmt, final DeclarationReference reference) { + return new RefOpenConfigHashedValueStatement(stmt, reference); } @Override protected OpenConfigHashedValueEffectiveStatement createEffective( final Current stmt, final ImmutableList> substatements) { - return new Effective(stmt, substatements); + return new OpenConfigHashedValueEffectiveStatementImpl(stmt, substatements); } } diff --git a/yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/OpenConfigHashedValueEffectiveStatementImpl.java b/yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/OpenConfigHashedValueEffectiveStatementImpl.java new file mode 100644 index 0000000000..75d7c94640 --- /dev/null +++ b/yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/OpenConfigHashedValueEffectiveStatementImpl.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2021 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.openconfig.parser; + +import com.google.common.collect.ImmutableList; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.concepts.Immutable; +import org.opendaylight.yangtools.openconfig.model.api.OpenConfigHashedValueEffectiveStatement; +import org.opendaylight.yangtools.openconfig.model.api.OpenConfigHashedValueStatement; +import org.opendaylight.yangtools.yang.common.Empty; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; +import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; +import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport; + +final class OpenConfigHashedValueEffectiveStatementImpl + extends UnknownEffectiveStatementBase + implements OpenConfigHashedValueEffectiveStatement { + private final @NonNull StatementDefinition definition; + private final @NonNull Immutable path; + + OpenConfigHashedValueEffectiveStatementImpl(final Current stmt, + final ImmutableList> substatements) { + super(stmt, substatements); + definition = stmt.publicDefinition(); + path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath() + .createChild(stmt.publicDefinition().getStatementName())); + } + + @Override + public QName getQName() { + return SchemaNodeDefaults.extractQName(path); + } + + @Override + @Deprecated + public SchemaPath getPath() { + return SchemaNodeDefaults.extractPath(this, path); + } + + @Override + public StatementDefinition statementDefinition() { + return definition; + } + + @Override + public OpenConfigHashedValueEffectiveStatement asEffectiveStatement() { + return this; + } +} \ No newline at end of file diff --git a/yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/OpenConfigHashedValueStatementImpl.java b/yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/OpenConfigHashedValueStatementImpl.java new file mode 100644 index 0000000000..c1bbcb8cf0 --- /dev/null +++ b/yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/OpenConfigHashedValueStatementImpl.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2021 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.openconfig.parser; + +import static java.util.Objects.requireNonNull; + +import com.google.common.collect.ImmutableList; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.openconfig.model.api.OpenConfigHashedValueStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithoutArgument.WithSubstatements; + +final class OpenConfigHashedValueStatementImpl extends WithSubstatements implements OpenConfigHashedValueStatement { + private final @NonNull StatementDefinition definition; + + OpenConfigHashedValueStatementImpl(final StatementDefinition definition, + final ImmutableList> substatements) { + super(substatements); + this.definition = requireNonNull(definition); + } + + @Override + public StatementDefinition statementDefinition() { + return definition; + } +} \ No newline at end of file diff --git a/yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/RefOpenConfigHashedValueStatement.java b/yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/RefOpenConfigHashedValueStatement.java new file mode 100644 index 0000000000..3be4d44390 --- /dev/null +++ b/yang/openconfig-parser-support/src/main/java/org/opendaylight/yangtools/openconfig/parser/RefOpenConfigHashedValueStatement.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2021 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.openconfig.parser; + +import org.opendaylight.yangtools.openconfig.model.api.OpenConfigHashedValueStatement; +import org.opendaylight.yangtools.yang.common.Empty; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefOpenConfigHashedValueStatement extends AbstractRefStatement + implements OpenConfigHashedValueStatement { + RefOpenConfigHashedValueStatement(final OpenConfigHashedValueStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/GetFilterElementAttributesEffectiveStatementImpl.java b/yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/GetFilterElementAttributesEffectiveStatementImpl.java new file mode 100644 index 0000000000..70114076e9 --- /dev/null +++ b/yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/GetFilterElementAttributesEffectiveStatementImpl.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2021 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.rfc6241.parser; + +import com.google.common.collect.ImmutableList; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.concepts.Immutable; +import org.opendaylight.yangtools.rfc6241.model.api.GetFilterElementAttributesEffectiveStatement; +import org.opendaylight.yangtools.rfc6241.model.api.GetFilterElementAttributesSchemaNode; +import org.opendaylight.yangtools.rfc6241.model.api.GetFilterElementAttributesStatement; +import org.opendaylight.yangtools.yang.common.Empty; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; +import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; +import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport; + +final class GetFilterElementAttributesEffectiveStatementImpl + extends UnknownEffectiveStatementBase + implements GetFilterElementAttributesEffectiveStatement, GetFilterElementAttributesSchemaNode { + private final @NonNull Immutable path; + + GetFilterElementAttributesEffectiveStatementImpl(final Current stmt, + final ImmutableList> substatements) { + super(stmt, substatements); + path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath() + .createChild(stmt.publicDefinition().getStatementName())); + } + + @Override + public QName getQName() { + return SchemaNodeDefaults.extractQName(path); + } + + @Override + @Deprecated + public SchemaPath getPath() { + return SchemaNodeDefaults.extractPath(this, path); + } + + @Override + public GetFilterElementAttributesEffectiveStatement asEffectiveStatement() { + return this; + } +} \ No newline at end of file diff --git a/yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/GetFilterElementAttributesStatementImpl.java b/yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/GetFilterElementAttributesStatementImpl.java new file mode 100644 index 0000000000..0ba8e44e0a --- /dev/null +++ b/yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/GetFilterElementAttributesStatementImpl.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2021 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.rfc6241.parser; + +import com.google.common.collect.ImmutableList; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.rfc6241.model.api.GetFilterElementAttributesStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithoutArgument.WithSubstatements; + +final class GetFilterElementAttributesStatementImpl extends WithSubstatements + implements GetFilterElementAttributesStatement { + static final @NonNull GetFilterElementAttributesStatementImpl EMPTY = + new GetFilterElementAttributesStatementImpl(ImmutableList.of()); + + GetFilterElementAttributesStatementImpl(final ImmutableList> substatements) { + super(substatements); + } +} \ No newline at end of file diff --git a/yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/GetFilterElementAttributesStatementSupport.java b/yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/GetFilterElementAttributesStatementSupport.java index 224f45423a..53d8a62e01 100644 --- a/yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/GetFilterElementAttributesStatementSupport.java +++ b/yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/GetFilterElementAttributesStatementSupport.java @@ -9,25 +9,17 @@ package org.opendaylight.yangtools.rfc6241.parser; import com.google.common.annotations.Beta; import com.google.common.collect.ImmutableList; -import org.eclipse.jdt.annotation.NonNull; -import org.opendaylight.yangtools.concepts.Immutable; import org.opendaylight.yangtools.rfc6241.model.api.GetFilterElementAttributesEffectiveStatement; -import org.opendaylight.yangtools.rfc6241.model.api.GetFilterElementAttributesSchemaNode; import org.opendaylight.yangtools.rfc6241.model.api.GetFilterElementAttributesStatement; import org.opendaylight.yangtools.rfc6241.model.api.NetconfStatements; import org.opendaylight.yangtools.yang.common.Empty; -import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults; -import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; -import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithoutArgument.WithSubstatements; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; -import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractEmptyStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; -import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable; import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; @@ -37,44 +29,6 @@ import org.slf4j.LoggerFactory; @Beta public final class GetFilterElementAttributesStatementSupport extends AbstractEmptyStatementSupport< GetFilterElementAttributesStatement, GetFilterElementAttributesEffectiveStatement> { - - private static final class Declared extends WithSubstatements implements GetFilterElementAttributesStatement { - static final @NonNull Declared EMPTY = new Declared(ImmutableList.of()); - - Declared(final ImmutableList> substatements) { - super(substatements); - } - } - - private static final class Effective - extends UnknownEffectiveStatementBase - implements GetFilterElementAttributesEffectiveStatement, GetFilterElementAttributesSchemaNode { - private final @NonNull Immutable path; - - Effective(final Current stmt, - final ImmutableList> substatements) { - super(stmt, substatements); - path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath() - .createChild(stmt.publicDefinition().getStatementName())); - } - - @Override - public QName getQName() { - return SchemaNodeDefaults.extractQName(path); - } - - @Override - @Deprecated - public SchemaPath getPath() { - return SchemaNodeDefaults.extractPath(this, path); - } - - @Override - public GetFilterElementAttributesEffectiveStatement asEffectiveStatement() { - return this; - } - } - private static final Logger LOG = LoggerFactory.getLogger(GetFilterElementAttributesStatementSupport.class); private static final SubstatementValidator VALIDATOR = SubstatementValidator.builder(NetconfStatements.GET_FILTER_ELEMENT_ATTRIBUTES).build(); @@ -99,14 +53,21 @@ public final class GetFilterElementAttributesStatementSupport extends AbstractEm protected GetFilterElementAttributesStatement createDeclared( final StmtContext ctx, final ImmutableList> substatements) { - return substatements.isEmpty() ? Declared.EMPTY : new Declared(substatements); + return substatements.isEmpty() ? GetFilterElementAttributesStatementImpl.EMPTY + : new GetFilterElementAttributesStatementImpl(substatements); + } + + @Override + protected GetFilterElementAttributesStatement attachDeclarationReference( + final GetFilterElementAttributesStatement stmt, final DeclarationReference reference) { + return new RefGetFilterElementAttributesStatement(stmt, reference); } @Override protected GetFilterElementAttributesEffectiveStatement createEffective( final Current stmt, final ImmutableList> substatements) { - return new Effective(stmt, substatements); + return new GetFilterElementAttributesEffectiveStatementImpl(stmt, substatements); } private static boolean computeSupported(final StmtContext stmt) { diff --git a/yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/RefGetFilterElementAttributesStatement.java b/yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/RefGetFilterElementAttributesStatement.java new file mode 100644 index 0000000000..13bbf6c5cc --- /dev/null +++ b/yang/rfc6241-parser-support/src/main/java/org/opendaylight/yangtools/rfc6241/parser/RefGetFilterElementAttributesStatement.java @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2021 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.rfc6241.parser; + +import org.opendaylight.yangtools.rfc6241.model.api.GetFilterElementAttributesStatement; +import org.opendaylight.yangtools.yang.common.Empty; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefGetFilterElementAttributesStatement + extends AbstractRefStatement + implements GetFilterElementAttributesStatement { + RefGetFilterElementAttributesStatement(final GetFilterElementAttributesStatement delegate, + final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyAllEffectiveStatementImpl.java b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyAllEffectiveStatementImpl.java new file mode 100644 index 0000000000..62f94f950c --- /dev/null +++ b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyAllEffectiveStatementImpl.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2021 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.rfc6536.parser; + +import com.google.common.collect.ImmutableList; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.concepts.Immutable; +import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyAllEffectiveStatement; +import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyAllSchemaNode; +import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyAllStatement; +import org.opendaylight.yangtools.yang.common.Empty; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; +import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; +import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport; + +final class DefaultDenyAllEffectiveStatementImpl extends UnknownEffectiveStatementBase + implements DefaultDenyAllEffectiveStatement, DefaultDenyAllSchemaNode { + private final @NonNull Immutable path; + + DefaultDenyAllEffectiveStatementImpl(final Current stmt, + final ImmutableList> substatements) { + super(stmt, substatements); + path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath() + .createChild(stmt.publicDefinition().getStatementName())); + } + + @Override + public QName getQName() { + return SchemaNodeDefaults.extractQName(path); + } + + @Override + @Deprecated + public SchemaPath getPath() { + return SchemaNodeDefaults.extractPath(this, path); + } + + @Override + public DefaultDenyAllEffectiveStatement asEffectiveStatement() { + return this; + } +} \ No newline at end of file diff --git a/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyAllStatementImpl.java b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyAllStatementImpl.java new file mode 100644 index 0000000000..42581c1aa5 --- /dev/null +++ b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyAllStatementImpl.java @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2021 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.rfc6536.parser; + +import com.google.common.collect.ImmutableList; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyAllStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithoutArgument.WithSubstatements; + +final class DefaultDenyAllStatementImpl extends WithSubstatements implements DefaultDenyAllStatement { + static final @NonNull DefaultDenyAllStatementImpl EMPTY = new DefaultDenyAllStatementImpl(ImmutableList.of()); + + DefaultDenyAllStatementImpl(final ImmutableList> substatements) { + super(substatements); + } +} \ No newline at end of file diff --git a/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyAllStatementSupport.java b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyAllStatementSupport.java index 996c40b612..1f983b9d84 100644 --- a/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyAllStatementSupport.java +++ b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyAllStatementSupport.java @@ -8,65 +8,21 @@ package org.opendaylight.yangtools.rfc6536.parser; import com.google.common.collect.ImmutableList; -import org.eclipse.jdt.annotation.NonNull; -import org.opendaylight.yangtools.concepts.Immutable; import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyAllEffectiveStatement; -import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyAllSchemaNode; import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyAllStatement; import org.opendaylight.yangtools.rfc6536.model.api.NACMStatements; import org.opendaylight.yangtools.yang.common.Empty; -import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults; -import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; -import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithoutArgument.WithSubstatements; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; -import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractEmptyStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; -import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; public final class DefaultDenyAllStatementSupport extends AbstractEmptyStatementSupport { - private static final class Declared extends WithSubstatements implements DefaultDenyAllStatement { - static final @NonNull Declared EMPTY = new Declared(ImmutableList.of()); - - Declared(final ImmutableList> substatements) { - super(substatements); - } - } - - private static final class Effective extends UnknownEffectiveStatementBase - implements DefaultDenyAllEffectiveStatement, DefaultDenyAllSchemaNode { - private final @NonNull Immutable path; - - Effective(final Current stmt, - final ImmutableList> substatements) { - super(stmt, substatements); - path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath() - .createChild(stmt.publicDefinition().getStatementName())); - } - - @Override - public QName getQName() { - return SchemaNodeDefaults.extractQName(path); - } - - @Override - @Deprecated - public SchemaPath getPath() { - return SchemaNodeDefaults.extractPath(this, path); - } - - @Override - public DefaultDenyAllEffectiveStatement asEffectiveStatement() { - return this; - } - } - private static final SubstatementValidator VALIDATOR = SubstatementValidator.builder(NACMStatements.DEFAULT_DENY_ALL).build(); @@ -82,12 +38,19 @@ public final class DefaultDenyAllStatementSupport @Override protected DefaultDenyAllStatement createDeclared(final StmtContext ctx, final ImmutableList> substatements) { - return substatements.isEmpty() ? Declared.EMPTY : new Declared(substatements); + return substatements.isEmpty() ? DefaultDenyAllStatementImpl.EMPTY + : new DefaultDenyAllStatementImpl(substatements); + } + + @Override + protected DefaultDenyAllStatement attachDeclarationReference(final DefaultDenyAllStatement stmt, + final DeclarationReference reference) { + return new RefDefaultDenyAllStatement(stmt, reference); } @Override protected DefaultDenyAllEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { - return new Effective(stmt, substatements); + return new DefaultDenyAllEffectiveStatementImpl(stmt, substatements); } } diff --git a/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyWriteEffectiveStatementImpl.java b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyWriteEffectiveStatementImpl.java new file mode 100644 index 0000000000..8591b31d58 --- /dev/null +++ b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyWriteEffectiveStatementImpl.java @@ -0,0 +1,52 @@ +/* + * 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.rfc6536.parser; + +import com.google.common.collect.ImmutableList; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.concepts.Immutable; +import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteEffectiveStatement; +import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteSchemaNode; +import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteStatement; +import org.opendaylight.yangtools.yang.common.Empty; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; +import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; +import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport; + +final class DefaultDenyWriteEffectiveStatementImpl + extends UnknownEffectiveStatementBase + implements DefaultDenyWriteEffectiveStatement, DefaultDenyWriteSchemaNode { + private final @NonNull Immutable path; + + DefaultDenyWriteEffectiveStatementImpl(final Current stmt, + final ImmutableList> substatements) { + super(stmt, substatements); + path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath() + .createChild(stmt.publicDefinition().getStatementName())); + } + + @Override + public QName getQName() { + return SchemaNodeDefaults.extractQName(path); + } + + @Override + @Deprecated + public SchemaPath getPath() { + return SchemaNodeDefaults.extractPath(this, path); + } + + @Override + public DefaultDenyWriteEffectiveStatement asEffectiveStatement() { + return this; + } +} \ No newline at end of file diff --git a/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyWriteStatementImpl.java b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyWriteStatementImpl.java new file mode 100644 index 0000000000..7fe8d01396 --- /dev/null +++ b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyWriteStatementImpl.java @@ -0,0 +1,22 @@ +/* + * 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.rfc6536.parser; + +import com.google.common.collect.ImmutableList; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithoutArgument.WithSubstatements; + +final class DefaultDenyWriteStatementImpl extends WithSubstatements implements DefaultDenyWriteStatement { + static final @NonNull DefaultDenyWriteStatementImpl EMPTY = new DefaultDenyWriteStatementImpl(ImmutableList.of()); + + DefaultDenyWriteStatementImpl(final ImmutableList> substatements) { + super(substatements); + } +} \ No newline at end of file diff --git a/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyWriteStatementSupport.java b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyWriteStatementSupport.java index 83e7270f4d..143ded2ff3 100644 --- a/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyWriteStatementSupport.java +++ b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/DefaultDenyWriteStatementSupport.java @@ -8,65 +8,21 @@ package org.opendaylight.yangtools.rfc6536.parser; import com.google.common.collect.ImmutableList; -import org.eclipse.jdt.annotation.NonNull; -import org.opendaylight.yangtools.concepts.Immutable; import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteEffectiveStatement; -import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteSchemaNode; import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteStatement; import org.opendaylight.yangtools.rfc6536.model.api.NACMStatements; import org.opendaylight.yangtools.yang.common.Empty; -import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults; -import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; -import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithoutArgument.WithSubstatements; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; -import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractEmptyStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; -import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; public final class DefaultDenyWriteStatementSupport extends AbstractEmptyStatementSupport { - private static final class Declared extends WithSubstatements implements DefaultDenyWriteStatement { - static final @NonNull Declared EMPTY = new Declared(ImmutableList.of()); - - Declared(final ImmutableList> substatements) { - super(substatements); - } - } - - private static final class Effective extends UnknownEffectiveStatementBase - implements DefaultDenyWriteEffectiveStatement, DefaultDenyWriteSchemaNode { - private final @NonNull Immutable path; - - Effective(final Current stmt, - final ImmutableList> substatements) { - super(stmt, substatements); - path = SchemaPathSupport.toEffectivePath(stmt.getEffectiveParent().getSchemaPath() - .createChild(stmt.publicDefinition().getStatementName())); - } - - @Override - public QName getQName() { - return SchemaNodeDefaults.extractQName(path); - } - - @Override - @Deprecated - public SchemaPath getPath() { - return SchemaNodeDefaults.extractPath(this, path); - } - - @Override - public DefaultDenyWriteEffectiveStatement asEffectiveStatement() { - return this; - } - } - private static final SubstatementValidator VALIDATOR = SubstatementValidator.builder(NACMStatements.DEFAULT_DENY_WRITE).build(); @@ -82,12 +38,19 @@ public final class DefaultDenyWriteStatementSupport @Override protected DefaultDenyWriteStatement createDeclared(final StmtContext ctx, final ImmutableList> substatements) { - return substatements.isEmpty() ? Declared.EMPTY : new Declared(substatements); + return substatements.isEmpty() ? DefaultDenyWriteStatementImpl.EMPTY + : new DefaultDenyWriteStatementImpl(substatements); + } + + @Override + protected DefaultDenyWriteStatement attachDeclarationReference(final DefaultDenyWriteStatement stmt, + final DeclarationReference reference) { + return new RefDefaultDenyWriteStatement(stmt, reference); } @Override protected DefaultDenyWriteEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { - return new Effective(stmt, substatements); + return new DefaultDenyWriteEffectiveStatementImpl(stmt, substatements); } } diff --git a/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/RefDefaultDenyAllStatement.java b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/RefDefaultDenyAllStatement.java new file mode 100644 index 0000000000..ba97a43744 --- /dev/null +++ b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/RefDefaultDenyAllStatement.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2021 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.rfc6536.parser; + +import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyAllStatement; +import org.opendaylight.yangtools.yang.common.Empty; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefDefaultDenyAllStatement extends AbstractRefStatement + implements DefaultDenyAllStatement { + RefDefaultDenyAllStatement(final DefaultDenyAllStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/RefDefaultDenyWriteStatement.java b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/RefDefaultDenyWriteStatement.java new file mode 100644 index 0000000000..0adad5e03a --- /dev/null +++ b/yang/rfc6536-parser-support/src/main/java/org/opendaylight/yangtools/rfc6536/parser/RefDefaultDenyWriteStatement.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2021 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.rfc6536.parser; + +import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteStatement; +import org.opendaylight.yangtools.yang.common.Empty; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefDefaultDenyWriteStatement extends AbstractRefStatement + implements DefaultDenyWriteStatement { + RefDefaultDenyWriteStatement(final DefaultDenyWriteStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasStatementSupport.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasStatementSupport.java index 05d8d7fb19..b8bb4f8dfb 100644 --- a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasStatementSupport.java +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasStatementSupport.java @@ -13,6 +13,7 @@ import org.opendaylight.yangtools.rfc6643.model.api.AliasEffectiveStatement; import org.opendaylight.yangtools.rfc6643.model.api.AliasStatement; import org.opendaylight.yangtools.rfc6643.model.api.IetfYangSmiv2ExtensionsMapping; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; @@ -47,6 +48,12 @@ public final class AliasStatementSupport return new AliasStatementImpl(ctx.getRawArgument(), substatements); } + @Override + protected AliasStatement attachDeclarationReference(final AliasStatement stmt, + final DeclarationReference reference) { + return new RefAliasStatement(stmt, reference); + } + @Override protected AliasEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValStatementSupport.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValStatementSupport.java index 161fae0b28..7ad6adacea 100644 --- a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValStatementSupport.java +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValStatementSupport.java @@ -12,6 +12,7 @@ import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.rfc6643.model.api.DefValEffectiveStatement; import org.opendaylight.yangtools.rfc6643.model.api.DefValStatement; import org.opendaylight.yangtools.rfc6643.model.api.IetfYangSmiv2ExtensionsMapping; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; @@ -41,6 +42,12 @@ public final class DefValStatementSupport return new DefValStatementImpl(ctx.getRawArgument(), substatements); } + @Override + protected DefValStatement attachDeclarationReference(final DefValStatement stmt, + final DeclarationReference reference) { + return new RefDefValStatement(stmt, reference); + } + @Override protected DefValEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintStatementSupport.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintStatementSupport.java index 1f348a1c17..b36dc96a9f 100644 --- a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintStatementSupport.java +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintStatementSupport.java @@ -12,6 +12,7 @@ import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.rfc6643.model.api.DisplayHintEffectiveStatement; import org.opendaylight.yangtools.rfc6643.model.api.DisplayHintStatement; import org.opendaylight.yangtools.rfc6643.model.api.IetfYangSmiv2ExtensionsMapping; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; @@ -41,6 +42,12 @@ public final class DisplayHintStatementSupport return new DisplayHintStatementImpl(ctx.getRawArgument(), substatements); } + @Override + protected DisplayHintStatement attachDeclarationReference(final DisplayHintStatement stmt, + final DeclarationReference reference) { + return new RefDisplayHintStatement(stmt, reference); + } + @Override protected DisplayHintEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedStatementSupport.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedStatementSupport.java index 0cd2f04670..32b489aa03 100644 --- a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedStatementSupport.java +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedStatementSupport.java @@ -12,6 +12,7 @@ import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.rfc6643.model.api.IetfYangSmiv2ExtensionsMapping; import org.opendaylight.yangtools.rfc6643.model.api.ImpliedEffectiveStatement; import org.opendaylight.yangtools.rfc6643.model.api.ImpliedStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; @@ -41,6 +42,12 @@ public final class ImpliedStatementSupport return new ImpliedStatementImpl(ctx.getRawArgument(), substatements); } + @Override + protected ImpliedStatement attachDeclarationReference(final ImpliedStatement stmt, + final DeclarationReference reference) { + return new RefImpliedStatement(stmt, reference); + } + @Override protected ImpliedEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessStatementSupport.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessStatementSupport.java index 10a711edba..abcb1faf23 100644 --- a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessStatementSupport.java +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessStatementSupport.java @@ -13,6 +13,7 @@ import org.opendaylight.yangtools.rfc6643.model.api.IetfYangSmiv2ExtensionsMappi import org.opendaylight.yangtools.rfc6643.model.api.MaxAccess; import org.opendaylight.yangtools.rfc6643.model.api.MaxAccessEffectiveStatement; import org.opendaylight.yangtools.rfc6643.model.api.MaxAccessStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; @@ -58,6 +59,12 @@ public final class MaxAccessStatementSupport return new MaxAccessStatementImpl(ctx.getArgument(), substatements); } + @Override + protected MaxAccessStatement attachDeclarationReference(final MaxAccessStatement stmt, + final DeclarationReference reference) { + return new RefMaxAccessStatement(stmt, reference); + } + @Override protected MaxAccessEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidIdStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidStatementImpl.java similarity index 84% rename from yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidIdStatementImpl.java rename to yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidStatementImpl.java index 6b0ad54ca7..6d6d8c7c09 100644 --- a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidIdStatementImpl.java +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidStatementImpl.java @@ -13,8 +13,8 @@ import org.opendaylight.yangtools.rfc6643.model.api.OidStatement; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.ArgumentToString.WithSubstatements; -final class OidIdStatementImpl extends WithSubstatements implements OidStatement { - OidIdStatementImpl(final ObjectIdentifier argument, +final class OidStatementImpl extends WithSubstatements implements OidStatement { + OidStatementImpl(final ObjectIdentifier argument, final ImmutableList> substatements) { super(argument, substatements); } diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidStatementSupport.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidStatementSupport.java index 6bff52c276..260232e8b6 100644 --- a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidStatementSupport.java +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidStatementSupport.java @@ -13,6 +13,7 @@ import org.opendaylight.yangtools.rfc6643.model.api.IetfYangSmiv2ExtensionsMappi import org.opendaylight.yangtools.rfc6643.model.api.ObjectIdentifier; import org.opendaylight.yangtools.rfc6643.model.api.OidEffectiveStatement; import org.opendaylight.yangtools.rfc6643.model.api.OidStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; @@ -49,7 +50,12 @@ public final class OidStatementSupport @Override protected OidStatement createDeclared(final StmtContext ctx, final ImmutableList> substatements) { - return new OidIdStatementImpl(ctx.getArgument(), substatements); + return new OidStatementImpl(ctx.getArgument(), substatements); + } + + @Override + protected OidStatement attachDeclarationReference(final OidStatement stmt, final DeclarationReference reference) { + return new RefOidStatement(stmt, reference); } @Override diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefAliasStatement.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefAliasStatement.java new file mode 100644 index 0000000000..8b7337b594 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefAliasStatement.java @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2021 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.rfc6643.parser; + +import org.opendaylight.yangtools.rfc6643.model.api.AliasStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefAliasStatement extends AbstractRefStatement implements AliasStatement { + RefAliasStatement(final AliasStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefDefValStatement.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefDefValStatement.java new file mode 100644 index 0000000000..053315516a --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefDefValStatement.java @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2021 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.rfc6643.parser; + +import org.opendaylight.yangtools.rfc6643.model.api.DefValStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefDefValStatement extends AbstractRefStatement implements DefValStatement { + RefDefValStatement(final DefValStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefDisplayHintStatement.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefDisplayHintStatement.java new file mode 100644 index 0000000000..d398d6a0fa --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefDisplayHintStatement.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2021 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.rfc6643.parser; + +import org.opendaylight.yangtools.rfc6643.model.api.DisplayHintStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefDisplayHintStatement extends AbstractRefStatement + implements DisplayHintStatement { + RefDisplayHintStatement(final DisplayHintStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefImpliedStatement.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefImpliedStatement.java new file mode 100644 index 0000000000..743bb69118 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefImpliedStatement.java @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2021 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.rfc6643.parser; + +import org.opendaylight.yangtools.rfc6643.model.api.ImpliedStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefImpliedStatement extends AbstractRefStatement implements ImpliedStatement { + RefImpliedStatement(final ImpliedStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefMaxAccessStatement.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefMaxAccessStatement.java new file mode 100644 index 0000000000..1fce7fcc92 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefMaxAccessStatement.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2021 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.rfc6643.parser; + +import org.opendaylight.yangtools.rfc6643.model.api.MaxAccess; +import org.opendaylight.yangtools.rfc6643.model.api.MaxAccessStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefMaxAccessStatement extends AbstractRefStatement + implements MaxAccessStatement { + RefMaxAccessStatement(final MaxAccessStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefOidStatement.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefOidStatement.java new file mode 100644 index 0000000000..b9ee6fdcd7 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefOidStatement.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2021 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.rfc6643.parser; + +import org.opendaylight.yangtools.rfc6643.model.api.ObjectIdentifier; +import org.opendaylight.yangtools.rfc6643.model.api.OidStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefOidStatement extends AbstractRefStatement implements OidStatement { + RefOidStatement(final OidStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefSubIdStatement.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefSubIdStatement.java new file mode 100644 index 0000000000..c4deb555b5 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/RefSubIdStatement.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2021 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.rfc6643.parser; + +import org.opendaylight.yangtools.rfc6643.model.api.SubIdStatement; +import org.opendaylight.yangtools.yang.common.Uint32; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefSubIdStatement extends AbstractRefStatement implements SubIdStatement { + RefSubIdStatement(final SubIdStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdStatementSupport.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdStatementSupport.java index 34e2181929..33e39d4797 100644 --- a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdStatementSupport.java +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdStatementSupport.java @@ -13,6 +13,7 @@ import org.opendaylight.yangtools.rfc6643.model.api.IetfYangSmiv2ExtensionsMappi import org.opendaylight.yangtools.rfc6643.model.api.SubIdEffectiveStatement; import org.opendaylight.yangtools.rfc6643.model.api.SubIdStatement; import org.opendaylight.yangtools.yang.common.Uint32; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; @@ -47,6 +48,12 @@ public final class SubIdStatementSupport return new SubIdStatementImpl(ctx.getArgument(), substatements); } + @Override + protected SubIdStatement attachDeclarationReference(final SubIdStatement stmt, + final DeclarationReference reference) { + return new RefSubIdStatement(stmt, reference); + } + @Override protected SubIdEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { diff --git a/yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/AnnotationEffectiveStatementImpl.java b/yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/AnnotationEffectiveStatementImpl.java new file mode 100644 index 0000000000..b011315330 --- /dev/null +++ b/yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/AnnotationEffectiveStatementImpl.java @@ -0,0 +1,83 @@ +/* + * 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.rfc7952.parser; + +import static com.google.common.base.Verify.verifyNotNull; + +import com.google.common.collect.ImmutableList; +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.Nullable; +import org.opendaylight.yangtools.rfc7952.model.api.AnnotationEffectiveStatement; +import org.opendaylight.yangtools.rfc7952.model.api.AnnotationSchemaNode; +import org.opendaylight.yangtools.rfc7952.model.api.AnnotationStatement; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.TypeDefinition; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement; +import org.opendaylight.yangtools.yang.model.ri.type.ConcreteTypeBuilder; +import org.opendaylight.yangtools.yang.model.ri.type.ConcreteTypes; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; +import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; +import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport; +import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; + +final class AnnotationEffectiveStatementImpl extends UnknownEffectiveStatementBase + implements AnnotationEffectiveStatement, AnnotationSchemaNode { + private final @NonNull TypeDefinition type; + private final @Nullable SchemaPath path; + + AnnotationEffectiveStatementImpl(final Current stmt, + final ImmutableList> substatements) { + super(stmt, substatements); + final QName qname = stmt.getArgument(); + + // FIXME: move this into onFullDefinitionDeclared() + final TypeEffectiveStatement typeStmt = SourceException.throwIfNull( + firstSubstatementOfType(TypeEffectiveStatement.class), stmt, + "AnnotationStatementSupport %s is missing a 'type' statement", qname); + + final ConcreteTypeBuilder builder = ConcreteTypes.concreteTypeBuilder(typeStmt.getTypeDefinition(), + qname); + final UnitsEffectiveStatement unitsStmt = firstSubstatementOfType(UnitsEffectiveStatement.class); + if (unitsStmt != null) { + builder.setUnits(unitsStmt.argument()); + } + type = builder.build(); + + path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(qname)); + } + + @Override + public QName getQName() { + return verifyNotNull(argument()); + } + + @Override + @Deprecated + public SchemaPath getPath() { + return SchemaNodeDefaults.throwUnsupportedIfNull(this, path); + } + + @Override + public TypeDefinition getType() { + return type; + } + + @Override + public TypeDefinition getTypeDefinition() { + return type; + } + + @Override + public AnnotationEffectiveStatement asEffectiveStatement() { + return this; + } +} \ No newline at end of file diff --git a/yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/AnnotationStatementImpl.java b/yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/AnnotationStatementImpl.java new file mode 100644 index 0000000000..237c4e1661 --- /dev/null +++ b/yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/AnnotationStatementImpl.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2021 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.rfc7952.parser; + +import com.google.common.collect.ImmutableList; +import org.opendaylight.yangtools.rfc7952.model.api.AnnotationStatement; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithQNameArgument.WithSubstatements; + +final class AnnotationStatementImpl extends WithSubstatements implements AnnotationStatement { + AnnotationStatementImpl(final QName argument, final ImmutableList> substatements) { + super(argument, substatements); + } +} \ No newline at end of file diff --git a/yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/AnnotationStatementSupport.java b/yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/AnnotationStatementSupport.java index 9d275b2825..bca16f5423 100644 --- a/yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/AnnotationStatementSupport.java +++ b/yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/AnnotationStatementSupport.java @@ -7,33 +7,19 @@ */ package org.opendaylight.yangtools.rfc7952.parser; -import static com.google.common.base.Verify.verifyNotNull; - import com.google.common.collect.ImmutableList; -import org.eclipse.jdt.annotation.NonNull; -import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.yangtools.rfc7952.model.api.AnnotationEffectiveStatement; -import org.opendaylight.yangtools.rfc7952.model.api.AnnotationSchemaNode; import org.opendaylight.yangtools.rfc7952.model.api.AnnotationStatement; import org.opendaylight.yangtools.rfc7952.model.api.MetadataStatements; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults; -import org.opendaylight.yangtools.yang.model.api.SchemaPath; -import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; 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.meta.StatementDefinition; -import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement; -import org.opendaylight.yangtools.yang.model.ri.type.ConcreteTypeBuilder; -import org.opendaylight.yangtools.yang.model.ri.type.ConcreteTypes; -import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithQNameArgument.WithSubstatements; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; -import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; -import org.opendaylight.yangtools.yang.parser.spi.meta.SchemaPathSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils; @@ -42,67 +28,6 @@ import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; public final class AnnotationStatementSupport extends AbstractStatementSupport { - - private static final class Declared extends WithSubstatements implements AnnotationStatement { - Declared(final QName argument, final ImmutableList> substatements) { - super(argument, substatements); - } - } - - private static final class Effective extends UnknownEffectiveStatementBase - implements AnnotationEffectiveStatement, AnnotationSchemaNode { - - private final @NonNull TypeDefinition type; - private final @Nullable SchemaPath path; - - Effective(final Current stmt, - final ImmutableList> substatements) { - super(stmt, substatements); - final QName qname = stmt.getArgument(); - - // FIXME: move this into onFullDefinitionDeclared() - final TypeEffectiveStatement typeStmt = SourceException.throwIfNull( - firstSubstatementOfType(TypeEffectiveStatement.class), stmt, - "AnnotationStatementSupport %s is missing a 'type' statement", qname); - - final ConcreteTypeBuilder builder = ConcreteTypes.concreteTypeBuilder(typeStmt.getTypeDefinition(), - qname); - final UnitsEffectiveStatement unitsStmt = firstSubstatementOfType(UnitsEffectiveStatement.class); - if (unitsStmt != null) { - builder.setUnits(unitsStmt.argument()); - } - type = builder.build(); - - path = SchemaPathSupport.toOptionalPath(stmt.getEffectiveParent().getSchemaPath().createChild(qname)); - } - - @Override - public QName getQName() { - return verifyNotNull(argument()); - } - - @Override - @Deprecated - public SchemaPath getPath() { - return SchemaNodeDefaults.throwUnsupportedIfNull(this, path); - } - - @Override - public TypeDefinition getType() { - return type; - } - - @Override - public TypeDefinition getTypeDefinition() { - return type; - } - - @Override - public AnnotationEffectiveStatement asEffectiveStatement() { - return this; - } - } - private static final SubstatementValidator VALIDATOR = SubstatementValidator.builder(MetadataStatements.ANNOTATION) .addMandatory(YangStmtMapping.TYPE) .addOptional(YangStmtMapping.DESCRIPTION) @@ -136,12 +61,18 @@ public final class AnnotationStatementSupport @Override protected AnnotationStatement createDeclared(final StmtContext ctx, final ImmutableList> substatements) { - return new Declared(ctx.getArgument(), substatements); + return new AnnotationStatementImpl(ctx.getArgument(), substatements); + } + + @Override + protected AnnotationStatement attachDeclarationReference(final AnnotationStatement stmt, + final DeclarationReference reference) { + return new RefAnnotationStatement(stmt, reference); } @Override protected AnnotationEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { - return new Effective(stmt, substatements); + return new AnnotationEffectiveStatementImpl(stmt, substatements); } } diff --git a/yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/RefAnnotationStatement.java b/yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/RefAnnotationStatement.java new file mode 100644 index 0000000000..8cb52c4ba4 --- /dev/null +++ b/yang/rfc7952-parser-support/src/main/java/org/opendaylight/yangtools/rfc7952/parser/RefAnnotationStatement.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2021 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.rfc7952.parser; + +import org.opendaylight.yangtools.rfc7952.model.api.AnnotationStatement; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefAnnotationStatement extends AbstractRefStatement + implements AnnotationStatement { + RefAnnotationStatement(final AnnotationStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/rfc8040-parser-support/src/main/java/org/opendaylight/yangtools/rfc8040/parser/RefYangDataStatement.java b/yang/rfc8040-parser-support/src/main/java/org/opendaylight/yangtools/rfc8040/parser/RefYangDataStatement.java new file mode 100644 index 0000000000..1e9aef7663 --- /dev/null +++ b/yang/rfc8040-parser-support/src/main/java/org/opendaylight/yangtools/rfc8040/parser/RefYangDataStatement.java @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2021 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.rfc8040.parser; + +import org.opendaylight.yangtools.rfc8040.model.api.YangDataStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefYangDataStatement extends AbstractRefStatement implements YangDataStatement { + RefYangDataStatement(final YangDataStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/rfc8040-parser-support/src/main/java/org/opendaylight/yangtools/rfc8040/parser/YangDataStatementImpl.java b/yang/rfc8040-parser-support/src/main/java/org/opendaylight/yangtools/rfc8040/parser/YangDataStatementImpl.java new file mode 100644 index 0000000000..4582ac81de --- /dev/null +++ b/yang/rfc8040-parser-support/src/main/java/org/opendaylight/yangtools/rfc8040/parser/YangDataStatementImpl.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2021 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.rfc8040.parser; + +import com.google.common.collect.ImmutableList; +import org.opendaylight.yangtools.rfc8040.model.api.YangDataStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithRawStringArgument.WithSubstatements; + +/** + * Declared statement representation of 'yang-data' extension defined in + * RFC 8040. + */ +final class YangDataStatementImpl extends WithSubstatements implements YangDataStatement { + YangDataStatementImpl(final String rawArgument, final ImmutableList> substatements) { + super(rawArgument, substatements); + } +} \ No newline at end of file diff --git a/yang/rfc8040-parser-support/src/main/java/org/opendaylight/yangtools/rfc8040/parser/YangDataStatementSupport.java b/yang/rfc8040-parser-support/src/main/java/org/opendaylight/yangtools/rfc8040/parser/YangDataStatementSupport.java index ab5262a356..72df7beedf 100644 --- a/yang/rfc8040-parser-support/src/main/java/org/opendaylight/yangtools/rfc8040/parser/YangDataStatementSupport.java +++ b/yang/rfc8040-parser-support/src/main/java/org/opendaylight/yangtools/rfc8040/parser/YangDataStatementSupport.java @@ -18,10 +18,10 @@ import org.opendaylight.yangtools.rfc8040.model.api.YangDataStatements; import org.opendaylight.yangtools.yang.common.Empty; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; 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.DataTreeEffectiveStatement; -import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithRawStringArgument.WithSubstatements; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; @@ -36,16 +36,6 @@ import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; @Beta public final class YangDataStatementSupport extends AbstractStringStatementSupport { - /** - * Declared statement representation of 'yang-data' extension defined in - * RFC 8040. - */ - private static final class Declared extends WithSubstatements implements YangDataStatement { - Declared(final String rawArgument, final ImmutableList> substatements) { - super(rawArgument, substatements); - } - } - private final SubstatementValidator declaredValidator; public YangDataStatementSupport(final YangParserConfiguration config) { @@ -91,7 +81,13 @@ public final class YangDataStatementSupport @Override protected YangDataStatement createDeclared(@NonNull final StmtContext ctx, final ImmutableList> substatements) { - return new Declared(ctx.getRawArgument(), substatements); + return new YangDataStatementImpl(ctx.getRawArgument(), substatements); + } + + @Override + protected YangDataStatement attachDeclarationReference(final YangDataStatement stmt, + final DeclarationReference reference) { + return new RefYangDataStatement(stmt, reference); } @Override diff --git a/yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/MountPointStatementSupport.java b/yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/MountPointStatementSupport.java index 93c3df00ef..0a35a86ae7 100644 --- a/yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/MountPointStatementSupport.java +++ b/yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/MountPointStatementSupport.java @@ -15,6 +15,7 @@ import org.opendaylight.yangtools.rfc8528.model.api.SchemaMountStatements; 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.DeclarationReference; 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.meta.StatementDefinition; @@ -82,6 +83,12 @@ public final class MountPointStatementSupport return new MountPointStatementImpl(ctx.getArgument(), substatements); } + @Override + protected MountPointStatement attachDeclarationReference(final MountPointStatement stmt, + final DeclarationReference reference) { + return new RefMountPointStatement(stmt, reference); + } + @Override protected MountPointEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { diff --git a/yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/RefMountPointStatement.java b/yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/RefMountPointStatement.java new file mode 100644 index 0000000000..10f1392155 --- /dev/null +++ b/yang/rfc8528-parser-support/src/main/java/org/opendaylight/yangtools/rfc8528/parser/RefMountPointStatement.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2021 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.rfc8528.parser; + +import org.opendaylight.yangtools.rfc8528.model.api.MountPointStatement; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement; + +final class RefMountPointStatement extends AbstractRefStatement + implements MountPointStatement { + RefMountPointStatement(final MountPointStatement delegate, final DeclarationReference ref) { + super(delegate, ref); + } +} diff --git a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractRefStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractRefStatement.java index 5b994e6688..204cb33b14 100644 --- a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractRefStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/meta/AbstractRefStatement.java @@ -11,6 +11,7 @@ import static java.util.Objects.requireNonNull; import java.util.Optional; import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.concepts.Delegator; import org.opendaylight.yangtools.yang.common.Empty; import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; @@ -23,7 +24,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; * @param Class representing declared version of this statement. */ public abstract class AbstractRefStatement> - extends ForwardingDeclaredStatement { + extends ForwardingDeclaredStatement implements Delegator { private final @NonNull DeclarationReference ref; private final @NonNull D delegate; @@ -37,6 +38,11 @@ public abstract class AbstractRefStatement> return Optional.of(ref); } + @Override + public final D getDelegate() { + return delegate; + } + @Override protected final D delegate() { return delegate; diff --git a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractStatementSupport.java b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractStatementSupport.java index 53b9056690..212acc5c1b 100644 --- a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractStatementSupport.java +++ b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractStatementSupport.java @@ -68,11 +68,7 @@ public abstract class AbstractStatementSupport * @param reference {@link DeclarationReference} to attach * @return Equivalent of stmt, potentially with specified reference attached. */ - // FIXME: make this method abstract - protected @NonNull D attachDeclarationReference(final @NonNull D stmt, - final @NonNull DeclarationReference reference) { - return stmt; - } + protected abstract @NonNull D attachDeclarationReference(@NonNull D stmt, @NonNull DeclarationReference reference); @Override public final E createEffective(final Current stmt, -- 2.36.6