From 4223bf8c4eae4a003b71554fbcc98b5377ddce2b Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Fri, 18 Sep 2020 17:54:47 +0200 Subject: [PATCH] Add RFC6643 parser support RFC6643 defines a way to map SMIv2 to YANG. This mapping retains the original SMI details using YANG extensions, so that the resulting model can be mapped back. This patch adds semantic support for these extensions, so that the semantics are supported out of the box. JIRA: YANGTOOLS-1134 Change-Id: I494b2537e89e5a104debe486a9012d22d5c7b3aa Signed-off-by: Robert Varga --- artifacts/pom.xml | 11 ++ docs/pom.xml | 9 ++ features/odl-yangtools-parser-api/pom.xml | 4 + features/odl-yangtools-parser/pom.xml | 4 + yang/pom.xml | 4 + yang/rfc6643-model-api/pom.xml | 53 +++++++ .../model/api/AliasEffectiveStatement.java | 16 ++ .../rfc6643/model/api/AliasSchemaNode.java | 17 ++ .../rfc6643/model/api/AliasStatement.java | 20 +++ .../model/api/DefValEffectiveStatement.java | 16 ++ .../rfc6643/model/api/DefValSchemaNode.java | 17 ++ .../rfc6643/model/api/DefValStatement.java | 16 ++ .../api/DisplayHintEffectiveStatement.java | 16 ++ .../model/api/DisplayHintSchemaNode.java | 16 ++ .../model/api/DisplayHintStatement.java | 16 ++ .../model/api/IetfYangSmiv2Constants.java | 53 +++++++ .../api/IetfYangSmiv2ExtensionsMapping.java | 68 ++++++++ .../model/api/ImpliedEffectiveStatement.java | 16 ++ .../rfc6643/model/api/ImpliedSchemaNode.java | 17 ++ .../rfc6643/model/api/ImpliedStatement.java | 16 ++ .../api/MaxAccessEffectiveStatement.java | 16 ++ .../model/api/MaxAccessSchemaNode.java | 17 ++ .../rfc6643/model/api/MaxAccessStatement.java | 16 ++ .../rfc6643/model/api/ObjectIdentifier.java | 129 ++++++++++++++++ .../model/api/OidEffectiveStatement.java | 16 ++ .../rfc6643/model/api/OidSchemaNode.java | 17 ++ .../rfc6643/model/api/OidStatement.java | 19 +++ .../model/api/SubIdEffectiveStatement.java | 16 ++ .../rfc6643/model/api/SubIdSchemaNode.java | 17 ++ .../rfc6643/model/api/SubIdStatement.java | 16 ++ yang/rfc6643-parser-support/pom.xml | 59 +++++++ .../parser/AliasEffectiveStatementImpl.java | 71 +++++++++ .../rfc6643/parser/AliasStatementImpl.java | 30 ++++ .../rfc6643/parser/AliasStatementSupport.java | 66 ++++++++ .../parser/DefValEffectiveStatementImpl.java | 79 ++++++++++ .../rfc6643/parser/DefValStatementImpl.java | 23 +++ .../parser/DefValStatementSupport.java | 59 +++++++ .../DisplayHintEffectiveStatementImpl.java | 73 +++++++++ .../parser/DisplayHintStatementImpl.java | 23 +++ .../parser/DisplayHintStatementSupport.java | 61 ++++++++ .../parser/IetfYangSmiv2Namespace.java | 17 ++ .../parser/ImpliedEffectiveStatementImpl.java | 79 ++++++++++ .../rfc6643/parser/ImpliedStatementImpl.java | 23 +++ .../parser/ImpliedStatementSupport.java | 59 +++++++ .../MaxAccessEffectiveStatementImpl.java | 79 ++++++++++ .../parser/MaxAccessStatementImpl.java | 23 +++ .../parser/MaxAccessStatementSupport.java | 61 ++++++++ .../parser/OidEffectiveStatementImpl.java | 73 +++++++++ .../rfc6643/parser/OidIdStatementImpl.java | 31 ++++ .../rfc6643/parser/OidStatementSupport.java | 62 ++++++++ .../parser/SubIdEffectiveStatementImpl.java | 72 +++++++++ .../rfc6643/parser/SubIdStatementImpl.java | 23 +++ .../rfc6643/parser/SubIdStatementSupport.java | 61 ++++++++ .../IetfYangSmiv2ExtensionPluginTest.java | 126 +++++++++++++++ .../IetfYangSmiv2ExtensionsMappingTest.java | 29 ++++ .../rfc6643/parser/ObjectIdentifierTest.java | 18 +++ .../src/test/resources/foo.yang | 64 ++++++++ .../src/test/resources/ietf-yang-smiv2.yang | 146 ++++++++++++++++++ yang/yang-parser-impl/pom.xml | 8 + .../yang/parser/impl/DefaultReactors.java | 20 +++ 60 files changed, 2302 insertions(+) create mode 100644 yang/rfc6643-model-api/pom.xml create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/AliasEffectiveStatement.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/AliasSchemaNode.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/AliasStatement.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DefValEffectiveStatement.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DefValSchemaNode.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DefValStatement.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DisplayHintEffectiveStatement.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DisplayHintSchemaNode.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DisplayHintStatement.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/IetfYangSmiv2Constants.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/IetfYangSmiv2ExtensionsMapping.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ImpliedEffectiveStatement.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ImpliedSchemaNode.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ImpliedStatement.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/MaxAccessEffectiveStatement.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/MaxAccessSchemaNode.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/MaxAccessStatement.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ObjectIdentifier.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/OidEffectiveStatement.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/OidSchemaNode.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/OidStatement.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/SubIdEffectiveStatement.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/SubIdSchemaNode.java create mode 100644 yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/SubIdStatement.java create mode 100644 yang/rfc6643-parser-support/pom.xml create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasEffectiveStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasStatementSupport.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValEffectiveStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValStatementSupport.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintEffectiveStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintStatementSupport.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/IetfYangSmiv2Namespace.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedEffectiveStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedStatementSupport.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessEffectiveStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessStatementSupport.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidEffectiveStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidIdStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidStatementSupport.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdEffectiveStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdStatementImpl.java create mode 100644 yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdStatementSupport.java create mode 100644 yang/rfc6643-parser-support/src/test/java/org/opendaylight/yangtools/rfc6643/parser/IetfYangSmiv2ExtensionPluginTest.java create mode 100644 yang/rfc6643-parser-support/src/test/java/org/opendaylight/yangtools/rfc6643/parser/IetfYangSmiv2ExtensionsMappingTest.java create mode 100644 yang/rfc6643-parser-support/src/test/java/org/opendaylight/yangtools/rfc6643/parser/ObjectIdentifierTest.java create mode 100644 yang/rfc6643-parser-support/src/test/resources/foo.yang create mode 100644 yang/rfc6643-parser-support/src/test/resources/ietf-yang-smiv2.yang diff --git a/artifacts/pom.xml b/artifacts/pom.xml index 45d1eee9bf..14cd5fbf85 100644 --- a/artifacts/pom.xml +++ b/artifacts/pom.xml @@ -185,6 +185,17 @@ 4.0.14-SNAPSHOT + + org.opendaylight.yangtools + rfc6643-model-api + 4.0.14-SNAPSHOT + + + org.opendaylight.yangtools + rfc6643-parser-support + 4.0.14-SNAPSHOT + + org.opendaylight.yangtools rfc7952-data-api diff --git a/docs/pom.xml b/docs/pom.xml index ed21295cb4..dc2d801019 100644 --- a/docs/pom.xml +++ b/docs/pom.xml @@ -139,6 +139,15 @@ rfc6536-parser-support + + org.opendaylight.yangtools + rfc6643-model-api + + + org.opendaylight.yangtools + rfc6643-parser-support + + org.opendaylight.yangtools rfc7952-model-api diff --git a/features/odl-yangtools-parser-api/pom.xml b/features/odl-yangtools-parser-api/pom.xml index 41752285ce..0b9ae5a390 100644 --- a/features/odl-yangtools-parser-api/pom.xml +++ b/features/odl-yangtools-parser-api/pom.xml @@ -64,6 +64,10 @@ org.opendaylight.yangtools rfc6536-model-api + + org.opendaylight.yangtools + rfc6643-model-api + org.opendaylight.yangtools rfc7952-model-api diff --git a/features/odl-yangtools-parser/pom.xml b/features/odl-yangtools-parser/pom.xml index 1d3ccc0ae4..f8667a3fbc 100644 --- a/features/odl-yangtools-parser/pom.xml +++ b/features/odl-yangtools-parser/pom.xml @@ -70,6 +70,10 @@ org.opendaylight.yangtools rfc6536-parser-support + + org.opendaylight.yangtools + rfc6643-parser-support + org.opendaylight.yangtools rfc7952-parser-support diff --git a/yang/pom.xml b/yang/pom.xml index 141937161e..d25a63188d 100644 --- a/yang/pom.xml +++ b/yang/pom.xml @@ -83,6 +83,10 @@ rfc6536-model-api rfc6536-parser-support + + rfc6643-model-api + rfc6643-parser-support + rfc7952-data-api rfc7952-data-util diff --git a/yang/rfc6643-model-api/pom.xml b/yang/rfc6643-model-api/pom.xml new file mode 100644 index 0000000000..22af89d7d5 --- /dev/null +++ b/yang/rfc6643-model-api/pom.xml @@ -0,0 +1,53 @@ + + + + + 4.0.0 + + org.opendaylight.yangtools + bundle-parent + 4.0.14-SNAPSHOT + ../../bundle-parent + + + rfc6643-model-api + bundle + ${project.artifactId} + RFC6643 extensions for SMIv2 + + + + org.opendaylight.yangtools + concepts + + + org.opendaylight.yangtools + yang-common + + + org.opendaylight.yangtools + yang-model-api + + + + + + + org.apache.felix + maven-bundle-plugin + + + org.opendaylight.yangtools.rfc6643.model.api + + + + + + + diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/AliasEffectiveStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/AliasEffectiveStatement.java new file mode 100644 index 0000000000..e2cea3ad57 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/AliasEffectiveStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; + +@Beta +public interface AliasEffectiveStatement extends EffectiveStatement { + +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/AliasSchemaNode.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/AliasSchemaNode.java new file mode 100644 index 0000000000..b8d6a398b1 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/AliasSchemaNode.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; + +@Beta +public interface AliasSchemaNode extends UnknownSchemaNode { + + String getArgument(); +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/AliasStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/AliasStatement.java new file mode 100644 index 0000000000..c58615f507 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/AliasStatement.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2016, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.stmt.DocumentedDeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement; + +@Beta +public interface AliasStatement extends UnknownStatement, DocumentedDeclaredStatement.WithStatus { + + @NonNull OidStatement getOidStatement(); +} + diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DefValEffectiveStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DefValEffectiveStatement.java new file mode 100644 index 0000000000..4083338ab5 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DefValEffectiveStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; + +@Beta +public interface DefValEffectiveStatement extends EffectiveStatement { + +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DefValSchemaNode.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DefValSchemaNode.java new file mode 100644 index 0000000000..b2f306b129 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DefValSchemaNode.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; + +@Beta +public interface DefValSchemaNode extends UnknownSchemaNode { + + String getArgument(); +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DefValStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DefValStatement.java new file mode 100644 index 0000000000..73cbf9cd6b --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DefValStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement; + +@Beta +public interface DefValStatement extends UnknownStatement { + +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DisplayHintEffectiveStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DisplayHintEffectiveStatement.java new file mode 100644 index 0000000000..fc91ab9e5d --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DisplayHintEffectiveStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; + +@Beta +public interface DisplayHintEffectiveStatement extends EffectiveStatement { + +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DisplayHintSchemaNode.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DisplayHintSchemaNode.java new file mode 100644 index 0000000000..8b8df5ef7a --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DisplayHintSchemaNode.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; + +@Beta +public interface DisplayHintSchemaNode extends UnknownSchemaNode { + +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DisplayHintStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DisplayHintStatement.java new file mode 100644 index 0000000000..11bd44ac32 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/DisplayHintStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement; + +@Beta +public interface DisplayHintStatement extends UnknownStatement { + +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/IetfYangSmiv2Constants.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/IetfYangSmiv2Constants.java new file mode 100644 index 0000000000..0a54912ab7 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/IetfYangSmiv2Constants.java @@ -0,0 +1,53 @@ +/* + * 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import com.google.common.collect.ImmutableList; +import java.net.URI; +import java.util.Collection; +import org.opendaylight.yangtools.yang.common.QNameModule; +import org.opendaylight.yangtools.yang.common.Revision; +import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier; +import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier; + +@Beta +public final class IetfYangSmiv2Constants { + private static final String MODULE_NAME = "ietf-yang-smiv2"; + private static final URI MODULE_NAMESPACE = URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-smiv2"); + private static final Revision RFC6643_REVISION = Revision.of("2012-06-22"); + + /** + * Runtime RFC6643 identity. + */ + public static final QNameModule RFC6643_MODULE = QNameModule.create(MODULE_NAMESPACE, RFC6643_REVISION).intern(); + + /** + * RFC6643 model source name. + */ + public static final SourceIdentifier RFC6643_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME, + RFC6643_REVISION); + + /** + * Normative prefix to use when importing {@link #RFC6643_SOURCE}. + */ + public static final String MODULE_PREFIX = "smiv2"; + + /** + * Return identifiers of all sources known to define NACM extension. + * + * @return Collection of identifiers. + */ + public static Collection knownModelSources() { + return ImmutableList.of(RFC6643_SOURCE); + } + + private IetfYangSmiv2Constants() { + // Hidden on purpose + } +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/IetfYangSmiv2ExtensionsMapping.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/IetfYangSmiv2ExtensionsMapping.java new file mode 100644 index 0000000000..38c00a56bd --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/IetfYangSmiv2ExtensionsMapping.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2016, 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.rfc6643.model.api; + +import static java.util.Objects.requireNonNull; + +import com.google.common.annotations.Beta; +import java.util.Optional; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.meta.ArgumentDefinition; +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; + +@Beta +public enum IetfYangSmiv2ExtensionsMapping implements StatementDefinition { + DISPLAY_HINT(DisplayHintStatement.class, DisplayHintEffectiveStatement.class, "display-hint", "format"), + MAX_ACCESS(MaxAccessStatement.class, MaxAccessEffectiveStatement.class, "max-access", "access"), + DEFVAL(DefValStatement.class, DefValEffectiveStatement.class, "defval", "value"), + IMPLIED(ImpliedStatement.class, ImpliedEffectiveStatement.class, "implied", "index"), + SUB_ID(SubIdStatement.class, SubIdEffectiveStatement.class, "subid", "value"), + OBJECT_ID(OidStatement.class, OidEffectiveStatement.class, "oid", "value"), + ALIAS(AliasStatement.class, AliasEffectiveStatement.class, "alias", "descriptor"); + + private final @NonNull Class> type; + private final @NonNull Class> effectiveType; + private final @NonNull QName name; + private final @NonNull ArgumentDefinition argument; + + IetfYangSmiv2ExtensionsMapping(final Class> declared, + final Class> effective, final String nameStr, + final String argumentStr) { + type = requireNonNull(declared); + effectiveType = requireNonNull(effective); + name = createQName(nameStr); + argument = ArgumentDefinition.of(createQName(argumentStr), false); + } + + private static @NonNull QName createQName(final String localName) { + return QName.create(IetfYangSmiv2Constants.RFC6643_MODULE, localName).intern(); + } + + @Override + public QName getStatementName() { + return name; + } + + @Override + public Optional getArgumentDefinition() { + return Optional.of(argument); + } + + @Override + public Class> getDeclaredRepresentationClass() { + return type; + } + + @Override + public Class> getEffectiveRepresentationClass() { + return effectiveType; + } +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ImpliedEffectiveStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ImpliedEffectiveStatement.java new file mode 100644 index 0000000000..5c5124775c --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ImpliedEffectiveStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; + +@Beta +public interface ImpliedEffectiveStatement extends EffectiveStatement { + +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ImpliedSchemaNode.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ImpliedSchemaNode.java new file mode 100644 index 0000000000..c97243576a --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ImpliedSchemaNode.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; + +@Beta +public interface ImpliedSchemaNode extends UnknownSchemaNode { + + String getArgument(); +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ImpliedStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ImpliedStatement.java new file mode 100644 index 0000000000..6c7479b6b4 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ImpliedStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement; + +@Beta +public interface ImpliedStatement extends UnknownStatement { + +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/MaxAccessEffectiveStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/MaxAccessEffectiveStatement.java new file mode 100644 index 0000000000..ff8ba64a06 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/MaxAccessEffectiveStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; + +@Beta +public interface MaxAccessEffectiveStatement extends EffectiveStatement { + +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/MaxAccessSchemaNode.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/MaxAccessSchemaNode.java new file mode 100644 index 0000000000..5a2fb8a8a5 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/MaxAccessSchemaNode.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; + +@Beta +public interface MaxAccessSchemaNode extends UnknownSchemaNode { + + String getArgument(); +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/MaxAccessStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/MaxAccessStatement.java new file mode 100644 index 0000000000..e04dcbd900 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/MaxAccessStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement; + +@Beta +public interface MaxAccessStatement extends UnknownStatement { + +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ObjectIdentifier.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ObjectIdentifier.java new file mode 100644 index 0000000000..c97a12379c --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/ObjectIdentifier.java @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2016, 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.rfc6643.model.api; + +import static com.google.common.base.Preconditions.checkArgument; + +import com.google.common.annotations.Beta; +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; +import java.util.Arrays; +import java.util.regex.Pattern; +import java.util.stream.IntStream; +import org.checkerframework.checker.regex.qual.Regex; +import org.opendaylight.yangtools.concepts.Identifier; +import org.opendaylight.yangtools.concepts.WritableObject; + +/** + * An OID, or ObjectIdentifier, as defined by ITU and ISO/IEC. + */ +// TODO: this class could also be Comparable +@Beta +public final class ObjectIdentifier implements Identifier, WritableObject { + private static final long serialVersionUID = 1L; + @Regex + private static final String CHECK_OID_REGEX = "^\\d+(\\.\\d+)*$"; + private static final Pattern CHECK_OID_PATTERN = Pattern.compile(CHECK_OID_REGEX); + private static final Pattern SPLIT_PATTERN = Pattern.compile(".", Pattern.LITERAL); + + private final int[] components; + + private ObjectIdentifier(final int[] components) { + this.components = components; + } + + /** + * Create an {@link ObjectIdentifier} from its integer components. + * + * @param components OID items + * @return An ObjectIdentifier. + */ + public static ObjectIdentifier forComponents(final int... components) { + return new ObjectIdentifier(components.clone()); + } + + /** + * Create an {@link ObjectIdentifier} from its string representation. + * + * @param str String OID representation. + * @return An ObjectIdentifier. + */ + public static ObjectIdentifier forString(final String str) { + return new ObjectIdentifier(parseObjectId(str)); + } + + public int[] getComponents() { + // Always make a defensive copy + return components.clone(); + } + + public IntStream streamComponents() { + return Arrays.stream(components); + } + + /** + * Read an {@link ObjectIdentifier} from a DataInput, performing the inverse of {@link #writeTo(DataOutput)}. For + * details see {@link WritableObject}. + * + * @param in Data input + * @return Object identifier + * @throws IOException If an I/O error is reported + */ + public static ObjectIdentifier readFrom(final DataInput in) throws IOException { + final int count = in.readInt(); + checkArgument(count >= 0, "Illegal item count"); + + final int[] oid = new int[count]; + for (int index = 0; index < count; ++index) { + oid[index] = in.readInt(); + } + + return new ObjectIdentifier(oid); + } + + @Override + public void writeTo(final DataOutput out) throws IOException { + out.writeInt(components.length); + for (int i : components) { + out.writeInt(i); + } + } + + @Override + public int hashCode() { + return Arrays.hashCode(components); + } + + @Override + public boolean equals(final Object obj) { + return this == obj || obj instanceof ObjectIdentifier + && Arrays.equals(components, ((ObjectIdentifier) obj).components); + } + + @Override + public String toString() { + StringBuilder stringBuilder = new StringBuilder(); + stringBuilder.append(components[0]); + for (int index = 1; index < components.length; index++) { + stringBuilder.append('.').append(components[index]); + } + return stringBuilder.toString(); + } + + private static int[] parseObjectId(final String objectId) { + checkArgument(CHECK_OID_PATTERN.matcher(objectId).matches(), "Wrong format for OID: '%s'", objectId); + + final String[] splitOid = SPLIT_PATTERN.split(objectId); + final int[] oid = new int[splitOid.length]; + for (int index = 0; index < splitOid.length; index ++) { + oid[index] = Integer.parseInt(splitOid[index]); + } + return oid; + } +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/OidEffectiveStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/OidEffectiveStatement.java new file mode 100644 index 0000000000..00000cbe77 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/OidEffectiveStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; + +@Beta +public interface OidEffectiveStatement extends EffectiveStatement { + +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/OidSchemaNode.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/OidSchemaNode.java new file mode 100644 index 0000000000..9721b3313d --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/OidSchemaNode.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; + +@Beta +public interface OidSchemaNode extends UnknownSchemaNode { + + ObjectIdentifier getArgument(); +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/OidStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/OidStatement.java new file mode 100644 index 0000000000..74035eecc8 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/OidStatement.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2016, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement; + +@Beta +public interface OidStatement extends UnknownStatement { + + @NonNull ObjectIdentifier getOid(); +} + diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/SubIdEffectiveStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/SubIdEffectiveStatement.java new file mode 100644 index 0000000000..a2957848ea --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/SubIdEffectiveStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; + +@Beta +public interface SubIdEffectiveStatement extends EffectiveStatement { + +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/SubIdSchemaNode.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/SubIdSchemaNode.java new file mode 100644 index 0000000000..c696abef60 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/SubIdSchemaNode.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; + +@Beta +public interface SubIdSchemaNode extends UnknownSchemaNode { + + int getArgument(); +} diff --git a/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/SubIdStatement.java b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/SubIdStatement.java new file mode 100644 index 0000000000..eba1c62f86 --- /dev/null +++ b/yang/rfc6643-model-api/src/main/java/org/opendaylight/yangtools/rfc6643/model/api/SubIdStatement.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2018, 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.rfc6643.model.api; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement; + +@Beta +public interface SubIdStatement extends UnknownStatement { + +} diff --git a/yang/rfc6643-parser-support/pom.xml b/yang/rfc6643-parser-support/pom.xml new file mode 100644 index 0000000000..53ebdd9464 --- /dev/null +++ b/yang/rfc6643-parser-support/pom.xml @@ -0,0 +1,59 @@ + + + + + 4.0.0 + + org.opendaylight.yangtools + bundle-parent + 4.0.14-SNAPSHOT + ../../bundle-parent + + + rfc6643-parser-support + bundle + ${project.artifactId} + RFC6643 parser support + + + + org.opendaylight.yangtools + concepts + + + org.opendaylight.yangtools + yang-common + + + + org.opendaylight.yangtools + rfc6643-model-api + + + + org.opendaylight.yangtools + yang-parser-rfc7950 + + + + + + + org.apache.felix + maven-bundle-plugin + + + org.opendaylight.yangtools.rfc6643.parser.support + + + + + + + diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasEffectiveStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasEffectiveStatementImpl.java new file mode 100644 index 0000000000..8326ad82a9 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasEffectiveStatementImpl.java @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import java.util.Objects; +import org.opendaylight.yangtools.rfc6643.model.api.AliasEffectiveStatement; +import org.opendaylight.yangtools.rfc6643.model.api.AliasSchemaNode; +import org.opendaylight.yangtools.rfc6643.model.api.AliasStatement; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class AliasEffectiveStatementImpl extends UnknownEffectiveStatementBase + implements AliasEffectiveStatement, AliasSchemaNode { + private final SchemaPath path; + + AliasEffectiveStatementImpl(final StmtContext ctx) { + super(ctx); + path = ctx.getParentContext().getSchemaPath().get().createChild(getNodeType()); + } + + @Override + public String getArgument() { + return argument(); + } + + @Override + public QName getQName() { + return getNodeType(); + } + + @Override + public SchemaPath getPath() { + return path; + } + + @Override + public int hashCode() { + return Objects.hash(path, getNodeType(), getNodeParameter()); + } + + @Override + public boolean equals(final Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + final AliasEffectiveStatementImpl other = (AliasEffectiveStatementImpl) obj; + if (!Objects.equals(path, other.path)) { + return false; + } + if (!Objects.equals(getNodeType(), other.getNodeType())) { + return false; + } + if (!Objects.equals(getNodeParameter(), other.getNodeParameter())) { + return false; + } + return true; + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasStatementImpl.java new file mode 100644 index 0000000000..fd010ebba0 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasStatementImpl.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.rfc6643.model.api.AliasStatement; +import org.opendaylight.yangtools.rfc6643.model.api.OidStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class AliasStatementImpl extends AbstractDeclaredStatement implements AliasStatement { + AliasStatementImpl(final StmtContext context) { + super(context); + } + + @Override + public String getArgument() { + return argument(); + } + + @Override + public @NonNull OidStatement getOidStatement() { + return findFirstDeclaredSubstatement(OidStatement.class).get(); + } +} 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 new file mode 100644 index 0000000000..76d34f139c --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/AliasStatementSupport.java @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import com.google.common.annotations.Beta; +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.parser.spi.meta.AbstractStatementSupport; +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; + +@Beta +public final class AliasStatementSupport + extends AbstractStatementSupport { + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = + SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.ALIAS) + .add(YangStmtMapping.DESCRIPTION, 0, 1) + .add(YangStmtMapping.REFERENCE, 0, 1) + .add(YangStmtMapping.STATUS, 0, 1) + .add(IetfYangSmiv2ExtensionsMapping.OBJECT_ID, 0, 1) + .build(); + private static final AliasStatementSupport INSTANCE = new AliasStatementSupport(); + + private AliasStatementSupport() { + super(IetfYangSmiv2ExtensionsMapping.ALIAS); + } + + public static AliasStatementSupport getInstance() { + return INSTANCE; + } + + @Override + public String parseArgumentValue(final StmtContext ctx, final String value) { + return value; + } + + @Override + public void onFullDefinitionDeclared(final Mutable stmt) { + stmt.addToNs(IetfYangSmiv2Namespace.class, stmt, "Ietf-yang-smiv2 namespace."); + getSubstatementValidator().validate(stmt); + } + + @Override + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; + } + + @Override + public AliasStatement createDeclared(final StmtContext ctx) { + return new AliasStatementImpl(ctx); + } + + @Override + public AliasEffectiveStatement createEffective( + final StmtContext ctx) { + return new AliasEffectiveStatementImpl(ctx); + } +} \ No newline at end of file diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValEffectiveStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValEffectiveStatementImpl.java new file mode 100644 index 0000000000..e6220a7edf --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValEffectiveStatementImpl.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import java.util.Objects; +import org.opendaylight.yangtools.rfc6643.model.api.DefValEffectiveStatement; +import org.opendaylight.yangtools.rfc6643.model.api.DefValSchemaNode; +import org.opendaylight.yangtools.rfc6643.model.api.DefValStatement; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class DefValEffectiveStatementImpl extends UnknownEffectiveStatementBase + implements DefValEffectiveStatement, DefValSchemaNode { + + private final SchemaPath path; + private final String valueFromNamespace; + + DefValEffectiveStatementImpl(final StmtContext ctx) { + super(ctx); + path = ctx.getParentContext().getSchemaPath().get().createChild(getNodeType()); + valueFromNamespace = ctx.getFromNamespace(IetfYangSmiv2Namespace.class, ctx); + } + + @Override + public String getArgument() { + return argument(); + } + + // FIXME: what good is this method? + public String getValueFromNamespace() { + return valueFromNamespace; + } + + @Override + public QName getQName() { + return getNodeType(); + } + + @Override + public SchemaPath getPath() { + return path; + } + + @Override + public int hashCode() { + return Objects.hash(path, getNodeType(), getNodeParameter()); + } + + @Override + public boolean equals(final Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + final DefValEffectiveStatementImpl other = (DefValEffectiveStatementImpl) obj; + if (!Objects.equals(path, other.path)) { + return false; + } + if (!Objects.equals(getNodeType(), other.getNodeType())) { + return false; + } + if (!Objects.equals(getNodeParameter(), other.getNodeParameter())) { + return false; + } + return true; + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValStatementImpl.java new file mode 100644 index 0000000000..853d38be3d --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValStatementImpl.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import org.opendaylight.yangtools.rfc6643.model.api.DefValStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class DefValStatementImpl extends AbstractDeclaredStatement implements DefValStatement { + DefValStatementImpl(final StmtContext context) { + super(context); + } + + @Override + public String getArgument() { + return argument(); + } +} 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 new file mode 100644 index 0000000000..8b4e906668 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DefValStatementSupport.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import com.google.common.annotations.Beta; +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.parser.spi.meta.AbstractStatementSupport; +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; + +@Beta +public final class DefValStatementSupport + extends AbstractStatementSupport { + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = + SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.DEFVAL).build(); + private static final DefValStatementSupport INSTANCE = new DefValStatementSupport(); + + private DefValStatementSupport() { + super(IetfYangSmiv2ExtensionsMapping.DEFVAL); + } + + public static DefValStatementSupport getInstance() { + return INSTANCE; + } + + @Override + public String parseArgumentValue(final StmtContext ctx, final String value) { + return value; + } + + @Override + public void onFullDefinitionDeclared(final Mutable stmt) { + stmt.addToNs(IetfYangSmiv2Namespace.class, stmt, "Ietf-yang-smiv2 namespace."); + } + + @Override + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; + } + + @Override + public DefValStatementImpl createDeclared(final StmtContext ctx) { + return new DefValStatementImpl(ctx); + } + + @Override + public DefValEffectiveStatement createEffective( + final StmtContext ctx) { + return new DefValEffectiveStatementImpl(ctx); + } +} \ No newline at end of file diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintEffectiveStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintEffectiveStatementImpl.java new file mode 100644 index 0000000000..1e78fab35c --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintEffectiveStatementImpl.java @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import java.util.Objects; +import org.opendaylight.yangtools.rfc6643.model.api.DisplayHintEffectiveStatement; +import org.opendaylight.yangtools.rfc6643.model.api.DisplayHintSchemaNode; +import org.opendaylight.yangtools.rfc6643.model.api.DisplayHintStatement; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class DisplayHintEffectiveStatementImpl extends UnknownEffectiveStatementBase + implements DisplayHintEffectiveStatement, DisplayHintSchemaNode { + + private final SchemaPath path; + private final String valueFromNamespace; + + DisplayHintEffectiveStatementImpl(final StmtContext ctx) { + super(ctx); + path = ctx.getParentContext().getSchemaPath().get().createChild(getNodeType()); + valueFromNamespace = ctx.getFromNamespace(IetfYangSmiv2Namespace.class, ctx); + } + + public String getValueFromNamespace() { + return valueFromNamespace; + } + + @Override + public QName getQName() { + return getNodeType(); + } + + @Override + public SchemaPath getPath() { + return path; + } + + @Override + public int hashCode() { + return Objects.hash(path, getNodeType(), getNodeParameter()); + } + + @Override + public boolean equals(final Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + final DisplayHintEffectiveStatementImpl other = (DisplayHintEffectiveStatementImpl) obj; + if (!Objects.equals(path, other.path)) { + return false; + } + if (!Objects.equals(getNodeType(), other.getNodeType())) { + return false; + } + if (!Objects.equals(getNodeParameter(), other.getNodeParameter())) { + return false; + } + return true; + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintStatementImpl.java new file mode 100644 index 0000000000..a7d7d0df02 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintStatementImpl.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import org.opendaylight.yangtools.rfc6643.model.api.DisplayHintStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class DisplayHintStatementImpl extends AbstractDeclaredStatement implements DisplayHintStatement { + DisplayHintStatementImpl(final StmtContext context) { + super(context); + } + + @Override + public String getArgument() { + return argument(); + } +} 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 new file mode 100644 index 0000000000..8cb9160c03 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/DisplayHintStatementSupport.java @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import com.google.common.annotations.Beta; +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.parser.spi.meta.AbstractStatementSupport; +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; + +@Beta +public final class DisplayHintStatementSupport + extends AbstractStatementSupport { + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = + SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.DISPLAY_HINT).build(); + private static final DisplayHintStatementSupport INSTANCE = new DisplayHintStatementSupport(); + + private DisplayHintStatementSupport() { + super(IetfYangSmiv2ExtensionsMapping.DISPLAY_HINT); + } + + public static DisplayHintStatementSupport getInstance() { + return INSTANCE; + } + + @Override + public String parseArgumentValue(final StmtContext ctx, final String value) { + return value; + } + + @Override + public void onFullDefinitionDeclared( + final Mutable stmt) { + stmt.addToNs(IetfYangSmiv2Namespace.class, stmt, "Ietf-yang-smiv2 namespace."); + } + + @Override + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; + } + + @Override + public DisplayHintStatement createDeclared(final StmtContext ctx) { + return new DisplayHintStatementImpl(ctx); + } + + @Override + public DisplayHintEffectiveStatement createEffective( + final StmtContext ctx) { + return new DisplayHintEffectiveStatementImpl(ctx); + } + +} \ No newline at end of file diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/IetfYangSmiv2Namespace.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/IetfYangSmiv2Namespace.java new file mode 100644 index 0000000000..00d52a6f65 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/IetfYangSmiv2Namespace.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +@Beta +public interface IetfYangSmiv2Namespace extends IdentifierNamespace, String> { + +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedEffectiveStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedEffectiveStatementImpl.java new file mode 100644 index 0000000000..37d40b224f --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedEffectiveStatementImpl.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import java.util.Objects; +import org.opendaylight.yangtools.rfc6643.model.api.ImpliedEffectiveStatement; +import org.opendaylight.yangtools.rfc6643.model.api.ImpliedSchemaNode; +import org.opendaylight.yangtools.rfc6643.model.api.ImpliedStatement; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class ImpliedEffectiveStatementImpl extends UnknownEffectiveStatementBase + implements ImpliedEffectiveStatement, ImpliedSchemaNode { + + private final SchemaPath path; + private final String valueFromNamespace; + + ImpliedEffectiveStatementImpl(final StmtContext ctx) { + super(ctx); + path = ctx.getParentContext().getSchemaPath().get().createChild(getNodeType()); + valueFromNamespace = ctx.getFromNamespace(IetfYangSmiv2Namespace.class, ctx); + } + + @Override + public String getArgument() { + return argument(); + } + + // FIXME: what good is this method? + public String getValueFromNamespace() { + return valueFromNamespace; + } + + @Override + public QName getQName() { + return getNodeType(); + } + + @Override + public SchemaPath getPath() { + return path; + } + + @Override + public int hashCode() { + return Objects.hash(path, getNodeType(), getNodeParameter()); + } + + @Override + public boolean equals(final Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + final ImpliedEffectiveStatementImpl other = (ImpliedEffectiveStatementImpl) obj; + if (!Objects.equals(path, other.path)) { + return false; + } + if (!Objects.equals(getNodeType(), other.getNodeType())) { + return false; + } + if (!Objects.equals(getNodeParameter(), other.getNodeParameter())) { + return false; + } + return true; + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedStatementImpl.java new file mode 100644 index 0000000000..55de64552b --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedStatementImpl.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import org.opendaylight.yangtools.rfc6643.model.api.ImpliedStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class ImpliedStatementImpl extends AbstractDeclaredStatement implements ImpliedStatement { + ImpliedStatementImpl(final StmtContext context) { + super(context); + } + + @Override + public String getArgument() { + return argument(); + } +} 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 new file mode 100644 index 0000000000..55a20e3aa0 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/ImpliedStatementSupport.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import com.google.common.annotations.Beta; +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.parser.spi.meta.AbstractStatementSupport; +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; + +@Beta +public final class ImpliedStatementSupport + extends AbstractStatementSupport { + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = + SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.IMPLIED).build(); + private static final ImpliedStatementSupport INSTANCE = new ImpliedStatementSupport(); + + private ImpliedStatementSupport() { + super(IetfYangSmiv2ExtensionsMapping.IMPLIED); + } + + public static ImpliedStatementSupport getInstance() { + return INSTANCE; + } + + @Override + public String parseArgumentValue(final StmtContext ctx, final String value) { + return value; + } + + @Override + public void onFullDefinitionDeclared(final Mutable stmt) { + stmt.addToNs(IetfYangSmiv2Namespace.class, stmt, "Ietf-yang-smiv2 namespace."); + } + + @Override + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; + } + + @Override + public ImpliedStatement createDeclared(final StmtContext ctx) { + return new ImpliedStatementImpl(ctx); + } + + @Override + public ImpliedEffectiveStatement createEffective( + final StmtContext ctx) { + return new ImpliedEffectiveStatementImpl(ctx); + } +} \ No newline at end of file diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessEffectiveStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessEffectiveStatementImpl.java new file mode 100644 index 0000000000..2c1fb205a2 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessEffectiveStatementImpl.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import java.util.Objects; +import org.opendaylight.yangtools.rfc6643.model.api.MaxAccessEffectiveStatement; +import org.opendaylight.yangtools.rfc6643.model.api.MaxAccessSchemaNode; +import org.opendaylight.yangtools.rfc6643.model.api.MaxAccessStatement; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class MaxAccessEffectiveStatementImpl extends UnknownEffectiveStatementBase + implements MaxAccessEffectiveStatement, MaxAccessSchemaNode { + + private final SchemaPath path; + private final String valueFromNamespace; + + MaxAccessEffectiveStatementImpl(final StmtContext ctx) { + super(ctx); + path = ctx.getParentContext().getSchemaPath().get().createChild(getNodeType()); + valueFromNamespace = ctx.getFromNamespace(IetfYangSmiv2Namespace.class, ctx); + } + + // FIXME: what good is this method? + public String getValueFromNamespace() { + return valueFromNamespace; + } + + @Override + public String getArgument() { + return argument(); + } + + @Override + public QName getQName() { + return getNodeType(); + } + + @Override + public SchemaPath getPath() { + return path; + } + + @Override + public int hashCode() { + return Objects.hash(path, getNodeType(), getNodeParameter()); + } + + @Override + public boolean equals(final Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + final MaxAccessEffectiveStatementImpl other = (MaxAccessEffectiveStatementImpl) obj; + if (!Objects.equals(path, other.path)) { + return false; + } + if (!Objects.equals(getNodeType(), other.getNodeType())) { + return false; + } + if (!Objects.equals(getNodeParameter(), other.getNodeParameter())) { + return false; + } + return true; + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessStatementImpl.java new file mode 100644 index 0000000000..701a7f89ea --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessStatementImpl.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import org.opendaylight.yangtools.rfc6643.model.api.MaxAccessStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class MaxAccessStatementImpl extends AbstractDeclaredStatement implements MaxAccessStatement { + MaxAccessStatementImpl(final StmtContext context) { + super(context); + } + + @Override + public String getArgument() { + return argument(); + } +} 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 new file mode 100644 index 0000000000..3187d0b548 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/MaxAccessStatementSupport.java @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import com.google.common.annotations.Beta; +import org.eclipse.jdt.annotation.Nullable; +import org.opendaylight.yangtools.rfc6643.model.api.IetfYangSmiv2ExtensionsMapping; +import org.opendaylight.yangtools.rfc6643.model.api.MaxAccessEffectiveStatement; +import org.opendaylight.yangtools.rfc6643.model.api.MaxAccessStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; +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; + +@Beta +public final class MaxAccessStatementSupport + extends AbstractStatementSupport { + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = + SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.MAX_ACCESS).build(); + private static final MaxAccessStatementSupport INSTANCE = new MaxAccessStatementSupport(); + + private MaxAccessStatementSupport() { + super(IetfYangSmiv2ExtensionsMapping.MAX_ACCESS); + } + + public static MaxAccessStatementSupport getInstance() { + return INSTANCE; + } + + @Override + public String parseArgumentValue(final StmtContext ctx, final String value) { + return value; + } + + @Override + public void onFullDefinitionDeclared(final Mutable stmt) { + stmt.addToNs(IetfYangSmiv2Namespace.class, stmt, "Ietf-yang-smiv2 namespace."); + } + + @Nullable + @Override + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; + } + + @Override + public MaxAccessStatement createDeclared(final StmtContext ctx) { + return new MaxAccessStatementImpl(ctx); + } + + @Override + public MaxAccessEffectiveStatement createEffective( + final StmtContext ctx) { + return new MaxAccessEffectiveStatementImpl(ctx); + } +} \ No newline at end of file diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidEffectiveStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidEffectiveStatementImpl.java new file mode 100644 index 0000000000..eb61726da4 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidEffectiveStatementImpl.java @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import java.util.Objects; +import org.opendaylight.yangtools.rfc6643.model.api.ObjectIdentifier; +import org.opendaylight.yangtools.rfc6643.model.api.OidEffectiveStatement; +import org.opendaylight.yangtools.rfc6643.model.api.OidSchemaNode; +import org.opendaylight.yangtools.rfc6643.model.api.OidStatement; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class OidEffectiveStatementImpl extends UnknownEffectiveStatementBase + implements OidEffectiveStatement, OidSchemaNode { + + private final SchemaPath path; + + OidEffectiveStatementImpl(final StmtContext ctx) { + super(ctx); + path = ctx.getParentContext().getSchemaPath().get().createChild(getNodeType()); + } + + @Override + public ObjectIdentifier getArgument() { + return argument(); + } + + @Override + public QName getQName() { + return getNodeType(); + } + + @Override + public SchemaPath getPath() { + return path; + } + + @Override + public int hashCode() { + return Objects.hash(path, getNodeType(), getNodeParameter()); + } + + @Override + public boolean equals(final Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + final OidEffectiveStatementImpl other = (OidEffectiveStatementImpl) obj; + if (!Objects.equals(path, other.path)) { + return false; + } + if (!Objects.equals(getNodeType(), other.getNodeType())) { + return false; + } + if (!Objects.equals(getNodeParameter(), other.getNodeParameter())) { + return false; + } + return true; + } +} \ No newline at end of file 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/OidIdStatementImpl.java new file mode 100644 index 0000000000..0fcd9bac82 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidIdStatementImpl.java @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import static com.google.common.base.Verify.verifyNotNull; + +import org.opendaylight.yangtools.rfc6643.model.api.ObjectIdentifier; +import org.opendaylight.yangtools.rfc6643.model.api.OidStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class OidIdStatementImpl extends AbstractDeclaredStatement implements OidStatement { + OidIdStatementImpl(final StmtContext context) { + super(context); + } + + @Override + public ObjectIdentifier getOid() { + return verifyNotNull(argument()); + } + + @Override + public ObjectIdentifier getArgument() { + return null; + } +} 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 new file mode 100644 index 0000000000..5997496978 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/OidStatementSupport.java @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import com.google.common.annotations.Beta; +import org.eclipse.jdt.annotation.Nullable; +import org.opendaylight.yangtools.rfc6643.model.api.IetfYangSmiv2ExtensionsMapping; +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.parser.spi.meta.AbstractStatementSupport; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; +import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; + +@Beta +public final class OidStatementSupport + extends AbstractStatementSupport { + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = + SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.OBJECT_ID).build(); + private static final OidStatementSupport INSTANCE = new OidStatementSupport(); + + private OidStatementSupport() { + super(IetfYangSmiv2ExtensionsMapping.OBJECT_ID); + } + + public static OidStatementSupport getInstance() { + return INSTANCE; + } + + @Override + public ObjectIdentifier parseArgumentValue(final StmtContext ctx, final String value) { + return ObjectIdentifier.forString(value); + } + + @Override + public void onFullDefinitionDeclared( + final StmtContext.Mutable stmt) { + stmt.addToNs(IetfYangSmiv2Namespace.class, stmt, "Ietf-yang-smiv2 namespace."); + } + + @Nullable + @Override + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; + } + + @Override + public OidStatement createDeclared(final StmtContext ctx) { + return new OidIdStatementImpl(ctx); + } + + @Override + public OidEffectiveStatement createEffective( + final StmtContext ctx) { + return new OidEffectiveStatementImpl(ctx); + } +} \ No newline at end of file diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdEffectiveStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdEffectiveStatementImpl.java new file mode 100644 index 0000000000..b65e52685a --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdEffectiveStatementImpl.java @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import java.util.Objects; +import org.opendaylight.yangtools.rfc6643.model.api.SubIdEffectiveStatement; +import org.opendaylight.yangtools.rfc6643.model.api.SubIdSchemaNode; +import org.opendaylight.yangtools.rfc6643.model.api.SubIdStatement; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class SubIdEffectiveStatementImpl extends UnknownEffectiveStatementBase + implements SubIdEffectiveStatement, SubIdSchemaNode { + + private final SchemaPath path; + + SubIdEffectiveStatementImpl(final StmtContext ctx) { + super(ctx); + path = ctx.getParentContext().getSchemaPath().get().createChild(getNodeType()); + } + + @Override + public int getArgument() { + return argument().intValue(); + } + + @Override + public QName getQName() { + return getNodeType(); + } + + @Override + public SchemaPath getPath() { + return path; + } + + @Override + public int hashCode() { + return Objects.hash(path, getNodeType(), getNodeParameter()); + } + + @Override + public boolean equals(final Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + final SubIdEffectiveStatementImpl other = (SubIdEffectiveStatementImpl) obj; + if (!Objects.equals(path, other.path)) { + return false; + } + if (!Objects.equals(getNodeType(), other.getNodeType())) { + return false; + } + if (!Objects.equals(getNodeParameter(), other.getNodeParameter())) { + return false; + } + return true; + } +} diff --git a/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdStatementImpl.java b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdStatementImpl.java new file mode 100644 index 0000000000..ed77079b6e --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdStatementImpl.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import org.opendaylight.yangtools.rfc6643.model.api.SubIdStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class SubIdStatementImpl extends AbstractDeclaredStatement implements SubIdStatement { + SubIdStatementImpl(final StmtContext context) { + super(context); + } + + @Override + public Integer getArgument() { + return argument(); + } +} 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 new file mode 100644 index 0000000000..23adfa2642 --- /dev/null +++ b/yang/rfc6643-parser-support/src/main/java/org/opendaylight/yangtools/rfc6643/parser/SubIdStatementSupport.java @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2016, 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.rfc6643.parser; + +import com.google.common.annotations.Beta; +import org.eclipse.jdt.annotation.Nullable; +import org.opendaylight.yangtools.rfc6643.model.api.IetfYangSmiv2ExtensionsMapping; +import org.opendaylight.yangtools.rfc6643.model.api.SubIdEffectiveStatement; +import org.opendaylight.yangtools.rfc6643.model.api.SubIdStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; +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; + +@Beta +public final class SubIdStatementSupport + extends AbstractStatementSupport { + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = + SubstatementValidator.builder(IetfYangSmiv2ExtensionsMapping.SUB_ID).build(); + private static final SubIdStatementSupport INSTANCE = new SubIdStatementSupport(); + + private SubIdStatementSupport() { + super(IetfYangSmiv2ExtensionsMapping.SUB_ID); + } + + public static SubIdStatementSupport getInstance() { + return INSTANCE; + } + + @Override + public Integer parseArgumentValue(final StmtContext ctx, final String value) { + return Integer.parseUnsignedInt(value); + } + + @Override + public void onFullDefinitionDeclared(final Mutable stmt) { + stmt.addToNs(IetfYangSmiv2Namespace.class, stmt, "Ietf-yang-smiv2 namespace."); + } + + @Nullable + @Override + protected SubstatementValidator getSubstatementValidator() { + return SUBSTATEMENT_VALIDATOR; + } + + @Override + public SubIdStatement createDeclared(final StmtContext ctx) { + return new SubIdStatementImpl(ctx); + } + + @Override + public SubIdEffectiveStatement createEffective( + final StmtContext ctx) { + return new SubIdEffectiveStatementImpl(ctx); + } +} diff --git a/yang/rfc6643-parser-support/src/test/java/org/opendaylight/yangtools/rfc6643/parser/IetfYangSmiv2ExtensionPluginTest.java b/yang/rfc6643-parser-support/src/test/java/org/opendaylight/yangtools/rfc6643/parser/IetfYangSmiv2ExtensionPluginTest.java new file mode 100644 index 0000000000..eecc69ac1b --- /dev/null +++ b/yang/rfc6643-parser-support/src/test/java/org/opendaylight/yangtools/rfc6643/parser/IetfYangSmiv2ExtensionPluginTest.java @@ -0,0 +1,126 @@ +/* + * Copyright (c) 2017, 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.rfc6643.parser; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.sourceLocal; + +import java.io.IOException; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; +import org.opendaylight.yangtools.rfc6643.model.api.AliasSchemaNode; +import org.opendaylight.yangtools.rfc6643.model.api.DefValSchemaNode; +import org.opendaylight.yangtools.rfc6643.model.api.ImpliedSchemaNode; +import org.opendaylight.yangtools.rfc6643.model.api.MaxAccessSchemaNode; +import org.opendaylight.yangtools.rfc6643.model.api.ObjectIdentifier; +import org.opendaylight.yangtools.rfc6643.model.api.OidSchemaNode; +import org.opendaylight.yangtools.rfc6643.model.api.SubIdSchemaNode; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; +import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException; +import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource; +import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors; +import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource; +import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase; +import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException; +import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor; + +public class IetfYangSmiv2ExtensionPluginTest { + private static final String NS = "urn:opendaylight:yang:extension:third-party"; + private static final String REV = "2016-06-09"; + + private static CrossSourceStatementReactor reactor; + + @BeforeClass + public static void createReactor() { + reactor = RFC7950Reactors.defaultReactorBuilder() + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, DisplayHintStatementSupport.getInstance()) + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, MaxAccessStatementSupport.getInstance()) + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, DefValStatementSupport.getInstance()) + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, ImpliedStatementSupport.getInstance()) + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, AliasStatementSupport.getInstance()) + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, OidStatementSupport.getInstance()) + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, SubIdStatementSupport.getInstance()) + .addNamespaceSupport(ModelProcessingPhase.FULL_DECLARATION, sourceLocal(IetfYangSmiv2Namespace.class)) + .build(); + } + + @AfterClass + public static void freeReactor() { + reactor = null; + } + + @Test + public void testExtensions() throws ReactorException, YangSyntaxErrorException, IOException { + SchemaContext schema = createSchema(); + + assertTrue(schema.getUnknownSchemaNodes().size() == 1); + AliasSchemaNode aliasExtEffectStmt = (AliasSchemaNode) schema.getUnknownSchemaNodes().get(0); + assertEquals(aliasExtEffectStmt.getArgument(), "ifXTable"); + assertTrue(aliasExtEffectStmt.getUnknownSchemaNodes().size() == 1); + OidSchemaNode oidExtEffectStmt = + (OidSchemaNode) aliasExtEffectStmt.getUnknownSchemaNodes().get(0); + assertEquals(oidExtEffectStmt.getArgument().toString(), "1.3.6.1.2.1.31.1.1"); + + final DataSchemaNode dataChildByName = schema.getDataChildByName(QName.create(NS, REV, "root")); + assertTrue(dataChildByName instanceof ContainerSchemaNode); + final ContainerSchemaNode root = (ContainerSchemaNode) dataChildByName; + assertTrue(root.getUnknownSchemaNodes().size() == 1); + OidSchemaNode oid = (OidSchemaNode) + root.getUnknownSchemaNodes().get(0); + assertEquals(oid.getArgument().toString(), "1"); + + ListSchemaNode ifStackEntry = (ListSchemaNode) root.getDataChildByName(QName.create(NS, REV, "ifStackEntry")); + assertTrue(ifStackEntry.getUnknownSchemaNodes().size() == 2); + ifStackEntry.getUnknownSchemaNodes().forEach(unknownSchemaNode -> { + if (unknownSchemaNode instanceof OidSchemaNode) { + assertEquals(((OidSchemaNode) unknownSchemaNode).getArgument().toString(), + ObjectIdentifier.forString("1.1").toString()); + } else if (unknownSchemaNode instanceof ImpliedSchemaNode) { + assertEquals(((ImpliedSchemaNode) unknownSchemaNode).getArgument(), "ifStackHigherLayer"); + } + }); + + LeafSchemaNode ifStackHigherLayer = (LeafSchemaNode) + ifStackEntry.getDataChildByName(QName.create(NS, REV, "ifStackHigherLayer")); + + ifStackHigherLayer.getUnknownSchemaNodes().forEach(unknownSchemaNode -> { + if (unknownSchemaNode instanceof MaxAccessSchemaNode) { + final MaxAccessSchemaNode maxAccess = (MaxAccessSchemaNode) unknownSchemaNode; + assertEquals(maxAccess.getArgument(), "not-accessible"); + } + }); + + LeafSchemaNode testNumberLeaf = (LeafSchemaNode) + ifStackEntry.getDataChildByName(QName.create(NS, REV, "test-number")); + assertTrue(testNumberLeaf.getUnknownSchemaNodes().size() == 3); + testNumberLeaf.getUnknownSchemaNodes().forEach(unknownSchemaNode -> { + if (unknownSchemaNode instanceof SubIdSchemaNode) { + assertEquals(((SubIdSchemaNode) unknownSchemaNode).getArgument(), 2); + } else if (unknownSchemaNode instanceof DefValSchemaNode) { + assertEquals(((DefValSchemaNode) unknownSchemaNode).getArgument(), "0"); + } + }); + } + + private static SchemaContext createSchema() throws ReactorException, YangSyntaxErrorException, IOException { + return reactor.newBuild() + .addSources( + YangStatementStreamSource.create(YangTextSchemaSource.forResource( + IetfYangSmiv2ExtensionPluginTest.class, "/foo.yang")), + YangStatementStreamSource.create(YangTextSchemaSource.forResource( + IetfYangSmiv2ExtensionPluginTest.class, "/ietf-yang-smiv2.yang"))) + .buildEffective(); + } +} diff --git a/yang/rfc6643-parser-support/src/test/java/org/opendaylight/yangtools/rfc6643/parser/IetfYangSmiv2ExtensionsMappingTest.java b/yang/rfc6643-parser-support/src/test/java/org/opendaylight/yangtools/rfc6643/parser/IetfYangSmiv2ExtensionsMappingTest.java new file mode 100644 index 0000000000..46ef7d825d --- /dev/null +++ b/yang/rfc6643-parser-support/src/test/java/org/opendaylight/yangtools/rfc6643/parser/IetfYangSmiv2ExtensionsMappingTest.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2015, 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.rfc6643.parser; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; + +import org.junit.Test; +import org.opendaylight.yangtools.rfc6643.model.api.AliasEffectiveStatement; +import org.opendaylight.yangtools.rfc6643.model.api.IetfYangSmiv2ExtensionsMapping; + +public class IetfYangSmiv2ExtensionsMappingTest { + @Test + public void testGetEffectiveRepresentationClass() { + IetfYangSmiv2ExtensionsMapping extensionMapping = IetfYangSmiv2ExtensionsMapping.ALIAS; + assertEquals(extensionMapping.getEffectiveRepresentationClass(), AliasEffectiveStatement.class); + } + + @Test + public void testIsArgumentYinElement() { + IetfYangSmiv2ExtensionsMapping extensionMapping = IetfYangSmiv2ExtensionsMapping.ALIAS; + assertFalse(extensionMapping.getArgumentDefinition().get().isYinElement()); + } +} diff --git a/yang/rfc6643-parser-support/src/test/java/org/opendaylight/yangtools/rfc6643/parser/ObjectIdentifierTest.java b/yang/rfc6643-parser-support/src/test/java/org/opendaylight/yangtools/rfc6643/parser/ObjectIdentifierTest.java new file mode 100644 index 0000000000..0529558c99 --- /dev/null +++ b/yang/rfc6643-parser-support/src/test/java/org/opendaylight/yangtools/rfc6643/parser/ObjectIdentifierTest.java @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2015, 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.rfc6643.parser; + +import org.junit.Test; +import org.opendaylight.yangtools.rfc6643.model.api.ObjectIdentifier; + +public class ObjectIdentifierTest { + @Test(expected = IllegalArgumentException.class) + public void testObjectIdentifierCreationWithBadOID() { + ObjectIdentifier.forString("bad oid"); + } +} diff --git a/yang/rfc6643-parser-support/src/test/resources/foo.yang b/yang/rfc6643-parser-support/src/test/resources/foo.yang new file mode 100644 index 0000000000..eff1019418 --- /dev/null +++ b/yang/rfc6643-parser-support/src/test/resources/foo.yang @@ -0,0 +1,64 @@ +module foo { + namespace "urn:opendaylight:yang:extension:third-party"; + prefix foo; + yang-version 1; + + import ietf-yang-smiv2 { prefix "smiv2"; } + + revision 2016-06-09; + + typedef InterfaceIndexOrZero { + type int32 { + range "0..2147483647"; + } + description + "This textual convention is an extension of the + InterfaceIndex convention. The latter defines a greater + than zero value used to identify an interface or interface + sub-layer in the managed system. This extension permits the + additional value of zero. the value zero is object-specific + and must therefore be defined as part of the description of + any object which uses this syntax. Examples of the usage of + zero might include situations where interface was unknown, + or when none or all interfaces need to be referenced."; + smiv2:display-hint "d"; + } + + container root { + smiv2:oid "1"; + + list ifStackEntry { + smiv2:oid "1.1"; + smiv2:implied "ifStackHigherLayer"; + key "ifStackHigherLayer"; + + leaf ifStackHigherLayer { + type foo:InterfaceIndexOrZero; + smiv2:max-access "not-accessible"; + description "The value of ifIndex corresponding to the higher sub-layer + of the relationship, i.e., the sub-layer which runs on 'top' + of the sub-layer identified by the corresponding instance of + ifStackLowerLayer. If there is no higher sub-layer (below + the internetwork layer), then this object has the value 0."; + smiv2:oid "1.1.1"; + } + + leaf test-number { + type int32; + description "Test leaf;"; + smiv2:max-access "not-accessible"; + smiv2:subid "2"; + smiv2:defval "0"; + } + } + } + + smiv2:alias "ifXTable" { + description "A list of interface entries. The number of entries is + given by the value of ifNumber. This table contains + additional objects for the interface table."; + smiv2:oid "1.3.6.1.2.1.31.1.1"; + } + + +} diff --git a/yang/rfc6643-parser-support/src/test/resources/ietf-yang-smiv2.yang b/yang/rfc6643-parser-support/src/test/resources/ietf-yang-smiv2.yang new file mode 100644 index 0000000000..5127e22f74 --- /dev/null +++ b/yang/rfc6643-parser-support/src/test/resources/ietf-yang-smiv2.yang @@ -0,0 +1,146 @@ +module ietf-yang-smiv2 { + + namespace "urn:ietf:params:xml:ns:yang:ietf-yang-smiv2"; + prefix "smiv2"; + + organization + "IETF NETMOD (NETCONF Data Modeling Language) Working Group"; + + contact + "WG Web: + WG List: + + WG Chair: David Kessens + + + WG Chair: Juergen Schoenwaelder + + + Editor: Juergen Schoenwaelder + "; + + description + "This module defines YANG extensions that are used to translate + SMIv2 concepts into YANG. + + Copyright (c) 2012 IETF Trust and the persons identified as + authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or + without modification, is permitted pursuant to, and subject + to the license terms contained in, the Simplified BSD License + set forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (http://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 6643; see + the RFC itself for full legal notices."; + + revision 2012-06-22 { + description + "Initial revision."; + reference + "RFC 6643: Translation of Structure of Management Information + Version 2 (SMIv2) MIB Modules to YANG Modules"; + } + + identity object-identity { + description + "Base identity for all SMIv2 OBJECT-IDENTITYs."; + } + + typedef opaque { + type binary; + description + "The Opaque type supports the capability to pass arbitrary ASN.1 + syntax. A value is encoded using the ASN.1 Basic Encoding Rules + into a string of octets. This, in turn, is encoded as an OCTET + STRING, in effect 'double-wrapping' the original ASN.1 value. + + In the value set and its semantics, this type is equivalent to + the Opaque type of the SMIv2. This type exists in the SMIv2 + solely for backward-compatibility reasons and this is also + true for this YANG data type."; + reference + "RFC 2578: Structure of Management Information Version 2 (SMIv2)"; + } + + extension display-hint { + argument "format"; + description + "The display-hint statement takes as an argument the DISPLAY-HINT + assigned to an SMIv2 textual convention."; + reference + "RFC 2579: Textual Conventions for SMIv2"; + } + + extension max-access { + argument "access"; + description + "The max-access statement takes as an argument the MAX-ACCESS + assigned to an SMIv2 object definition. + + The MAX-ACCESS value is SMIv2 specific and has no impact on + the access provided to YANG objects through protocols such + as NETCONF."; + reference + "RFC 2578: Structure of Management Information Version 2 (SMIv2)"; + } + + extension defval { + argument "value"; + description + "The defval statement takes as an argument a default value + defined by an SMIv2 DEFVAL clause. Note that the value is in + the SMIv2 value space defined by the SMIv2 syntax of the + corresponding object and not in the YANG value space + defined by the corresponding YANG data type."; + reference + "RFC 2578: Structure of Management Information Version 2 (SMIv2)"; + } + + extension implied { + argument "index"; + description + "If an SMIv2 INDEX object is preceded by the IMPLIED keyword, then + the implied statement is present in the YANG module and takes as + an argument the name of the IMPLIED index object."; + reference + "RFC 2578: Structure of Management Information Version 2 (SMIv2)"; + } + + extension alias { + argument "descriptor"; + description + "The alias statement introduces an SMIv2 descriptor. The body of + the alias statement is expected to contain an oid statement that + provides the numeric OID associated with the descriptor."; + reference + "RFC 2578: Structure of Management Information Version 2 (SMIv2)"; + } + + extension oid { + argument "value"; + description + "The oid statement takes as an argument the object identifier + assigned to an SMIv2 definition. The object identifier value + is written in decimal dotted notation."; + reference + "RFC 2578: Structure of Management Information Version 2 (SMIv2)"; + } + + extension subid { + argument "value"; + description + "The subid statement takes as an argument the last sub-identifier + of the object identifier assigned to an SMIv2 definition. The + sub-identifier value is a single positive decimal natural number. + The subid statement may not be used as a substatement to any + top-level node in a YANG document. The subid substatement may + be used only as a substatement to a node having a parent node + defined with either an smiv2:oid or smiv2:subid substatement."; + reference + "RFC 2578: Structure of Management Information Version 2 (SMIv2)"; + } + +} diff --git a/yang/yang-parser-impl/pom.xml b/yang/yang-parser-impl/pom.xml index e3f1452f30..9c914b2b07 100644 --- a/yang/yang-parser-impl/pom.xml +++ b/yang/yang-parser-impl/pom.xml @@ -90,6 +90,14 @@ org.opendaylight.yangtools rfc6536-parser-support + + org.opendaylight.yangtools + rfc6643-model-api + + + org.opendaylight.yangtools + rfc6643-parser-support + org.opendaylight.yangtools rfc7952-model-api diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/DefaultReactors.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/DefaultReactors.java index 3bcd1c6107..8d66a4d04d 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/DefaultReactors.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/DefaultReactors.java @@ -7,6 +7,8 @@ */ package org.opendaylight.yangtools.yang.parser.impl; +import static org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.sourceLocal; + import com.google.common.annotations.Beta; import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.odlext.parser.AnyxmlSchemaLocationNamespace; @@ -17,6 +19,14 @@ import org.opendaylight.yangtools.openconfig.parser.HashedValueStatementSupport; import org.opendaylight.yangtools.rfc6241.parser.GetFilterElementAttributesStatementSupport; import org.opendaylight.yangtools.rfc6536.parser.DefaultDenyAllStatementSupport; import org.opendaylight.yangtools.rfc6536.parser.DefaultDenyWriteStatementSupport; +import org.opendaylight.yangtools.rfc6643.parser.AliasStatementSupport; +import org.opendaylight.yangtools.rfc6643.parser.DefValStatementSupport; +import org.opendaylight.yangtools.rfc6643.parser.DisplayHintStatementSupport; +import org.opendaylight.yangtools.rfc6643.parser.IetfYangSmiv2Namespace; +import org.opendaylight.yangtools.rfc6643.parser.ImpliedStatementSupport; +import org.opendaylight.yangtools.rfc6643.parser.MaxAccessStatementSupport; +import org.opendaylight.yangtools.rfc6643.parser.OidStatementSupport; +import org.opendaylight.yangtools.rfc6643.parser.SubIdStatementSupport; import org.opendaylight.yangtools.rfc7952.parser.AnnotationStatementSupport; import org.opendaylight.yangtools.rfc8040.parser.YangDataStatementSupport; import org.opendaylight.yangtools.rfc8528.parser.MountPointStatementSupport; @@ -81,6 +91,16 @@ public final class DefaultReactors { .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, DefaultDenyWriteStatementSupport.getInstance()) + // RFC6643 extensions + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, DisplayHintStatementSupport.getInstance()) + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, MaxAccessStatementSupport.getInstance()) + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, DefValStatementSupport.getInstance()) + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, ImpliedStatementSupport.getInstance()) + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, AliasStatementSupport.getInstance()) + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, OidStatementSupport.getInstance()) + .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, SubIdStatementSupport.getInstance()) + .addNamespaceSupport(ModelProcessingPhase.FULL_DECLARATION, sourceLocal(IetfYangSmiv2Namespace.class)) + // RFC7952 annotation support .addStatementSupport(ModelProcessingPhase.FULL_DECLARATION, AnnotationStatementSupport.getInstance()) -- 2.36.6