import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
import org.opendaylight.yangtools.yang.model.util.type.ConcreteTypeBuilder;
import org.opendaylight.yangtools.yang.model.util.type.ConcreteTypes;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.UnknownEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
@Override
protected boolean valueEquals(final AbstractImmutableNormalizedNode<?, ?> other) {
// We can not call directly getValue.equals because of Empty Type
- // Definition leaves which allways have NULL value
+ // RequireInstanceStatementSupport leaves which allways have NULL value
if (!Objects.deepEquals(value(), other.getValue())) {
return false;
-/**
+/*
* Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
+import com.google.common.annotations.Beta;
import java.util.Optional;
import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModifierEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-abstract class AbstractConstraintEffectiveStatement<A, D extends DeclaredStatement<A>> extends
+@Beta
+public abstract class AbstractConstraintEffectiveStatement<A, D extends DeclaredStatement<A>> extends
DeclaredEffectiveStatementBase<A, D> implements ConstraintMetaDefinition {
private final String description;
private final String reference;
private final ModifierKind modifier;
private final A constraints;
- AbstractConstraintEffectiveStatement(final StmtContext<A, D, ?> ctx) {
+
protected AbstractConstraintEffectiveStatement(final StmtContext<A, D, ?> ctx) {
super(ctx);
String descriptionInit = null;
String referenceInit = null;
return Optional.ofNullable(errorMessage);
}
- abstract A createConstraints(A argument);
+ protected abstract A createConstraints(A argument);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import static java.util.Objects.requireNonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.AbstractEffectiveDocumentedNode;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.EffectiveStmtUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.AugmentToChoiceNamespace;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangValidationBundles;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.CaseShorthandImpl;
-abstract class AbstractEffectiveDocumentedDataNodeContainer<A, D extends DeclaredStatement<A>>
- extends AbstractEffectiveDocumentedNode<A, D> implements
- DataNodeContainer {
+public abstract class AbstractEffectiveDocumentedDataNodeContainer<A, D extends DeclaredStatement<A>>
+ extends AbstractEffectiveDocumentedNode<A, D> implements DataNodeContainer {
private final Map<QName, DataSchemaNode> childNodes;
private final Set<GroupingDefinition> groupings;
private final Set<TypeDefinition<?>> typeDefinitions;
private final Set<DataSchemaNode> publicChildNodes;
- protected AbstractEffectiveDocumentedDataNodeContainer(
- final StmtContext<A, D, ?> ctx) {
+ protected AbstractEffectiveDocumentedDataNodeContainer(final StmtContext<A, D, ?> ctx) {
super(ctx);
Map<QName, DataSchemaNode> mutableChildNodes = new LinkedHashMap<>();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.rfc6020.util;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import java.util.Optional;
import javax.annotation.Nonnull;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.requireNonNull;
+import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.AbstractEffectiveDocumentedNode;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.EffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.EffectiveStmtUtils;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.belongs_to.BelongsToEffectiveStatementImpl;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension.ExtensionEffectiveStatementImpl;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule.SubmoduleEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.spi.meta.MutableStatement;
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.openconfig.OpenconfigVersionEffectiveStatement;
-abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> extends
+@Beta
+public abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> extends
AbstractEffectiveDocumentedNode<String, D> implements Module, MutableStatement {
private final String name;
private final String prefix;
private Set<Module> submodules;
private boolean sealed;
- AbstractEffectiveModule(final StmtContext<String, D, ? extends EffectiveStatement<String, ?>> ctx) {
+ protected AbstractEffectiveModule(final StmtContext<String, D, ? extends EffectiveStatement<String, ?>> ctx) {
super(ctx);
this.name = argument();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.rfc6020.util;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import com.google.common.collect.ImmutableList;
import java.util.List;
private final SchemaPath path;
private final List<UnknownSchemaNode> unknownNodes;
- public AbstractEffectiveSchemaNode(final StmtContext<QName, D, ?> ctx) {
+ protected AbstractEffectiveSchemaNode(final StmtContext<QName, D, ?> ctx) {
super(ctx);
this.path = ctx.getSchemaPath().get();
@Nonnull
@Override
- public QName getQName() {
+ public final QName getQName() {
return path.getLastComponent();
}
@Nonnull
@Override
- public SchemaPath getPath() {
+ public final SchemaPath getPath() {
return path;
}
@Nonnull
@Override
- public List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ public final List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
}
}
-/**
+/*
* Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
+import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-abstract class AbstractListConstraintEffectiveStatement<T, D extends DeclaredStatement<List<T>>>
+@Beta
+public abstract class AbstractListConstraintEffectiveStatement<T, D extends DeclaredStatement<List<T>>>
extends AbstractConstraintEffectiveStatement<List<T>, D> {
- AbstractListConstraintEffectiveStatement(final StmtContext<List<T>, D, ?> ctx) {
+ protected AbstractListConstraintEffectiveStatement(final StmtContext<List<T>, D, ?> ctx) {
super(ctx);
}
@Override
- final List<T> createConstraints(final List<T> argument) {
+ protected final List<T> createConstraints(final List<T> argument) {
return ImmutableList.copyOf(argument);
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import java.util.Collection;
import javax.annotation.Nonnull;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.rfc6020.util;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import com.google.common.base.Verify;
import javax.annotation.Nonnull;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.rfc6020.util;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableList;
/**
* Create a set of substatements. This method is split out so it can be overridden in
- * {@link org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ExtensionEffectiveStatementImpl} to leak
+ * {@link org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension.ExtensionEffectiveStatementImpl} to leak
* a not-fully-initialized instance.
*
* @param substatementsInit proposed substatements
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.rfc6020.util;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.rfc6020.util;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import com.google.common.base.Verify;
import javax.annotation.Nonnull;
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.rfc6020.util;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.action;
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableSet;
import org.opendaylight.yangtools.yang.model.api.stmt.ActionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.AbstractEffectiveSchemaNode;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.EffectiveStmtUtils;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveSchemaNode;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStmtUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.InputEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OutputEffectiveStatementImpl;
-
public class ActionEffectiveStatementImpl extends AbstractEffectiveSchemaNode<ActionStatement>
+
final class ActionEffectiveStatementImpl extends AbstractEffectiveSchemaNode<ActionStatement>
implements ActionDefinition, ActionEffectiveStatement {
private final ContainerSchemaNode input;
private final ContainerSchemaNode output;
private final boolean augmenting;
private final boolean addedByUses;
- public ActionEffectiveStatementImpl(
+ ActionEffectiveStatementImpl(
final StmtContext<QName, ActionStatement, EffectiveStatement<QName, ActionStatement>> ctx) {
super(ctx);
this.input = firstEffective(InputEffectiveStatementImpl.class);
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.action;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class ActionStatementImpl extends AbstractDeclaredStatement<QName> implements ActionStatement {
+ ActionStatementImpl(final StmtContext<QName,ActionStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public QName getName() {
+ return argument();
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends TypedefStatement> getTypedefs() {
+ return allDeclared(TypedefStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends GroupingStatement> getGroupings() {
+ return allDeclared(GroupingStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Override
+ public InputStatement getInput() {
+ return firstDeclared(InputStatement.class);
+ }
+
+ @Override
+ public OutputStatement getOutput() {
+ return firstDeclared(OutputStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends IfFeatureStatement> getIfFeatures() {
+ return allDeclared(IfFeatureStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.action;
+
+import com.google.common.collect.ImmutableSet;
+import java.util.Set;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input.InputStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output.OutputStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.spi.source.ImplicitSubstatement;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementDefinitionContext;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
+
+public final class ActionStatementSupport
+ extends AbstractQNameStatementSupport<ActionStatement, EffectiveStatement<QName, ActionStatement>> {
+ private static final Set<StatementDefinition> ILLEGAL_PARENTS = ImmutableSet.of(YangStmtMapping.NOTIFICATION,
+ YangStmtMapping.RPC, YangStmtMapping.ACTION);
+ private static final StatementSupport<?, ?, ?> IMPLICIT_INPUT = new InputStatementRFC7950Support();
+ private static final StatementSupport<?, ?, ?> IMPLICIT_OUTPUT = new OutputStatementRFC7950Support();
+
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.ACTION)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.INPUT)
+ .addOptional(YangStmtMapping.OUTPUT)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .build();
+
+ public ActionStatementSupport() {
+ super(YangStmtMapping.ACTION);
+ }
+
+ @Override
+ public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public void onStatementAdded(
+ final StmtContext.Mutable<QName, ActionStatement, EffectiveStatement<QName, ActionStatement>> stmt) {
+ stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
+ }
+
+ @Override
+ public ActionStatement createDeclared(
+ final StmtContext<QName, ActionStatement, ?> ctx) {
+ return new ActionStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<QName, ActionStatement> createEffective(
+ final StmtContext<QName, ActionStatement, EffectiveStatement<QName, ActionStatement>> ctx) {
+ SourceException.throwIf(StmtContextUtils.hasAncestorOfType(ctx, ILLEGAL_PARENTS),
+ ctx.getStatementSourceReference(),
+ "Action %s is defined within a notification, rpc or another action", ctx.getStatementArgument());
+ SourceException.throwIf(!StmtContextUtils.hasAncestorOfTypeWithChildOfType(ctx, YangStmtMapping.LIST,
+ YangStmtMapping.KEY), ctx.getStatementSourceReference(),
+ "Action %s is defined within a list that has no key statement", ctx.getStatementArgument());
+ SourceException.throwIf(StmtContextUtils.hasParentOfType(ctx, YangStmtMapping.CASE),
+ ctx.getStatementSourceReference(), "Action %s is defined within a case statement",
+ ctx.getStatementArgument());
+ SourceException.throwIf(StmtContextUtils.hasParentOfType(ctx, YangStmtMapping.MODULE),
+ ctx.getStatementSourceReference(), "Action %s is defined at the top level of a module",
+ ctx.getStatementArgument());
+ return new ActionEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, ActionStatement,
+ EffectiveStatement<QName, ActionStatement>> stmt) {
+ super.onFullDefinitionDeclared(stmt);
+
+ if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, InputStatement.class) == null) {
+ addImplicitStatement((StatementContextBase<?, ?, ?>) stmt, IMPLICIT_INPUT);
+ }
+
+ if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, OutputStatement.class) == null) {
+ addImplicitStatement((StatementContextBase<?, ?, ?>) stmt, IMPLICIT_OUTPUT);
+ }
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+
+ private static void addImplicitStatement(final StatementContextBase<?, ?, ?> parent,
+ final StatementSupport<?, ?, ?> statementToAdd) {
+ final StatementDefinitionContext<?, ?, ?> stmtDefCtx = new StatementDefinitionContext<>(statementToAdd);
+
+ parent.createSubstatement(parent.declaredSubstatements().size(), stmtDefCtx,
+ ImplicitSubstatement.of(parent.getStatementSourceReference()), null);
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.anydata;
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
* YANG 1.1 AnyData effective statement implementation.
*/
@Beta
-
public final class AnydataEffectiveStatementImpl extends AbstractEffectiveDataSchemaNode<AnydataStatement>
+final class AnydataEffectiveStatementImpl extends AbstractEffectiveDataSchemaNode<AnydataStatement>
implements AnydataEffectiveStatement, AnyDataSchemaNode, DerivableSchemaNode {
private final AnyDataSchemaNode original;
private final ContainerSchemaNode schema;
private final boolean mandatory;
- public AnydataEffectiveStatementImpl(
+ AnydataEffectiveStatementImpl(
final StmtContext<QName, AnydataStatement, EffectiveStatement<QName, AnydataStatement>> ctx) {
super(ctx);
this.original = (AnyDataSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective).orElse(null);
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.anydata;
+
+import com.google.common.annotations.Beta;
+import java.util.Collection;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.AnydataStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+/**
+ * YANG 1.1 AnyData declared statement implementation.
+ */
+@Beta
+final class AnydataStatementImpl extends AbstractDeclaredStatement<QName> implements AnydataStatement {
+ AnydataStatementImpl(final StmtContext<QName, AnydataStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public QName getName() {
+ return argument();
+ }
+
+ @Override
+ public WhenStatement getWhenStatement() {
+ return firstDeclared(WhenStatement.class);
+ }
+
+ @Override
+ public Collection<? extends IfFeatureStatement> getIfFeatures() {
+ return allDeclared(IfFeatureStatement.class);
+ }
+
+ @Override
+ public Collection<? extends MustStatement> getMusts() {
+ return allDeclared(MustStatement.class);
+ }
+
+ @Override
+ public ConfigStatement getConfig() {
+ return firstDeclared(ConfigStatement.class);
+ }
+
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Override
+ public MandatoryStatement getMandatory() {
+ return firstDeclared(MandatoryStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.anydata;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.AnydataStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
+
+public final class AnydataStatementSupport extends
+ AbstractQNameStatementSupport<AnydataStatement, EffectiveStatement<QName, AnydataStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.ANYDATA)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.MANDATORY)
+ .addAny(YangStmtMapping.MUST)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
+
+ public AnydataStatementSupport() {
+ super(YangStmtMapping.ANYDATA);
+ }
+
+ @Override
+ public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public void onStatementAdded(final Mutable<QName, AnydataStatement,
+ EffectiveStatement<QName, AnydataStatement>> stmt) {
+ stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
+ }
+
+ @Override
+ public AnydataStatement createDeclared(final StmtContext<QName, AnydataStatement, ?> ctx) {
+ return new AnydataStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<QName, AnydataStatement> createEffective(
+ final StmtContext<QName, AnydataStatement, EffectiveStatement<QName, AnydataStatement>> ctx) {
+ return new AnydataEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.anyxml;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class AnyxmlStatementImpl extends AbstractDeclaredStatement<QName> implements AnyxmlStatement {
+ AnyxmlStatementImpl(final StmtContext<QName, AnyxmlStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public QName getName() {
+ return argument();
+ }
+
+ @Override
+ public WhenStatement getWhenStatement() {
+ return firstDeclared(WhenStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends IfFeatureStatement> getIfFeatures() {
+ return allDeclared(IfFeatureStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends MustStatement> getMusts() {
+ return allDeclared(MustStatement.class);
+ }
+
+ @Override
+ public ConfigStatement getConfig() {
+ return firstDeclared(ConfigStatement.class);
+ }
+
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Override
+ public MandatoryStatement getMandatory() {
+ return firstDeclared(MandatoryStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.anyxml;
+
+import java.util.Map;
+import java.util.Optional;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.stmt.anyxmlschema.AnyxmlSchemaLocationNamespace;
+import org.opendaylight.yangtools.yang.parser.stmt.anyxmlschema.AnyxmlSchemaLocationStatement;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.SupportedExtensionsMapping;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.AnyxmlEffectiveStatementImpl;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.YangModeledAnyXmlEffectiveStatementImpl;
+
+public final class AnyxmlStatementSupport extends
+ AbstractQNameStatementSupport<AnyxmlStatement, EffectiveStatement<QName, AnyxmlStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .ANYXML)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.MANDATORY)
+ .addAny(YangStmtMapping.MUST)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addOptional(YangStmtMapping.WHEN)
+ .addOptional(SupportedExtensionsMapping.ANYXML_SCHEMA_LOCATION)
+ .build();
+
+ public AnyxmlStatementSupport() {
+ super(YangStmtMapping.ANYXML);
+ }
+
+ @Override
+ public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public void onStatementAdded(final Mutable<QName, AnyxmlStatement,
+ EffectiveStatement<QName, AnyxmlStatement>> stmt) {
+ stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
+ }
+
+ @Override
+ public AnyxmlStatement createDeclared(final StmtContext<QName, AnyxmlStatement, ?> ctx) {
+ return new AnyxmlStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<QName, AnyxmlStatement> createEffective(
+ final StmtContext<QName, AnyxmlStatement, EffectiveStatement<QName, AnyxmlStatement>> ctx) {
+ final Map<StatementDefinition, Mutable<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement,
+ EffectiveStatement<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement>>> schemaLocations =
+ ctx.getAllFromCurrentStmtCtxNamespace(AnyxmlSchemaLocationNamespace.class);
+ if (schemaLocations != null && !schemaLocations.isEmpty()) {
+ final SchemaNodeIdentifier anyXmlSchemaNodeIdentifier = schemaLocations.values().iterator().next()
+ .getStatementArgument();
+ final Optional<ContainerSchemaNode> anyXmlSchema = getAnyXmlSchema(ctx, anyXmlSchemaNodeIdentifier);
+ if (anyXmlSchema.isPresent()) {
+ return new YangModeledAnyXmlEffectiveStatementImpl(ctx, anyXmlSchema.get());
+ }
+ }
+ return new AnyxmlEffectiveStatementImpl(ctx);
+ }
+
+ private static Optional<ContainerSchemaNode> getAnyXmlSchema(
+ final StmtContext<QName, AnyxmlStatement, EffectiveStatement<QName, AnyxmlStatement>> ctx,
+ final SchemaNodeIdentifier contentSchemaPath) {
+ final StmtContext<?, ?, ?> findNode = Utils.findNode(ctx.getRoot(), contentSchemaPath);
+ if (findNode != null) {
+ final EffectiveStatement<?, ?> anyXmlSchemaNode = findNode.buildEffective();
+ if (anyXmlSchemaNode instanceof ContainerSchemaNode) {
+ return Optional.of((ContainerSchemaNode) anyXmlSchemaNode);
+ }
+ }
+ return Optional.empty();
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.argument;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+// FIXME: hide this class
public final class ArgumentEffectiveStatementImpl extends DeclaredEffectiveStatementBase<QName, ArgumentStatement>
implements ArgumentEffectiveStatement {
- public ArgumentEffectiveStatementImpl(final StmtContext<QName, ArgumentStatement, ?> ctx) {
+ ArgumentEffectiveStatementImpl(final StmtContext<QName, ArgumentStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.argument;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class ArgumentStatementImpl extends AbstractDeclaredStatement<QName> implements ArgumentStatement {
+ ArgumentStatementImpl(final StmtContext<QName, ArgumentStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public QName getName() {
+ return argument();
+ }
+
+ @Override
+ public YinElementStatement getYinElement() {
+ return firstDeclared(YinElementStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.argument;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class ArgumentStatementSupport
+ extends AbstractQNameStatementSupport<ArgumentStatement, EffectiveStatement<QName, ArgumentStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .ARGUMENT)
+ .addOptional(YangStmtMapping.YIN_ELEMENT)
+ .build();
+
+ public ArgumentStatementSupport() {
+ super(YangStmtMapping.ARGUMENT);
+ }
+
+ @Override
+ public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public ArgumentStatement createDeclared(
+ final StmtContext<QName, ArgumentStatement, ?> ctx) {
+ return new ArgumentStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<QName, ArgumentStatement> createEffective(
+ final StmtContext<QName, ArgumentStatement, EffectiveStatement<QName, ArgumentStatement>> ctx) {
+ return new ArgumentEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.augment;
+
+import com.google.common.base.Verify;
+import com.google.common.collect.ImmutableSet;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Objects;
+import java.util.Set;
+import java.util.regex.Pattern;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.YangVersion;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.source.AugmentToChoiceNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.spi.source.StmtOrderingNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace.ValidationBundleType;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.SchemaNodeIdentifierBuildNamespace;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+abstract class AbstractAugmentStatementSupport extends AbstractStatementSupport<SchemaNodeIdentifier, AugmentStatement,
+ EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> {
+ private static final Logger LOG = LoggerFactory.getLogger(AugmentStatementImpl.class);
+ private static final Pattern PATH_REL_PATTERN1 = Pattern.compile("\\.\\.?\\s*/(.+)");
+ private static final Pattern PATH_REL_PATTERN2 = Pattern.compile("//.*");
+
+ AbstractAugmentStatementSupport() {
+ super(YangStmtMapping.AUGMENT);
+ }
+
+ @Override
+ public final SchemaNodeIdentifier parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ SourceException.throwIf(PATH_REL_PATTERN1.matcher(value).matches()
+ || PATH_REL_PATTERN2.matcher(value).matches(), ctx.getStatementSourceReference(),
+ "Augment argument \'%s\' is not valid, it can be only absolute path; or descendant if used in uses",
+ value);
+
+ return Utils.nodeIdentifierFromPath(ctx, value);
+ }
+
+ @Override
+ public final AugmentStatement createDeclared(final StmtContext<SchemaNodeIdentifier, AugmentStatement, ?> ctx) {
+ return new AugmentStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<SchemaNodeIdentifier, AugmentStatement> createEffective(
+ final StmtContext<SchemaNodeIdentifier, AugmentStatement,
+ EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> ctx) {
+ return new AugmentEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public final void onFullDefinitionDeclared(final Mutable<SchemaNodeIdentifier, AugmentStatement,
+ EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> augmentNode) {
+ if (!augmentNode.isSupportedByFeatures()) {
+ return;
+ }
+
+ super.onFullDefinitionDeclared(augmentNode);
+
+ if (StmtContextUtils.isInExtensionBody(augmentNode)) {
+ return;
+ }
+
+ final ModelActionBuilder augmentAction = augmentNode.newInferenceAction(
+ ModelProcessingPhase.EFFECTIVE_MODEL);
+ final Prerequisite<StmtContext<SchemaNodeIdentifier, AugmentStatement,
+ EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>>> sourceCtxPrereq =
+ augmentAction.requiresCtx(augmentNode, ModelProcessingPhase.EFFECTIVE_MODEL);
+ final Prerequisite<Mutable<?, ?, EffectiveStatement<?, ?>>> target =
+ augmentAction.mutatesEffectiveCtx(getSearchRoot(augmentNode),
+ SchemaNodeIdentifierBuildNamespace.class, augmentNode.getStatementArgument());
+
+ augmentAction.apply(new ModelActionBuilder.InferenceAction() {
+ @Override
+ public void apply(final ModelActionBuilder.InferenceContext ctx) {
+ final StatementContextBase<?, ?, ?> augmentTargetCtx =
+ (StatementContextBase<?, ?, ?>) target.resolve(ctx);
+ if (!isSupportedAugmentTarget(augmentTargetCtx)
+ || StmtContextUtils.isInExtensionBody(augmentTargetCtx)) {
+ augmentNode.setIsSupportedToBuildEffective(false);
+ return;
+ }
+ /**
+ * Marks case short hand in augment
+ */
+ if (augmentTargetCtx.getPublicDefinition() == YangStmtMapping.CHOICE) {
+ augmentNode.addToNs(AugmentToChoiceNamespace.class, augmentNode, Boolean.TRUE);
+ }
+
+ // FIXME: this is a workaround for models which augment a node which is added via an extension
+ // which we do not handle. This needs to be reworked in terms of unknown schema nodes.
+ final StatementContextBase<?, ?, ?> augmentSourceCtx = (StatementContextBase<?, ?, ?>) augmentNode;
+ try {
+ copyFromSourceToTarget(augmentSourceCtx, augmentTargetCtx);
+ augmentTargetCtx.addEffectiveSubstatement(augmentSourceCtx);
+ updateAugmentOrder(augmentSourceCtx);
+ } catch (final SourceException e) {
+ LOG.warn("Failed to add augmentation {} defined at {}",
+ augmentTargetCtx.getStatementSourceReference(),
+ augmentSourceCtx.getStatementSourceReference(), e);
+ }
+ }
+
+ private void updateAugmentOrder(final StatementContextBase<?, ?, ?> augmentSourceCtx) {
+ Integer currentOrder = augmentSourceCtx.getFromNamespace(StmtOrderingNamespace.class,
+ YangStmtMapping.AUGMENT);
+ if (currentOrder == null) {
+ currentOrder = 1;
+ } else {
+ currentOrder++;
+ }
+
+ augmentSourceCtx.addToNs(StmtOrderingNamespace.class, YangStmtMapping.AUGMENT, currentOrder);
+ }
+
+ @Override
+ public void prerequisiteFailed(final Collection<? extends ModelActionBuilder.Prerequisite<?>> failed) {
+ /*
+ * Do not fail, if it is an uses-augment to an unknown node.
+ */
+ if (YangStmtMapping.USES == augmentNode.getParentContext().getPublicDefinition()) {
+ final StatementContextBase<?, ?, ?> targetNode = Utils.findNode(getSearchRoot(augmentNode),
+ augmentNode.getStatementArgument());
+ if (targetNode != null && StmtContextUtils.isUnknownStatement(targetNode)) {
+ augmentNode.setIsSupportedToBuildEffective(false);
+ LOG.warn(
+ "Uses-augment to unknown node {}. Augmentation has not been performed. At line: {}",
+ augmentNode.getStatementArgument(), augmentNode.getStatementSourceReference());
+ return;
+ }
+ }
+
+ throw new InferenceException(augmentNode.getStatementSourceReference(),
+ "Augment target '%s' not found", augmentNode.getStatementArgument());
+ }
+ });
+ }
+
+ private static Mutable<?, ?, ?> getSearchRoot(final Mutable<?, ?, ?> augmentContext) {
+ final Mutable<?, ?, ?> parent = augmentContext.getParentContext();
+ // Augment is in uses - we need to augment instantiated nodes in parent.
+ if (YangStmtMapping.USES == parent.getPublicDefinition()) {
+ return parent.getParentContext();
+ }
+ return parent;
+ }
+
+ static void copyFromSourceToTarget(final StatementContextBase<?, ?, ?> sourceCtx,
+ final StatementContextBase<?, ?, ?> targetCtx) {
+ final CopyType typeOfCopy = UsesStatement.class.equals(sourceCtx.getParentContext().getPublicDefinition()
+ .getDeclaredRepresentationClass()) ? CopyType.ADDED_BY_USES_AUGMENTATION
+ : CopyType.ADDED_BY_AUGMENTATION;
+ /*
+ * Since Yang 1.1, if an augmentation is made conditional with a
+ * "when" statement, it is allowed to add mandatory nodes.
+ */
+ final boolean skipCheckOfMandatoryNodes = YangVersion.VERSION_1_1.equals(sourceCtx.getRootVersion())
+ && isConditionalAugmentStmt(sourceCtx);
+
+ final Collection<? extends Mutable<?, ?, ?>> declared = sourceCtx.mutableDeclaredSubstatements();
+ final Collection<? extends Mutable<?, ?, ?>> effective = sourceCtx.mutableEffectiveSubstatements();
+ final Collection<Mutable<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
+
+ for (final Mutable<?, ?, ?> originalStmtCtx : declared) {
+ if (originalStmtCtx.isSupportedByFeatures()) {
+ copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer, skipCheckOfMandatoryNodes);
+ }
+ }
+ for (final Mutable<?, ?, ?> originalStmtCtx : effective) {
+ copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer, skipCheckOfMandatoryNodes);
+ }
+
+ targetCtx.addEffectiveSubstatements(buffer);
+ }
+
+ /**
+ * Checks whether supplied statement context is conditional augment
+ * statement.
+ *
+ * @param ctx
+ * statement context to be checked
+ *
+ * @return true if supplied statement context is conditional augment
+ * statement, otherwise false
+ */
+ private static boolean isConditionalAugmentStmt(final StmtContext<?, ?, ?> ctx) {
+ return ctx.getPublicDefinition() == YangStmtMapping.AUGMENT
+ && StmtContextUtils.findFirstSubstatement(ctx, WhenStatement.class) != null;
+ }
+
+ private static void copyStatement(final Mutable<?, ?, ?> original, final StatementContextBase<?, ?, ?> target,
+ final CopyType typeOfCopy, final Collection<Mutable<?, ?, ?>> buffer,
+ final boolean skipCheckOfMandatoryNodes) {
+ if (needToCopyByAugment(original)) {
+ validateNodeCanBeCopiedByAugment(original, target, typeOfCopy, skipCheckOfMandatoryNodes);
+
+ buffer.add(target.childCopyOf(original, typeOfCopy));
+ } else if (isReusedByAugment(original)) {
+ buffer.add(original);
+ }
+ }
+
+ private static void validateNodeCanBeCopiedByAugment(final StmtContext<?, ?, ?> sourceCtx,
+ final StatementContextBase<?, ?, ?> targetCtx, final CopyType typeOfCopy,
+ final boolean skipCheckOfMandatoryNodes) {
+
+ if (WhenStatement.class.equals(sourceCtx.getPublicDefinition().getDeclaredRepresentationClass())) {
+ return;
+ }
+
+ if (!skipCheckOfMandatoryNodes && typeOfCopy == CopyType.ADDED_BY_AUGMENTATION
+ && reguiredCheckOfMandatoryNodes(sourceCtx, targetCtx)) {
+ checkForMandatoryNodes(sourceCtx);
+ }
+
+ for (final StmtContext<?, ?, ?> subStatement : targetCtx.allSubstatements()) {
+ final boolean sourceIsDataNode = DataDefinitionStatement.class.isAssignableFrom(sourceCtx
+ .getPublicDefinition().getDeclaredRepresentationClass());
+ final boolean targetIsDataNode = DataDefinitionStatement.class.isAssignableFrom(subStatement
+ .getPublicDefinition().getDeclaredRepresentationClass());
+ final boolean qNamesEqual = sourceIsDataNode && targetIsDataNode
+ && Objects.equals(sourceCtx.getStatementArgument(), subStatement.getStatementArgument());
+
+ InferenceException.throwIf(qNamesEqual, sourceCtx.getStatementSourceReference(),
+ "An augment cannot add node named '%s' because this name is already used in target",
+ sourceCtx.rawStatementArgument());
+ }
+ }
+
+ private static void checkForMandatoryNodes(final StmtContext<?, ?, ?> sourceCtx) {
+ if (StmtContextUtils.isNonPresenceContainer(sourceCtx)) {
+ /*
+ * We need to iterate over both declared and effective sub-statements,
+ * because a mandatory node can be:
+ * a) declared in augment body
+ * b) added to augment body also via uses of a grouping and
+ * such sub-statements are stored in effective sub-statements collection.
+ */
+ sourceCtx.allSubstatementsStream().forEach(AbstractAugmentStatementSupport::checkForMandatoryNodes);
+ }
+
+ InferenceException.throwIf(StmtContextUtils.isMandatoryNode(sourceCtx),
+ sourceCtx.getStatementSourceReference(),
+ "An augment cannot add node '%s' because it is mandatory and in module different than target",
+ sourceCtx.rawStatementArgument());
+ }
+
+ private static boolean reguiredCheckOfMandatoryNodes(final StmtContext<?, ?, ?> sourceCtx,
+ Mutable<?, ?, ?> targetCtx) {
+ /*
+ * If the statement argument is not QName, it cannot be mandatory
+ * statement, therefore return false and skip mandatory nodes validation
+ */
+ if (!(sourceCtx.getStatementArgument() instanceof QName)) {
+ return false;
+ }
+ final QName sourceStmtQName = (QName) sourceCtx.getStatementArgument();
+
+ // RootStatementContext, for example
+ final Mutable<?, ?, ?> root = targetCtx.getRoot();
+ do {
+ Verify.verify(targetCtx.getStatementArgument() instanceof QName,
+ "Argument of augment target statement must be QName.");
+ final QName targetStmtQName = (QName) targetCtx.getStatementArgument();
+ /*
+ * If target is from another module, return true and perform
+ * mandatory nodes validation
+ */
+ if (!Utils.belongsToTheSameModule(targetStmtQName, sourceStmtQName)) {
+ return true;
+ }
+
+ /*
+ * If target or one of the target's ancestors from the same namespace
+ * is a presence container
+ * or is non-mandatory choice
+ * or is non-mandatory list
+ * return false and skip mandatory nodes validation, because these nodes
+ * are not mandatory node containers according to RFC 6020 section 3.1.
+ */
+ if (StmtContextUtils.isPresenceContainer(targetCtx)
+ || StmtContextUtils.isNotMandatoryNodeOfType(targetCtx, YangStmtMapping.CHOICE)
+ || StmtContextUtils.isNotMandatoryNodeOfType(targetCtx, YangStmtMapping.LIST)) {
+ return false;
+ }
+ } while ((targetCtx = targetCtx.getParentContext()) != root);
+
+ /*
+ * All target node's parents belong to the same module as source node,
+ * therefore return false and skip mandatory nodes validation.
+ */
+ return false;
+ }
+
+ private static final Set<YangStmtMapping> NOCOPY_DEF_SET = ImmutableSet.of(YangStmtMapping.USES,
+ YangStmtMapping.WHEN, YangStmtMapping.DESCRIPTION, YangStmtMapping.REFERENCE, YangStmtMapping.STATUS);
+
+ private static boolean needToCopyByAugment(final StmtContext<?, ?, ?> stmtContext) {
+ return !NOCOPY_DEF_SET.contains(stmtContext.getPublicDefinition());
+ }
+
+ private static final Set<YangStmtMapping> REUSED_DEF_SET = ImmutableSet.of(YangStmtMapping.TYPEDEF);
+
+ private static boolean isReusedByAugment(final StmtContext<?, ?, ?> stmtContext) {
+ return REUSED_DEF_SET.contains(stmtContext.getPublicDefinition());
+ }
+
+ static boolean isSupportedAugmentTarget(final StmtContext<?, ?, ?> substatementCtx) {
+ /*
+ * :TODO Substatement must be allowed augment target type e.g.
+ * Container, etc... and must not be for example grouping, identity etc.
+ * It is problem in case when more than one substatements have the same
+ * QName, for example Grouping and Container are siblings and they have
+ * the same QName. We must find the Container and the Grouping must be
+ * ignored as disallowed augment target.
+ */
+ final Collection<?> allowedAugmentTargets = substatementCtx.getFromNamespace(
+ ValidationBundlesNamespace.class, ValidationBundleType.SUPPORTED_AUGMENT_TARGETS);
+
+ // if no allowed target is returned we consider all targets allowed
+ return allowedAugmentTargets == null || allowedAugmentTargets.isEmpty()
+ || allowedAugmentTargets.contains(substatementCtx.getPublicDefinition());
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.augment;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveDocumentedDataNodeContainer;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-public final class AugmentEffectiveStatementImpl
+final class AugmentEffectiveStatementImpl
extends AbstractEffectiveDocumentedDataNodeContainer<SchemaNodeIdentifier, AugmentStatement>
implements AugmentEffectiveStatement, AugmentationSchemaNode, NamespaceRevisionAware {
private final SchemaPath targetPath;
private final RevisionAwareXPath whenCondition;
private final AugmentationSchemaNode copyOf;
- public AugmentEffectiveStatementImpl(final StmtContext<SchemaNodeIdentifier, AugmentStatement,
+ AugmentEffectiveStatementImpl(final StmtContext<SchemaNodeIdentifier, AugmentStatement,
EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> ctx) {
super(ctx);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.augment;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeIdentifier> implements AugmentStatement {
+ AugmentStatementImpl(final StmtContext<SchemaNodeIdentifier, AugmentStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public SchemaNodeIdentifier getTargetNode() {
+ return argument();
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
+ return allDeclared(DataDefinitionStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends ActionStatement> getActions() {
+ return allDeclared(ActionStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends NotificationStatement> getNotifications() {
+ return allDeclared(NotificationStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public WhenStatement getWhenStatement() {
+ return firstDeclared(WhenStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends CaseStatement> getCases() {
+ return allDeclared(CaseStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends IfFeatureStatement> getIfFeatures() {
+ return allDeclared(IfFeatureStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.augment;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class AugmentStatementRFC6020Support extends AbstractAugmentStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator
+ .builder(YangStmtMapping.AUGMENT)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CASE)
+ .addAny(YangStmtMapping.CHOICE)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.USES)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.augment;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.AugmentStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 Augment statement.
*/
@Beta
-public final class AugmentStatementRfc7950Support extends AugmentStatementImpl.Definition {
+public final class AugmentStatementRFC7950Support extends AbstractAugmentStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator
.builder(YangStmtMapping.AUGMENT)
.addAny(YangStmtMapping.ACTION)
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.base;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.stmt.BaseEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public class BaseEffectiveStatementImpl extends DeclaredEffectiveStatementBase<QName, BaseStatement>
+final class BaseEffectiveStatementImpl extends DeclaredEffectiveStatementBase<QName, BaseStatement>
implements BaseEffectiveStatement {
- public BaseEffectiveStatementImpl(final StmtContext<QName, BaseStatement, ?> ctx) {
+ BaseEffectiveStatementImpl(final StmtContext<QName, BaseStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.base;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class BaseStatementImpl extends AbstractDeclaredStatement<QName> implements BaseStatement {
+ BaseStatementImpl(final StmtContext<QName, BaseStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public QName getName() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.base;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
+import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.DerivedIdentitiesNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class BaseStatementSupport
+ extends AbstractQNameStatementSupport<BaseStatement, EffectiveStatement<QName, BaseStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.BASE).build();
+
+ public BaseStatementSupport() {
+ super(YangStmtMapping.BASE);
+ }
+
+ @Override
+ public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public BaseStatement createDeclared(final StmtContext<QName, BaseStatement, ?> ctx) {
+ return new BaseStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<QName, BaseStatement> createEffective(
+ final StmtContext<QName, BaseStatement, EffectiveStatement<QName, BaseStatement>> ctx) {
+ return new BaseEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public void onStatementDefinitionDeclared(
+ final Mutable<QName, BaseStatement, EffectiveStatement<QName, BaseStatement>> baseStmtCtx) {
+ final Mutable<?, ?, ?> baseParentCtx = baseStmtCtx.getParentContext();
+ if (StmtContextUtils.producesDeclared(baseParentCtx, IdentityStatement.class)) {
+
+ final QName baseIdentityQName = baseStmtCtx.getStatementArgument();
+ final ModelActionBuilder baseIdentityAction = baseStmtCtx.newInferenceAction(
+ ModelProcessingPhase.STATEMENT_DEFINITION);
+ final Prerequisite<StmtContext<?, ?, ?>> requiresPrereq = baseIdentityAction.requiresCtx(baseStmtCtx,
+ IdentityNamespace.class, baseIdentityQName, ModelProcessingPhase.STATEMENT_DEFINITION);
+ final Prerequisite<StmtContext.Mutable<?, ?, ?>> mutatesPrereq = baseIdentityAction.mutatesCtx(
+ baseParentCtx, ModelProcessingPhase.STATEMENT_DEFINITION);
+
+ baseIdentityAction.apply(new InferenceAction() {
+ @Override
+ public void apply(final InferenceContext ctx) {
+ List<StmtContext<?, ?, ?>> derivedIdentities = baseStmtCtx.getFromNamespace(
+ DerivedIdentitiesNamespace.class, baseStmtCtx.getStatementArgument());
+ if (derivedIdentities == null) {
+ derivedIdentities = new ArrayList<>(1);
+ baseStmtCtx.addToNs(DerivedIdentitiesNamespace.class, baseIdentityQName, derivedIdentities);
+ }
+ derivedIdentities.add(baseParentCtx);
+ }
+
+ @Override
+ public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
+ throw new InferenceException(baseStmtCtx.getStatementSourceReference(),
+ "Unable to resolve identity %s and base identity %s",
+ baseParentCtx.getStatementArgument(), baseStmtCtx.getStatementArgument());
+ }
+ });
+ }
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.belongs_to;
import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+// FIXME: hide this class
public final class BelongsToEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, BelongsToStatement>
implements BelongsToEffectiveStatement {
- public BelongsToEffectiveStatementImpl(final StmtContext<String, BelongsToStatement, ?> ctx) {
+ BelongsToEffectiveStatementImpl(final StmtContext<String, BelongsToStatement, ?> ctx) {
super(ctx);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.belongs_to;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class BelongsToStatementImpl extends AbstractDeclaredStatement<String>
+ implements BelongsToStatement {
+ BelongsToStatementImpl(final StmtContext<String, BelongsToStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getModule() {
+ return argument();
+ }
+
+ @Nonnull
+ @Override
+ public PrefixStatement getPrefix() {
+ return firstDeclared(PrefixStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.belongs_to;
+
+import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
+
+import java.util.Collection;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
+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;
+import org.opendaylight.yangtools.yang.parser.spi.source.BelongsToModuleContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.BelongsToPrefixToModuleCtx;
+import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNamespaceForBelongsTo;
+
+public class BelongsToStatementSupport
+ extends
+ AbstractStatementSupport<String, BelongsToStatement, EffectiveStatement<String, BelongsToStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.BELONGS_TO).addMandatory(YangStmtMapping.PREFIX).build();
+
+ public BelongsToStatementSupport() {
+ super(YangStmtMapping.BELONGS_TO);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public BelongsToStatement createDeclared(
+ final StmtContext<String, BelongsToStatement, ?> ctx) {
+ return new BelongsToStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, BelongsToStatement> createEffective(
+ final StmtContext<String, BelongsToStatement, EffectiveStatement<String, BelongsToStatement>> ctx) {
+ return new BelongsToEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public void onPreLinkageDeclared(final StmtContext.Mutable<String, BelongsToStatement,
+ EffectiveStatement<String, BelongsToStatement>> belongsToCtx) {
+ belongsToCtx.addRequiredSource(getSourceIdentifier(belongsToCtx));
+ }
+
+ @Override
+ public void onLinkageDeclared(final Mutable<String, BelongsToStatement,
+ EffectiveStatement<String, BelongsToStatement>> belongsToCtx) {
+ ModelActionBuilder belongsToAction = belongsToCtx.newInferenceAction(ModelProcessingPhase.SOURCE_LINKAGE);
+
+ final SourceIdentifier belongsToSourceIdentifier = getSourceIdentifier(belongsToCtx);
+ final Prerequisite<StmtContext<?, ?, ?>> belongsToPrereq = belongsToAction.requiresCtx(belongsToCtx,
+ ModuleNamespaceForBelongsTo.class, belongsToCtx.getStatementArgument(),
+ ModelProcessingPhase.SOURCE_LINKAGE);
+
+ belongsToAction.apply(new InferenceAction() {
+ @Override
+ public void apply(final InferenceContext ctx) {
+ StmtContext<?, ?, ?> belongsToModuleCtx = belongsToPrereq.resolve(ctx);
+
+ belongsToCtx.addToNs(BelongsToModuleContext.class, belongsToSourceIdentifier, belongsToModuleCtx);
+ belongsToCtx.addToNs(BelongsToPrefixToModuleCtx.class,
+ findFirstDeclaredSubstatement(belongsToCtx, PrefixStatement.class).getStatementArgument(),
+ belongsToModuleCtx);
+ }
+
+ @Override
+ public void prerequisiteFailed(final Collection<? extends ModelActionBuilder.Prerequisite<?>> failed) {
+ if (failed.contains(belongsToPrereq)) {
+ throw new InferenceException(belongsToCtx.getStatementSourceReference(),
+ "Module '%s' from belongs-to was not found", belongsToCtx.getStatementArgument());
+ }
+ }
+ });
+ }
+
+ private static SourceIdentifier getSourceIdentifier(final StmtContext<String, BelongsToStatement,
+ EffectiveStatement<String, BelongsToStatement>> belongsToCtx) {
+ return RevisionSourceIdentifier.create(belongsToCtx.getStatementArgument());
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.bit;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+
+abstract class AbstractBitStatementSupport extends
+ AbstractQNameStatementSupport<BitStatement, EffectiveStatement<QName, BitStatement>> {
+ AbstractBitStatementSupport() {
+ super(YangStmtMapping.BIT);
+ }
+
+ @Override
+ public final QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public final BitStatement createDeclared(final StmtContext<QName, BitStatement, ?> ctx) {
+ return new BitStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<QName, BitStatement> createEffective(
+ final StmtContext<QName, BitStatement, EffectiveStatement<QName, BitStatement>> ctx) {
+ return new BitEffectiveStatementImpl(ctx);
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.bit;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PositionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.AbstractEffectiveDocumentedNode;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveDocumentedNode;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public class BitEffectiveStatementImpl extends AbstractEffectiveDocumentedNode<QName, BitStatement>
+// FIXME: hide this class
+public final class BitEffectiveStatementImpl extends AbstractEffectiveDocumentedNode<QName, BitStatement>
implements BitEffectiveStatement {
private final QName qname;
private final Long declaredPosition;
private final List<UnknownSchemaNode> unknownSchemaNodes;
- public BitEffectiveStatementImpl(final StmtContext<QName, BitStatement, ?> ctx) {
+ BitEffectiveStatementImpl(final StmtContext<QName, BitStatement, ?> ctx) {
super(ctx);
qname = ctx.getStatementArgument();
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.bit;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class BitStatementImpl extends AbstractDeclaredStatement<QName> implements BitStatement {
+ BitStatementImpl(final StmtContext<QName, BitStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends IfFeatureStatement> getIfFeatures() {
+ return allDeclared(IfFeatureStatement.class);
+ }
+
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public String getName() {
+ return argument().getLocalName();
+ }
+
+ @Override
+ public PositionStatement getPosition() {
+ return firstDeclared(PositionStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.bit;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public class BitStatementRFC6020Support extends AbstractBitStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.BIT)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addOptional(YangStmtMapping.POSITION)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.bit;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.BitStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 Bit statement.
*/
@Beta
-public final class BitStatementRfc7950Support extends BitStatementImpl.Definition {
+public final class BitStatementRFC7950Support extends AbstractBitStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.BIT)
.addOptional(YangStmtMapping.DESCRIPTION)
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.CaseEffectiveStatementImpl;
+
+abstract class AbstractCaseStatementSupport
+ extends AbstractQNameStatementSupport<CaseStatement, EffectiveStatement<QName, CaseStatement>> {
+
+ AbstractCaseStatementSupport() {
+ super(YangStmtMapping.CASE);
+ }
+
+ @Override
+ public final QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public final void onStatementAdded(
+ final Mutable<QName, CaseStatement, EffectiveStatement<QName, CaseStatement>> stmt) {
+ stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
+ }
+
+ @Override
+ public final CaseStatement createDeclared(final StmtContext<QName, CaseStatement, ?> ctx) {
+ return new CaseStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<QName, CaseStatement> createEffective(
+ final StmtContext<QName, CaseStatement, EffectiveStatement<QName, CaseStatement>> ctx) {
+ return new CaseEffectiveStatementImpl(ctx);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class CaseStatementImpl extends AbstractDeclaredStatement<QName> implements CaseStatement {
+ CaseStatementImpl(final StmtContext<QName, CaseStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public QName getName() {
+ return argument();
+ }
+
+ @Override
+ public WhenStatement getWhenStatement() {
+ return firstDeclared(WhenStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends IfFeatureStatement> getIfFeatures() {
+ return allDeclared(IfFeatureStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
+ return allDeclared(DataDefinitionStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class CaseStatementRFC6020Support extends AbstractCaseStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.CASE)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.USES)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.CaseStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 Case statement.
*/
@Beta
-public final class CaseStatementRfc7950Support extends CaseStatementImpl.Definition {
+public final class CaseStatementRFC7950Support extends AbstractCaseStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.CASE)
.addAny(YangStmtMapping.ANYDATA)
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.choice;
+
+import java.util.Optional;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangValidationBundles;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ChoiceEffectiveStatementImpl;
+
+abstract class AbstractChoiceStatementSupport extends
+ AbstractQNameStatementSupport<ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> {
+ AbstractChoiceStatementSupport() {
+ super(YangStmtMapping.CHOICE);
+ }
+
+ @Override
+ public final QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public final Optional<StatementSupport<?, ?, ?>> getImplicitParentFor(final StatementDefinition stmtDef) {
+ if (YangValidationBundles.SUPPORTED_CASE_SHORTHANDS.contains(stmtDef)) {
+ return Optional.of(implictCase());
+ }
+ return Optional.empty();
+ }
+
+ @Override
+ public final void onStatementAdded(
+ final Mutable<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> stmt) {
+ stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
+ }
+
+ @Override
+ public final ChoiceStatement createDeclared(final StmtContext<QName, ChoiceStatement, ?> ctx) {
+ return new ChoiceStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<QName, ChoiceStatement> createEffective(
+ final StmtContext<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> ctx) {
+ return new ChoiceEffectiveStatementImpl(ctx);
+ }
+
+ abstract StatementSupport<?, ?, ?> implictCase();
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.choice;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class ChoiceStatementImpl extends AbstractDeclaredStatement<QName>
+ implements ChoiceStatement {
+ ChoiceStatementImpl(final StmtContext<QName, ChoiceStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public QName getName() {
+ return argument();
+ }
+
+ @Nullable
+ @Override
+ public DefaultStatement getDefault() {
+ return firstDeclared(DefaultStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public ConfigStatement getConfig() {
+ return firstDeclared(ConfigStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public MandatoryStatement getMandatory() {
+ return firstDeclared(MandatoryStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends CaseStatement> getCases() {
+ return allDeclared(CaseStatement.class);
+ }
+
+ @Override
+ public WhenStatement getWhenStatement() {
+ return firstDeclared(WhenStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends IfFeatureStatement> getIfFeatures() {
+ return allDeclared(IfFeatureStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.choice;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_.CaseStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class ChoiceStatementRFC6020Support extends AbstractChoiceStatementSupport {
+ // FIXME: share instance
+ private static final StatementSupport<?, ?, ?> IMPLICIT_CASE = new CaseStatementRFC6020Support();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .CHOICE)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CASE)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DEFAULT)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addOptional(YangStmtMapping.MANDATORY)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
+
+ @Override
+ StatementSupport<?, ?, ?> implictCase() {
+ return IMPLICIT_CASE;
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.choice;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_.CaseStatementRFC7950Support;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChoiceStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 Choice statement.
*/
@Beta
-public final class ChoiceStatementRfc7950Support extends ChoiceStatementImpl.Definition {
+public final class ChoiceStatementRFC7950Support extends AbstractChoiceStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.CHOICE)
.addAny(YangStmtMapping.ANYDATA)
.addOptional(YangStmtMapping.WHEN)
.build();
- private static final StatementSupport<?, ?, ?> IMPLICIT_CASE = new CaseStatementRfc7950Support();
+ // FIXME: share instance
+ private static final StatementSupport<?, ?, ?> IMPLICIT_CASE = new CaseStatementRFC7950Support();
@Override
- protected StatementSupport<?, ?, ?> implictCase() {
+ StatementSupport<?, ?, ?> implictCase() {
return IMPLICIT_CASE;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.config;
import org.opendaylight.yangtools.yang.model.api.stmt.ConfigEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
public final class ConfigEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Boolean, ConfigStatement>
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.config;
+
+import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class ConfigStatementImpl extends AbstractDeclaredStatement<Boolean> implements ConfigStatement {
+ ConfigStatementImpl(final StmtContext<Boolean, ConfigStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public boolean getValue() {
+ return argument().booleanValue();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.config;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+
+public class ConfigStatementSupport extends
+ AbstractStatementSupport<Boolean, ConfigStatement, EffectiveStatement<Boolean, ConfigStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.CONFIG).build();
+
+ public ConfigStatementSupport() {
+ super(YangStmtMapping.CONFIG);
+ }
+
+ @Override
+ public Boolean parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return Utils.parseBoolean(ctx, value);
+ }
+
+ @Override
+ public ConfigStatement createDeclared(final StmtContext<Boolean, ConfigStatement, ?> ctx) {
+ final ConfigStatement ret = new ConfigStatementImpl(ctx);
+
+ if (EmptyConfigStatement.FALSE.equals(ret)) {
+ return EmptyConfigStatement.FALSE;
+ } else if (EmptyConfigStatement.TRUE.equals(ret)) {
+ return EmptyConfigStatement.TRUE;
+ } else {
+ return ret;
+ }
+ }
+
+ @Override
+ public EffectiveStatement<Boolean, ConfigStatement> createEffective(
+ final StmtContext<Boolean, ConfigStatement, EffectiveStatement<Boolean, ConfigStatement>> ctx) {
+ final EffectiveStatement<Boolean, ConfigStatement> ret = new ConfigEffectiveStatementImpl(ctx);
+ final ConfigStatement declared = ret.getDeclared();
+ if (declared instanceof EmptyConfigStatement && ret.effectiveSubstatements().isEmpty()) {
+ return ((EmptyConfigStatement)declared).toEffective();
+ }
+ return ret;
+ }
+
+ @Override
+ public String internArgument(final String rawArgument) {
+ return Utils.internBoolean(rawArgument);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.config;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.config;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.contact;
import org.opendaylight.yangtools.yang.model.api.stmt.ContactEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class ContactEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, ContactStatement>
+final class ContactEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, ContactStatement>
implements ContactEffectiveStatement {
- public ContactEffectiveStatementImpl(final StmtContext<String, ContactStatement, ?> ctx) {
+ ContactEffectiveStatementImpl(final StmtContext<String, ContactStatement, ?> ctx) {
super(ctx);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.contact;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class ContactStatementImpl extends AbstractDeclaredStatement<String> implements ContactStatement {
+ ContactStatementImpl(final StmtContext<String, ContactStatement,?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getText() {
+ return rawArgument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.contact;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement;
+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;
+
+public final class ContactStatementSupport
+ extends AbstractStatementSupport<String, ContactStatement,EffectiveStatement<String, ContactStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.CONTACT).build();
+
+ public ContactStatementSupport() {
+ super(YangStmtMapping.CONTACT);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public ContactStatement createDeclared(final StmtContext<String, ContactStatement, ?> ctx) {
+ return new ContactStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, ContactStatement> createEffective(
+ final StmtContext<String, ContactStatement, EffectiveStatement<String, ContactStatement>> ctx) {
+ return new ContactEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.container;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContainerEffectiveStatementImpl;
+
+abstract class AbstractContainerStatementSupport
+ extends AbstractQNameStatementSupport<ContainerStatement, EffectiveStatement<QName, ContainerStatement>> {
+
+ AbstractContainerStatementSupport() {
+ super(YangStmtMapping.CONTAINER);
+ }
+
+ @Override
+ public final QName parseArgumentValue(final StmtContext<?,?,?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx,value);
+ }
+
+ @Override
+ public final void onStatementAdded(
+ final Mutable<QName, ContainerStatement, EffectiveStatement<QName, ContainerStatement>> stmt) {
+ stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
+ }
+
+ @Override
+ public final ContainerStatement createDeclared(final StmtContext<QName, ContainerStatement,?> ctx) {
+ return new ContainerStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<QName,ContainerStatement> createEffective(
+ final StmtContext<QName, ContainerStatement, EffectiveStatement<QName,ContainerStatement>> ctx) {
+ return new ContainerEffectiveStatementImpl(ctx);
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.container;
import java.util.Collection;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContainerEffectiveStatementImpl;
-
-public class ContainerStatementImpl extends AbstractDeclaredStatement<QName> implements ContainerStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .CONTAINER)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addOptional(YangStmtMapping.CONFIG)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addAny(YangStmtMapping.MUST)
- .addOptional(YangStmtMapping.PRESENCE)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .addOptional(YangStmtMapping.WHEN)
- .build();
-
- protected ContainerStatementImpl(final StmtContext<QName, ContainerStatement,?> context) {
- super(context);
- }
- public static class Definition
- extends AbstractQNameStatementSupport<ContainerStatement, EffectiveStatement<QName, ContainerStatement>> {
-
- public Definition() {
- super(YangStmtMapping.CONTAINER);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?,?,?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx,value);
- }
-
- @Override
- public void onStatementAdded(
- final Mutable<QName, ContainerStatement, EffectiveStatement<QName, ContainerStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override
- public ContainerStatement createDeclared(final StmtContext<QName, ContainerStatement,?> ctx) {
- return new ContainerStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName,ContainerStatement> createEffective(final StmtContext<QName, ContainerStatement,
- EffectiveStatement<QName,ContainerStatement>> ctx) {
- return new ContainerEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
+final class ContainerStatementImpl extends AbstractDeclaredStatement<QName> implements ContainerStatement {
+ ContainerStatementImpl(final StmtContext<QName, ContainerStatement,?> context) {
+ super(context);
}
@Nonnull
}
@Override
- public final Collection<? extends NotificationStatement> getNotifications() {
+ public Collection<? extends NotificationStatement> getNotifications() {
return allDeclared(NotificationStatement.class);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.container;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class ContainerStatementRFC6020Support extends AbstractContainerStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.CONTAINER)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addAny(YangStmtMapping.MUST)
+ .addOptional(YangStmtMapping.PRESENCE)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.container;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ContainerStatementImpl;
/**
- * Class providing necessary support for processing YANG 1.1 Container
- * statement.
+ * Class providing necessary support for processing YANG 1.1 Container statement.
*/
@Beta
-public final class ContainerStatementRfc7950Support extends ContainerStatementImpl.Definition {
+public final class ContainerStatementRFC7950Support extends AbstractContainerStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.CONTAINER)
.addAny(YangStmtMapping.ACTION)
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.default_;
import org.opendaylight.yangtools.yang.model.api.stmt.DefaultEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class DefaultEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, DefaultStatement>
+final class DefaultEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, DefaultStatement>
implements DefaultEffectiveStatement {
- public DefaultEffectiveStatementImpl(final StmtContext<String, DefaultStatement, ?> ctx) {
+ DefaultEffectiveStatementImpl(final StmtContext<String, DefaultStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.default_;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class DefaultStatementImpl extends AbstractDeclaredStatement<String> implements
+ DefaultStatement {
+ DefaultStatementImpl(final StmtContext<String, DefaultStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getValue() {
+ return rawArgument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.default_;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
+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;
+
+public final class DefaultStatementSupport
+ extends AbstractStatementSupport<String, DefaultStatement, EffectiveStatement<String, DefaultStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.DEFAULT).build();
+
+ public DefaultStatementSupport() {
+ super(YangStmtMapping.DEFAULT);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public DefaultStatement createDeclared(final StmtContext<String, DefaultStatement, ?> ctx) {
+ return new DefaultStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, DefaultStatement> createEffective(
+ final StmtContext<String, DefaultStatement, EffectiveStatement<String, DefaultStatement>> ctx) {
+ return new DefaultEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.description;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class DescriptionEffectiveStatementImpl
+final class DescriptionEffectiveStatementImpl
extends DeclaredEffectiveStatementBase<String, DescriptionStatement> implements DescriptionEffectiveStatement {
- public DescriptionEffectiveStatementImpl(final StmtContext<String, DescriptionStatement, ?> ctx) {
+ DescriptionEffectiveStatementImpl(final StmtContext<String, DescriptionStatement, ?> ctx) {
super(ctx);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.description;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class DescriptionStatementImpl extends AbstractDeclaredStatement<String> implements DescriptionStatement {
+ DescriptionStatementImpl(final StmtContext<String, DescriptionStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getText() {
+ return rawArgument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.description;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+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;
+
+public final class DescriptionStatementSupport extends AbstractStatementSupport<String, DescriptionStatement,
+ EffectiveStatement<String, DescriptionStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.DESCRIPTION).build();
+
+ public DescriptionStatementSupport() {
+ super(YangStmtMapping.DESCRIPTION);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public DescriptionStatement createDeclared(final StmtContext<String, DescriptionStatement, ?> ctx) {
+ return new DescriptionStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, DescriptionStatement> createEffective(
+ final StmtContext<String, DescriptionStatement, EffectiveStatement<String, DescriptionStatement>> ctx) {
+ return new DescriptionEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.deviate;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMap.Builder;
+import com.google.common.collect.ImmutableSet;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.YangVersion;
+import org.opendaylight.yangtools.yang.model.api.DeviateKind;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.api.stmt.DeviateStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
+import org.opendaylight.yangtools.yang.parser.spi.source.ModulesDeviatedByModules;
+import org.opendaylight.yangtools.yang.parser.spi.source.ModulesDeviatedByModules.SupportedModules;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.SchemaNodeIdentifierBuildNamespace;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangValidationBundles;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+abstract class AbstractDeviateStatementSupport extends AbstractStatementSupport<DeviateKind, DeviateStatement,
+ EffectiveStatement<DeviateKind, DeviateStatement>> {
+ private static final Logger LOG = LoggerFactory.getLogger(DeviateStatementImpl.class);
+
+ private static final SubstatementValidator DEVIATE_NOT_SUPPORTED_SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.DEVIATE).build();
+
+ private static final SubstatementValidator DEVIATE_ADD_SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.DEVIATE)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addOptional(YangStmtMapping.DEFAULT)
+ .addOptional(YangStmtMapping.MANDATORY)
+ .addOptional(YangStmtMapping.MAX_ELEMENTS)
+ .addOptional(YangStmtMapping.MIN_ELEMENTS)
+ .addAny(YangStmtMapping.MUST)
+ .addAny(YangStmtMapping.UNIQUE)
+ .addOptional(YangStmtMapping.UNITS)
+ .build();
+
+ private static final SubstatementValidator DEVIATE_REPLACE_SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.DEVIATE)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addOptional(YangStmtMapping.DEFAULT)
+ .addOptional(YangStmtMapping.MANDATORY)
+ .addOptional(YangStmtMapping.MAX_ELEMENTS)
+ .addOptional(YangStmtMapping.MIN_ELEMENTS)
+ .addOptional(YangStmtMapping.TYPE)
+ .addOptional(YangStmtMapping.UNITS)
+ .build();
+
+ private static final SubstatementValidator DEVIATE_DELETE_SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.DEVIATE)
+ .addOptional(YangStmtMapping.DEFAULT)
+ .addAny(YangStmtMapping.MUST)
+ .addAny(YangStmtMapping.UNIQUE)
+ .addOptional(YangStmtMapping.UNITS)
+ .build();
+
+ private static final Map<String, DeviateKind> KEYWORD_TO_DEVIATE_MAP;
+
+ static {
+ final Builder<String, DeviateKind> keywordToDeviateMapBuilder = ImmutableMap.builder();
+ for (final DeviateKind deviate : DeviateKind.values()) {
+ keywordToDeviateMapBuilder.put(deviate.getKeyword(), deviate);
+ }
+ KEYWORD_TO_DEVIATE_MAP = keywordToDeviateMapBuilder.build();
+ }
+
+ private static final Set<YangStmtMapping> SINGLETON_STATEMENTS = ImmutableSet.of(
+ YangStmtMapping.UNITS, YangStmtMapping.CONFIG, YangStmtMapping.MANDATORY,
+ YangStmtMapping.MIN_ELEMENTS, YangStmtMapping.MAX_ELEMENTS);
+
+ private static final Set<YangStmtMapping> IMPLICIT_STATEMENTS = ImmutableSet.of(YangStmtMapping.CONFIG,
+ YangStmtMapping.MANDATORY, YangStmtMapping.MAX_ELEMENTS, YangStmtMapping.MIN_ELEMENTS);
+
+ AbstractDeviateStatementSupport() {
+ super(YangStmtMapping.DEVIATE);
+ }
+
+ @Override
+ public final DeviateKind parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return SourceException.throwIfNull(KEYWORD_TO_DEVIATE_MAP.get(value),
+ ctx.getStatementSourceReference(), "String '%s' is not valid deviate argument", value);
+ }
+
+ @Override
+ public final DeviateStatement createDeclared(final StmtContext<DeviateKind, DeviateStatement, ?> ctx) {
+ return new DeviateStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<DeviateKind, DeviateStatement> createEffective(
+ final StmtContext<DeviateKind, DeviateStatement, EffectiveStatement<DeviateKind,
+ DeviateStatement>> ctx) {
+ return new DeviateEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public final void onFullDefinitionDeclared(final Mutable<DeviateKind, DeviateStatement,
+ EffectiveStatement<DeviateKind, DeviateStatement>> deviateStmtCtx) {
+ final DeviateKind deviateKind = deviateStmtCtx.getStatementArgument();
+ getSubstatementValidatorForDeviate(deviateKind).validate(deviateStmtCtx);
+
+ final SchemaNodeIdentifier deviationTarget =
+ (SchemaNodeIdentifier) deviateStmtCtx.getParentContext().getStatementArgument();
+
+ if (!isDeviationSupported(deviateStmtCtx, deviationTarget)) {
+ return;
+ }
+
+ final ModelActionBuilder deviateAction = deviateStmtCtx.newInferenceAction(
+ ModelProcessingPhase.EFFECTIVE_MODEL);
+
+ final Prerequisite<StmtContext<DeviateKind, DeviateStatement, EffectiveStatement<DeviateKind,
+ DeviateStatement>>> sourceCtxPrerequisite =
+ deviateAction.requiresCtx(deviateStmtCtx, ModelProcessingPhase.EFFECTIVE_MODEL);
+
+ final Prerequisite<Mutable<?, ?, EffectiveStatement<?, ?>>> targetCtxPrerequisite =
+ deviateAction.mutatesEffectiveCtx(deviateStmtCtx.getRoot(),
+ SchemaNodeIdentifierBuildNamespace.class, deviationTarget);
+
+ deviateAction.apply(new InferenceAction() {
+ @Override
+ public void apply(final InferenceContext ctx) throws InferenceException {
+ // FIXME once BUG-7760 gets fixed, there will be no need for these dirty casts
+ final StatementContextBase<?, ?, ?> sourceNodeStmtCtx =
+ (StatementContextBase<?, ?, ?>) sourceCtxPrerequisite.resolve(ctx);
+ final StatementContextBase<?, ?, ?> targetNodeStmtCtx =
+ (StatementContextBase<?, ?, ?>) targetCtxPrerequisite.resolve(ctx);
+
+ switch (deviateKind) {
+ case NOT_SUPPORTED:
+ targetNodeStmtCtx.setIsSupportedToBuildEffective(false);
+ break;
+ case ADD:
+ performDeviateAdd(sourceNodeStmtCtx, targetNodeStmtCtx);
+ break;
+ case REPLACE:
+ performDeviateReplace(sourceNodeStmtCtx, targetNodeStmtCtx);
+ break;
+ case DELETE:
+ performDeviateDelete(sourceNodeStmtCtx, targetNodeStmtCtx);
+ break;
+ default:
+ throw new IllegalStateException("Unsupported deviate " + deviateKind);
+ }
+ }
+
+ @Override
+ public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
+ throw new InferenceException(deviateStmtCtx.getParentContext().getStatementSourceReference(),
+ "Deviation target '%s' not found.", deviationTarget);
+ }
+ });
+ }
+
+ @Override
+ protected final SubstatementValidator getSubstatementValidator() {
+ return null;
+ }
+
+ protected SubstatementValidator getSubstatementValidatorForDeviate(final DeviateKind deviateKind) {
+ switch (deviateKind) {
+ case NOT_SUPPORTED:
+ return DEVIATE_NOT_SUPPORTED_SUBSTATEMENT_VALIDATOR;
+ case ADD:
+ return DEVIATE_ADD_SUBSTATEMENT_VALIDATOR;
+ case REPLACE:
+ return DEVIATE_REPLACE_SUBSTATEMENT_VALIDATOR;
+ case DELETE:
+ return DEVIATE_DELETE_SUBSTATEMENT_VALIDATOR;
+ default:
+ throw new IllegalStateException(String.format(
+ "Substatement validator for deviate %s has not been defined.", deviateKind));
+ }
+ }
+
+ private static boolean isDeviationSupported(final Mutable<DeviateKind, DeviateStatement,
+ EffectiveStatement<DeviateKind, DeviateStatement>> deviateStmtCtx,
+ final SchemaNodeIdentifier deviationTarget) {
+ final Map<QNameModule, Set<QNameModule>> modulesDeviatedByModules = deviateStmtCtx.getFromNamespace(
+ ModulesDeviatedByModules.class, SupportedModules.SUPPORTED_MODULES);
+ if (modulesDeviatedByModules == null) {
+ return true;
+ }
+
+ final QNameModule currentModule = deviateStmtCtx.getFromNamespace(ModuleCtxToModuleQName.class,
+ deviateStmtCtx.getRoot());
+ final QNameModule targetModule = deviationTarget.getLastComponent().getModule();
+
+ final Set<QNameModule> deviationModulesSupportedByTargetModule = modulesDeviatedByModules.get(targetModule);
+ if (deviationModulesSupportedByTargetModule != null) {
+ return deviationModulesSupportedByTargetModule.contains(currentModule);
+ }
+
+ return false;
+ }
+
+ private static void performDeviateAdd(final StatementContextBase<?, ?, ?> deviateStmtCtx,
+ final StatementContextBase<?, ?, ?> targetCtx) {
+ for (Mutable<?, ?, ?> originalStmtCtx : deviateStmtCtx.mutableDeclaredSubstatements()) {
+ validateDeviationTarget(originalStmtCtx, targetCtx);
+ addStatement(originalStmtCtx, targetCtx);
+ }
+ }
+
+ private static void addStatement(final Mutable<?, ?, ?> stmtCtxToBeAdded,
+ final StatementContextBase<?, ?, ?> targetCtx) {
+ if (!StmtContextUtils.isUnknownStatement(stmtCtxToBeAdded)) {
+ final StatementDefinition stmtToBeAdded = stmtCtxToBeAdded.getPublicDefinition();
+ if (SINGLETON_STATEMENTS.contains(stmtToBeAdded) || YangStmtMapping.DEFAULT.equals(stmtToBeAdded)
+ && YangStmtMapping.LEAF.equals(targetCtx.getPublicDefinition())) {
+ for (final StmtContext<?, ?, ?> targetCtxSubstatement : targetCtx.allSubstatements()) {
+ InferenceException.throwIf(stmtToBeAdded.equals(targetCtxSubstatement.getPublicDefinition()),
+ stmtCtxToBeAdded.getStatementSourceReference(),
+ "Deviation cannot add substatement %s to target node %s because it is already defined "
+ + "in target and can appear only once.",
+ stmtToBeAdded.getStatementName(), targetCtx.getStatementArgument());
+ }
+ }
+ }
+
+ copyStatement(stmtCtxToBeAdded, targetCtx);
+ }
+
+ private static void performDeviateReplace(final StatementContextBase<?, ?, ?> deviateStmtCtx,
+ final StatementContextBase<?, ?, ?> targetCtx) {
+ for (Mutable<?, ?, ?> originalStmtCtx : deviateStmtCtx.mutableDeclaredSubstatements()) {
+ validateDeviationTarget(originalStmtCtx, targetCtx);
+ replaceStatement(originalStmtCtx, targetCtx);
+ }
+ }
+
+ private static void replaceStatement(final Mutable<?, ?, ?> stmtCtxToBeReplaced,
+ final StatementContextBase<?, ?, ?> targetCtx) {
+ final StatementDefinition stmtToBeReplaced = stmtCtxToBeReplaced.getPublicDefinition();
+
+ if (YangStmtMapping.DEFAULT.equals(stmtToBeReplaced)
+ && YangStmtMapping.LEAF_LIST.equals(targetCtx.getPublicDefinition())) {
+ LOG.error("Deviation cannot replace substatement {} in target leaf-list {} because a leaf-list can "
+ + "have multiple default statements. At line: {}", stmtToBeReplaced.getStatementName(),
+ targetCtx.getStatementArgument(), stmtCtxToBeReplaced.getStatementSourceReference());
+ return;
+ }
+
+ for (final StmtContext<?, ?, ?> targetCtxSubstatement : targetCtx.effectiveSubstatements()) {
+ if (stmtToBeReplaced.equals(targetCtxSubstatement.getPublicDefinition())) {
+ targetCtx.removeStatementFromEffectiveSubstatements(stmtToBeReplaced);
+ copyStatement(stmtCtxToBeReplaced, targetCtx);
+ return;
+ }
+ }
+
+ for (final Mutable<?, ?, ?> targetCtxSubstatement : targetCtx.mutableDeclaredSubstatements()) {
+ if (stmtToBeReplaced.equals(targetCtxSubstatement.getPublicDefinition())) {
+ targetCtxSubstatement.setIsSupportedToBuildEffective(false);
+ copyStatement(stmtCtxToBeReplaced, targetCtx);
+ return;
+ }
+ }
+
+ // This is a special case when deviate replace of a config/mandatory/max/min-elements substatement targets
+ // a node which does not contain an explicitly declared config/mandatory/max/min-elements.
+ // However, according to RFC6020/RFC7950, these properties are always implicitly present.
+ if (IMPLICIT_STATEMENTS.contains(stmtToBeReplaced)) {
+ addStatement(stmtCtxToBeReplaced, targetCtx);
+ return;
+ }
+
+ throw new InferenceException(stmtCtxToBeReplaced.getStatementSourceReference(), "Deviation cannot replace "
+ + "substatement %s in target node %s because it does not exist in target node.",
+ stmtToBeReplaced.getStatementName(), targetCtx.getStatementArgument());
+ }
+
+ private static void performDeviateDelete(final StatementContextBase<?, ?, ?> deviateStmtCtx,
+ final StatementContextBase<?, ?, ?> targetCtx) {
+ for (Mutable<?, ?, ?> originalStmtCtx : deviateStmtCtx.mutableDeclaredSubstatements()) {
+ validateDeviationTarget(originalStmtCtx, targetCtx);
+ deleteStatement(originalStmtCtx, targetCtx);
+ }
+ }
+
+ private static void deleteStatement(final StmtContext<?, ?, ?> stmtCtxToBeDeleted,
+ final StatementContextBase<?, ?, ?> targetCtx) {
+ final StatementDefinition stmtToBeDeleted = stmtCtxToBeDeleted.getPublicDefinition();
+ final String stmtArgument = stmtCtxToBeDeleted.rawStatementArgument();
+
+ for (final Mutable<?, ?, ?> targetCtxSubstatement : targetCtx.mutableEffectiveSubstatements()) {
+ if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.getPublicDefinition(),
+ targetCtxSubstatement.rawStatementArgument())) {
+ targetCtx.removeStatementFromEffectiveSubstatements(stmtToBeDeleted, stmtArgument);
+ return;
+ }
+ }
+
+ for (final Mutable<?, ?, ?> targetCtxSubstatement : targetCtx.mutableDeclaredSubstatements()) {
+ if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.getPublicDefinition(),
+ targetCtxSubstatement.rawStatementArgument())) {
+ targetCtxSubstatement.setIsSupportedToBuildEffective(false);
+ return;
+ }
+ }
+
+ LOG.error("Deviation cannot delete substatement {} with argument '{}' in target node {} because it does "
+ + "not exist in the target node. At line: {}", stmtToBeDeleted.getStatementName(), stmtArgument,
+ targetCtx.getStatementArgument(), stmtCtxToBeDeleted.getStatementSourceReference());
+ }
+
+ private static void copyStatement(final Mutable<?, ?, ?> stmtCtxToBeCopied,
+ final StatementContextBase<?, ?, ?> targetCtx) {
+ // we need to make a copy of the statement context only if it is an unknown statement, otherwise
+ // we can reuse the original statement context
+ if (!StmtContextUtils.isUnknownStatement(stmtCtxToBeCopied)) {
+ targetCtx.addEffectiveSubstatement(stmtCtxToBeCopied);
+ } else {
+ targetCtx.addEffectiveSubstatement(targetCtx.childCopyOf(stmtCtxToBeCopied, CopyType.ORIGINAL));
+ }
+ }
+
+ private static boolean statementsAreEqual(final StatementDefinition firstStmtDef, final String firstStmtArg,
+ final StatementDefinition secondStmtDef, final String secondStmtArg) {
+ return firstStmtDef.equals(secondStmtDef) && Objects.equals(firstStmtArg, secondStmtArg);
+ }
+
+ private static void validateDeviationTarget(final StmtContext<?, ?, ?> deviateSubStmtCtx,
+ final StmtContext<?, ?, ?> targetCtx) {
+ InferenceException.throwIf(!isSupportedDeviationTarget(deviateSubStmtCtx, targetCtx,
+ targetCtx.getRootVersion()), deviateSubStmtCtx.getStatementSourceReference(),
+ "%s is not a valid deviation target for substatement %s.",
+ targetCtx.getStatementArgument(), deviateSubStmtCtx.getPublicDefinition().getStatementName());
+ }
+
+ private static boolean isSupportedDeviationTarget(final StmtContext<?, ?, ?> deviateSubstatementCtx,
+ final StmtContext<?, ?, ?> deviateTargetCtx, final YangVersion yangVersion) {
+ Set<StatementDefinition> supportedDeviationTargets =
+ YangValidationBundles.SUPPORTED_DEVIATION_TARGETS.get(deviateTargetCtx.getRootVersion(),
+ deviateSubstatementCtx.getPublicDefinition());
+
+ if (supportedDeviationTargets == null) {
+ supportedDeviationTargets = YangValidationBundles.SUPPORTED_DEVIATION_TARGETS.get(YangVersion.VERSION_1,
+ deviateSubstatementCtx.getPublicDefinition());
+ }
+
+ // if supportedDeviationTargets is null, it means that the deviate substatement is an unknown statement
+ return supportedDeviationTargets == null || supportedDeviationTargets.contains(
+ deviateTargetCtx.getPublicDefinition());
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.deviate;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class DeviateEffectiveStatementImpl extends DeclaredEffectiveStatementBase<DeviateKind, DeviateStatement>
+final class DeviateEffectiveStatementImpl extends DeclaredEffectiveStatementBase<DeviateKind, DeviateStatement>
implements DeviateDefinition, DeviateEffectiveStatement {
private final DeviateKind deviateType;
private final byte deviatedConfig;
private final byte deviatedMandatory;
- public DeviateEffectiveStatementImpl(final StmtContext<DeviateKind, DeviateStatement, ?> ctx) {
+ DeviateEffectiveStatementImpl(final StmtContext<DeviateKind, DeviateStatement, ?> ctx) {
super(ctx);
this.deviateType = argument();
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.deviate;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.DeviateKind;
+import org.opendaylight.yangtools.yang.model.api.stmt.DeviateStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind> implements DeviateStatement {
+ DeviateStatementImpl(final StmtContext<DeviateKind, DeviateStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public DeviateKind getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.deviate;
+
+public final class DeviateStatementRFC6020Support extends AbstractDeviateStatementSupport {
+
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.deviate;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.DeviateKind;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.DeviateStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 deviate statement.
*/
@Beta
-public class DeviateStatementRfc7950Support extends DeviateStatementImpl.Definition {
+public final class DeviateStatementRFC7950Support extends AbstractDeviateStatementSupport {
private static final SubstatementValidator DEVIATE_ADD_SUBSTATEMENT_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.DEVIATE)
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.deviation;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public class DeviationEffectiveStatementImpl
+final class DeviationEffectiveStatementImpl
extends DeclaredEffectiveStatementBase<SchemaNodeIdentifier, DeviationStatement>
implements Deviation, DeviationEffectiveStatement, Immutable {
private final SchemaPath targetPath;
private final List<UnknownSchemaNode> unknownSchemaNodes;
private final List<DeviateDefinition> deviateDefinitions;
- public DeviationEffectiveStatementImpl(final StmtContext<SchemaNodeIdentifier, DeviationStatement, ?> ctx) {
+ DeviationEffectiveStatementImpl(final StmtContext<SchemaNodeIdentifier, DeviationStatement, ?> ctx) {
super(ctx);
this.targetPath = ctx.getStatementArgument().asSchemaPath();
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.deviation;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DeviateStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class DeviationStatementImpl extends AbstractDeclaredStatement<SchemaNodeIdentifier>
+ implements DeviationStatement {
+ DeviationStatementImpl(final StmtContext<SchemaNodeIdentifier, DeviationStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public SchemaNodeIdentifier getTargetNode() {
+ return argument();
+ }
+
+ @Nullable
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends DeviateStatement> getDeviateStatements() {
+ return allDeclared(DeviateStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.deviation;
+
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+
+public final class DeviationStatementSupport extends AbstractStatementSupport<SchemaNodeIdentifier, DeviationStatement,
+ EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .DEVIATION)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.DEVIATE)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .build();
+
+ public DeviationStatementSupport() {
+ super(YangStmtMapping.DEVIATION);
+ }
+
+ @Override
+ public SchemaNodeIdentifier parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return Utils.nodeIdentifierFromPath(ctx, value);
+ }
+
+ @Override
+ public DeviationStatement createDeclared(final StmtContext<SchemaNodeIdentifier, DeviationStatement, ?> ctx) {
+ return new DeviationStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<SchemaNodeIdentifier, DeviationStatement> createEffective(
+ final StmtContext<SchemaNodeIdentifier, DeviationStatement,
+ EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> ctx) {
+ return new DeviationEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<SchemaNodeIdentifier, DeviationStatement,
+ EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> ctx) {
+ final QNameModule currentModule = ctx.getFromNamespace(ModuleCtxToModuleQName.class,
+ ctx.getRoot());
+ final QNameModule targetModule = ctx.getStatementArgument().getLastComponent().getModule();
+
+ if (currentModule.equals(targetModule)) {
+ throw new InferenceException(ctx.getStatementSourceReference(),
+ "Deviation must not target the same module as the one it is defined in: %s", currentModule);
+ }
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.enum_;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+abstract class AbstractEnumStatementSupport extends
+ AbstractStatementSupport<String, EnumStatement, EffectiveStatement<String, EnumStatement>> {
+
+ AbstractEnumStatementSupport() {
+ super(YangStmtMapping.ENUM);
+ }
+
+ @Override
+ public final String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ // FIXME: Checks for real value
+ return value;
+ }
+
+ @Override
+ public final EnumStatement createDeclared(final StmtContext<String, EnumStatement, ?> ctx) {
+ return new EnumStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<String, EnumStatement> createEffective(
+ final StmtContext<String, EnumStatement, EffectiveStatement<String, EnumStatement>> ctx) {
+ return new EnumEffectiveStatementImpl(ctx);
+ }
+}
\ No newline at end of file
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.enum_;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import org.opendaylight.yangtools.yang.model.api.stmt.EnumEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.AbstractEffectiveDocumentedNode;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveDocumentedNode;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public class EnumEffectiveStatementImpl extends AbstractEffectiveDocumentedNode<String, EnumStatement>
+// FIXME: hide this class
+public final class EnumEffectiveStatementImpl extends AbstractEffectiveDocumentedNode<String, EnumStatement>
implements EnumEffectiveStatement {
private final List<UnknownSchemaNode> unknownSchemaNodes;
private final String name;
private final Integer declaredValue;
- public EnumEffectiveStatementImpl(final StmtContext<String, EnumStatement, ?> ctx) {
+ EnumEffectiveStatementImpl(final StmtContext<String, EnumStatement, ?> ctx) {
super(ctx);
name = ctx.rawStatementArgument();
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.enum_;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class EnumStatementImpl extends AbstractDeclaredStatement<String> implements EnumStatement {
+ EnumStatementImpl(final StmtContext<String, EnumStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends IfFeatureStatement> getIfFeatures() {
+ return allDeclared(IfFeatureStatement.class);
+ }
+
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public String getName() {
+ return argument();
+ }
+
+ @Override
+ public ValueStatement getValue() {
+ return firstDeclared(ValueStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.enum_;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class EnumStatementRFC6020Support extends AbstractEnumStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.ENUM)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addOptional(YangStmtMapping.VALUE)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.enum_;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.EnumStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 Enum statement.
*/
@Beta
-public final class EnumStatementRfc7950Support extends EnumStatementImpl.Definition {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .ENUM)
+public final class EnumStatementRFC7950Support extends AbstractEnumStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.ENUM)
.addOptional(YangStmtMapping.DESCRIPTION)
.addAny(YangStmtMapping.IF_FEATURE)
.addOptional(YangStmtMapping.REFERENCE)
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_app_tag;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class ErrorAppTagEffectiveStatementImpl
- extends DeclaredEffectiveStatementBase<String, ErrorAppTagStatement> implements ErrorAppTagEffectiveStatement {
- public ErrorAppTagEffectiveStatementImpl(final StmtContext<String, ErrorAppTagStatement, ?> ctx) {
+final class ErrorAppTagEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, ErrorAppTagStatement>
+ implements ErrorAppTagEffectiveStatement {
+ ErrorAppTagEffectiveStatementImpl(final StmtContext<String, ErrorAppTagStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_app_tag;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class ErrorAppTagStatementImpl extends AbstractDeclaredStatement<String> implements ErrorAppTagStatement {
+ ErrorAppTagStatementImpl(final StmtContext<String, ErrorAppTagStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_app_tag;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
+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;
+
+public class ErrorAppTagStatementSupport extends
+ AbstractStatementSupport<String, ErrorAppTagStatement, EffectiveStatement<String, ErrorAppTagStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.ERROR_APP_TAG).build();
+
+ public ErrorAppTagStatementSupport() {
+ super(YangStmtMapping.ERROR_APP_TAG);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public ErrorAppTagStatement createDeclared(
+ final StmtContext<String, ErrorAppTagStatement, ?> ctx) {
+ return new ErrorAppTagStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, ErrorAppTagStatement> createEffective(
+ final StmtContext<String, ErrorAppTagStatement, EffectiveStatement<String, ErrorAppTagStatement>> ctx) {
+ return new ErrorAppTagEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_message;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class ErrorMessageEffectiveStatementImpl
- extends DeclaredEffectiveStatementBase<String, ErrorMessageStatement>
+final class ErrorMessageEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, ErrorMessageStatement>
implements ErrorMessageEffectiveStatement {
- public ErrorMessageEffectiveStatementImpl(final StmtContext<String, ErrorMessageStatement, ?> ctx) {
+ ErrorMessageEffectiveStatementImpl(final StmtContext<String, ErrorMessageStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_message;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class ErrorMessageStatementImpl extends AbstractDeclaredStatement<String> implements ErrorMessageStatement {
+ ErrorMessageStatementImpl(final StmtContext<String, ErrorMessageStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_message;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
+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;
+
+public final class ErrorMessageStatementSupport extends
+ AbstractStatementSupport<String, ErrorMessageStatement, EffectiveStatement<String, ErrorMessageStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .ERROR_MESSAGE)
+ .build();
+
+ public ErrorMessageStatementSupport() {
+ super(YangStmtMapping.ERROR_MESSAGE);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public ErrorMessageStatement createDeclared(final StmtContext<String, ErrorMessageStatement, ?> ctx) {
+ return new ErrorMessageStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, ErrorMessageStatement> createEffective(
+ final StmtContext<String, ErrorMessageStatement,
+ EffectiveStatement<String, ErrorMessageStatement>> ctx) {
+ return new ErrorMessageEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension;
import com.google.common.collect.ImmutableList;
import java.util.ArrayDeque;
import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YinElementEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.AbstractEffectiveDocumentedNode;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveDocumentedNode;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.argument.ArgumentEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public class ExtensionEffectiveStatementImpl extends AbstractEffectiveDocumentedNode<QName, ExtensionStatement>
+// FIXME: hide this class
+public final class ExtensionEffectiveStatementImpl extends AbstractEffectiveDocumentedNode<QName, ExtensionStatement>
implements ExtensionDefinition, ExtensionEffectiveStatement {
private static final class RecursionDetector extends ThreadLocal<Deque<ExtensionEffectiveStatementImpl>> {
boolean check(final ExtensionEffectiveStatementImpl current) {
* @param ctx Statement context
* @return A potentially under-initialized instance
*/
- public static EffectiveStatement<QName, ExtensionStatement> create(
+ static EffectiveStatement<QName, ExtensionStatement> create(
final StmtContext<QName, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> ctx) {
// Look at the thread-local leak in case we are invoked recursively
final ExtensionEffectiveStatementImpl existing = RecursiveObjectLeaker.lookup(ctx,
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class ExtensionStatementImpl extends AbstractDeclaredStatement<QName> implements ExtensionStatement {
+ ExtensionStatementImpl(final StmtContext<QName, ExtensionStatement,?> context) {
+ super(context);
+ }
+
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Override
+ public ArgumentStatement getArgument() {
+ return firstDeclared(ArgumentStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
+import org.opendaylight.yangtools.yang.parser.spi.ExtensionNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StatementDefinitionNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.SupportedExtensionsMapping;
+
+public final class ExtensionStatementSupport
+ extends AbstractQNameStatementSupport<ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .EXTENSION)
+ .addOptional(YangStmtMapping.ARGUMENT)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .build();
+
+ public ExtensionStatementSupport() {
+ super(YangStmtMapping.EXTENSION);
+ }
+
+ @Override
+ public QName parseArgumentValue(final StmtContext<?,?,?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public ExtensionStatement createDeclared(final StmtContext<QName, ExtensionStatement,?> ctx) {
+ return new ExtensionStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<QName, ExtensionStatement> createEffective(
+ final StmtContext<QName, ExtensionStatement, EffectiveStatement<QName,ExtensionStatement>> ctx) {
+ return ExtensionEffectiveStatementImpl.create(ctx);
+ }
+
+ @Override
+ public void onStatementDefinitionDeclared(
+ final Mutable<QName, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> stmt) {
+ super.onStatementDefinitionDeclared(stmt);
+
+ QName stmtName = stmt.getStatementArgument();
+ if (SupportedExtensionsMapping.OPENCONFIG_VERSION.getStatementName().isEqualWithoutRevision(stmtName)) {
+ stmtName = stmtName.withoutRevision();
+ }
+
+ stmt.addContext(ExtensionNamespace.class, stmtName, stmt);
+
+ final StmtContext<QName, ?, ?> argument = StmtContextUtils.findFirstDeclaredSubstatement(stmt,
+ ArgumentStatement.class);
+ final StmtContext<Boolean, ?, ?> yinElement = StmtContextUtils.findFirstDeclaredSubstatement(stmt,
+ YinElementStatement.class);
+
+ stmt.addToNs(StatementDefinitionNamespace.class, stmt.getStatementArgument(),
+ new ModelDefinedStatementSupport(new ModelDefinedStatementDefinition(stmt.getStatementArgument(),
+ argument != null ? argument.getStatementArgument() : null,
+ yinElement != null ? yinElement.getStatementArgument() : false)));
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension;
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
* Public definition for statements declared by extensions. This class is instantiated for every extension that is seen
* to be declared in a model.
*/
-@Beta
-public final class ModelDefinedStatementDefinition implements StatementDefinition {
+final class ModelDefinedStatementDefinition implements StatementDefinition {
private final QName statementName;
private final QName argumentName;
private final boolean yinElement;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension;
import java.util.Optional;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
/**
* StatementSupport for statements defined via YANG extensions. This is implemented by piggy-backing
- * to a {@link UnrecognizedStatementImpl.Definition}.
+ * to a {@link UnrecognizedStatementSupport}.
*
* @author Robert Varga
*/
-public final class ModelDefinedStatementSupport extends AbstractStatementSupport<String,
+final class ModelDefinedStatementSupport extends AbstractStatementSupport<String,
UnrecognizedStatement, EffectiveStatement<String, UnrecognizedStatement>> {
- private final UnrecognizedStatementImpl.Definition definition;
+ private final UnrecognizedStatementSupport definition;
ModelDefinedStatementSupport(final ModelDefinedStatementDefinition publicDefinition) {
super(publicDefinition);
- this.definition = new UnrecognizedStatementImpl.Definition(publicDefinition);
+ this.definition = new UnrecognizedStatementSupport(publicDefinition);
}
@Override
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension;
import java.util.Objects;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.UnknownEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-public final class UnrecognizedEffectiveStatementImpl
- extends UnknownEffectiveStatementBase<String, UnrecognizedStatement>
+final class UnrecognizedEffectiveStatementImpl extends UnknownEffectiveStatementBase<String, UnrecognizedStatement>
implements UnrecognizedEffectiveStatement {
private final QName maybeQNameArgument;
private final SchemaPath path;
- public UnrecognizedEffectiveStatementImpl(final StmtContext<String, UnrecognizedStatement, ?> ctx) {
+ UnrecognizedEffectiveStatementImpl(final StmtContext<String, UnrecognizedStatement, ?> ctx) {
super(ctx);
// FIXME: Remove following section after fixing 4380
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension;
+
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class UnrecognizedStatementImpl extends AbstractDeclaredStatement<String> implements UnrecognizedStatement {
+ UnrecognizedStatementImpl(final StmtContext<String, ?, ?> context) {
+ super(context);
+ }
+
+ @Nullable
+ @Override
+ public String getArgument() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension;
+
+import java.util.Optional;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+final class UnrecognizedStatementSupport extends AbstractStatementSupport<String, UnrecognizedStatement,
+ EffectiveStatement<String, UnrecognizedStatement>> {
+ UnrecognizedStatementSupport(final StatementDefinition publicDefinition) {
+ super(publicDefinition);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public UnrecognizedStatement createDeclared(final StmtContext<String, UnrecognizedStatement, ?> ctx) {
+ return new UnrecognizedStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, UnrecognizedStatement> createEffective(
+ final StmtContext<String, UnrecognizedStatement,
+ EffectiveStatement<String, UnrecognizedStatement>> ctx) {
+ return new UnrecognizedEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return null;
+ }
+
+ @Override
+ public Optional<StatementSupport<?, ?, ?>> getUnknownStatementDefinitionOf(
+ final StatementDefinition yangStmtDef) {
+ final QName baseQName = getStatementName();
+ final QName argumentName = yangStmtDef.getArgumentName();
+ return Optional.of(new ModelDefinedStatementSupport(new ModelDefinedStatementDefinition(
+ QName.create(baseQName, yangStmtDef.getStatementName().getLocalName()),
+ argumentName != null ? QName.create(baseQName, argumentName.getLocalName()) : null,
+ yangStmtDef.isArgumentYinElement())));
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.feature;
import java.util.Objects;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.FeatureEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.AbstractEffectiveSchemaNode;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveSchemaNode;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class FeatureEffectiveStatementImpl extends AbstractEffectiveSchemaNode<FeatureStatement> implements
- FeatureDefinition, FeatureEffectiveStatement {
+final class FeatureEffectiveStatementImpl extends AbstractEffectiveSchemaNode<FeatureStatement>
+ implements FeatureDefinition, FeatureEffectiveStatement {
- public FeatureEffectiveStatementImpl(final StmtContext<QName, FeatureStatement, ?> ctx) {
+ FeatureEffectiveStatementImpl(final StmtContext<QName, FeatureStatement, ?> ctx) {
super(ctx);
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.feature;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class FeatureStatementImpl extends AbstractDeclaredStatement<QName> implements FeatureStatement {
+ FeatureStatementImpl(final StmtContext<QName, FeatureStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends IfFeatureStatement> getIfFeatures() {
+ return allDeclared(IfFeatureStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public QName getName() {
+ return argument();
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.feature;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class FeatureStatementSupport
+ extends AbstractQNameStatementSupport<FeatureStatement, EffectiveStatement<QName, FeatureStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.FEATURE)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .build();
+
+ public FeatureStatementSupport() {
+ super(YangStmtMapping.FEATURE);
+ }
+
+ @Override
+ public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public FeatureStatement createDeclared(
+ final StmtContext<QName, FeatureStatement, ?> ctx) {
+ return new FeatureStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<QName, FeatureStatement> createEffective(
+ final StmtContext<QName, FeatureStatement, EffectiveStatement<QName, FeatureStatement>> ctx) {
+ return new FeatureEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.fraction_digits;
import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class FractionDigitsEffectiveStatementImpl
+final class FractionDigitsEffectiveStatementImpl
extends DeclaredEffectiveStatementBase<Integer, FractionDigitsStatement>
implements FractionDigitsEffectiveStatement {
- public FractionDigitsEffectiveStatementImpl(final StmtContext<Integer, FractionDigitsStatement, ?> ctx) {
+ FractionDigitsEffectiveStatementImpl(final StmtContext<Integer, FractionDigitsStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.fraction_digits;
+
+import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class FractionDigitsStatementImpl extends AbstractDeclaredStatement<Integer> implements FractionDigitsStatement {
+ FractionDigitsStatementImpl(final StmtContext<Integer, FractionDigitsStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public int getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.fraction_digits;
+
+import com.google.common.collect.Range;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+public final class FractionDigitsStatementSupport extends AbstractStatementSupport<Integer, FractionDigitsStatement,
+ EffectiveStatement<Integer, FractionDigitsStatement>> {
+ private static final Range<Integer> FRAC_DIGITS_ALLOWED = Range.closed(1, 18);
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.FRACTION_DIGITS)
+ .build();
+
+ public FractionDigitsStatementSupport() {
+ super(YangStmtMapping.FRACTION_DIGITS);
+ }
+
+ @Override
+ public Integer parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ final Integer fractionDigits;
+ try {
+ fractionDigits = Integer.valueOf(value);
+ } catch (NumberFormatException e) {
+ throw new SourceException(ctx.getStatementSourceReference(), e,
+ "%s is not valid fraction-digits integer argument", value);
+ }
+
+ SourceException.throwIf(!FRAC_DIGITS_ALLOWED.contains(fractionDigits), ctx.getStatementSourceReference(),
+ "fraction-digits argument should be integer within %s", FRAC_DIGITS_ALLOWED);
+ return fractionDigits;
+ }
+
+ @Override
+ public FractionDigitsStatement createDeclared(final StmtContext<Integer, FractionDigitsStatement, ?> ctx) {
+ return new FractionDigitsStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<Integer, FractionDigitsStatement> createEffective(
+ final StmtContext<Integer, FractionDigitsStatement,
+ EffectiveStatement<Integer, FractionDigitsStatement>> ctx) {
+ return new FractionDigitsEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.grouping;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
+import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+
+abstract class AbstractGroupingStatementSupport
+ extends AbstractQNameStatementSupport<GroupingStatement, EffectiveStatement<QName, GroupingStatement>> {
+
+ AbstractGroupingStatementSupport() {
+ super(YangStmtMapping.GROUPING);
+ }
+
+ @Override
+ public final QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public final GroupingStatement createDeclared(final StmtContext<QName, GroupingStatement, ?> ctx) {
+ return new GroupingStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<QName, GroupingStatement> createEffective(
+ final StmtContext<QName, GroupingStatement, EffectiveStatement<QName, GroupingStatement>> ctx) {
+ return new GroupingEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public final void onFullDefinitionDeclared(final Mutable<QName, GroupingStatement,
+ EffectiveStatement<QName, GroupingStatement>> stmt) {
+ super.onFullDefinitionDeclared(stmt);
+
+ if (stmt != null && stmt.getParentContext() != null) {
+ stmt.getParentContext().addContext(GroupingNamespace.class, stmt.getStatementArgument(), stmt);
+ }
+ }
+}
\ No newline at end of file
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.grouping;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveDocumentedDataNodeContainer;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public class GroupingEffectiveStatementImpl
+final class GroupingEffectiveStatementImpl
extends AbstractEffectiveDocumentedDataNodeContainer<QName, GroupingStatement>
implements GroupingDefinition, GroupingEffectiveStatement {
private final QName qname;
private final Set<NotificationDefinition> notifications;
private final List<UnknownSchemaNode> unknownNodes;
- public GroupingEffectiveStatementImpl(
+ GroupingEffectiveStatementImpl(
final StmtContext<QName, GroupingStatement, EffectiveStatement<QName, GroupingStatement>> ctx) {
super(ctx);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.grouping;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+public class GroupingStatementImpl extends AbstractDeclaredStatement<QName>
+ implements GroupingStatement {
+ GroupingStatementImpl(final StmtContext<QName, GroupingStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public QName getName() {
+ return argument();
+ }
+
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends TypedefStatement> getTypedefs() {
+ return allDeclared(TypedefStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends GroupingStatement> getGroupings() {
+ return allDeclared(GroupingStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
+ return allDeclared(DataDefinitionStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends ActionStatement> getActions() {
+ return allDeclared(ActionStatement.class);
+ }
+
+ @Override
+ public final Collection<? extends NotificationStatement> getNotifications() {
+ return allDeclared(NotificationStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.grouping;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class GroupingStatementRFC6020Support extends AbstractGroupingStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .GROUPING)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.grouping;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.GroupingStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 Grouping statement.
*/
@Beta
-public final class GroupingStatementRfc7950Support extends GroupingStatementImpl.Definition {
+public final class GroupingStatementRFC7950Support extends AbstractGroupingStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.GROUPING)
.addAny(YangStmtMapping.ACTION)
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.identity;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
+import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+
+abstract class AbstractIdentityStatementSupport
+ extends AbstractQNameStatementSupport<IdentityStatement, EffectiveStatement<QName, IdentityStatement>> {
+
+ AbstractIdentityStatementSupport() {
+ super(YangStmtMapping.IDENTITY);
+ }
+
+ @Override
+ public final QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public final IdentityStatement createDeclared(final StmtContext<QName, IdentityStatement, ?> ctx) {
+ return new IdentityStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<QName, IdentityStatement> createEffective(
+ final StmtContext<QName, IdentityStatement, EffectiveStatement<QName, IdentityStatement>> ctx) {
+ return new IdentityEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public final void onStatementDefinitionDeclared(final StmtContext.Mutable<QName, IdentityStatement,
+ EffectiveStatement<QName, IdentityStatement>> stmt) {
+ stmt.addToNs(IdentityNamespace.class, stmt.getStatementArgument(), stmt);
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.identity;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.AbstractEffectiveSchemaNode;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveSchemaNode;
import org.opendaylight.yangtools.yang.parser.spi.meta.DerivedIdentitiesNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.MutableStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class IdentityEffectiveStatementImpl extends AbstractEffectiveSchemaNode<IdentityStatement>
+final class IdentityEffectiveStatementImpl extends AbstractEffectiveSchemaNode<IdentityStatement>
implements IdentityEffectiveStatement, IdentitySchemaNode, MutableStatement {
private final Set<IdentitySchemaNode> derivedIdentities;
private Set<IdentitySchemaNode> baseIdentities;
private boolean sealed;
- public IdentityEffectiveStatementImpl(
+ IdentityEffectiveStatementImpl(
final StmtContext<QName, IdentityStatement, EffectiveStatement<QName, IdentityStatement>> ctx) {
super(ctx);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.identity;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class IdentityStatementImpl extends AbstractDeclaredStatement<QName> implements IdentityStatement {
+ IdentityStatementImpl(final StmtContext<QName, IdentityStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends IfFeatureStatement> getIfFeatures() {
+ return allDeclared(IfFeatureStatement.class);
+ }
+
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends BaseStatement> getBases() {
+ return allDeclared(BaseStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public QName getName() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.identity;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class IdentityStatementRFC6020Support extends AbstractIdentityStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.IDENTITY)
+ .addOptional(YangStmtMapping.BASE)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.identity;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.IdentityStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 Identity statement.
*/
@Beta
-public final class IdentityStatementRfc7950Support extends IdentityStatementImpl.Definition {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .IDENTITY)
+public final class IdentityStatementRFC7950Support extends AbstractIdentityStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.IDENTITY)
.addAny(YangStmtMapping.BASE)
.addOptional(YangStmtMapping.DESCRIPTION)
.addAny(YangStmtMapping.IF_FEATURE)
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.if_feature;
import java.util.Set;
import java.util.function.Predicate;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class IfFeatureEffectiveStatementImpl
+final class IfFeatureEffectiveStatementImpl
extends DeclaredEffectiveStatementBase<Predicate<Set<QName>>, IfFeatureStatement>
implements IfFeatureEffectiveStatement {
-
public IfFeatureEffectiveStatementImpl(final StmtContext<Predicate<Set<QName>>, IfFeatureStatement, ?> ctx) {
+ IfFeatureEffectiveStatementImpl(final StmtContext<Predicate<Set<QName>>, IfFeatureStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.if_feature;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.Set;
+import java.util.function.Predicate;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionLexer;
+import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionParser;
+import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionParser.Identifier_ref_argContext;
+import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionParser.If_feature_exprContext;
+import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionParser.If_feature_factorContext;
+import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionParser.If_feature_termContext;
+import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionParserBaseVisitor;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+final class IfFeaturePredicateVisitor extends IfFeatureExpressionParserBaseVisitor<Predicate<Set<QName>>> {
+ private final StmtContext<?, ?, ?> stmtCtx;
+
+ private IfFeaturePredicateVisitor(final StmtContext<?, ?, ?> ctx) {
+ this.stmtCtx = requireNonNull(ctx);
+ }
+
+ static Predicate<Set<QName>> parseIfFeatureExpression(final StmtContext<?, ?, ?> ctx, final String value) {
+ final IfFeatureExpressionLexer lexer = new IfFeatureExpressionLexer(CharStreams.fromString(value));
+ final CommonTokenStream tokens = new CommonTokenStream(lexer);
+ final IfFeatureExpressionParser parser = new IfFeatureExpressionParser(tokens);
+
+ return new IfFeaturePredicateVisitor(ctx).visit(parser.if_feature_expr());
+ }
+
+ @Override
+ public Predicate<Set<QName>> visitIf_feature_expr(final If_feature_exprContext ctx) {
+ if (ctx.if_feature_expr() == null) {
+ return visitIf_feature_term(ctx.if_feature_term());
+ }
+
+ return visitIf_feature_term(ctx.if_feature_term()).or(visitIf_feature_expr(ctx.if_feature_expr()));
+ }
+
+ @Override
+ public Predicate<Set<QName>> visitIf_feature_term(final If_feature_termContext ctx) {
+ if (ctx.if_feature_term() == null) {
+ return visitIf_feature_factor(ctx.if_feature_factor());
+ }
+
+ return visitIf_feature_factor(ctx.if_feature_factor()).and(visitIf_feature_term(ctx.if_feature_term()));
+ }
+
+ @Override
+ public Predicate<Set<QName>> visitIf_feature_factor(final If_feature_factorContext ctx) {
+ if (ctx.if_feature_expr() != null) {
+ return visitIf_feature_expr(ctx.if_feature_expr());
+ } else if (ctx.if_feature_factor() != null) {
+ return visitIf_feature_factor(ctx.if_feature_factor()).negate();
+ } else if (ctx.identifier_ref_arg() != null) {
+ return visitIdentifier_ref_arg(ctx.identifier_ref_arg());
+ }
+
+ throw new SourceException("Unexpected grammar context during parsing of IfFeature expression. "
+ + "Most probably IfFeature grammar has been changed.", stmtCtx.getStatementSourceReference());
+ }
+
+ @Override
+ public Predicate<Set<QName>> visitIdentifier_ref_arg(final Identifier_ref_argContext ctx) {
+ final QName featureQName = StmtContextUtils.qnameFromArgument(stmtCtx, ctx.getText());
+ return setQNames -> setQNames.contains(featureQName);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.if_feature;
+
+import java.util.Set;
+import java.util.function.Predicate;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class IfFeatureStatementImpl extends AbstractDeclaredStatement<Predicate<Set<QName>>>
+ implements IfFeatureStatement {
+ IfFeatureStatementImpl(final StmtContext<Predicate<Set<QName>>, IfFeatureStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public Predicate<Set<QName>> getIfFeaturePredicate() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.if_feature;
+
+import java.util.Set;
+import java.util.function.Predicate;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.YangVersion;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+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.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class IfFeatureStatementSupport extends AbstractStatementSupport<Predicate<Set<QName>>, IfFeatureStatement,
+ EffectiveStatement<Predicate<Set<QName>>, IfFeatureStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.IF_FEATURE)
+ .build();
+
+ public IfFeatureStatementSupport() {
+ super(YangStmtMapping.IF_FEATURE);
+ }
+
+ @Override
+ public Predicate<Set<QName>> parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ if (YangVersion.VERSION_1_1.equals(ctx.getRootVersion())) {
+ return IfFeaturePredicateVisitor.parseIfFeatureExpression(ctx, value);
+ }
+
+ final QName qname = StmtContextUtils.qnameFromArgument(ctx, value);
+ return setQNames -> setQNames.contains(qname);
+ }
+
+ @Override
+ public IfFeatureStatement createDeclared(final StmtContext<Predicate<Set<QName>>, IfFeatureStatement, ?> ctx) {
+ return new IfFeatureStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<Predicate<Set<QName>>, IfFeatureStatement> createEffective(
+ final StmtContext<Predicate<Set<QName>>, IfFeatureStatement,
+ EffectiveStatement<Predicate<Set<QName>>, IfFeatureStatement>> ctx) {
+ return new IfFeatureEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.import_;
+
+import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_PRE_LINKAGE;
+import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
+
+import com.google.common.base.Verify;
+import java.net.URI;
+import java.util.Collection;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+import org.opendaylight.yangtools.yang.parser.spi.PreLinkageModuleNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
+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.source.ImpPrefixToNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNameToNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+abstract class AbstractImportStatementSupport extends
+ AbstractStatementSupport<String, ImportStatement, EffectiveStatement<String, ImportStatement>> {
+ AbstractImportStatementSupport() {
+ super(YangStmtMapping.IMPORT);
+ }
+
+ @Override
+ public final String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public final ImportStatement createDeclared(final StmtContext<String, ImportStatement, ?> ctx) {
+ return new ImportStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<String, ImportStatement> createEffective(
+ final StmtContext<String, ImportStatement, EffectiveStatement<String, ImportStatement>> ctx) {
+ return new ImportEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public final void onPreLinkageDeclared(final Mutable<String, ImportStatement,
+ EffectiveStatement<String, ImportStatement>> stmt) {
+ /*
+ * Add ModuleIdentifier of a module which is required by this module.
+ * Based on this information, required modules are searched from library
+ * sources.
+ */
+ stmt.addRequiredSource(RevisionImport.getImportedSourceIdentifier(stmt));
+
+ final String moduleName = stmt.getStatementArgument();
+ final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_PRE_LINKAGE);
+ final Prerequisite<StmtContext<?, ?, ?>> imported = importAction.requiresCtx(stmt,
+ PreLinkageModuleNamespace.class, moduleName, SOURCE_PRE_LINKAGE);
+ final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction
+ .mutatesCtx(stmt.getRoot(), SOURCE_PRE_LINKAGE);
+
+ importAction.apply(new InferenceAction() {
+ @Override
+ public void apply(final InferenceContext ctx) {
+ final StmtContext<?, ?, ?> importedModuleContext = imported.resolve(ctx);
+ Verify.verify(moduleName.equals(importedModuleContext.getStatementArgument()));
+ final URI importedModuleNamespace = importedModuleContext.getFromNamespace(ModuleNameToNamespace.class,
+ moduleName);
+ Verify.verifyNotNull(importedModuleNamespace);
+ final String impPrefix = SourceException.throwIfNull(
+ firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class),
+ stmt.getStatementSourceReference(), "Missing prefix statement");
+
+ stmt.addToNs(ImpPrefixToNamespace.class, impPrefix, importedModuleNamespace);
+ }
+
+ @Override
+ public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
+ InferenceException.throwIf(failed.contains(imported), stmt.getStatementSourceReference(),
+ "Imported module [%s] was not found.", moduleName);
+ }
+ });
+ }
+
+ @Override
+ public final void onLinkageDeclared(
+ final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
+ if (stmt.isEnabledSemanticVersioning()) {
+ SemanticVersionImport.onLinkageDeclared(stmt);
+ } else {
+ RevisionImport.onLinkageDeclared(stmt);
+ }
+ }
+}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.import_;
import com.google.common.base.MoreObjects;
import java.util.Objects;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateEffectiveStatement;
import org.opendaylight.yangtools.yang.model.repo.api.SemVerSourceIdentifier;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.MissingSubstatementException;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToSemVerSourceIdentifier;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-public class ImportEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, ImportStatement>
+final class ImportEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, ImportStatement>
implements ImportEffectiveStatement, ModuleImport {
private final String moduleName;
private final String description;
private final String reference;
- public ImportEffectiveStatementImpl(final StmtContext<String, ImportStatement, ?> ctx) {
+ ImportEffectiveStatementImpl(final StmtContext<String, ImportStatement, ?> ctx) {
super(ctx);
moduleName = ctx.getStatementArgument();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.import_;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public class ImportStatementImpl extends AbstractDeclaredStatement<String> implements ImportStatement {
+final class ImportStatementImpl extends AbstractDeclaredStatement<String> implements ImportStatement {
- ImportStatementImpl(StmtContext<String, ImportStatement,?> context) {
+ ImportStatementImpl(final StmtContext<String, ImportStatement,?> context) {
super(context);
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.import_;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.SupportedExtensionsMapping;
+
+public final class ImportStatementRFC6020Support extends AbstractImportStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator
+ .builder(YangStmtMapping.IMPORT)
+ .addMandatory(YangStmtMapping.PREFIX)
+ .addOptional(YangStmtMapping.REVISION_DATE)
+ .addOptional(SupportedExtensionsMapping.OPENCONFIG_VERSION)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.import_;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ImportStatementDefinition;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.SupportedExtensionsMapping;
/**
* allow import statement to have "description" and "reference" as substatements.
*/
@Beta
-public class ImportStatementRfc7950Support extends ImportStatementDefinition {
-
+public final class ImportStatementRFC7950Support extends AbstractImportStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator
.builder(YangStmtMapping.IMPORT)
.addMandatory(YangStmtMapping.PREFIX)
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.import_;
+
+import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_LINKAGE;
+import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
+import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
+
+import java.net.URI;
+import java.util.Collection;
+import java.util.Optional;
+import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
+import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.ModuleNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
+import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceKeyCriterion;
+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.source.ImportPrefixToModuleCtx;
+import org.opendaylight.yangtools.yang.parser.spi.source.ImportedModuleContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToSourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.URIStringToImpPrefix;
+
+final class RevisionImport {
+
+ private RevisionImport() {
+ throw new UnsupportedOperationException("Utility class");
+ }
+
+ static void onLinkageDeclared(
+ final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
+ final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
+ final Prerequisite<StmtContext<?, ?, ?>> imported;
+ final String moduleName = stmt.getStatementArgument();
+ final Revision revision = firstAttributeOf(stmt.declaredSubstatements(), RevisionDateStatement.class);
+ if (revision == null) {
+ imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
+ NamespaceKeyCriterion.latestRevisionModule(moduleName), SOURCE_LINKAGE);
+ } else {
+ imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
+ RevisionSourceIdentifier.create(moduleName, Optional.of(revision)), SOURCE_LINKAGE);
+ }
+
+ final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction.mutatesCtx(stmt.getRoot(),
+ SOURCE_LINKAGE);
+
+ importAction.apply(new InferenceAction() {
+ @Override
+ public void apply(final InferenceContext ctx) {
+ final StmtContext<?, ?, ?> importedModule = imported.resolve(ctx);
+
+ linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class,
+ stmt.getFromNamespace(ModuleCtxToSourceIdentifier.class, importedModule), importedModule);
+ final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class);
+ final URI modNs = firstAttributeOf(importedModule.declaredSubstatements(),
+ NamespaceStatement.class);
+ stmt.addToNs(ImportPrefixToModuleCtx.class, impPrefix, importedModule);
+ stmt.addToNs(URIStringToImpPrefix.class, modNs.toString(), impPrefix);
+ }
+
+ @Override
+ public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
+ if (failed.contains(imported)) {
+ throw new InferenceException(stmt.getStatementSourceReference(),
+ "Imported module [%s] was not found.", moduleName);
+ }
+ }
+ });
+ }
+
+ static SourceIdentifier getImportedSourceIdentifier(final StmtContext<String, ImportStatement, ?> stmt) {
+ final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
+ RevisionDateStatement.class);
+ return revision == null ? RevisionSourceIdentifier.create(stmt.getStatementArgument())
+ : RevisionSourceIdentifier.create(stmt.getStatementArgument(), revision.getStatementArgument());
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.import_;
+
+import static java.util.Objects.requireNonNull;
+import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_LINKAGE;
+import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
+
+import com.google.common.base.MoreObjects.ToStringHelper;
+import java.net.URI;
+import java.util.Collection;
+import java.util.Optional;
+import org.opendaylight.yangtools.concepts.SemVer;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+import org.opendaylight.yangtools.yang.model.repo.api.SemVerSourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
+import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceKeyCriterion;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionModuleNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionNamespace;
+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.source.ImportPrefixToModuleCtx;
+import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToSemVerSourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.source.ImportedModuleContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToSourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.URIStringToImpPrefix;
+
+final class SemanticVersionImport {
+
+ private abstract static class CompatibleCriterion extends NamespaceKeyCriterion<SemVerSourceIdentifier> {
+ private final String moduleName;
+
+ CompatibleCriterion(final String moduleName) {
+ this.moduleName = requireNonNull(moduleName);
+ }
+
+ @Override
+ public boolean match(final SemVerSourceIdentifier key) {
+ return moduleName.equals(key.getName());
+ }
+
+ @Override
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return toStringHelper.add("moduleName", moduleName);
+ }
+ }
+
+ private static final class NoVerCompatibleCriterion extends SemanticVersionImport.CompatibleCriterion {
+ NoVerCompatibleCriterion(final String moduleName) {
+ super(moduleName);
+ }
+
+ @Override
+ public SemVerSourceIdentifier select(final SemVerSourceIdentifier first,
+ final SemVerSourceIdentifier second) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+ }
+
+ private static final class SemVerCompatibleCriterion extends SemanticVersionImport.CompatibleCriterion {
+ private final SemVer semVer;
+
+ SemVerCompatibleCriterion(final String moduleName, final SemVer semVer) {
+ super(moduleName);
+ this.semVer = requireNonNull(semVer);
+ }
+
+ @Override
+ public boolean match(final SemVerSourceIdentifier key) {
+ if (!super.match(key)) {
+ return false;
+ }
+ final Optional<SemVer> optKeyVer = key.getSemanticVersion();
+ if (!optKeyVer.isPresent()) {
+ return false;
+ }
+
+ final SemVer keyVer = optKeyVer.get();
+ if (semVer.getMajor() != keyVer.getMajor()) {
+ return false;
+ }
+ if (semVer.getMinor() > keyVer.getMinor()) {
+ return false;
+ }
+ return semVer.getMinor() < keyVer.getMinor() || semVer.getPatch() <= keyVer.getPatch();
+ }
+
+ @Override
+ public SemVerSourceIdentifier select(final SemVerSourceIdentifier first,
+ final SemVerSourceIdentifier second) {
+ return first.getSemanticVersion().get().compareTo(second.getSemanticVersion().get()) >= 0 ? first
+ : second;
+ }
+
+ @Override
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return super.addToStringAttributes(toStringHelper).add("version", semVer);
+ }
+ }
+
+
+ private SemanticVersionImport() {
+ throw new UnsupportedOperationException("Utility class");
+ }
+
+ static void onLinkageDeclared(
+ final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
+ final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
+ final String moduleName = stmt.getStatementArgument();
+ final SemVer semanticVersion = stmt.getFromNamespace(SemanticVersionNamespace.class, stmt);
+ final SemanticVersionImport.CompatibleCriterion criterion = semanticVersion == null
+ ? new NoVerCompatibleCriterion(moduleName)
+ : new SemVerCompatibleCriterion(moduleName, semanticVersion);
+
+ final Prerequisite<StmtContext<?, ?, ?>> imported = importAction.requiresCtx(stmt,
+ SemanticVersionModuleNamespace.class, criterion, SOURCE_LINKAGE);
+ final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction.mutatesCtx(stmt.getRoot(),
+ SOURCE_LINKAGE);
+
+ importAction.apply(new InferenceAction() {
+ @Override
+ public void apply(final InferenceContext ctx) {
+ final StmtContext<?, ?, ?> importedModule = imported.resolve(ctx);
+ final SemVer importedVersion = stmt.getFromNamespace(SemanticVersionNamespace.class, stmt);
+ final SourceIdentifier importedModuleIdentifier = importedModule.getFromNamespace(
+ ModuleCtxToSourceIdentifier.class, importedModule);
+ final SemVerSourceIdentifier semVerModuleIdentifier = createSemVerModuleIdentifier(
+ importedModuleIdentifier, importedVersion);
+
+ linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class, importedModuleIdentifier,
+ importedModule);
+ final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class);
+ stmt.addToNs(ImportPrefixToModuleCtx.class, impPrefix, importedModule);
+ stmt.addToNs(ImportPrefixToSemVerSourceIdentifier.class, impPrefix, semVerModuleIdentifier);
+
+ final URI modNs = firstAttributeOf(importedModule.declaredSubstatements(),
+ NamespaceStatement.class);
+ stmt.addToNs(URIStringToImpPrefix.class, modNs.toString(), impPrefix);
+ }
+
+ @Override
+ public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
+ if (failed.contains(imported)) {
+ throw new InferenceException(stmt.getStatementSourceReference(),
+ "Unable to find module compatible with requested import [%s(%s)].", moduleName,
+ getRequestedImportVersionString(stmt));
+ }
+ }
+ });
+ }
+
+ private static Optional<SemVer> getRequestedImportVersion(final StmtContext<?, ?, ?> stmt) {
+ return Optional.ofNullable(stmt.getFromNamespace(SemanticVersionNamespace.class, stmt));
+ }
+
+ private static String getRequestedImportVersionString(final StmtContext<?, ?, ?> stmt) {
+ return getRequestedImportVersion(stmt).map(SemVer::toString).orElse("<any>");
+ }
+
+ private static SemVerSourceIdentifier createSemVerModuleIdentifier(
+ final SourceIdentifier importedModuleIdentifier, final SemVer semVer) {
+ return SemVerSourceIdentifier.create(importedModuleIdentifier.getName(),
+ importedModuleIdentifier.getRevision(), semVer);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.include;
+
+import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_LINKAGE;
+import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
+
+import java.util.Collection;
+import java.util.Optional;
+import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
+import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
+import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceKeyCriterion;
+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.source.IncludedModuleContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.IncludedSubmoduleNameToModuleCtx;
+
+abstract class AbstractIncludeStatementSupport extends
+ AbstractStatementSupport<String, IncludeStatement, EffectiveStatement<String, IncludeStatement>> {
+
+ AbstractIncludeStatementSupport() {
+ super(YangStmtMapping.INCLUDE);
+ }
+
+ @Override
+ public final String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public final IncludeStatement createDeclared(final StmtContext<String, IncludeStatement, ?> ctx) {
+ return new IncludeStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<String, IncludeStatement> createEffective(
+ final StmtContext<String, IncludeStatement, EffectiveStatement<String, IncludeStatement>> ctx) {
+ return new IncludeEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public final void onPreLinkageDeclared(
+ final Mutable<String, IncludeStatement, EffectiveStatement<String, IncludeStatement>> stmt) {
+ final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
+ RevisionDateStatement.class);
+ stmt.addRequiredSource(revision == null ? RevisionSourceIdentifier.create(stmt.getStatementArgument())
+ : RevisionSourceIdentifier.create(stmt.getStatementArgument(), revision.getStatementArgument()));
+ }
+
+ @Override
+ public final void onLinkageDeclared(
+ final Mutable<String, IncludeStatement, EffectiveStatement<String, IncludeStatement>> stmt) {
+ final String submoduleName = stmt.getStatementArgument();
+ final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
+ RevisionDateStatement.class);
+
+ final ModelActionBuilder includeAction = stmt.newInferenceAction(SOURCE_LINKAGE);
+ final Prerequisite<StmtContext<?, ?, ?>> requiresCtxPrerequisite;
+ if (revision == null) {
+ requiresCtxPrerequisite = includeAction.requiresCtx(stmt, SubmoduleNamespace.class,
+ NamespaceKeyCriterion.latestRevisionModule(submoduleName), SOURCE_LINKAGE);
+ } else {
+ requiresCtxPrerequisite = includeAction.requiresCtx(stmt, SubmoduleNamespace.class,
+ RevisionSourceIdentifier.create(submoduleName, Optional.of(revision.getStatementArgument())),
+ SOURCE_LINKAGE);
+ }
+
+ includeAction.apply(new InferenceAction() {
+ @Override
+ public void apply(final InferenceContext ctx) {
+ final StmtContext<?, ?, ?> includedSubModuleContext = requiresCtxPrerequisite.resolve(ctx);
+
+ stmt.addToNs(IncludedModuleContext.class, revision != null
+ ? RevisionSourceIdentifier.create(submoduleName, revision.getStatementArgument())
+ : RevisionSourceIdentifier.create(submoduleName), includedSubModuleContext);
+ stmt.addToNs(IncludedSubmoduleNameToModuleCtx.class, stmt.getStatementArgument(),
+ includedSubModuleContext);
+ }
+
+ @Override
+ public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
+ InferenceException.throwIf(failed.contains(requiresCtxPrerequisite),
+ stmt.getStatementSourceReference(),
+ "Included submodule '%s' was not found: ", stmt.getStatementArgument());
+ }
+ });
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.include;
import org.opendaylight.yangtools.yang.model.api.stmt.IncludeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class IncludeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, IncludeStatement>
+final class IncludeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, IncludeStatement>
implements IncludeEffectiveStatement {
- public IncludeEffectiveStatementImpl(final StmtContext<String, IncludeStatement, ?> ctx) {
+ IncludeEffectiveStatementImpl(final StmtContext<String, IncludeStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.include;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class IncludeStatementImpl extends AbstractDeclaredStatement<String> implements IncludeStatement {
+ IncludeStatementImpl(final StmtContext<String, IncludeStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getModule() {
+ return argument();
+ }
+
+ @Override
+ public RevisionDateStatement getRevisionDate() {
+ return firstDeclared(RevisionDateStatement.class);
+ }
+
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.include;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class IncludeStatementRFC6020Support extends AbstractIncludeStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.INCLUDE).addOptional(YangStmtMapping.REVISION_DATE).build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.include;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.IncludeStatementImpl;
/**
* Implementation of include statement definition for Yang 1.1 (RFC 7950) to
* allow include statement to have "description" and "reference" as substatements.
*/
@Beta
-public class IncludeStatementRfc7950Support extends IncludeStatementImpl.Definition {
-
+public final class IncludeStatementRFC7950Support extends AbstractIncludeStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator
.builder(YangStmtMapping.INCLUDE)
.addOptional(YangStmtMapping.REVISION_DATE)
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.InputEffectiveStatementImpl;
+
+abstract class AbstractInputStatementSupport
+ extends AbstractQNameStatementSupport<InputStatement, EffectiveStatement<QName, InputStatement>> {
+ AbstractInputStatementSupport() {
+ super(YangStmtMapping.INPUT);
+ }
+
+ @Override
+ public final QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, "input");
+ }
+
+ @Override
+ public final void onStatementAdded(final Mutable<QName, InputStatement,
+ EffectiveStatement<QName, InputStatement>> stmt) {
+ stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
+ }
+
+ @Override
+ public final InputStatement createDeclared(final StmtContext<QName, InputStatement, ?> ctx) {
+ return new InputStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<QName, InputStatement> createEffective(
+ final StmtContext<QName, InputStatement, EffectiveStatement<QName, InputStatement>> ctx) {
+ return new InputEffectiveStatementImpl(ctx);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class InputStatementImpl extends AbstractDeclaredStatement<QName> implements InputStatement {
+ InputStatementImpl(final StmtContext<QName, InputStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends TypedefStatement> getTypedefs() {
+ return allDeclared(TypedefStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends GroupingStatement> getGroupings() {
+ return allDeclared(GroupingStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
+ return allDeclared(DataDefinitionStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends MustStatement> getMusts() {
+ return allDeclared(MustStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class InputStatementRFC6020Support extends AbstractInputStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .INPUT)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.InputStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 Input statement.
*/
@Beta
-public final class InputStatementRfc7950Support extends InputStatementImpl.Definition {
+public final class InputStatementRFC7950Support extends AbstractInputStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.INPUT)
.addAny(YangStmtMapping.ANYDATA)
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.key;
import java.util.Collection;
import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class KeyEffectiveStatementImpl
+final class KeyEffectiveStatementImpl
extends DeclaredEffectiveStatementBase<Collection<SchemaNodeIdentifier>, KeyStatement>
implements KeyEffectiveStatement {
- public KeyEffectiveStatementImpl(final StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement, ?> ctx) {
+ KeyEffectiveStatementImpl(final StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement, ?> ctx) {
super(ctx);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.key;
+
+import java.util.Collection;
+import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class KeyStatementImpl extends AbstractDeclaredStatement<Collection<SchemaNodeIdentifier>>
+ implements KeyStatement {
+ KeyStatementImpl(final StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement, ?> context) {
+ super(context);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.key;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSet.Builder;
+import java.util.Collection;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.QNameCacheNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+public final class KeyStatementSupport
+ extends AbstractStatementSupport<Collection<SchemaNodeIdentifier>, KeyStatement,
+ EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.KEY)
+ .build();
+
+ public KeyStatementSupport() {
+ super(YangStmtMapping.KEY);
+ }
+
+ @Override
+ public Collection<SchemaNodeIdentifier> parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ final Builder<SchemaNodeIdentifier> builder = ImmutableSet.builder();
+ int tokens = 0;
+ for (String keyToken : StmtContextUtils.LIST_KEY_SPLITTER.split(value)) {
+ builder.add(SchemaNodeIdentifier.create(false, StmtContextUtils.qnameFromArgument(ctx, keyToken)));
+ tokens++;
+ }
+
+ // Throws NPE on nulls, retains first inserted value, cannot be modified
+ final Collection<SchemaNodeIdentifier> ret = builder.build();
+ SourceException.throwIf(ret.size() != tokens, ctx.getStatementSourceReference(),
+ "Key argument '%s' contains duplicates", value);
+ return ret;
+ }
+
+ @Override
+ public Collection<SchemaNodeIdentifier> adaptArgumentValue(
+ final StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement,
+ EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement>> ctx,
+ final QNameModule targetModule) {
+ final Builder<SchemaNodeIdentifier> builder = ImmutableSet.builder();
+ boolean replaced = false;
+ for (final SchemaNodeIdentifier arg : ctx.getStatementArgument()) {
+ final QName qname = arg.getLastComponent();
+ if (!targetModule.equals(qname.getModule())) {
+ final QName newQname = ctx.getFromNamespace(QNameCacheNamespace.class,
+ QName.create(targetModule, qname.getLocalName()));
+ builder.add(SchemaNodeIdentifier.create(false, newQname));
+ replaced = true;
+ } else {
+ builder.add(arg);
+ }
+ }
+
+ // This makes sure we reuse the collection when a grouping is
+ // instantiated in the same module
+ return replaced ? builder.build() : ctx.getStatementArgument();
+ }
+
+ @Override
+ public KeyStatement createDeclared(final StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement, ?> ctx) {
+ return new KeyStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement> createEffective(
+ final StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement,
+ EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement>> ctx) {
+ return new KeyEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf;
import java.util.Collection;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafEffectiveStatementImpl;
-public class LeafStatementImpl extends AbstractDeclaredStatement<QName> implements LeafStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .LEAF)
- .addOptional(YangStmtMapping.CONFIG)
- .addOptional(YangStmtMapping.DEFAULT)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.MANDATORY)
- .addAny(YangStmtMapping.MUST)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addMandatory(YangStmtMapping.TYPE)
- .addOptional(YangStmtMapping.UNITS)
- .addOptional(YangStmtMapping.WHEN)
- .build();
-
- protected LeafStatementImpl(final StmtContext<QName, LeafStatement, ?> context) {
+final class LeafStatementImpl extends AbstractDeclaredStatement<QName> implements LeafStatement {
+ LeafStatementImpl(final StmtContext<QName, LeafStatement, ?> context) {
super(context);
}
- public static class Definition
- extends AbstractQNameStatementSupport<LeafStatement, EffectiveStatement<QName, LeafStatement>> {
-
- public Definition() {
- super(YangStmtMapping.LEAF);
- }
-
- @Override public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx,value);
- }
-
- @Override
- public void onStatementAdded(final Mutable<QName, LeafStatement,
- EffectiveStatement<QName, LeafStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override
- public LeafStatement createDeclared(final StmtContext<QName, LeafStatement, ?> ctx) {
- return new LeafStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, LeafStatement> createEffective(
- final StmtContext<QName, LeafStatement, EffectiveStatement<QName, LeafStatement>> ctx) {
- return new LeafEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
- @Override
- public void onFullDefinitionDeclared(
- final Mutable<QName, LeafStatement, EffectiveStatement<QName, LeafStatement>> ctx) {
- super.onFullDefinitionDeclared(ctx);
- StmtContextUtils.validateIfFeatureAndWhenOnListKeys(ctx);
- }
- }
-
@Nullable
@Override
public Collection<? extends MustStatement> getMusts() {
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.LeafStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafEffectiveStatementImpl;
+
+public final class LeafStatementSupport
+ extends AbstractQNameStatementSupport<LeafStatement, EffectiveStatement<QName, LeafStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .LEAF)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addOptional(YangStmtMapping.DEFAULT)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.MANDATORY)
+ .addAny(YangStmtMapping.MUST)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addMandatory(YangStmtMapping.TYPE)
+ .addOptional(YangStmtMapping.UNITS)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
+
+ public LeafStatementSupport() {
+ super(YangStmtMapping.LEAF);
+ }
+
+ @Override
+ public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx,value);
+ }
+
+ @Override
+ public void onStatementAdded(final Mutable<QName, LeafStatement, EffectiveStatement<QName, LeafStatement>> stmt) {
+ stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
+ }
+
+ @Override
+ public void onFullDefinitionDeclared(
+ final Mutable<QName, LeafStatement, EffectiveStatement<QName, LeafStatement>> ctx) {
+ super.onFullDefinitionDeclared(ctx);
+ StmtContextUtils.validateIfFeatureAndWhenOnListKeys(ctx);
+ }
+
+ @Override
+ public LeafStatement createDeclared(final StmtContext<QName, LeafStatement, ?> ctx) {
+ return new LeafStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<QName, LeafStatement> createEffective(
+ final StmtContext<QName, LeafStatement, EffectiveStatement<QName, LeafStatement>> ctx) {
+ return new LeafEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf_list;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.LeafListStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafListEffectiveStatementImpl;
+
+abstract class AbstractLeafListStatementSupport
+ extends AbstractQNameStatementSupport<LeafListStatement, EffectiveStatement<QName, LeafListStatement>> {
+
+ AbstractLeafListStatementSupport() {
+ super(YangStmtMapping.LEAF_LIST);
+ }
+
+ @Override
+ public final void onStatementAdded(
+ final Mutable<QName, LeafListStatement, EffectiveStatement<QName, LeafListStatement>> stmt) {
+ stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
+ }
+
+ @Override
+ public final QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public final LeafListStatement createDeclared(final StmtContext<QName, LeafListStatement, ?> ctx) {
+ return new LeafListStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<QName, LeafListStatement> createEffective(
+ final StmtContext<QName, LeafListStatement, EffectiveStatement<QName, LeafListStatement>> ctx) {
+ return new LeafListEffectiveStatementImpl(ctx);
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf_list;
import java.util.Collection;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafListEffectiveStatementImpl;
-
-public class LeafListStatementImpl extends AbstractDeclaredStatement<QName> implements LeafListStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .LEAF_LIST)
- .addOptional(YangStmtMapping.CONFIG)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.MIN_ELEMENTS)
- .addOptional(YangStmtMapping.MAX_ELEMENTS)
- .addAny(YangStmtMapping.MUST)
- .addOptional(YangStmtMapping.ORDERED_BY)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addMandatory(YangStmtMapping.TYPE)
- .addOptional(YangStmtMapping.UNITS)
- .addOptional(YangStmtMapping.WHEN)
- .build();
-
- protected LeafListStatementImpl(final StmtContext<QName, LeafListStatement, ?> context) {
- super(context);
- }
- public static class Definition
- extends AbstractQNameStatementSupport<LeafListStatement, EffectiveStatement<QName, LeafListStatement>> {
-
- public Definition() {
- super(YangStmtMapping.LEAF_LIST);
- }
-
- @Override
- public void onStatementAdded(
- final Mutable<QName, LeafListStatement, EffectiveStatement<QName, LeafListStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public LeafListStatement createDeclared(final StmtContext<QName, LeafListStatement, ?> ctx) {
- return new LeafListStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, LeafListStatement> createEffective(
- final StmtContext<QName, LeafListStatement, EffectiveStatement<QName, LeafListStatement>> ctx) {
- return new LeafListEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
+final class LeafListStatementImpl extends AbstractDeclaredStatement<QName> implements LeafListStatement {
+ LeafListStatementImpl(final StmtContext<QName, LeafListStatement, ?> context) {
+ super(context);
}
@Nonnull
}
@Override
- public final Collection<? extends DefaultStatement> getDefaults() {
+ public Collection<? extends DefaultStatement> getDefaults() {
return allDeclared(DefaultStatement.class);
}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf_list;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class LeafListStatementRFC6020Support extends AbstractLeafListStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .LEAF_LIST)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.MIN_ELEMENTS)
+ .addOptional(YangStmtMapping.MAX_ELEMENTS)
+ .addAny(YangStmtMapping.MUST)
+ .addOptional(YangStmtMapping.ORDERED_BY)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addMandatory(YangStmtMapping.TYPE)
+ .addOptional(YangStmtMapping.UNITS)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf_list;
-import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.LeafListStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 leaf-list statement.
*/
-@Beta
-public class LeafListStatementRfc7950Support extends LeafListStatementImpl.Definition {
+public final class LeafListStatementRFC7950Support extends AbstractLeafListStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.LEAF_LIST)
.addOptional(YangStmtMapping.CONFIG)
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.length;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.stmt.LengthEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LengthStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractListConstraintEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public class LengthEffectiveStatementImpl
+// FIXME: hide this type
+public final class LengthEffectiveStatementImpl
extends AbstractListConstraintEffectiveStatement<ValueRange, LengthStatement>
implements LengthEffectiveStatement {
- public LengthEffectiveStatementImpl(final StmtContext<List<ValueRange>, LengthStatement, ?> ctx) {
+ LengthEffectiveStatementImpl(final StmtContext<List<ValueRange>, LengthStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.length;
+
+import java.util.List;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.LengthStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class LengthStatementImpl extends AbstractDeclaredStatement<List<ValueRange>> implements LengthStatement {
+ LengthStatementImpl(final StmtContext<List<ValueRange>, LengthStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public ErrorAppTagStatement getErrorAppTagStatement() {
+ return firstDeclared(ErrorAppTagStatement.class);
+ }
+
+ @Override
+ public ErrorMessageStatement getErrorMessageStatement() {
+ return firstDeclared(ErrorMessageStatement.class);
+ }
+
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.length;
+
+import java.util.List;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.LengthStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
+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;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
+
+public final class LengthStatementSupport extends AbstractStatementSupport<List<ValueRange>, LengthStatement,
+ EffectiveStatement<List<ValueRange>, LengthStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .LENGTH)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.ERROR_APP_TAG)
+ .addOptional(YangStmtMapping.ERROR_MESSAGE)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .build();
+
+ public LengthStatementSupport() {
+ super(YangStmtMapping.LENGTH);
+ }
+
+ @Override
+ public List<ValueRange> parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return TypeUtils.parseLengthListFromString(ctx, value);
+ }
+
+ @Override
+ public LengthStatement createDeclared(final StmtContext<List<ValueRange>, LengthStatement, ?> ctx) {
+ return new LengthStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<List<ValueRange>, LengthStatement> createEffective(
+ final StmtContext<List<ValueRange>, LengthStatement, EffectiveStatement<List<ValueRange>,
+ LengthStatement>> ctx) {
+ return new LengthEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.list;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ListEffectiveStatementImpl;
+
+abstract class AbstractListStatementSupport
+ extends AbstractQNameStatementSupport<ListStatement, EffectiveStatement<QName, ListStatement>> {
+
+ AbstractListStatementSupport() {
+ super(YangStmtMapping.LIST);
+ }
+
+ @Override
+ public final QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public final void onStatementAdded(
+ final Mutable<QName, ListStatement, EffectiveStatement<QName, ListStatement>> stmt) {
+ stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
+ }
+
+ @Override
+ public final ListStatement createDeclared(final StmtContext<QName, ListStatement, ?> ctx) {
+ return new ListStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<QName, ListStatement> createEffective(
+ final StmtContext<QName, ListStatement, EffectiveStatement<QName, ListStatement>> ctx) {
+ return new ListEffectiveStatementImpl(ctx);
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.list;
import java.util.Collection;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ListEffectiveStatementImpl;
-
-public class ListStatementImpl extends AbstractDeclaredStatement<QName> implements ListStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .LIST)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addOptional(YangStmtMapping.CONFIG)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.KEY)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addOptional(YangStmtMapping.MAX_ELEMENTS)
- .addOptional(YangStmtMapping.MIN_ELEMENTS)
- .addAny(YangStmtMapping.MUST)
- .addOptional(YangStmtMapping.ORDERED_BY)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.UNIQUE)
- .addAny(YangStmtMapping.USES)
- .addOptional(YangStmtMapping.WHEN)
- .build();
-
- protected ListStatementImpl(final StmtContext<QName, ListStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractQNameStatementSupport<ListStatement, EffectiveStatement<QName, ListStatement>> {
-
- public Definition() {
- super(YangStmtMapping.LIST);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
- @Override
- public void onStatementAdded(
- final Mutable<QName, ListStatement, EffectiveStatement<QName, ListStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override
- public ListStatement createDeclared(
- final StmtContext<QName, ListStatement, ?> ctx) {
- return new ListStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, ListStatement> createEffective(
- final StmtContext<QName, ListStatement, EffectiveStatement<QName, ListStatement>> ctx) {
- return new ListEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
+final class ListStatementImpl extends AbstractDeclaredStatement<QName> implements ListStatement {
+ ListStatementImpl(final StmtContext<QName, ListStatement, ?> context) {
+ super(context);
}
@Nonnull
}
@Override
- public final Collection<? extends NotificationStatement> getNotifications() {
+ public Collection<? extends NotificationStatement> getNotifications() {
return allDeclared(NotificationStatement.class);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.list;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class ListStatementRFC6020Support extends AbstractListStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .LIST)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.KEY)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addOptional(YangStmtMapping.MAX_ELEMENTS)
+ .addOptional(YangStmtMapping.MIN_ELEMENTS)
+ .addAny(YangStmtMapping.MUST)
+ .addOptional(YangStmtMapping.ORDERED_BY)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.UNIQUE)
+ .addAny(YangStmtMapping.USES)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
+
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.list;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ListStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 List statement.
*/
@Beta
-public final class ListStatementRfc7950Support extends ListStatementImpl.Definition {
+public final class ListStatementRFC7950Support extends AbstractListStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.LIST)
.addAny(YangStmtMapping.ACTION)
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.mandatory;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.mandatory;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.mandatory;
import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class MandatoryEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Boolean, MandatoryStatement>
+final class MandatoryEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Boolean, MandatoryStatement>
implements MandatoryEffectiveStatement {
- public MandatoryEffectiveStatementImpl(final StmtContext<Boolean, MandatoryStatement, ?> ctx) {
+ MandatoryEffectiveStatementImpl(final StmtContext<Boolean, MandatoryStatement, ?> ctx) {
super(ctx);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.mandatory;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class MandatoryStatementImpl extends AbstractDeclaredStatement<Boolean> implements MandatoryStatement {
+ MandatoryStatementImpl(final StmtContext<Boolean, MandatoryStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ @Nonnull public Boolean getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.mandatory;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+
+public class MandatoryStatementSupport extends
+ AbstractStatementSupport<Boolean, MandatoryStatement, EffectiveStatement<Boolean, MandatoryStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.MANDATORY).build();
+
+ public MandatoryStatementSupport() {
+ super(YangStmtMapping.MANDATORY);
+ }
+
+ @Override
+ public Boolean parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return Utils.parseBoolean(ctx, value);
+ }
+
+ @Override
+ public MandatoryStatement createDeclared(final StmtContext<Boolean, MandatoryStatement, ?> ctx) {
+ final MandatoryStatement ret = new MandatoryStatementImpl(ctx);
+ if (EmptyMandatoryStatement.FALSE.equals(ret)) {
+ return EmptyMandatoryStatement.FALSE;
+ } else if (EmptyMandatoryStatement.TRUE.equals(ret)) {
+ return EmptyMandatoryStatement.TRUE;
+ } else {
+ return ret;
+ }
+ }
+
+ @Override
+ public EffectiveStatement<Boolean, MandatoryStatement> createEffective(
+ final StmtContext<Boolean, MandatoryStatement, EffectiveStatement<Boolean, MandatoryStatement>> ctx) {
+ final EffectiveStatement<Boolean, MandatoryStatement> ret = new MandatoryEffectiveStatementImpl(ctx);
+ final MandatoryStatement declared = ret.getDeclared();
+ if (declared instanceof EmptyMandatoryStatement && ret.effectiveSubstatements().isEmpty()) {
+ return ((EmptyMandatoryStatement)declared).toEffective();
+ }
+ return ret;
+ }
+
+ @Override
+ public String internArgument(final String rawArgument) {
+ return Utils.internBoolean(rawArgument);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.max_elements;
import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class MaxElementsEffectiveStatementImpl
- extends DeclaredEffectiveStatementBase<String, MaxElementsStatement>
+final class MaxElementsEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, MaxElementsStatement>
implements MaxElementsEffectiveStatement {
- public MaxElementsEffectiveStatementImpl(final StmtContext<String, MaxElementsStatement, ?> ctx) {
+ MaxElementsEffectiveStatementImpl(final StmtContext<String, MaxElementsStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.max_elements;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class MaxElementsStatementImpl extends AbstractDeclaredStatement<String> implements MaxElementsStatement {
+ MaxElementsStatementImpl(final StmtContext<String, MaxElementsStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.max_elements;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
+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;
+
+public final class MaxElementsStatementSupport extends
+ AbstractStatementSupport<String, MaxElementsStatement, EffectiveStatement<String, MaxElementsStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.MAX_ELEMENTS)
+ .build();
+
+ public MaxElementsStatementSupport() {
+ super(YangStmtMapping.MAX_ELEMENTS);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public MaxElementsStatement createDeclared(
+ final StmtContext<String, MaxElementsStatement, ?> ctx) {
+ return new MaxElementsStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, MaxElementsStatement> createEffective(
+ final StmtContext<String, MaxElementsStatement, EffectiveStatement<String, MaxElementsStatement>> ctx) {
+ return new MaxElementsEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.min_elements;
import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class MinElementsEffectiveStatementImpl
- extends DeclaredEffectiveStatementBase<Integer, MinElementsStatement>
+final class MinElementsEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Integer, MinElementsStatement>
implements MinElementsEffectiveStatement {
- public MinElementsEffectiveStatementImpl(final StmtContext<Integer, MinElementsStatement, ?> ctx) {
+ MinElementsEffectiveStatementImpl(final StmtContext<Integer, MinElementsStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.min_elements;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class MinElementsStatementImpl extends AbstractDeclaredStatement<Integer> implements MinElementsStatement {
+ MinElementsStatementImpl(final StmtContext<Integer, MinElementsStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public Integer getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.min_elements;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
+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;
+
+public final class MinElementsStatementSupport extends
+ AbstractStatementSupport<Integer, MinElementsStatement, EffectiveStatement<Integer, MinElementsStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.MIN_ELEMENTS)
+ .build();
+
+ public MinElementsStatementSupport() {
+ super(YangStmtMapping.MIN_ELEMENTS);
+ }
+
+ @Override
+ public Integer parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return Integer.parseInt(value);
+ }
+
+ @Override
+ public MinElementsStatement createDeclared(
+ final StmtContext<Integer, MinElementsStatement, ?> ctx) {
+ return new MinElementsStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<Integer, MinElementsStatement> createEffective(
+ final StmtContext<Integer, MinElementsStatement,
+ EffectiveStatement<Integer, MinElementsStatement>> ctx) {
+ return new MinElementsEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.modifier;
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import org.opendaylight.yangtools.yang.model.api.stmt.ModifierEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModifierStatement;
import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
/**
* YANG 1.1 Modifier effective statement implementation.
*/
@Beta
-public final class ModifierEffectiveStatementImpl
- extends DeclaredEffectiveStatementBase<ModifierKind, ModifierStatement>
+final class ModifierEffectiveStatementImpl extends DeclaredEffectiveStatementBase<ModifierKind, ModifierStatement>
implements ModifierEffectiveStatement {
- public ModifierEffectiveStatementImpl(final StmtContext<ModifierKind, ModifierStatement, ?> ctx) {
+ ModifierEffectiveStatementImpl(final StmtContext<ModifierKind, ModifierStatement, ?> ctx) {
super(ctx);
}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.modifier;
+
+import com.google.common.annotations.Beta;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModifierStatement;
+import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+/**
+ * Class providing necessary support for processing YANG 1.1 Modifier statement.
+ */
+@Beta
+final class ModifierStatementImpl extends AbstractDeclaredStatement<ModifierKind> implements ModifierStatement {
+ ModifierStatementImpl(final StmtContext<ModifierKind, ModifierStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public ModifierKind getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.modifier;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModifierStatement;
+import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
+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;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+public final class ModifierStatementSupport extends AbstractStatementSupport<ModifierKind, ModifierStatement,
+ EffectiveStatement<ModifierKind, ModifierStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.MODIFIER).build();
+
+ public ModifierStatementSupport() {
+ super(YangStmtMapping.MODIFIER);
+ }
+
+ @Override
+ public ModifierKind parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return SourceException.unwrap(ModifierKind.parse(value), ctx.getStatementSourceReference(),
+ "'%s' is not valid argument of modifier statement", value);
+ }
+
+ @Override
+ public ModifierStatement createDeclared(final StmtContext<ModifierKind, ModifierStatement, ?> ctx) {
+ return new ModifierStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<ModifierKind, ModifierStatement> createEffective(
+ final StmtContext<ModifierKind, ModifierStatement,
+ EffectiveStatement<ModifierKind, ModifierStatement>> ctx) {
+ return new ModifierEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.module;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.ImpPrefixToNamespace;
import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToModuleCtx;
import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
import org.opendaylight.yangtools.yang.parser.spi.source.ModuleQNameToModuleName;
import org.opendaylight.yangtools.yang.parser.spi.source.PrefixToModule;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ModuleEffectiveStatementImpl;
-public class ModuleStatementSupport extends
+abstract class AbstractModuleStatementSupport extends
AbstractStatementSupport<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .MODULE)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.AUGMENT)
- .addAny(YangStmtMapping.CHOICE)
- .addOptional(YangStmtMapping.CONTACT)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.DEVIATION)
- .addAny(YangStmtMapping.EXTENSION)
- .addAny(YangStmtMapping.FEATURE)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IDENTITY)
- .addAny(YangStmtMapping.IMPORT)
- .addAny(YangStmtMapping.INCLUDE)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addMandatory(YangStmtMapping.NAMESPACE)
- .addAny(YangStmtMapping.NOTIFICATION)
- .addOptional(YangStmtMapping.ORGANIZATION)
- .addMandatory(YangStmtMapping.PREFIX)
- .addOptional(YangStmtMapping.REFERENCE)
- .addAny(YangStmtMapping.REVISION)
- .addAny(YangStmtMapping.RPC)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .addOptional(YangStmtMapping.YANG_VERSION)
- .addOptional(SupportedExtensionsMapping.OPENCONFIG_VERSION)
- .build();
-
- public ModuleStatementSupport() {
+ AbstractModuleStatementSupport() {
super(YangStmtMapping.MODULE);
}
@Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ public final String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return value;
}
@Override
- public ModuleStatement createDeclared(final StmtContext<String, ModuleStatement, ?> ctx) {
+ public final ModuleStatement createDeclared(final StmtContext<String, ModuleStatement, ?> ctx) {
return new ModuleStatementImpl(ctx);
}
@Override
- public EffectiveStatement<String, ModuleStatement> createEffective(
+ public final EffectiveStatement<String, ModuleStatement> createEffective(
final StmtContext<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> ctx) {
return new ModuleEffectiveStatementImpl(ctx);
}
@Override
- public void onPreLinkageDeclared(final Mutable<String, ModuleStatement,
+ public final void onPreLinkageDeclared(final Mutable<String, ModuleStatement,
EffectiveStatement<String, ModuleStatement>> stmt) {
final String moduleName = stmt.getStatementArgument();
}
@Override
- public void onLinkageDeclared(final Mutable<String, ModuleStatement,
+ public final void onLinkageDeclared(final Mutable<String, ModuleStatement,
EffectiveStatement<String, ModuleStatement>> stmt) {
final Optional<URI> moduleNs = Optional.ofNullable(firstAttributeOf(stmt.declaredSubstatements(),
final SemVerSourceIdentifier id = SemVerSourceIdentifier.create(moduleName, moduleSemVer);
stmt.addToNs(SemanticVersionModuleNamespace.class, id, stmt);
}
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.module;
import com.google.common.base.Verify;
import java.util.Objects;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveModule;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
-public final class ModuleEffectiveStatementImpl extends AbstractEffectiveModule<ModuleStatement>
+final class ModuleEffectiveStatementImpl extends AbstractEffectiveModule<ModuleStatement>
implements ModuleEffectiveStatement {
private final QNameModule qnameModule;
- public ModuleEffectiveStatementImpl(
+ ModuleEffectiveStatementImpl(
final StmtContext<String, ModuleStatement, EffectiveStatement<String, ModuleStatement>> ctx) {
super(ctx);
-
qnameModule = Verify.verifyNotNull(ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx));
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.module;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractRootStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public class ModuleStatementImpl extends AbstractRootStatement<ModuleStatement> implements ModuleStatement {
-
- protected ModuleStatementImpl(StmtContext<String, ModuleStatement,?> context) {
+final class ModuleStatementImpl extends AbstractRootStatement<ModuleStatement> implements ModuleStatement {
+ ModuleStatementImpl(final StmtContext<String, ModuleStatement,?> context) {
super(context);
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.module;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.SupportedExtensionsMapping;
+
+public final class ModuleStatementRFC6020Support extends AbstractModuleStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .MODULE)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.AUGMENT)
+ .addAny(YangStmtMapping.CHOICE)
+ .addOptional(YangStmtMapping.CONTACT)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.DEVIATION)
+ .addAny(YangStmtMapping.EXTENSION)
+ .addAny(YangStmtMapping.FEATURE)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IDENTITY)
+ .addAny(YangStmtMapping.IMPORT)
+ .addAny(YangStmtMapping.INCLUDE)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addMandatory(YangStmtMapping.NAMESPACE)
+ .addAny(YangStmtMapping.NOTIFICATION)
+ .addOptional(YangStmtMapping.ORGANIZATION)
+ .addMandatory(YangStmtMapping.PREFIX)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addAny(YangStmtMapping.REVISION)
+ .addAny(YangStmtMapping.RPC)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .addOptional(YangStmtMapping.YANG_VERSION)
+ .addOptional(SupportedExtensionsMapping.OPENCONFIG_VERSION)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.module;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ModuleStatementSupport;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.SupportedExtensionsMapping;
@Beta
-public class ModuleStatementRfc7950Support extends ModuleStatementSupport {
+public final class ModuleStatementRFC7950Support extends AbstractModuleStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.MODULE)
.addAny(YangStmtMapping.ANYDATA)
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.must;
import java.util.Objects;
import java.util.Optional;
import org.opendaylight.yangtools.yang.model.api.stmt.MustEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public class MustEffectiveStatementImpl extends DeclaredEffectiveStatementBase<RevisionAwareXPath, MustStatement>
+final class MustEffectiveStatementImpl extends DeclaredEffectiveStatementBase<RevisionAwareXPath, MustStatement>
implements MustDefinition, MustEffectiveStatement {
private final RevisionAwareXPath xpath;
private final String errorMessage;
private final String reference;
- public MustEffectiveStatementImpl(final StmtContext<RevisionAwareXPath, MustStatement, ?> ctx) {
+ MustEffectiveStatementImpl(final StmtContext<RevisionAwareXPath, MustStatement, ?> ctx) {
super(ctx);
this.xpath = ctx.getStatementArgument();
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.must;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class MustStatementImpl extends AbstractDeclaredStatement<RevisionAwareXPath> implements MustStatement {
+ MustStatementImpl(final StmtContext<RevisionAwareXPath, MustStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public RevisionAwareXPath getCondition() {
+ return argument();
+ }
+
+ @Nullable
+ @Override
+ public ErrorAppTagStatement getErrorAppTagStatement() {
+ return firstDeclared(ErrorAppTagStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public ErrorMessageStatement getErrorMessageStatement() {
+ return firstDeclared(ErrorMessageStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.must;
+
+import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+
+public final class MustStatementSupport extends AbstractStatementSupport<RevisionAwareXPath, MustStatement,
+ EffectiveStatement<RevisionAwareXPath, MustStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .MUST)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.ERROR_APP_TAG)
+ .addOptional(YangStmtMapping.ERROR_MESSAGE)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .build();
+
+ public MustStatementSupport() {
+ super(YangStmtMapping.MUST);
+ }
+
+ @Override
+ public RevisionAwareXPath parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return Utils.parseXPath(ctx, value);
+ }
+
+ @Override
+ public MustStatement createDeclared(final StmtContext<RevisionAwareXPath, MustStatement, ?> ctx) {
+ return new MustStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<RevisionAwareXPath, MustStatement> createEffective(
+ final StmtContext<RevisionAwareXPath, MustStatement,
+ EffectiveStatement<RevisionAwareXPath, MustStatement>> ctx) {
+ return new MustEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.namespace;
import java.net.URI;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class NamespaceEffectiveStatementImpl extends DeclaredEffectiveStatementBase<URI, NamespaceStatement>
+final class NamespaceEffectiveStatementImpl extends DeclaredEffectiveStatementBase<URI, NamespaceStatement>
implements NamespaceEffectiveStatement {
- public NamespaceEffectiveStatementImpl(final StmtContext<URI, NamespaceStatement, ?> ctx) {
+ NamespaceEffectiveStatementImpl(final StmtContext<URI, NamespaceStatement, ?> ctx) {
super(ctx);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.namespace;
+
+import java.net.URI;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class NamespaceStatementImpl extends AbstractDeclaredStatement<URI> implements NamespaceStatement {
+ NamespaceStatementImpl(final StmtContext<URI, NamespaceStatement,?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public URI getUri() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.namespace;
+
+import java.net.URI;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
+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;
+
+public final class NamespaceStatementSupport extends AbstractStatementSupport<URI, NamespaceStatement,
+ EffectiveStatement<URI, NamespaceStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .NAMESPACE)
+ .build();
+
+ public NamespaceStatementSupport() {
+ super(org.opendaylight.yangtools.yang.model.api.YangStmtMapping.NAMESPACE);
+ }
+
+ @Override
+ public URI parseArgumentValue(final StmtContext<?, ?,?> ctx, final String value) {
+ return URI.create(value);
+ }
+
+ @Override
+ public NamespaceStatement createDeclared(final StmtContext<URI, NamespaceStatement,?> ctx) {
+ return new NamespaceStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<URI,NamespaceStatement> createEffective(
+ final StmtContext<URI, NamespaceStatement, EffectiveStatement<URI, NamespaceStatement>> ctx) {
+ return new NamespaceEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
+
+abstract class AbstractNotificationStatementSupport
+ extends AbstractQNameStatementSupport<NotificationStatement, EffectiveStatement<QName, NotificationStatement>> {
+ AbstractNotificationStatementSupport() {
+ super(YangStmtMapping.NOTIFICATION);
+ }
+
+ @Override
+ public final QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public final void onStatementAdded(
+ final Mutable<QName, NotificationStatement, EffectiveStatement<QName, NotificationStatement>> stmt) {
+ stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
+ }
+
+ @Override
+ public final NotificationStatement createDeclared(final StmtContext<QName, NotificationStatement, ?> ctx) {
+ return new NotificationStatementImpl(ctx);
+ }
+}
\ No newline at end of file
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NotificationEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveDocumentedDataNodeContainer;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public class NotificationEffectiveStatementImpl
+final class NotificationEffectiveStatementImpl
extends AbstractEffectiveDocumentedDataNodeContainer<QName, NotificationStatement>
implements NotificationDefinition, NotificationEffectiveStatement {
private final QName qname;
private final boolean addedByUses;
private final Collection<MustDefinition> mustConstraints;
- public NotificationEffectiveStatementImpl(
+ NotificationEffectiveStatementImpl(
final StmtContext<QName, NotificationStatement, EffectiveStatement<QName, NotificationStatement>> ctx) {
super(ctx);
this.qname = ctx.getStatementArgument();
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class NotificationStatementImpl extends AbstractDeclaredStatement<QName> implements NotificationStatement {
+ NotificationStatementImpl(final StmtContext<QName, NotificationStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public QName getName() {
+ return argument();
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends TypedefStatement> getTypedefs() {
+ return allDeclared(TypedefStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends GroupingStatement> getGroupings() {
+ return allDeclared(GroupingStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
+ return allDeclared(DataDefinitionStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends MustStatement> getMusts() {
+ return allDeclared(MustStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends IfFeatureStatement> getIfFeatures() {
+ return allDeclared(IfFeatureStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class NotificationStatementRFC6020Support extends AbstractNotificationStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.NOTIFICATION)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .build();
+
+ @Override
+ public EffectiveStatement<QName, NotificationStatement> createEffective(
+ final StmtContext<QName, NotificationStatement, EffectiveStatement<QName, NotificationStatement>> ctx) {
+ return new NotificationEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification;
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableSet;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.NotificationStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.NotificationEffectiveStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 Notification
* statement.
*/
@Beta
-public final class NotificationStatementRfc7950Support extends NotificationStatementImpl.Definition {
+public final class NotificationStatementRFC7950Support extends AbstractNotificationStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.NOTIFICATION)
.addAny(YangStmtMapping.ANYDATA)
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ordered_by;
import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class OrderedByEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, OrderedByStatement>
+final class OrderedByEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, OrderedByStatement>
implements OrderedByEffectiveStatement {
- public OrderedByEffectiveStatementImpl(final StmtContext<String, OrderedByStatement, ?> ctx) {
+ OrderedByEffectiveStatementImpl(final StmtContext<String, OrderedByStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ordered_by;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class OrderedByStatementImpl extends AbstractDeclaredStatement<String> implements OrderedByStatement {
+ OrderedByStatementImpl(final StmtContext<String, OrderedByStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ordered_by;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
+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;
+
+public final class OrderedByStatementSupport
+ extends AbstractStatementSupport<String, OrderedByStatement, EffectiveStatement<String, OrderedByStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.ORDERED_BY)
+ .build();
+
+ public OrderedByStatementSupport() {
+ super(YangStmtMapping.ORDERED_BY);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public OrderedByStatement createDeclared(final StmtContext<String, OrderedByStatement, ?> ctx) {
+ return new OrderedByStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, OrderedByStatement> createEffective(
+ final StmtContext<String, OrderedByStatement, EffectiveStatement<String, OrderedByStatement>> ctx) {
+ return new OrderedByEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+
+ @Override
+ public String internArgument(final String rawArgument) {
+ if ("user".equals(rawArgument)) {
+ return "user";
+ } else if ("system".equals(rawArgument)) {
+ return "system";
+ } else {
+ return rawArgument;
+ }
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.organization;
import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class OrganizationEffectiveStatementImpl
- extends DeclaredEffectiveStatementBase<String, OrganizationStatement>
+final class OrganizationEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, OrganizationStatement>
implements OrganizationEffectiveStatement {
- public OrganizationEffectiveStatementImpl(final StmtContext<String, OrganizationStatement, ?> ctx) {
+ OrganizationEffectiveStatementImpl(final StmtContext<String, OrganizationStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.organization;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class OrganizationStatementImpl extends AbstractDeclaredStatement<String> implements OrganizationStatement {
+ OrganizationStatementImpl(final StmtContext<String, OrganizationStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getText() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.organization;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement;
+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;
+
+public final class OrganizationStatementSupport extends
+ AbstractStatementSupport<String, OrganizationStatement, EffectiveStatement<String, OrganizationStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.ORGANIZATION)
+ .build();
+
+ public OrganizationStatementSupport() {
+ super(YangStmtMapping.ORGANIZATION);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public OrganizationStatement createDeclared(
+ final StmtContext<String, OrganizationStatement, ?> ctx) {
+ return new OrganizationStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, OrganizationStatement> createEffective(
+ final StmtContext<String, OrganizationStatement,
+ EffectiveStatement<String, OrganizationStatement>> ctx) {
+ return new OrganizationEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OutputEffectiveStatementImpl;
+
+abstract class AbstractOutputStatementSupport extends
+ AbstractQNameStatementSupport<OutputStatement, EffectiveStatement<QName, OutputStatement>> {
+ AbstractOutputStatementSupport() {
+ super(YangStmtMapping.OUTPUT);
+ }
+
+ @Override
+ public final QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, "output");
+ }
+
+ @Override
+ public final void onStatementAdded(final Mutable<QName, OutputStatement,
+ EffectiveStatement<QName, OutputStatement>> stmt) {
+ stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
+ }
+
+ @Override
+ public final OutputStatement createDeclared(final StmtContext<QName, OutputStatement, ?> ctx) {
+ return new OutputStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<QName, OutputStatement> createEffective(
+ final StmtContext<QName, OutputStatement, EffectiveStatement<QName, OutputStatement>> ctx) {
+ return new OutputEffectiveStatementImpl(ctx);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class OutputStatementImpl extends AbstractDeclaredStatement<QName> implements OutputStatement {
+ OutputStatementImpl(final StmtContext<QName, OutputStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends TypedefStatement> getTypedefs() {
+ return allDeclared(TypedefStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends GroupingStatement> getGroupings() {
+ return allDeclared(GroupingStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
+ return allDeclared(DataDefinitionStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends MustStatement> getMusts() {
+ return allDeclared(MustStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class OutputStatementRFC6020Support extends AbstractOutputStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .OUTPUT)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CHOICE)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.OutputStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 Output statement.
*/
@Beta
-public final class OutputStatementRfc7950Support extends OutputStatementImpl.Definition {
+public final class OutputStatementRFC7950Support extends AbstractOutputStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.OUTPUT)
.addAny(YangStmtMapping.ANYDATA)
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, 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
+ */
+/**
+ * Statement library for YANG version 1 and 1.1, as defined in RFC6020 and RFC7950. Since YANG 1.1 is built on top
+ * of YANG 1 and our semantic model follows version 1.1, base statements are organized in a single package hierarchy.
+ *
+ * <p>
+ * Each statement has its own package underneath this package, from which it exports the StatementSupport instance,
+ * which can be wired into the statement reactor. Other classes should be kept package-private, so inter-statement
+ * interactions follow properly-exposed API interfaces.
+ *
+ * <p>
+ * Common base and utility classes for individual statement implementations are maintained in this package.
+ *
+ * @author Robert Varga
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.path;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
import org.opendaylight.yangtools.yang.model.api.stmt.PathEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class PathEffectiveStatementImpl
- extends DeclaredEffectiveStatementBase<RevisionAwareXPath, PathStatement>
+final class PathEffectiveStatementImpl extends DeclaredEffectiveStatementBase<RevisionAwareXPath, PathStatement>
implements PathEffectiveStatement {
- public PathEffectiveStatementImpl(final StmtContext<RevisionAwareXPath, PathStatement, ?> ctx) {
+ PathEffectiveStatementImpl(final StmtContext<RevisionAwareXPath, PathStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.path;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class PathStatementImpl extends AbstractDeclaredStatement<RevisionAwareXPath> implements PathStatement {
+ PathStatementImpl(final StmtContext<RevisionAwareXPath, PathStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getValue() {
+ return rawArgument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.path;
+
+import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+
+public final class PathStatementSupport extends AbstractStatementSupport<RevisionAwareXPath, PathStatement,
+ EffectiveStatement<RevisionAwareXPath, PathStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .PATH)
+ .build();
+
+ public PathStatementSupport() {
+ super(YangStmtMapping.PATH);
+ }
+
+ @Override
+ public RevisionAwareXPath parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return Utils.parseXPath(ctx, value);
+ }
+
+ @Override
+ public PathStatement createDeclared(final StmtContext<RevisionAwareXPath, PathStatement, ?> ctx) {
+ return new PathStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<RevisionAwareXPath, PathStatement> createEffective(
+ final StmtContext<RevisionAwareXPath, PathStatement,
+ EffectiveStatement<RevisionAwareXPath, PathStatement>> ctx) {
+ return new PathEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern;
+
+import java.util.Optional;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
+import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
+import org.opendaylight.yangtools.yang.model.util.RegexUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+abstract class AbstractPatternStatementSupport extends AbstractStatementSupport<PatternConstraint, PatternStatement,
+ EffectiveStatement<PatternConstraint, PatternStatement>> {
+ private static final Logger LOG = LoggerFactory.getLogger(AbstractPatternStatementSupport.class);
+
+ AbstractPatternStatementSupport() {
+ super(YangStmtMapping.PATTERN);
+ }
+
+ @Override
+ public final PatternConstraint parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ final String pattern = RegexUtils.getJavaRegexFromXSD(value);
+
+ try {
+ Pattern.compile(pattern);
+ } catch (final PatternSyntaxException e) {
+ LOG.debug("Pattern \"{}\" failed to compile at {}", pattern, ctx.getStatementSourceReference(), e);
+ return null;
+ }
+
+ return new PatternConstraintImpl(pattern, value, Optional.empty(), Optional.empty());
+ }
+
+ @Override
+ public final PatternStatement createDeclared(final StmtContext<PatternConstraint, PatternStatement, ?> ctx) {
+ return new PatternStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<PatternConstraint, PatternStatement> createEffective(
+ final StmtContext<PatternConstraint, PatternStatement,
+ EffectiveStatement<PatternConstraint, PatternStatement>> ctx) {
+ return new PatternEffectiveStatementImpl(ctx);
+ }
+}
\ No newline at end of file
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern;
import static java.util.Objects.requireNonNull;
import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-public class PatternConstraintEffectiveImpl implements PatternConstraint {
+final class PatternConstraintImpl implements PatternConstraint {
private final String regEx;
private final String rawRegEx;
private final String errorMessage;
private final ModifierKind modifier;
- public PatternConstraintEffectiveImpl(final String regex, final String rawRegex,
+ PatternConstraintImpl(final String regex, final String rawRegex,
final Optional<String> description, final Optional<String> reference) {
this(regex, rawRegex, description.orElse(null), reference.orElse(null), null, null, null);
}
- public PatternConstraintEffectiveImpl(final String regex, final String rawRegex, final String description,
+ PatternConstraintImpl(final String regex, final String rawRegex, final String description,
final String reference, final String errorAppTag, final String errorMessage, final ModifierKind modifier) {
this.regEx = requireNonNull(regex, "regex must not be null");
this.rawRegEx = requireNonNull(rawRegex, "raw regex must not be null");
if (getClass() != obj.getClass()) {
return false;
}
- final PatternConstraintEffectiveImpl other = (PatternConstraintEffectiveImpl) obj;
+ final PatternConstraintImpl other = (PatternConstraintImpl) obj;
return Objects.equals(description, other.description) && Objects.equals(errorAppTag, other.errorAppTag)
&& Objects.equals(errorMessage, other.errorMessage) && Objects.equals(reference, other.reference)
&& Objects.equals(regEx, other.regEx) && Objects.equals(modifier, other.modifier);
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern;
import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractConstraintEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public class PatternEffectiveStatementImpl
+final class PatternEffectiveStatementImpl
extends AbstractConstraintEffectiveStatement<PatternConstraint, PatternStatement>
implements PatternEffectiveStatement {
-
public PatternEffectiveStatementImpl(final StmtContext<PatternConstraint, PatternStatement, ?> ctx) {
+ PatternEffectiveStatementImpl(final StmtContext<PatternConstraint, PatternStatement, ?> ctx) {
super(ctx);
}
return argument;
}
- return new PatternConstraintEffectiveImpl(argument.getJavaPatternString(),
+ return new PatternConstraintImpl(argument.getJavaPatternString(),
argument.getRegularExpressionString(),
getDescription().orElse(null), getReference().orElse(null), getErrorAppTag().orElse(null),
getErrorMessage().orElse(null), getModifier());
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModifierStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+public class PatternStatementImpl extends AbstractDeclaredStatement<PatternConstraint> implements PatternStatement {
+
+ protected PatternStatementImpl(final StmtContext<PatternConstraint, PatternStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public ErrorAppTagStatement getErrorAppTagStatement() {
+ return firstDeclared(ErrorAppTagStatement.class);
+ }
+
+ @Override
+ public ErrorMessageStatement getErrorMessageStatement() {
+ return firstDeclared(ErrorMessageStatement.class);
+ }
+
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Override
+ public ModifierStatement getModifierStatement() {
+ return firstDeclared(ModifierStatement.class);
+ }
+
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public PatternConstraint getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class PatternStatementRFC6020Support extends AbstractPatternStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .PATTERN)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.ERROR_APP_TAG)
+ .addOptional(YangStmtMapping.ERROR_MESSAGE)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.PatternStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 Pattern statement.
*/
@Beta
-public final class PatternStatementRfc7950Support extends PatternStatementImpl.Definition {
+public final class PatternStatementRFC7950Support extends AbstractPatternStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.PATTERN)
.addOptional(YangStmtMapping.DESCRIPTION)
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.position;
import org.opendaylight.yangtools.yang.model.api.stmt.PositionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class PositionEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Long, PositionStatement>
+final class PositionEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Long, PositionStatement>
implements PositionEffectiveStatement {
- public PositionEffectiveStatementImpl(final StmtContext<Long, PositionStatement, ?> ctx) {
+ PositionEffectiveStatementImpl(final StmtContext<Long, PositionStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.position;
+
+import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class PositionStatementImpl extends AbstractDeclaredStatement<Long> implements PositionStatement {
+ PositionStatementImpl(final StmtContext<Long, PositionStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public long getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.position;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+public final class PositionStatementSupport
+ extends AbstractStatementSupport<Long, PositionStatement, EffectiveStatement<Long, PositionStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.POSITION).build();
+
+ public PositionStatementSupport() {
+ super(YangStmtMapping.POSITION);
+ }
+
+ @Override
+ public Long parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ try {
+ return Long.parseLong(value);
+ } catch (NumberFormatException e) {
+ throw new SourceException(String.format("Bit position value %s is not valid integer", value),
+ ctx.getStatementSourceReference(), e);
+ }
+ }
+
+ @Override
+ public PositionStatement createDeclared(final StmtContext<Long, PositionStatement, ?> ctx) {
+ return new PositionStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<Long, PositionStatement> createEffective(
+ final StmtContext<Long, PositionStatement, EffectiveStatement<Long, PositionStatement>> ctx) {
+ return new PositionEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.prefix;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class PrefixEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, PrefixStatement>
+final class PrefixEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, PrefixStatement>
implements PrefixEffectiveStatement {
- public PrefixEffectiveStatementImpl(final StmtContext<String, PrefixStatement, ?> ctx) {
+ PrefixEffectiveStatementImpl(final StmtContext<String, PrefixStatement, ?> ctx) {
super(ctx);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.prefix;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class PrefixStatementImpl extends AbstractDeclaredStatement<String> implements PrefixStatement {
+ PrefixStatementImpl(final StmtContext<String, PrefixStatement,?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getValue() {
+ return rawArgument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.prefix;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+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;
+
+public final class PrefixStatementSupport
+ extends AbstractStatementSupport<String, PrefixStatement, EffectiveStatement<String, PrefixStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .PREFIX)
+ .build();
+
+ public PrefixStatementSupport() {
+ super(YangStmtMapping.PREFIX);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?,?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public PrefixStatement createDeclared(final StmtContext<String, PrefixStatement,?> ctx) {
+ return new PrefixStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String,PrefixStatement> createEffective(
+ final StmtContext<String, PrefixStatement, EffectiveStatement<String, PrefixStatement>> ctx) {
+ return new PrefixEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.presence;
import org.opendaylight.yangtools.yang.model.api.stmt.PresenceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class PresenceEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, PresenceStatement>
+final class PresenceEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, PresenceStatement>
implements PresenceEffectiveStatement {
- public PresenceEffectiveStatementImpl(final StmtContext<String, PresenceStatement, ?> ctx) {
+ PresenceEffectiveStatementImpl(final StmtContext<String, PresenceStatement, ?> ctx) {
super(ctx);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.presence;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class PresenceStatementImpl extends AbstractDeclaredStatement<String> implements PresenceStatement {
+ PresenceStatementImpl(final StmtContext<String, PresenceStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.presence;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement;
+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;
+
+public final class PresenceStatementSupport
+ extends AbstractStatementSupport<String, PresenceStatement, EffectiveStatement<String, PresenceStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .PRESENCE)
+ .build();
+
+ public PresenceStatementSupport() {
+ super(YangStmtMapping.PRESENCE);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public PresenceStatement createDeclared(final StmtContext<String, PresenceStatement, ?> ctx) {
+ return new PresenceStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, PresenceStatement> createEffective(
+ final StmtContext<String, PresenceStatement, EffectiveStatement<String, PresenceStatement>> ctx) {
+ return new PresenceEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
-/**
+/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.range;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.stmt.RangeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractListConstraintEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public class RangeEffectiveStatementImpl extends AbstractListConstraintEffectiveStatement<ValueRange, RangeStatement>
+// FIXME: hide this class
+public final class RangeEffectiveStatementImpl
+ extends AbstractListConstraintEffectiveStatement<ValueRange, RangeStatement>
implements RangeEffectiveStatement {
- public RangeEffectiveStatementImpl(final StmtContext<List<ValueRange>, RangeStatement, ?> ctx) {
+ RangeEffectiveStatementImpl(final StmtContext<List<ValueRange>, RangeStatement, ?> ctx) {
super(ctx);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.range;
+
+import java.util.List;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class RangeStatementImpl extends AbstractDeclaredStatement<List<ValueRange>> implements RangeStatement {
+ RangeStatementImpl(final StmtContext<List<ValueRange>, RangeStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public ErrorAppTagStatement getErrorAppTagStatement() {
+ return firstDeclared(ErrorAppTagStatement.class);
+ }
+
+ @Override
+ public ErrorMessageStatement getErrorMessageStatement() {
+ return firstDeclared(ErrorMessageStatement.class);
+ }
+
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.range;
+
+import java.util.List;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
+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;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
+
+public final class RangeStatementSupport extends AbstractStatementSupport<List<ValueRange>, RangeStatement,
+ EffectiveStatement<List<ValueRange>, RangeStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .RANGE)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.ERROR_APP_TAG)
+ .addOptional(YangStmtMapping.ERROR_MESSAGE)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .build();
+
+ public RangeStatementSupport() {
+ super(YangStmtMapping.RANGE);
+ }
+
+ @Override
+ public List<ValueRange> parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return TypeUtils.parseRangeListFromString(ctx, value);
+ }
+
+ @Override
+ public RangeStatement createDeclared(final StmtContext<List<ValueRange>, RangeStatement, ?> ctx) {
+ return new RangeStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<List<ValueRange>, RangeStatement> createEffective(
+ final StmtContext<List<ValueRange>, RangeStatement, EffectiveStatement<List<ValueRange>,
+ RangeStatement>> ctx) {
+ return new RangeEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.reference;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class ReferenceEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, ReferenceStatement>
+final class ReferenceEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, ReferenceStatement>
implements ReferenceEffectiveStatement {
- public ReferenceEffectiveStatementImpl(final StmtContext<String, ReferenceStatement, ?> ctx) {
+ ReferenceEffectiveStatementImpl(final StmtContext<String, ReferenceStatement, ?> ctx) {
super(ctx);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.reference;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class ReferenceStatementImpl extends AbstractDeclaredStatement<String> implements ReferenceStatement {
+ ReferenceStatementImpl(final StmtContext<String, ReferenceStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getText() {
+ return rawArgument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.reference;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+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;
+
+public final class ReferenceStatementSupport extends AbstractStatementSupport<String, ReferenceStatement,
+ EffectiveStatement<String, ReferenceStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.REFERENCE)
+ .build();
+
+ public ReferenceStatementSupport() {
+ super(YangStmtMapping.REFERENCE);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public ReferenceStatement createDeclared(final StmtContext<String, ReferenceStatement, ?> ctx) {
+ return new ReferenceStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, ReferenceStatement> createEffective(
+ final StmtContext<String, ReferenceStatement, EffectiveStatement<String, ReferenceStatement>> ctx) {
+ return new ReferenceEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+
+abstract class AbstractRefineStatementSupport extends AbstractStatementSupport<SchemaNodeIdentifier, RefineStatement,
+ EffectiveStatement<SchemaNodeIdentifier, RefineStatement>> {
+
+ AbstractRefineStatementSupport() {
+ super(YangStmtMapping.REFINE);
+ }
+
+ @Override
+ public final SchemaNodeIdentifier parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return Utils.nodeIdentifierFromPath(ctx, value);
+ }
+
+ @Override
+ public final RefineStatement createDeclared(final StmtContext<SchemaNodeIdentifier, RefineStatement, ?> ctx) {
+ return new RefineStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<SchemaNodeIdentifier, RefineStatement> createEffective(
+ final StmtContext<SchemaNodeIdentifier, RefineStatement,
+ EffectiveStatement<SchemaNodeIdentifier, RefineStatement>> ctx) {
+ return new RefineEffectiveStatementImpl(ctx);
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine;
import com.google.common.collect.ImmutableList;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.stmt.RefineEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.AbstractEffectiveDocumentedNode;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveDocumentedNode;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+// FIXME: hide this class
public final class RefineEffectiveStatementImpl
extends AbstractEffectiveDocumentedNode<SchemaNodeIdentifier, RefineStatement>
implements RefineEffectiveStatement, SchemaNode {
private final List<UnknownSchemaNode> unknownNodes;
private final SchemaNode refineTargetNode;
- public RefineEffectiveStatementImpl(final StmtContext<SchemaNodeIdentifier, RefineStatement, ?> ctx) {
+ RefineEffectiveStatementImpl(final StmtContext<SchemaNodeIdentifier, RefineStatement, ?> ctx) {
super(ctx);
qname = ctx.getStatementArgument().getLastComponent();
path = ctx.getSchemaPath().get();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine;
import java.util.Collection;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RefineEffectiveStatementImpl;
-
-public class RefineStatementImpl extends AbstractDeclaredStatement<SchemaNodeIdentifier> implements RefineStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .REFINE)
- .addOptional(YangStmtMapping.DEFAULT)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.CONFIG)
- .addOptional(YangStmtMapping.MANDATORY)
- .addOptional(YangStmtMapping.PRESENCE)
- .addAny(YangStmtMapping.MUST)
- .addOptional(YangStmtMapping.MIN_ELEMENTS)
- .addOptional(YangStmtMapping.MAX_ELEMENTS)
- .build();
- protected RefineStatementImpl(final StmtContext<SchemaNodeIdentifier, RefineStatement, ?> context) {
+final class RefineStatementImpl extends AbstractDeclaredStatement<SchemaNodeIdentifier> implements RefineStatement {
+ RefineStatementImpl(final StmtContext<SchemaNodeIdentifier, RefineStatement, ?> context) {
super(context);
}
- public static class Definition extends AbstractStatementSupport<SchemaNodeIdentifier, RefineStatement,
- EffectiveStatement<SchemaNodeIdentifier, RefineStatement>> {
-
- public Definition() {
- super(YangStmtMapping.REFINE);
- }
-
- @Override
- public SchemaNodeIdentifier parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return Utils.nodeIdentifierFromPath(ctx, value);
- }
-
- @Override
- public RefineStatement createDeclared(final StmtContext<SchemaNodeIdentifier, RefineStatement, ?> ctx) {
- return new RefineStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<SchemaNodeIdentifier, RefineStatement> createEffective(
- final StmtContext<SchemaNodeIdentifier, RefineStatement,
- EffectiveStatement<SchemaNodeIdentifier, RefineStatement>> ctx) {
- return new RefineEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
@Override
public String getTargetNode() {
return rawArgument();
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class RefineStatementRFC6020Support extends AbstractRefineStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.REFINE)
+ .addOptional(YangStmtMapping.DEFAULT)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.CONFIG)
+ .addOptional(YangStmtMapping.MANDATORY)
+ .addOptional(YangStmtMapping.PRESENCE)
+ .addAny(YangStmtMapping.MUST)
+ .addOptional(YangStmtMapping.MIN_ELEMENTS)
+ .addOptional(YangStmtMapping.MAX_ELEMENTS)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.RefineStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 Refine statement.
*/
@Beta
-public final class RefineStatementRfc7950Support extends RefineStatementImpl.Definition {
+public final class RefineStatementRFC7950Support extends AbstractRefineStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.REFINE)
.addOptional(YangStmtMapping.DEFAULT)
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.require_instance;
import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class RequireInstanceEffectiveStatementImpl
+final class RequireInstanceEffectiveStatementImpl
extends DeclaredEffectiveStatementBase<Boolean, RequireInstanceStatement>
implements RequireInstanceEffectiveStatement {
- public RequireInstanceEffectiveStatementImpl(final StmtContext<Boolean, RequireInstanceStatement, ?> ctx) {
+ RequireInstanceEffectiveStatementImpl(final StmtContext<Boolean, RequireInstanceStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.require_instance;
+
+import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class RequireInstanceStatementImpl extends AbstractDeclaredStatement<Boolean>
+ implements RequireInstanceStatement {
+ RequireInstanceStatementImpl(final StmtContext<Boolean, RequireInstanceStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public boolean getValue() {
+ return argument().booleanValue();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.require_instance;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+
+public final class RequireInstanceStatementSupport extends AbstractStatementSupport<Boolean, RequireInstanceStatement,
+ EffectiveStatement<Boolean, RequireInstanceStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.REQUIRE_INSTANCE).build();
+
+ public RequireInstanceStatementSupport() {
+ super(YangStmtMapping.REQUIRE_INSTANCE);
+ }
+
+ @Override
+ public Boolean parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return Utils.parseBoolean(ctx, value);
+ }
+
+ @Override
+ public RequireInstanceStatement createDeclared(final StmtContext<Boolean, RequireInstanceStatement, ?> ctx) {
+ return new RequireInstanceStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<Boolean, RequireInstanceStatement> createEffective(
+ final StmtContext<Boolean, RequireInstanceStatement,
+ EffectiveStatement<Boolean, RequireInstanceStatement>> ctx) {
+ return new RequireInstanceEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public String internArgument(final String rawArgument) {
+ return Utils.internBoolean(rawArgument);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.revision;
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class RevisionEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Revision, RevisionStatement>
+final class RevisionEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Revision, RevisionStatement>
implements DocumentedNode, RevisionEffectiveStatement {
private final String reference;
private final String description;
- public RevisionEffectiveStatementImpl(final StmtContext<Revision, RevisionStatement, ?> ctx) {
+ RevisionEffectiveStatementImpl(final StmtContext<Revision, RevisionStatement, ?> ctx) {
super(ctx);
final DescriptionEffectiveStatement descStmt = firstEffective(DescriptionEffectiveStatement.class);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.revision;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class RevisionStatementImpl extends AbstractDeclaredStatement<Revision> implements RevisionStatement {
+ RevisionStatementImpl(final StmtContext<Revision, RevisionStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public Revision getDate() {
+ return argument();
+ }
+
+ @Nullable
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.revision;
+
+import java.time.format.DateTimeParseException;
+import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+public final class RevisionStatementSupport extends
+ AbstractStatementSupport<Revision, RevisionStatement, EffectiveStatement<Revision, RevisionStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.REVISION)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .build();
+
+ public RevisionStatementSupport() {
+ super(YangStmtMapping.REVISION);
+ }
+
+ @Override
+ public Revision parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ try {
+ return Revision.of(value);
+ } catch (DateTimeParseException e) {
+ throw new SourceException(ctx.getStatementSourceReference(), e,
+ "Revision value %s is not in required format yyyy-MM-dd", value);
+ }
+ }
+
+ @Override
+ public RevisionStatement createDeclared(final StmtContext<Revision, RevisionStatement, ?> ctx) {
+ return new RevisionStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<Revision, RevisionStatement> createEffective(
+ final StmtContext<Revision, RevisionStatement, EffectiveStatement<Revision, RevisionStatement>> ctx) {
+ return new RevisionEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.revision_date;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class RevisionDateEffectiveStatementImpl
- extends DeclaredEffectiveStatementBase<Revision, RevisionDateStatement>
+final class RevisionDateEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Revision, RevisionDateStatement>
implements RevisionDateEffectiveStatement {
- public RevisionDateEffectiveStatementImpl(final StmtContext<Revision, RevisionDateStatement, ?> ctx) {
+ RevisionDateEffectiveStatementImpl(final StmtContext<Revision, RevisionDateStatement, ?> ctx) {
super(ctx);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.revision_date;
+
+import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class RevisionDateStatementImpl extends AbstractDeclaredStatement<Revision> implements RevisionDateStatement {
+ RevisionDateStatementImpl(final StmtContext<Revision, RevisionDateStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public Revision getDate() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.revision_date;
+
+import java.time.format.DateTimeParseException;
+import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+public final class RevisionDateStatementSupport extends AbstractStatementSupport<Revision, RevisionDateStatement,
+ EffectiveStatement<Revision, RevisionDateStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
+ SubstatementValidator.builder(YangStmtMapping.REVISION_DATE).build();
+
+ public RevisionDateStatementSupport() {
+ super(YangStmtMapping.REVISION_DATE);
+ }
+
+ @Override
+ public Revision parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ try {
+ return Revision.of(value);
+ } catch (DateTimeParseException e) {
+ throw new SourceException(ctx.getStatementSourceReference(), e,
+ "Revision value %s is not in required format yyyy-MM-dd", value);
+ }
+ }
+
+ @Override
+ public RevisionDateStatement createDeclared(final StmtContext<Revision, RevisionDateStatement, ?> ctx) {
+ return new RevisionDateStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<Revision, RevisionDateStatement> createEffective(final StmtContext<Revision,
+ RevisionDateStatement, EffectiveStatement<Revision, RevisionDateStatement>> ctx) {
+ return new RevisionDateEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.rpc;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.spi.source.ImplicitSubstatement;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementDefinitionContext;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
+
+abstract class AbstractRpcStatementSupport
+ extends AbstractQNameStatementSupport<RpcStatement, EffectiveStatement<QName, RpcStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.RPC)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addOptional(YangStmtMapping.INPUT)
+ .addOptional(YangStmtMapping.OUTPUT)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .build();
+
+ AbstractRpcStatementSupport() {
+ super(YangStmtMapping.RPC);
+ }
+
+ @Override
+ public final QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public final void onStatementAdded(
+ final Mutable<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> stmt) {
+ stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
+ }
+
+ @Override
+ public final RpcStatement createDeclared(final StmtContext<QName, RpcStatement, ?> ctx) {
+ return new RpcStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<QName, RpcStatement> createEffective(
+ final StmtContext<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> ctx) {
+ return new RpcEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public final void onFullDefinitionDeclared(
+ final Mutable<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> stmt) {
+ super.onFullDefinitionDeclared(stmt);
+
+ if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, InputStatement.class) == null) {
+ addImplicitStatement((StatementContextBase<?, ?, ?>) stmt, implictInput());
+ }
+
+ if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, OutputStatement.class) == null) {
+ addImplicitStatement((StatementContextBase<?, ?, ?>) stmt, implictOutput());
+ }
+ }
+
+
+ @Override
+ protected final SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+
+ abstract StatementSupport<?, ?, ?> implictInput();
+
+ abstract StatementSupport<?, ?, ?> implictOutput();
+
+ private static void addImplicitStatement(final StatementContextBase<?, ?, ?> parent,
+ final StatementSupport<?, ?, ?> statementToAdd) {
+ final StatementDefinitionContext<?, ?, ?> stmtDefCtx = new StatementDefinitionContext<>(statementToAdd);
+
+ parent.createSubstatement(parent.declaredSubstatements().size(), stmtDefCtx,
+ ImplicitSubstatement.of(parent.getStatementSourceReference()), null);
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.rpc;
import com.google.common.collect.ImmutableSet;
import java.util.HashSet;
import org.opendaylight.yangtools.yang.model.api.stmt.RpcEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.AbstractEffectiveSchemaNode;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.EffectiveStmtUtils;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveSchemaNode;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStmtUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.InputEffectiveStatementImpl;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OutputEffectiveStatementImpl;
-public class RpcEffectiveStatementImpl extends AbstractEffectiveSchemaNode<RpcStatement>
+final class RpcEffectiveStatementImpl extends AbstractEffectiveSchemaNode<RpcStatement>
implements RpcDefinition, RpcEffectiveStatement {
private final ContainerSchemaNode input;
private final ContainerSchemaNode output;
private final Set<TypeDefinition<?>> typeDefinitions;
private final Set<GroupingDefinition> groupings;
- public RpcEffectiveStatementImpl(final StmtContext<QName, RpcStatement,
+ RpcEffectiveStatementImpl(final StmtContext<QName, RpcStatement,
EffectiveStatement<QName, RpcStatement>> ctx) {
super(ctx);
this.input = firstEffective(InputEffectiveStatementImpl.class);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.rpc;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class RpcStatementImpl extends AbstractDeclaredStatement<QName> implements RpcStatement {
+ RpcStatementImpl(final StmtContext<QName, RpcStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public QName getName() {
+ return argument();
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends TypedefStatement> getTypedefs() {
+ return allDeclared(TypedefStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends GroupingStatement> getGroupings() {
+ return allDeclared(GroupingStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Override
+ public InputStatement getInput() {
+ return firstDeclared(InputStatement.class);
+ }
+
+ @Override
+ public OutputStatement getOutput() {
+ return firstDeclared(OutputStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends IfFeatureStatement> getIfFeatures() {
+ return allDeclared(IfFeatureStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.rpc;
+
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input.InputStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output.OutputStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
+
+public final class RpcStatementRFC6020Support extends AbstractRpcStatementSupport {
+ // TODO: share instances
+ private static final StatementSupport<?, ?, ?> IMPLICIT_INPUT = new InputStatementRFC6020Support();
+ private static final StatementSupport<?, ?, ?> IMPLICIT_OUTPUT = new OutputStatementRFC6020Support();
+
+ @Override
+ StatementSupport<?, ?, ?> implictInput() {
+ return IMPLICIT_INPUT;
+ }
+
+ @Override
+ StatementSupport<?, ?, ?> implictOutput() {
+ return IMPLICIT_OUTPUT;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.rpc;
import com.google.common.annotations.Beta;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input.InputStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output.OutputStatementRFC7950Support;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.RpcStatementImpl;
/**
* Bridge class for RFC7950 RPCs. Specializes implicit input/output statements.
* @author Robert Varga
*/
@Beta
-public final class RpcStatementRfc7950Support extends RpcStatementImpl.Definition {
+public final class RpcStatementRFC7950Support extends AbstractRpcStatementSupport {
// TODO: share instances
- private static final StatementSupport<?, ?, ?> IMPLICIT_INPUT = new InputStatementRfc7950Support();
- private static final StatementSupport<?, ?, ?> IMPLICIT_OUTPUT = new OutputStatementRfc7950Support();
+ private static final StatementSupport<?, ?, ?> IMPLICIT_INPUT = new InputStatementRFC7950Support();
+ private static final StatementSupport<?, ?, ?> IMPLICIT_OUTPUT = new OutputStatementRFC7950Support();
@Override
- protected StatementSupport<?, ?, ?> implictInput() {
+ StatementSupport<?, ?, ?> implictInput() {
return IMPLICIT_INPUT;
}
@Override
- protected StatementSupport<?, ?, ?> implictOutput() {
+ StatementSupport<?, ?, ?> implictOutput() {
return IMPLICIT_OUTPUT;
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.status;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class StatusEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Status, StatusStatement>
+final class StatusEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Status, StatusStatement>
implements StatusEffectiveStatement {
- public StatusEffectiveStatementImpl(final StmtContext<Status, StatusStatement, ?> ctx) {
+ StatusEffectiveStatementImpl(final StmtContext<Status, StatusStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.status;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.Status;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class StatusStatementImpl extends AbstractDeclaredStatement<Status> implements StatusStatement {
+ StatusStatementImpl(final StmtContext<Status, StatusStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public Status getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.status;
+
+import org.opendaylight.yangtools.yang.model.api.Status;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+public final class StatusStatementSupport
+ extends AbstractStatementSupport<Status, StatusStatement, EffectiveStatement<Status, StatusStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .STATUS)
+ .build();
+
+ public StatusStatementSupport() {
+ super(YangStmtMapping.STATUS);
+ }
+
+ @Override
+ public Status parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ switch (value) {
+ case "current":
+ return Status.CURRENT;
+ case "deprecated":
+ return Status.DEPRECATED;
+ case "obsolete":
+ return Status.OBSOLETE;
+ default:
+ throw new SourceException(ctx.getStatementSourceReference(),
+ "Invalid status '%s', must be one of 'current', 'deprecated' or 'obsolete'", value);
+ }
+ }
+
+ @Override
+ public StatusStatement createDeclared(
+ final StmtContext<Status, StatusStatement, ?> ctx) {
+ return new StatusStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<Status, StatusStatement> createEffective(
+ final StmtContext<Status, StatusStatement, EffectiveStatement<Status, StatusStatement>> ctx) {
+ return new StatusEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public String internArgument(final String rawArgument) {
+ if ("current".equals(rawArgument)) {
+ return "current";
+ } else if ("deprecated".equals(rawArgument)) {
+ return "deprecated";
+ } else if ("obsolete".equals(rawArgument)) {
+ return "obsolete";
+ } else {
+ return rawArgument;
+ }
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule;
+
+import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
+import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
+import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace;
+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.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.source.BelongsToPrefixToModuleName;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+abstract class AbstractSubmoduleStatementSupport
+ extends AbstractStatementSupport<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> {
+ AbstractSubmoduleStatementSupport() {
+ super(YangStmtMapping.SUBMODULE);
+ }
+
+ @Override
+ public final String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public final SubmoduleStatement createDeclared(final StmtContext<String, SubmoduleStatement, ?> ctx) {
+ return new SubmoduleStatementImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<String, SubmoduleStatement> createEffective(
+ final StmtContext<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> ctx) {
+ return new SubmoduleEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public final void onPreLinkageDeclared(
+ final Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> stmt) {
+ stmt.setRootIdentifier(RevisionSourceIdentifier.create(stmt.getStatementArgument(),
+ StmtContextUtils.getLatestRevision(stmt.declaredSubstatements())));
+ }
+
+ @Override
+ public final void onLinkageDeclared(
+ final Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> stmt) {
+ final SourceIdentifier submoduleIdentifier = RevisionSourceIdentifier.create(stmt.getStatementArgument(),
+ StmtContextUtils.getLatestRevision(stmt.declaredSubstatements()));
+
+ final StmtContext<?, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>>
+ possibleDuplicateSubmodule = stmt.getFromNamespace(SubmoduleNamespace.class, submoduleIdentifier);
+ if (possibleDuplicateSubmodule != null && possibleDuplicateSubmodule != stmt) {
+ throw new SourceException(stmt.getStatementSourceReference(), "Submodule name collision: %s. At %s",
+ stmt.getStatementArgument(), possibleDuplicateSubmodule.getStatementSourceReference());
+ }
+
+ stmt.addContext(SubmoduleNamespace.class, submoduleIdentifier, stmt);
+
+ final String belongsToModuleName = firstAttributeOf(stmt.declaredSubstatements(), BelongsToStatement.class);
+ final StmtContext<?, ?, ?> prefixSubStmtCtx = findFirstDeclaredSubstatement(stmt, 0,
+ BelongsToStatement.class, PrefixStatement.class);
+ SourceException.throwIfNull(prefixSubStmtCtx, stmt.getStatementSourceReference(),
+ "Prefix of belongsTo statement is missing in submodule [%s]", stmt.getStatementArgument());
+
+ final String prefix = (String) prefixSubStmtCtx.getStatementArgument();
+
+ stmt.addToNs(BelongsToPrefixToModuleName.class, prefix, belongsToModuleName);
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveModule;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNameToModuleQName;
+// FIXME: hide this class
public final class SubmoduleEffectiveStatementImpl extends AbstractEffectiveModule<SubmoduleStatement>
implements SubmoduleEffectiveStatement {
private final QNameModule qnameModule;
- public SubmoduleEffectiveStatementImpl(
+ SubmoduleEffectiveStatementImpl(
final StmtContext<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> ctx) {
super(ctx);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractRootStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class SubmoduleStatementImpl extends AbstractRootStatement<SubmoduleStatement> implements SubmoduleStatement {
+ SubmoduleStatementImpl(final StmtContext<String, SubmoduleStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getName() {
+ return rawArgument();
+ }
+
+ @Override
+ public YangVersionStatement getYangVersion() {
+ return firstDeclared(YangVersionStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public BelongsToStatement getBelongsTo() {
+ return firstDeclared(BelongsToStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+public final class SubmoduleStatementRFC6020Support extends AbstractSubmoduleStatementSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .SUBMODULE)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.AUGMENT)
+ .addMandatory(YangStmtMapping.BELONGS_TO)
+ .addAny(YangStmtMapping.CHOICE)
+ .addOptional(YangStmtMapping.CONTACT)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.DEVIATION)
+ .addAny(YangStmtMapping.EXTENSION)
+ .addAny(YangStmtMapping.FEATURE)
+ .addAny(YangStmtMapping.GROUPING)
+ .addAny(YangStmtMapping.IDENTITY)
+ .addAny(YangStmtMapping.IMPORT)
+ .addAny(YangStmtMapping.INCLUDE)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addAny(YangStmtMapping.NOTIFICATION)
+ .addOptional(YangStmtMapping.ORGANIZATION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addAny(YangStmtMapping.REVISION)
+ .addAny(YangStmtMapping.RPC)
+ .addAny(YangStmtMapping.TYPEDEF)
+ .addAny(YangStmtMapping.USES)
+ .addOptional(YangStmtMapping.YANG_VERSION)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule;
import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.SubmoduleStatementImpl;
/**
* Class providing necessary support for processing YANG 1.1 Submodule statement.
*/
@Beta
-public final class SubmoduleStatementRfc7950Support extends SubmoduleStatementImpl.Definition {
+public final class SubmoduleStatementRFC7950Support extends AbstractSubmoduleStatementSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.SUBMODULE)
.addAny(YangStmtMapping.ANYDATA)
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import java.util.Collection;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.IdentityRefSpecification;
+import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+
+abstract class AbstractIdentityRefSpecificationSupport
+ extends AbstractStatementSupport<String, IdentityRefSpecification,
+ EffectiveStatement<String, IdentityRefSpecification>> {
+ AbstractIdentityRefSpecificationSupport() {
+ super(YangStmtMapping.TYPE);
+ }
+
+ @Override
+ public final String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public final IdentityRefSpecification createDeclared(final StmtContext<String, IdentityRefSpecification, ?> ctx) {
+ return new IdentityRefSpecificationImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<String, IdentityRefSpecification> createEffective(
+ final StmtContext<String, IdentityRefSpecification,
+ EffectiveStatement<String, IdentityRefSpecification>> ctx) {
+ return new IdentityRefSpecificationEffectiveStatement(ctx);
+ }
+
+ @Override
+ public final void onFullDefinitionDeclared(final Mutable<String, IdentityRefSpecification,
+ EffectiveStatement<String, IdentityRefSpecification>> stmt) {
+ super.onFullDefinitionDeclared(stmt);
+
+ final Collection<StmtContext<QName, BaseStatement, ?>> baseStatements =
+ StmtContextUtils.<QName, BaseStatement>findAllDeclaredSubstatements(stmt, BaseStatement.class);
+ for (StmtContext<QName, BaseStatement, ?> baseStmt : baseStatements) {
+ final QName baseIdentity = baseStmt.getStatementArgument();
+ final StmtContext<?, ?, ?> stmtCtx = stmt.getFromNamespace(IdentityNamespace.class, baseIdentity);
+ InferenceException.throwIfNull(stmtCtx, stmt.getStatementSourceReference(),
+ "Referenced base identity '%s' doesn't exist in given scope (module, imported modules, submodules)",
+ baseIdentity.getLocalName());
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.LeafrefSpecification;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+abstract class AbstractLeafrefSpecificationSupport
+ extends
+ AbstractStatementSupport<String, LeafrefSpecification, EffectiveStatement<String, LeafrefSpecification>> {
+ AbstractLeafrefSpecificationSupport() {
+ super(YangStmtMapping.TYPE);
+ }
+
+ @Override
+ public final String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public final LeafrefSpecification createDeclared(final StmtContext<String, LeafrefSpecification, ?> ctx) {
+ return new LeafrefSpecificationImpl(ctx);
+ }
+
+ @Override
+ public final EffectiveStatement<String, LeafrefSpecification> createEffective(
+ final StmtContext<String, LeafrefSpecification, EffectiveStatement<String, LeafrefSpecification>> ctx) {
+ return new LeafrefSpecificationEffectiveStatement(ctx);
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
import org.opendaylight.yangtools.yang.model.util.type.TypeBuilder;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
abstract class AbstractTypeEffectiveStatement<T extends TypeDefinition<T>> extends
DeclaredEffectiveStatementBase<String, TypeStatement> implements TypeEffectiveStatement<TypeStatement> {
private final T typeDefinition;
- protected AbstractTypeEffectiveStatement(
+ AbstractTypeEffectiveStatement(
final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
final TypeBuilder<T> builder) {
super(ctx);
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import com.google.common.base.Verify;
+import com.google.common.collect.ImmutableMap;
+import java.util.Collection;
+import java.util.Map;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
+import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.typedef.TypedefEffectiveStatementImpl;
+import org.opendaylight.yangtools.yang.parser.spi.TypeNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
+
+abstract class AbstractTypeStatementSupport
+ extends AbstractStatementSupport<String, TypeStatement, EffectiveStatement<String, TypeStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.TYPE)
+ .addOptional(YangStmtMapping.BASE)
+ .addAny(YangStmtMapping.BIT)
+ .addAny(YangStmtMapping.ENUM)
+ .addOptional(YangStmtMapping.FRACTION_DIGITS)
+ .addOptional(YangStmtMapping.LENGTH)
+ .addOptional(YangStmtMapping.PATH)
+ .addAny(YangStmtMapping.PATTERN)
+ .addOptional(YangStmtMapping.RANGE)
+ .addOptional(YangStmtMapping.REQUIRE_INSTANCE)
+ .addAny(YangStmtMapping.TYPE)
+ .build();
+
+ private static final Map<String, StatementSupport<?, ?, ?>> ARGUMENT_SPECIFIC_SUPPORTS =
+ ImmutableMap.<String, StatementSupport<?, ?, ?>>builder()
+ .put(TypeUtils.BITS, new BitsSpecificationSupport())
+ .put(TypeUtils.DECIMAL64, new Decimal64SpecificationSupport())
+ .put(TypeUtils.ENUMERATION, new EnumSpecificationSupport())
+ .put(TypeUtils.IDENTITY_REF, new IdentityRefSpecificationRFC6020Support())
+ .put(TypeUtils.INSTANCE_IDENTIFIER, new InstanceIdentifierSpecificationSupport())
+ .put(TypeUtils.LEAF_REF, new LeafrefSpecificationRFC6020Support())
+ .put(TypeUtils.UNION, new UnionSpecificationSupport())
+ .build();
+
+ AbstractTypeStatementSupport() {
+ super(YangStmtMapping.TYPE);
+ }
+
+ @Override
+ public final String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public final TypeStatement createDeclared(final StmtContext<String, TypeStatement, ?> ctx) {
+ return BuiltinTypeStatement.maybeReplace(new TypeStatementImpl(ctx));
+ }
+
+ @Override
+ public final TypeEffectiveStatement<TypeStatement> createEffective(
+ final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx) {
+
+ // First look up the proper base type
+ final TypeEffectiveStatement<TypeStatement> typeStmt;
+ switch (ctx.getStatementArgument()) {
+ case TypeUtils.BINARY:
+ typeStmt = BuiltinEffectiveStatement.BINARY;
+ break;
+ case TypeUtils.BOOLEAN:
+ typeStmt = BuiltinEffectiveStatement.BOOLEAN;
+ break;
+ case TypeUtils.EMPTY:
+ typeStmt = BuiltinEffectiveStatement.EMPTY;
+ break;
+ case TypeUtils.INSTANCE_IDENTIFIER:
+ typeStmt = BuiltinEffectiveStatement.INSTANCE_IDENTIFIER;
+ break;
+ case TypeUtils.INT8:
+ typeStmt = BuiltinEffectiveStatement.INT8;
+ break;
+ case TypeUtils.INT16:
+ typeStmt = BuiltinEffectiveStatement.INT16;
+ break;
+ case TypeUtils.INT32:
+ typeStmt = BuiltinEffectiveStatement.INT32;
+ break;
+ case TypeUtils.INT64:
+ typeStmt = BuiltinEffectiveStatement.INT64;
+ break;
+ case TypeUtils.STRING:
+ typeStmt = BuiltinEffectiveStatement.STRING;
+ break;
+ case TypeUtils.UINT8:
+ typeStmt = BuiltinEffectiveStatement.UINT8;
+ break;
+ case TypeUtils.UINT16:
+ typeStmt = BuiltinEffectiveStatement.UINT16;
+ break;
+ case TypeUtils.UINT32:
+ typeStmt = BuiltinEffectiveStatement.UINT32;
+ break;
+ case TypeUtils.UINT64:
+ typeStmt = BuiltinEffectiveStatement.UINT64;
+ break;
+ default:
+ final QName qname = StmtContextUtils.qnameFromArgument(ctx, ctx.getStatementArgument());
+ final StmtContext<?, TypedefStatement, TypedefEffectiveStatement> typedef =
+ SourceException.throwIfNull(ctx.getFromNamespace(TypeNamespace.class, qname),
+ ctx.getStatementSourceReference(), "Type '%s' not found", qname);
+
+ final TypedefEffectiveStatement effectiveTypedef = typedef.buildEffective();
+ Verify.verify(effectiveTypedef instanceof TypedefEffectiveStatementImpl);
+ typeStmt = ((TypedefEffectiveStatementImpl) effectiveTypedef).asTypeEffectiveStatement();
+ }
+
+ if (ctx.declaredSubstatements().isEmpty() && ctx.effectiveSubstatements().isEmpty()) {
+ return typeStmt;
+ }
+
+ // Now instantiate the proper effective statement for that type
+ final TypeDefinition<?> baseType = typeStmt.getTypeDefinition();
+ if (baseType instanceof BinaryTypeDefinition) {
+ return new BinaryTypeEffectiveStatementImpl(ctx, (BinaryTypeDefinition) baseType);
+ } else if (baseType instanceof BitsTypeDefinition) {
+ return new BitsTypeEffectiveStatementImpl(ctx, (BitsTypeDefinition) baseType);
+ } else if (baseType instanceof BooleanTypeDefinition) {
+ return new BooleanTypeEffectiveStatementImpl(ctx, (BooleanTypeDefinition) baseType);
+ } else if (baseType instanceof DecimalTypeDefinition) {
+ return new DecimalTypeEffectiveStatementImpl(ctx, (DecimalTypeDefinition) baseType);
+ } else if (baseType instanceof EmptyTypeDefinition) {
+ return new EmptyTypeEffectiveStatementImpl(ctx, (EmptyTypeDefinition) baseType);
+ } else if (baseType instanceof EnumTypeDefinition) {
+ return new EnumTypeEffectiveStatementImpl(ctx, (EnumTypeDefinition) baseType);
+ } else if (baseType instanceof IdentityrefTypeDefinition) {
+ return new IdentityrefTypeEffectiveStatementImpl(ctx, (IdentityrefTypeDefinition) baseType);
+ } else if (baseType instanceof InstanceIdentifierTypeDefinition) {
+ return new InstanceIdentifierTypeEffectiveStatementImpl(ctx,
+ (InstanceIdentifierTypeDefinition) baseType);
+ } else if (baseType instanceof Int8TypeDefinition) {
+ return new IntegralTypeEffectiveStatementImpl<>(ctx,
+ RestrictedTypes.newInt8Builder((Int8TypeDefinition) baseType,
+ TypeUtils.typeEffectiveSchemaPath(ctx)));
+ } else if (baseType instanceof Int16TypeDefinition) {
+ return new IntegralTypeEffectiveStatementImpl<>(ctx,
+ RestrictedTypes.newInt16Builder((Int16TypeDefinition) baseType,
+ TypeUtils.typeEffectiveSchemaPath(ctx)));
+ } else if (baseType instanceof Int32TypeDefinition) {
+ return new IntegralTypeEffectiveStatementImpl<>(ctx,
+ RestrictedTypes.newInt32Builder((Int32TypeDefinition) baseType,
+ TypeUtils.typeEffectiveSchemaPath(ctx)));
+ } else if (baseType instanceof Int64TypeDefinition) {
+ return new IntegralTypeEffectiveStatementImpl<>(ctx,
+ RestrictedTypes.newInt64Builder((Int64TypeDefinition) baseType,
+ TypeUtils.typeEffectiveSchemaPath(ctx)));
+ } else if (baseType instanceof LeafrefTypeDefinition) {
+ return new LeafrefTypeEffectiveStatementImpl(ctx, (LeafrefTypeDefinition) baseType);
+ } else if (baseType instanceof StringTypeDefinition) {
+ return new StringTypeEffectiveStatementImpl(ctx, (StringTypeDefinition) baseType);
+ } else if (baseType instanceof Uint8TypeDefinition) {
+ return new IntegralTypeEffectiveStatementImpl<>(ctx,
+ RestrictedTypes.newUint8Builder((Uint8TypeDefinition) baseType,
+ TypeUtils.typeEffectiveSchemaPath(ctx)));
+ } else if (baseType instanceof Uint16TypeDefinition) {
+ return new IntegralTypeEffectiveStatementImpl<>(ctx,
+ RestrictedTypes.newUint16Builder((Uint16TypeDefinition) baseType,
+ TypeUtils.typeEffectiveSchemaPath(ctx)));
+ } else if (baseType instanceof Uint32TypeDefinition) {
+ return new IntegralTypeEffectiveStatementImpl<>(ctx,
+ RestrictedTypes.newUint32Builder((Uint32TypeDefinition) baseType,
+ TypeUtils.typeEffectiveSchemaPath(ctx)));
+ } else if (baseType instanceof Uint64TypeDefinition) {
+ return new IntegralTypeEffectiveStatementImpl<>(ctx,
+ RestrictedTypes.newUint64Builder((Uint64TypeDefinition) baseType,
+ TypeUtils.typeEffectiveSchemaPath(ctx)));
+ } else if (baseType instanceof UnionTypeDefinition) {
+ return new UnionTypeEffectiveStatementImpl(ctx, (UnionTypeDefinition) baseType);
+ } else {
+ throw new IllegalStateException("Unhandled base type " + baseType);
+ }
+ }
+
+ @Override
+ public final void onFullDefinitionDeclared(
+ final Mutable<String, TypeStatement, EffectiveStatement<String, TypeStatement>> stmt) {
+ super.onFullDefinitionDeclared(stmt);
+
+ // if it is yang built-in type, no prerequisite is needed, so simply return
+ if (TypeUtils.isYangBuiltInTypeString(stmt.getStatementArgument())) {
+ return;
+ }
+
+ final QName typeQName = StmtContextUtils.qnameFromArgument(stmt, stmt.getStatementArgument());
+ final ModelActionBuilder typeAction = stmt.newInferenceAction(ModelProcessingPhase.EFFECTIVE_MODEL);
+ final Prerequisite<StmtContext<?, ?, ?>> typePrereq = typeAction.requiresCtx(stmt, TypeNamespace.class,
+ typeQName, ModelProcessingPhase.EFFECTIVE_MODEL);
+ typeAction.mutatesEffectiveCtx(stmt.getParentContext());
+
+ /*
+ * If the type does not exist, throw new InferenceException.
+ * Otherwise perform no operation.
+ */
+ typeAction.apply(new InferenceAction() {
+ @Override
+ public void apply(final InferenceContext ctx) {
+ // Intentional NOOP
+ }
+
+ @Override
+ public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
+ InferenceException.throwIf(failed.contains(typePrereq), stmt.getStatementSourceReference(),
+ "Type [%s] was not found.", typeQName);
+ }
+ });
+ }
+
+ @Override
+ protected final SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+
+ @Override
+ public final String internArgument(final String rawArgument) {
+ final String found = TypeUtils.findBuiltinString(rawArgument);
+ return found != null ? found : rawArgument;
+ }
+
+ @Override
+ public boolean hasArgumentSpecificSupports() {
+ return !ARGUMENT_SPECIFIC_SUPPORTS.isEmpty();
+ }
+
+ @Override
+ public StatementSupport<?, ?, ?> getSupportSpecificForArgument(final String argument) {
+ return ARGUMENT_SPECIFIC_SUPPORTS.get(argument);
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.util.type.InvalidLengthConstraintException;
import org.opendaylight.yangtools.yang.model.util.type.LengthRestrictedTypeBuilder;
import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.length.LengthEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
-public final class BinaryTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, TypeStatement>
+final class BinaryTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, TypeStatement>
implements TypeEffectiveStatement<TypeStatement> {
private final BinaryTypeDefinition typeDefinition;
- public BinaryTypeEffectiveStatementImpl(
+ BinaryTypeEffectiveStatementImpl(
final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
final BinaryTypeDefinition baseType) {
super(ctx);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+import com.google.common.annotations.VisibleForTesting;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.BitsTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.bit.BitEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-public final class BitsSpecificationEffectiveStatementImpl extends
+@VisibleForTesting
+// FIXME: hide this class
+public final class BitsSpecificationEffectiveStatement extends
DeclaredEffectiveStatementBase<String, BitsSpecification> implements TypeEffectiveStatement<BitsSpecification> {
private final BitsTypeDefinition typeDefinition;
- public BitsSpecificationEffectiveStatementImpl(
+ BitsSpecificationEffectiveStatement(
final StmtContext<String, BitsSpecification, EffectiveStatement<String, BitsSpecification>> ctx) {
super(ctx);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.BitsSpecification;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+public class BitsSpecificationImpl extends AbstractDeclaredStatement<String> implements BitsSpecification {
+ protected BitsSpecificationImpl(final StmtContext<String, BitsSpecification, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getName() {
+ return argument();
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends BitStatement> getBits() {
+ return allDeclared(BitStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.BitsSpecification;
+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;
+
+final class BitsSpecificationSupport
+ extends AbstractStatementSupport<String, BitsSpecification, EffectiveStatement<String, BitsSpecification>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.TYPE)
+ .addMultiple(YangStmtMapping.BIT)
+ .build();
+
+ BitsSpecificationSupport() {
+ super(YangStmtMapping.TYPE);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public BitsSpecification createDeclared(final StmtContext<String, BitsSpecification, ?> ctx) {
+ return new BitsSpecificationImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, BitsSpecification> createEffective(
+ final StmtContext<String, BitsSpecification, EffectiveStatement<String, BitsSpecification>> ctx) {
+ return new BitsSpecificationEffectiveStatement(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
import org.opendaylight.yangtools.yang.model.util.type.BitsTypeBuilder;
import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.bit.BitEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-public final class BitsTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, TypeStatement>
+final class BitsTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, TypeStatement>
implements TypeEffectiveStatement<TypeStatement> {
private final BitsTypeDefinition typeDefinition;
- public BitsTypeEffectiveStatementImpl(
+ BitsTypeEffectiveStatementImpl(
final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
final BitsTypeDefinition baseType) {
super(ctx);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
-public final class BooleanTypeEffectiveStatementImpl extends AbstractTypeEffectiveStatement<BooleanTypeDefinition> {
- public BooleanTypeEffectiveStatementImpl(
+final class BooleanTypeEffectiveStatementImpl extends AbstractTypeEffectiveStatement<BooleanTypeDefinition> {
+ BooleanTypeEffectiveStatementImpl(
final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
final BooleanTypeDefinition baseType) {
super(ctx, RestrictedTypes.newBooleanBuilder(baseType, TypeUtils.typeEffectiveSchemaPath(ctx)));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import static java.util.Objects.requireNonNull;
/**
* Common shared effective statements for built-in types.
*/
-public enum BuiltinEffectiveStatement implements TypeEffectiveStatement<TypeStatement> {
+enum BuiltinEffectiveStatement implements TypeEffectiveStatement<TypeStatement> {
BINARY(BaseTypes.binaryType()),
BOOLEAN(BaseTypes.booleanType()),
EMPTY(BaseTypes.emptyType()),
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import static java.util.Objects.requireNonNull;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
final class BuiltinTypeStatement implements TypeStatement {
private static final Map<String, BuiltinTypeStatement> BUILTINS;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+import com.google.common.annotations.VisibleForTesting;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.DecimalTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.range.RangeEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class Decimal64SpecificationEffectiveStatementImpl extends
- DeclaredEffectiveStatementBase<String, Decimal64Specification>
+// FIXME: hide this class
+@VisibleForTesting
+public final class Decimal64SpecificationEffectiveStatement
+ extends DeclaredEffectiveStatementBase<String, Decimal64Specification>
implements TypeEffectiveStatement<Decimal64Specification> {
private final DecimalTypeDefinition typeDefinition;
- public Decimal64SpecificationEffectiveStatementImpl(
+ Decimal64SpecificationEffectiveStatement(
final StmtContext<String, Decimal64Specification, EffectiveStatement<String, Decimal64Specification>> ctx) {
super(ctx);
final DecimalTypeBuilder builder = BaseTypes.decimalTypeBuilder(ctx.getSchemaPath().get());
-
for (final EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
if (stmt instanceof FractionDigitsEffectiveStatement) {
builder.setFractionDigits(((FractionDigitsEffectiveStatement) stmt).argument());
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.Decimal64Specification;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class Decimal64SpecificationImpl extends AbstractDeclaredStatement<String> implements Decimal64Specification {
+ Decimal64SpecificationImpl(final StmtContext<String, Decimal64Specification, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getName() {
+ return argument();
+ }
+
+ @Nonnull
+ @Override
+ public FractionDigitsStatement getFractionDigits() {
+ return firstDeclared(FractionDigitsStatement.class);
+ }
+
+ @Override
+ public RangeStatement getRange() {
+ return firstDeclared(RangeStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.Decimal64Specification;
+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;
+
+final class Decimal64SpecificationSupport extends AbstractStatementSupport<String, Decimal64Specification,
+ EffectiveStatement<String, Decimal64Specification>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.TYPE)
+ .addMandatory(YangStmtMapping.FRACTION_DIGITS)
+ .addOptional(YangStmtMapping.RANGE)
+ .build();
+
+ Decimal64SpecificationSupport() {
+ super(YangStmtMapping.TYPE);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public Decimal64Specification createDeclared(final StmtContext<String, Decimal64Specification, ?> ctx) {
+ return new Decimal64SpecificationImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, Decimal64Specification> createEffective(final StmtContext<String,
+ Decimal64Specification, EffectiveStatement<String, Decimal64Specification>> ctx) {
+ return new Decimal64SpecificationEffectiveStatement(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import java.math.BigDecimal;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.RangeRestrictedTypeBuilder;
import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.range.RangeEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
-public final class DecimalTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, TypeStatement>
+final class DecimalTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, TypeStatement>
implements TypeEffectiveStatement<TypeStatement> {
private final DecimalTypeDefinition typeDefinition;
- public DecimalTypeEffectiveStatementImpl(
+ DecimalTypeEffectiveStatementImpl(
final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
final DecimalTypeDefinition baseType) {
super(ctx);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
import org.opendaylight.yangtools.yang.model.util.type.BitBuilder;
import org.opendaylight.yangtools.yang.model.util.type.EnumPairBuilder;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.bit.BitEffectiveStatementImpl;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.enum_.EnumEffectiveStatementImpl;
+@Beta
final class EffectiveTypeUtil {
private EffectiveTypeUtil() {
throw new UnsupportedOperationException();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
-public final class EmptyTypeEffectiveStatementImpl extends AbstractTypeEffectiveStatement<EmptyTypeDefinition> {
- public EmptyTypeEffectiveStatementImpl(
+final class EmptyTypeEffectiveStatementImpl extends AbstractTypeEffectiveStatement<EmptyTypeDefinition> {
+ EmptyTypeEffectiveStatementImpl(
final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
final EmptyTypeDefinition baseType) {
super(ctx, RestrictedTypes.newEmptyBuilder(baseType, TypeUtils.typeEffectiveSchemaPath(ctx)));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+import com.google.common.annotations.VisibleForTesting;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.EnumerationTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.enum_.EnumEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-public final class EnumSpecificationEffectiveStatementImpl extends
+@VisibleForTesting
+// FIXME: hide this class
+public final class EnumSpecificationEffectiveStatement extends
DeclaredEffectiveStatementBase<String, EnumSpecification> implements
TypeEffectiveStatement<EnumSpecification> {
private final EnumTypeDefinition typeDefinition;
- public EnumSpecificationEffectiveStatementImpl(
+ EnumSpecificationEffectiveStatement(
final StmtContext<String, EnumSpecification, EffectiveStatement<String, EnumSpecification>> ctx) {
super(ctx);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.EnumSpecification;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class EnumSpecificationImpl extends AbstractDeclaredStatement<String> implements EnumSpecification {
+ EnumSpecificationImpl(final StmtContext<String, EnumSpecification, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getName() {
+ return argument();
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends EnumStatement> getEnums() {
+ return allDeclared(EnumStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.EnumSpecification;
+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;
+
+final class EnumSpecificationSupport
+ extends AbstractStatementSupport<String, EnumSpecification, EffectiveStatement<String, EnumSpecification>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .TYPE)
+ .addMultiple(YangStmtMapping.ENUM)
+ .build();
+
+ EnumSpecificationSupport() {
+ super(YangStmtMapping.TYPE);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public EnumSpecification createDeclared(final StmtContext<String, EnumSpecification, ?> ctx) {
+ return new EnumSpecificationImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, EnumSpecification> createEffective(
+ final StmtContext<String, EnumSpecification, EffectiveStatement<String, EnumSpecification>> ctx) {
+ return new EnumSpecificationEffectiveStatement(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
import org.opendaylight.yangtools.yang.model.util.type.EnumerationTypeBuilder;
import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.enum_.EnumEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-public final class EnumTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, TypeStatement>
+final class EnumTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, TypeStatement>
implements TypeEffectiveStatement<TypeStatement> {
private final EnumTypeDefinition typeDefinition;
- public EnumTypeEffectiveStatementImpl(
+ EnumTypeEffectiveStatementImpl(
final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
final EnumTypeDefinition baseType) {
super(ctx);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.IdentityrefTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class IdentityRefSpecificationEffectiveStatementImpl extends
+// FIXME: hide this class
+public final class IdentityRefSpecificationEffectiveStatement extends
DeclaredEffectiveStatementBase<String, IdentityRefSpecification> implements
TypeEffectiveStatement<IdentityRefSpecification> {
private final IdentityrefTypeDefinition typeDefinition;
- public IdentityRefSpecificationEffectiveStatementImpl(final StmtContext<String, IdentityRefSpecification,
+ IdentityRefSpecificationEffectiveStatement(final StmtContext<String, IdentityRefSpecification,
EffectiveStatement<String, IdentityRefSpecification>> ctx) {
super(ctx);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.IdentityRefSpecification;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class IdentityRefSpecificationImpl extends AbstractDeclaredStatement<String> implements IdentityRefSpecification {
+ IdentityRefSpecificationImpl(final StmtContext<String, IdentityRefSpecification, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getName() {
+ return argument();
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends BaseStatement> getBases() {
+ return allDeclared(BaseStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+final class IdentityRefSpecificationRFC6020Support extends AbstractIdentityRefSpecificationSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .TYPE)
+ .addMandatory(YangStmtMapping.BASE)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
-
-import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.IdentityRefSpecificationImpl;
/**
* Class providing necessary support for processing YANG 1.1 identityref statement.
*/
-@Beta
-public class IdentityrefSpecificationRfc7950Support extends IdentityRefSpecificationImpl.Definition {
+final class IdentityrefSpecificationRFC7950Support extends AbstractIdentityRefSpecificationSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.TYPE)
.addMultiple(YangStmtMapping.BASE)
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
-public final class IdentityrefTypeEffectiveStatementImpl extends
- AbstractTypeEffectiveStatement<IdentityrefTypeDefinition> {
-
- public IdentityrefTypeEffectiveStatementImpl(
+final class IdentityrefTypeEffectiveStatementImpl extends AbstractTypeEffectiveStatement<IdentityrefTypeDefinition> {
+ IdentityrefTypeEffectiveStatementImpl(
final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
final IdentityrefTypeDefinition baseType) {
super(ctx, RestrictedTypes.newIdentityrefBuilder(baseType, TypeUtils.typeEffectiveSchemaPath(ctx)));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.InstanceIdentifierTypeBuilder;
import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class InstanceIdentifierSpecificationEffectiveStatementImpl
+final class InstanceIdentifierSpecificationEffectiveStatement
extends DeclaredEffectiveStatementBase<String, InstanceIdentifierSpecification>
implements TypeEffectiveStatement<InstanceIdentifierSpecification> {
private final InstanceIdentifierTypeDefinition typeDefinition;
- public InstanceIdentifierSpecificationEffectiveStatementImpl(final StmtContext<String,
+ InstanceIdentifierSpecificationEffectiveStatement(final StmtContext<String,
InstanceIdentifierSpecification, EffectiveStatement<String, InstanceIdentifierSpecification>> ctx) {
super(ctx);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.InstanceIdentifierSpecification;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class InstanceIdentifierSpecificationImpl extends AbstractDeclaredStatement<String>
+ implements InstanceIdentifierSpecification {
+ InstanceIdentifierSpecificationImpl(final StmtContext<String, InstanceIdentifierSpecification, ?> ctx) {
+ super(ctx);
+ }
+
+ @Nonnull
+ @Override
+ public String getName() {
+ return argument();
+ }
+
+ @Override
+ public RequireInstanceStatement getRequireInstance() {
+ return firstDeclared(RequireInstanceStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.InstanceIdentifierSpecification;
+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;
+
+final class InstanceIdentifierSpecificationSupport extends AbstractStatementSupport<String,
+ InstanceIdentifierSpecification, EffectiveStatement<String, InstanceIdentifierSpecification>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.TYPE)
+ .addOptional(YangStmtMapping.REQUIRE_INSTANCE)
+ .build();
+
+ InstanceIdentifierSpecificationSupport() {
+ super(YangStmtMapping.TYPE);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public InstanceIdentifierSpecification createDeclared(
+ final StmtContext<String, InstanceIdentifierSpecification, ?> ctx) {
+ return new InstanceIdentifierSpecificationImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, InstanceIdentifierSpecification> createEffective(
+ final StmtContext<String, InstanceIdentifierSpecification,
+ EffectiveStatement<String, InstanceIdentifierSpecification>> ctx) {
+ return new InstanceIdentifierSpecificationEffectiveStatement(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.InstanceIdentifierTypeBuilder;
import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
-public final class InstanceIdentifierTypeEffectiveStatementImpl
+final class InstanceIdentifierTypeEffectiveStatementImpl
extends DeclaredEffectiveStatementBase<String, TypeStatement> implements TypeEffectiveStatement<TypeStatement> {
private final InstanceIdentifierTypeDefinition typeDefinition;
- public InstanceIdentifierTypeEffectiveStatementImpl(
+ InstanceIdentifierTypeEffectiveStatementImpl(
final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
final InstanceIdentifierTypeDefinition baseType) {
super(ctx);
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
+import org.opendaylight.yangtools.yang.model.util.type.InvalidRangeConstraintException;
+import org.opendaylight.yangtools.yang.model.util.type.RangeRestrictedTypeBuilder;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.range.RangeEffectiveStatementImpl;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+final class IntegralTypeEffectiveStatementImpl<T extends RangeRestrictedTypeDefinition<T, N>,
+ N extends Number & Comparable<N>> extends DeclaredEffectiveStatementBase<String, TypeStatement>
+ implements TypeEffectiveStatement<TypeStatement> {
+
+ private final T typeDefinition;
+
+ IntegralTypeEffectiveStatementImpl(
+ final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
+ final RangeRestrictedTypeBuilder<T, N> builder) {
+ super(ctx);
+
+ for (EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
+ if (stmt instanceof RangeEffectiveStatementImpl) {
+ final RangeEffectiveStatementImpl rangeStmt = (RangeEffectiveStatementImpl)stmt;
+ builder.setRangeConstraint(rangeStmt, rangeStmt.argument());
+ }
+ if (stmt instanceof UnknownSchemaNode) {
+ builder.addUnknownSchemaNode((UnknownSchemaNode)stmt);
+ }
+ }
+
+ try {
+ typeDefinition = builder.build();
+ } catch (InvalidRangeConstraintException e) {
+ throw new SourceException(ctx.getStatementSourceReference(), e, "Invalid range constraint: %s",
+ e.getOffendingRanges());
+ }
+ }
+
+ @Nonnull
+ @Override
+ public T getTypeDefinition() {
+ return typeDefinition;
+ }
+}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+import com.google.common.annotations.VisibleForTesting;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.LeafrefTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class LeafrefSpecificationEffectiveStatementImpl
+@VisibleForTesting
+// FIXME: hide this class
+public final class LeafrefSpecificationEffectiveStatement
extends DeclaredEffectiveStatementBase<String, LeafrefSpecification>
implements TypeEffectiveStatement<LeafrefSpecification> {
private final LeafrefTypeDefinition typeDefinition;
- public LeafrefSpecificationEffectiveStatementImpl(final StmtContext<String, LeafrefSpecification,
+ LeafrefSpecificationEffectiveStatement(final StmtContext<String, LeafrefSpecification,
EffectiveStatement<String, LeafrefSpecification>> ctx) {
super(ctx);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.LeafrefSpecification;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class LeafrefSpecificationImpl extends AbstractDeclaredStatement<String> implements LeafrefSpecification {
+ LeafrefSpecificationImpl(final StmtContext<String, LeafrefSpecification, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getName() {
+ return argument();
+ }
+
+ @Nonnull
+ @Override
+ public PathStatement getPath() {
+ return firstDeclared(PathStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public RequireInstanceStatement getRequireInstance() {
+ return firstDeclared(RequireInstanceStatement.class);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+
+final class LeafrefSpecificationRFC6020Support extends AbstractLeafrefSpecificationSupport {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .TYPE)
+ .addMandatory(YangStmtMapping.PATH)
+ .build();
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
-
-import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.LeafrefSpecificationImpl;
/**
* Class providing necessary support for processing YANG 1.1 leafref statement.
*/
-@Beta
-public class LeafrefSpecificationRfc7950Support extends LeafrefSpecificationImpl.Definition {
+final class LeafrefSpecificationRFC7950Support extends AbstractLeafrefSpecificationSupport {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.TYPE)
.addMandatory(YangStmtMapping.PATH)
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.RequireInstanceRestrictedTypeBuilder;
import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
-public final class LeafrefTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, TypeStatement>
+final class LeafrefTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, TypeStatement>
implements TypeEffectiveStatement<TypeStatement> {
private final LeafrefTypeDefinition typeDefinition;
- public LeafrefTypeEffectiveStatementImpl(
+ LeafrefTypeEffectiveStatementImpl(
final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
final LeafrefTypeDefinition baseType) {
super(ctx);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.util.type.InvalidLengthConstraintException;
import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes;
import org.opendaylight.yangtools.yang.model.util.type.StringTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.length.LengthEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class StringTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, TypeStatement>
+final class StringTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, TypeStatement>
implements TypeEffectiveStatement<TypeStatement> {
private static final Logger LOG = LoggerFactory.getLogger(StringTypeEffectiveStatementImpl.class);
private final StringTypeDefinition typeDefinition;
- public StringTypeEffectiveStatementImpl(
+ StringTypeEffectiveStatementImpl(
final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
final StringTypeDefinition baseType) {
super(ctx);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class TypeStatementImpl extends AbstractDeclaredStatement<String> implements TypeStatement {
+ TypeStatementImpl(final StmtContext<String, TypeStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getName() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+public final class TypeStatementRFC6020Support extends AbstractTypeStatementSupport {
+
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableMap;
import java.util.Map;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeStatementImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
/**
* Class providing necessary support for processing YANG 1.1 Type statement.
*/
@Beta
-public final class TypeStatementRfc7950Support extends TypeStatementImpl.Definition {
- private static final Map<String, StatementSupport<?, ?, ?>> ARGUMENT_SPECIFIC_SUPPORTS =
- ImmutableMap.<String, StatementSupport<?, ?, ?>>of(
- TypeUtils.LEAF_REF, new LeafrefSpecificationRfc7950Support(),
- TypeUtils.IDENTITY_REF, new IdentityrefSpecificationRfc7950Support());
+public final class TypeStatementRFC7950Support extends AbstractTypeStatementSupport {
+ private static final Map<String, StatementSupport<?, ?, ?>> ARGUMENT_SPECIFIC_SUPPORTS = ImmutableMap.of(
+ TypeUtils.LEAF_REF, new LeafrefSpecificationRFC7950Support(),
+ TypeUtils.IDENTITY_REF, new IdentityrefSpecificationRFC7950Support());
@Override
public boolean hasArgumentSpecificSupports() {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+import com.google.common.annotations.VisibleForTesting;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.UnionTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class UnionSpecificationEffectiveStatementImpl extends
+@VisibleForTesting
+// FIXME: hide this class
+public final class UnionSpecificationEffectiveStatement extends
DeclaredEffectiveStatementBase<String, UnionSpecification> implements
TypeEffectiveStatement<UnionSpecification> {
private final UnionTypeDefinition typeDefinition;
- public UnionSpecificationEffectiveStatementImpl(
+ UnionSpecificationEffectiveStatement(
final StmtContext<String, UnionSpecification, EffectiveStatement<String, UnionSpecification>> ctx) {
super(ctx);
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.UnionSpecification;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class UnionSpecificationImpl extends AbstractDeclaredStatement<String> implements UnionSpecification {
+ UnionSpecificationImpl(final StmtContext<String, UnionSpecification, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getName() {
+ return argument();
+ }
+
+ @Nonnull
+ @Override
+ public Collection<? extends TypeStatement> getTypes() {
+ return allDeclared(TypeStatement.class);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.UnionSpecification;
+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;
+
+final class UnionSpecificationSupport extends
+ AbstractStatementSupport<String, UnionSpecification, EffectiveStatement<String, UnionSpecification>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .TYPE)
+ .addMultiple(YangStmtMapping.TYPE)
+ .build();
+
+ UnionSpecificationSupport() {
+ super(YangStmtMapping.TYPE);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public UnionSpecification createDeclared(final StmtContext<String, UnionSpecification, ?> ctx) {
+ return new UnionSpecificationImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, UnionSpecification> createEffective(
+ final StmtContext<String, UnionSpecification, EffectiveStatement<String, UnionSpecification>> ctx) {
+ return new UnionSpecificationEffectiveStatement(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
-public final class UnionTypeEffectiveStatementImpl extends AbstractTypeEffectiveStatement<UnionTypeDefinition> {
- public UnionTypeEffectiveStatementImpl(
+final class UnionTypeEffectiveStatementImpl extends AbstractTypeEffectiveStatement<UnionTypeDefinition> {
+ UnionTypeEffectiveStatementImpl(
final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
final UnionTypeDefinition baseType) {
super(ctx, RestrictedTypes.newUnionBuilder(baseType, TypeUtils.typeEffectiveSchemaPath(ctx)));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.typedef;
import java.util.Collection;
import java.util.Map;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.type.DerivedTypeBuilder;
import org.opendaylight.yangtools.yang.model.util.type.DerivedTypes;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.AbstractEffectiveSchemaNode;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveSchemaNode;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class TypeDefEffectiveStatementImpl extends AbstractEffectiveSchemaNode<TypedefStatement> implements
+// FIXME: hide this class
+public final class TypedefEffectiveStatementImpl extends AbstractEffectiveSchemaNode<TypedefStatement> implements
TypedefEffectiveStatement {
- private static final Logger LOG = LoggerFactory.getLogger(TypeDefEffectiveStatementImpl.class);
+ private static final Logger LOG = LoggerFactory.getLogger(TypedefEffectiveStatementImpl.class);
private final TypeDefinition<?> typeDefinition;
private TypeEffectiveStatement<TypeStatement> typeStatement;
- public TypeDefEffectiveStatementImpl(final StmtContext<QName, TypedefStatement, ?> ctx) {
+ TypedefEffectiveStatementImpl(final StmtContext<QName, TypedefStatement, ?> ctx) {
super(ctx);
final TypeEffectiveStatement<?> typeEffectiveStmt = firstSubstatementOfType(TypeEffectiveStatement.class);
@Override
public <K, V, N extends IdentifierNamespace<K, V>> V get(@Nonnull final Class<N> namespace,
@Nonnull final K identifier) {
- return TypeDefEffectiveStatementImpl.this.get(namespace, identifier);
+ return TypedefEffectiveStatementImpl.this.get(namespace, identifier);
}
@Override
public <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(@Nonnull final Class<N> namespace) {
- return TypeDefEffectiveStatementImpl.this.getAll(namespace);
+ return TypedefEffectiveStatementImpl.this.getAll(namespace);
}
@Nonnull
@Override
public Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
- return TypeDefEffectiveStatementImpl.this.effectiveSubstatements();
+ return TypedefEffectiveStatementImpl.this.effectiveSubstatements();
}
@Nonnull
@Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
- return TypeDefEffectiveStatementImpl.this.getTypeDefinition();
+ return TypedefEffectiveStatementImpl.this.getTypeDefinition();
}
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.typedef;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class TypedefStatementImpl extends AbstractDeclaredStatement<QName> implements TypedefStatement {
+ TypedefStatementImpl(final StmtContext<QName, TypedefStatement, ?> context) {
+ super(context);
+ }
+
+ @Nullable
+ @Override
+ public StatusStatement getStatus() {
+ return firstDeclared(StatusStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public TypeStatement getType() {
+ return firstDeclared(TypeStatement.class);
+ }
+
+ @Override
+ public UnitsStatement getUnits() {
+ return firstDeclared(UnitsStatement.class);
+ }
+
+ @Nonnull
+ @Override
+ public QName getName() {
+ return argument();
+ }
+
+ @Nullable
+ @Override
+ public DefaultStatement getDefault() {
+ return firstDeclared(DefaultStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.typedef;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.parser.spi.TypeNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+public final class TypedefStatementSupport extends
+ AbstractQNameStatementSupport<TypedefStatement, EffectiveStatement<QName, TypedefStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.TYPEDEF)
+ .addOptional(YangStmtMapping.DEFAULT)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addMandatory(YangStmtMapping.TYPE)
+ .addOptional(YangStmtMapping.UNITS)
+ .build();
+
+ public TypedefStatementSupport() {
+ super(YangStmtMapping.TYPEDEF);
+ }
+
+ @Override
+ public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public TypedefStatement createDeclared(final StmtContext<QName, TypedefStatement, ?> ctx) {
+ return new TypedefStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<QName, TypedefStatement> createEffective(
+ final StmtContext<QName, TypedefStatement, EffectiveStatement<QName, TypedefStatement>> ctx) {
+ return new TypedefEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, TypedefStatement,
+ EffectiveStatement<QName, TypedefStatement>> stmt) {
+ super.onFullDefinitionDeclared(stmt);
+
+ if (stmt != null && stmt.getParentContext() != null) {
+ final StmtContext<?, TypedefStatement, TypedefEffectiveStatement> existing = stmt.getParentContext()
+ .getFromNamespace(TypeNamespace.class, stmt.getStatementArgument());
+ SourceException.throwIf(existing != null, stmt.getStatementSourceReference(),
+ "Duplicate name for typedef %s", stmt.getStatementArgument());
+
+ stmt.getParentContext().addContext(TypeNamespace.class, stmt.getStatementArgument(), stmt);
+ }
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.unique;
import java.util.Collection;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Relative;
import org.opendaylight.yangtools.yang.model.api.stmt.UniqueEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class UniqueEffectiveStatementImpl
- extends DeclaredEffectiveStatementBase<Collection<Relative>, UniqueStatement>
+final class UniqueEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Collection<Relative>, UniqueStatement>
implements UniqueConstraint, UniqueEffectiveStatement {
- public UniqueEffectiveStatementImpl(final StmtContext<Collection<Relative>, UniqueStatement, ?> ctx) {
+ UniqueEffectiveStatementImpl(final StmtContext<Collection<Relative>, UniqueStatement, ?> ctx) {
super(ctx);
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.unique;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Relative;
+import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class UniqueStatementImpl extends AbstractDeclaredStatement<Collection<SchemaNodeIdentifier.Relative>>
+ implements UniqueStatement {
+ UniqueStatementImpl(final StmtContext<Collection<SchemaNodeIdentifier.Relative>, UniqueStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public Collection<Relative> getTag() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.unique;
+
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableSet;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Relative;
+import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+
+public final class UniqueStatementSupport
+ extends AbstractStatementSupport<Collection<SchemaNodeIdentifier.Relative>, UniqueStatement,
+ EffectiveStatement<Collection<SchemaNodeIdentifier.Relative>, UniqueStatement>> {
+ private static final Splitter SPACE_SPLITTER = Splitter.on(' ').omitEmptyStrings().trimResults();
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.UNIQUE)
+ .build();
+
+ public UniqueStatementSupport() {
+ super(YangStmtMapping.UNIQUE);
+ }
+
+ @Override
+ public Collection<SchemaNodeIdentifier.Relative> parseArgumentValue(final StmtContext<?, ?, ?> ctx,
+ final String value) {
+ final Collection<Relative> uniqueConstraints = parseUniqueConstraintArgument(ctx, value);
+ SourceException.throwIf(uniqueConstraints.isEmpty(), ctx.getStatementSourceReference(),
+ "Invalid argument value '%s' of unique statement. The value must contains at least "
+ + "one descendant schema node identifier.", value);
+ return uniqueConstraints;
+ }
+
+ @Override
+ public UniqueStatement createDeclared(final StmtContext<Collection<Relative>, UniqueStatement, ?> ctx) {
+ return new UniqueStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<Collection<Relative>, UniqueStatement> createEffective(
+ final StmtContext<Collection<Relative>, UniqueStatement,
+ EffectiveStatement<Collection<Relative>, UniqueStatement>> ctx) {
+ return new UniqueEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+
+ private static Collection<SchemaNodeIdentifier.Relative> parseUniqueConstraintArgument(
+ final StmtContext<?, ?, ?> ctx, final String argumentValue) {
+ final Set<SchemaNodeIdentifier.Relative> uniqueConstraintNodes = new HashSet<>();
+ for (final String uniqueArgToken : SPACE_SPLITTER.split(argumentValue)) {
+ final SchemaNodeIdentifier nodeIdentifier = Utils.nodeIdentifierFromPath(ctx, uniqueArgToken);
+ SourceException.throwIf(nodeIdentifier.isAbsolute(), ctx.getStatementSourceReference(),
+ "Unique statement argument '%s' contains schema node identifier '%s' "
+ + "which is not in the descendant node identifier form.", argumentValue, uniqueArgToken);
+ uniqueConstraintNodes.add((SchemaNodeIdentifier.Relative) nodeIdentifier);
+ }
+ return ImmutableSet.copyOf(uniqueConstraintNodes);
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.units;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class UnitsEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, UnitsStatement>
+final class UnitsEffectiveStatementImpl extends DeclaredEffectiveStatementBase<String, UnitsStatement>
implements UnitsEffectiveStatement {
- public UnitsEffectiveStatementImpl(final StmtContext<String, UnitsStatement, ?> ctx) {
+ UnitsEffectiveStatementImpl(final StmtContext<String, UnitsStatement, ?> ctx) {
super(ctx);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.units;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class UnitsStatementImpl extends AbstractDeclaredStatement<String> implements UnitsStatement {
+ UnitsStatementImpl(final StmtContext<String, UnitsStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public String getName() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.units;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
+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;
+
+public final class UnitsStatementSupport
+ extends AbstractStatementSupport<String, UnitsStatement, EffectiveStatement<String, UnitsStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.UNITS)
+ .build();
+
+ public UnitsStatementSupport() {
+ super(YangStmtMapping.UNITS);
+ }
+
+ @Override
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return value;
+ }
+
+ @Override
+ public UnitsStatement createDeclared(
+ final StmtContext<String, UnitsStatement, ?> ctx) {
+ return new UnitsStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<String, UnitsStatement> createEffective(
+ final StmtContext<String, UnitsStatement, EffectiveStatement<String, UnitsStatement>> ctx) {
+ return new UnitsEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.uses;
import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
-import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace.ValidationBundleType;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UsesEffectiveStatementImpl;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangValidationBundles;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implements UsesStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .USES)
- .addAny(YangStmtMapping.AUGMENT)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addAny(YangStmtMapping.REFINE)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addOptional(YangStmtMapping.WHEN)
- .build();
-
+final class UsesStatementImpl extends AbstractDeclaredStatement<QName> implements UsesStatement {
private static final Logger LOG = LoggerFactory.getLogger(UsesStatementImpl.class);
- protected UsesStatementImpl(final StmtContext<QName, UsesStatement, ?> context) {
+ UsesStatementImpl(final StmtContext<QName, UsesStatement, ?> context) {
super(context);
}
- public static class Definition extends
- AbstractQNameStatementSupport<UsesStatement, EffectiveStatement<QName, UsesStatement>> {
-
- public Definition() {
- super(YangStmtMapping.USES);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public void onFullDefinitionDeclared(
- final Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode) {
- if (!usesNode.isSupportedByFeatures()) {
- return;
- }
- super.onFullDefinitionDeclared(usesNode);
-
- final ModelActionBuilder usesAction = usesNode.newInferenceAction(ModelProcessingPhase.EFFECTIVE_MODEL);
- final QName groupingName = usesNode.getStatementArgument();
-
- final Prerequisite<StmtContext<?, ?, ?>> sourceGroupingPre = usesAction.requiresCtx(usesNode,
- GroupingNamespace.class, groupingName, ModelProcessingPhase.EFFECTIVE_MODEL);
- final Prerequisite<? extends StmtContext.Mutable<?, ?, ?>> targetNodePre = usesAction.mutatesEffectiveCtx(
- usesNode.getParentContext());
-
- usesAction.apply(new InferenceAction() {
-
- @Override
- public void apply(final InferenceContext ctx) {
- final StatementContextBase<?, ?, ?> targetNodeStmtCtx =
- (StatementContextBase<?, ?, ?>) targetNodePre.resolve(ctx);
- final StatementContextBase<?, ?, ?> sourceGrpStmtCtx =
- (StatementContextBase<?, ?, ?>) sourceGroupingPre.resolve(ctx);
-
- try {
- copyFromSourceToTarget(sourceGrpStmtCtx, targetNodeStmtCtx, usesNode);
- resolveUsesNode(usesNode, targetNodeStmtCtx);
- StmtContextUtils.validateIfFeatureAndWhenOnListKeys(usesNode);
- } catch (final SourceException e) {
- LOG.warn(e.getMessage(), e);
- throw e;
- }
- }
-
- @Override
- public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
- InferenceException.throwIf(failed.contains(sourceGroupingPre),
- usesNode.getStatementSourceReference(), "Grouping '%s' was not resolved.", groupingName);
- throw new InferenceException("Unknown error occurred.", usesNode.getStatementSourceReference());
- }
- });
- }
-
- @Override
- public UsesStatement createDeclared(final StmtContext<QName, UsesStatement, ?> ctx) {
- return new UsesStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, UsesStatement> createEffective(
- final StmtContext<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> ctx) {
- return new UsesEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
- }
-
@Nonnull
@Override
public QName getName() {
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.uses;
+
+import java.util.Collection;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
+import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UsesEffectiveStatementImpl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public final class UsesStatementSupport extends
+ AbstractQNameStatementSupport<UsesStatement, EffectiveStatement<QName, UsesStatement>> {
+ private static final Logger LOG = LoggerFactory.getLogger(UsesStatementSupport.class);
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .USES)
+ .addAny(YangStmtMapping.AUGMENT)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addAny(YangStmtMapping.REFINE)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addOptional(YangStmtMapping.WHEN)
+ .build();
+
+ public UsesStatementSupport() {
+ super(YangStmtMapping.USES);
+ }
+
+ @Override
+ public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return StmtContextUtils.qnameFromArgument(ctx, value);
+ }
+
+ @Override
+ public void onFullDefinitionDeclared(
+ final Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode) {
+ if (!usesNode.isSupportedByFeatures()) {
+ return;
+ }
+ super.onFullDefinitionDeclared(usesNode);
+
+ final ModelActionBuilder usesAction = usesNode.newInferenceAction(ModelProcessingPhase.EFFECTIVE_MODEL);
+ final QName groupingName = usesNode.getStatementArgument();
+
+ final Prerequisite<StmtContext<?, ?, ?>> sourceGroupingPre = usesAction.requiresCtx(usesNode,
+ GroupingNamespace.class, groupingName, ModelProcessingPhase.EFFECTIVE_MODEL);
+ final Prerequisite<? extends StmtContext.Mutable<?, ?, ?>> targetNodePre = usesAction.mutatesEffectiveCtx(
+ usesNode.getParentContext());
+
+ usesAction.apply(new InferenceAction() {
+
+ @Override
+ public void apply(final InferenceContext ctx) {
+ final StatementContextBase<?, ?, ?> targetNodeStmtCtx =
+ (StatementContextBase<?, ?, ?>) targetNodePre.resolve(ctx);
+ final StatementContextBase<?, ?, ?> sourceGrpStmtCtx =
+ (StatementContextBase<?, ?, ?>) sourceGroupingPre.resolve(ctx);
+
+ try {
+ UsesStatementImpl.copyFromSourceToTarget(sourceGrpStmtCtx, targetNodeStmtCtx, usesNode);
+ UsesStatementImpl.resolveUsesNode(usesNode, targetNodeStmtCtx);
+ StmtContextUtils.validateIfFeatureAndWhenOnListKeys(usesNode);
+ } catch (final SourceException e) {
+ LOG.warn(e.getMessage(), e);
+ throw e;
+ }
+ }
+
+ @Override
+ public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
+ InferenceException.throwIf(failed.contains(sourceGroupingPre),
+ usesNode.getStatementSourceReference(), "Grouping '%s' was not resolved.", groupingName);
+ throw new InferenceException("Unknown error occurred.", usesNode.getStatementSourceReference());
+ }
+ });
+ }
+
+ @Override
+ public UsesStatement createDeclared(final StmtContext<QName, UsesStatement, ?> ctx) {
+ return new UsesStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<QName, UsesStatement> createEffective(
+ final StmtContext<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> ctx) {
+ return new UsesEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.value;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class ValueEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Integer, ValueStatement>
+final class ValueEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Integer, ValueStatement>
implements ValueEffectiveStatement {
- public ValueEffectiveStatementImpl(final StmtContext<Integer, ValueStatement, ?> ctx) {
+ ValueEffectiveStatementImpl(final StmtContext<Integer, ValueStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.value;
+
+import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class ValueStatementImpl extends AbstractDeclaredStatement<Integer> implements ValueStatement {
+ ValueStatementImpl(final StmtContext<Integer, ValueStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public int getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.value;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+public final class ValueStatementSupport extends
+ AbstractStatementSupport<Integer, ValueStatement, EffectiveStatement<Integer, ValueStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.VALUE).build();
+
+ public ValueStatementSupport() {
+ super(YangStmtMapping.VALUE);
+ }
+
+ @Override
+ public Integer parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ try {
+ return Integer.valueOf(value);
+ } catch (NumberFormatException e) {
+ throw new SourceException(ctx.getStatementSourceReference(), e,
+ "%s is not valid value statement integer argument in a range of -2147483648..2147483647", value);
+ }
+ }
+
+ @Override
+ public ValueStatement createDeclared(final StmtContext<Integer, ValueStatement, ?> ctx) {
+ return new ValueStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<Integer, ValueStatement> createEffective(
+ final StmtContext<Integer, ValueStatement, EffectiveStatement<Integer, ValueStatement>> ctx) {
+ return new ValueEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.when;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class WhenEffectiveStatementImpl
- extends DeclaredEffectiveStatementBase<RevisionAwareXPath, WhenStatement> implements WhenEffectiveStatement {
- public WhenEffectiveStatementImpl(final StmtContext<RevisionAwareXPath, WhenStatement, ?> ctx) {
+final class WhenEffectiveStatementImpl extends DeclaredEffectiveStatementBase<RevisionAwareXPath, WhenStatement>
+ implements WhenEffectiveStatement {
+ WhenEffectiveStatementImpl(final StmtContext<RevisionAwareXPath, WhenStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.when;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class WhenStatementImpl extends AbstractDeclaredStatement<RevisionAwareXPath> implements WhenStatement {
+ WhenStatementImpl(final StmtContext<RevisionAwareXPath, WhenStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public RevisionAwareXPath getCondition() {
+ return argument();
+ }
+
+ @Nullable
+ @Override
+ public DescriptionStatement getDescription() {
+ return firstDeclared(DescriptionStatement.class);
+ }
+
+ @Nullable
+ @Override
+ public ReferenceStatement getReference() {
+ return firstDeclared(ReferenceStatement.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.when;
+
+import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+
+public final class WhenStatementSupport extends AbstractStatementSupport<RevisionAwareXPath, WhenStatement,
+ EffectiveStatement<RevisionAwareXPath, WhenStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.WHEN)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .build();
+
+ public WhenStatementSupport() {
+ super(YangStmtMapping.WHEN);
+ }
+
+ @Override
+ public RevisionAwareXPath parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return Utils.parseXPath(ctx, value);
+ }
+
+ @Override
+ public WhenStatement createDeclared(final StmtContext<RevisionAwareXPath, WhenStatement, ?> ctx) {
+ return new WhenStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<RevisionAwareXPath, WhenStatement> createEffective(
+ final StmtContext<RevisionAwareXPath, WhenStatement,
+ EffectiveStatement<RevisionAwareXPath, WhenStatement>> ctx) {
+ return new WhenEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.yang_version;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class YangVersionEffectiveStatementImpl
- extends DeclaredEffectiveStatementBase<YangVersion, YangVersionStatement>
+final class YangVersionEffectiveStatementImpl extends DeclaredEffectiveStatementBase<YangVersion, YangVersionStatement>
implements YangVersionEffectiveStatement {
- public YangVersionEffectiveStatementImpl(final StmtContext<YangVersion, YangVersionStatement, ?> ctx) {
+ YangVersionEffectiveStatementImpl(final StmtContext<YangVersion, YangVersionStatement, ?> ctx) {
super(ctx);
}
}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.yang_version;
+
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.YangVersion;
+import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class YangVersionStatementImpl extends AbstractDeclaredStatement<YangVersion> implements YangVersionStatement {
+ YangVersionStatementImpl(final StmtContext<YangVersion, YangVersionStatement, ?> context) {
+ super(context);
+ }
+
+ @Nonnull
+ @Override
+ public YangVersion getValue() {
+ return argument();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.yang_version;
+
+import org.opendaylight.yangtools.yang.common.YangVersion;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+
+public final class YangVersionStatementSupport extends AbstractStatementSupport<YangVersion, YangVersionStatement,
+ EffectiveStatement<YangVersion, YangVersionStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
+ .YANG_VERSION)
+ .build();
+
+ public YangVersionStatementSupport() {
+ super(YangStmtMapping.YANG_VERSION);
+ }
+
+ @Override
+ public YangVersion parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return SourceException.unwrap(YangVersion.parse(value), ctx.getStatementSourceReference(),
+ "Unsupported YANG version %s", value);
+ }
+
+ @Override
+ public YangVersionStatement createDeclared(final StmtContext<YangVersion, YangVersionStatement, ?> ctx) {
+ return new YangVersionStatementImpl(ctx);
+ }
+
+ @Override
+ public void onPreLinkageDeclared(final Mutable<YangVersion, YangVersionStatement,
+ EffectiveStatement<YangVersion, YangVersionStatement>> stmt) {
+ stmt.setRootVersion(stmt.getStatementArgument());
+ }
+
+ @Override
+ public EffectiveStatement<YangVersion, YangVersionStatement> createEffective(final StmtContext<YangVersion,
+ YangVersionStatement, EffectiveStatement<YangVersion, YangVersionStatement>> ctx) {
+ return new YangVersionEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.yin_element;
import org.opendaylight.yangtools.yang.model.api.stmt.YinElementEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-public final class YinElementEffectiveStatementImpl
- extends DeclaredEffectiveStatementBase<Boolean, YinElementStatement>
+final class YinElementEffectiveStatementImpl extends DeclaredEffectiveStatementBase<Boolean, YinElementStatement>
implements YinElementEffectiveStatement {
- public YinElementEffectiveStatementImpl(final StmtContext<Boolean, YinElementStatement, ?> ctx) {
+ YinElementEffectiveStatementImpl(final StmtContext<Boolean, YinElementStatement, ?> ctx) {
super(ctx);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.yin_element;
+
+import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+
+final class YinElementStatementImpl extends AbstractDeclaredStatement<Boolean> implements YinElementStatement {
+ YinElementStatementImpl(final StmtContext<Boolean, YinElementStatement, ?> context) {
+ super(context);
+ }
+
+ @Override
+ public boolean getValue() {
+ return argument().booleanValue();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.yin_element;
+
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
+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;
+import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.Utils;
+
+public final class YinElementStatementSupport extends
+ AbstractStatementSupport<Boolean, YinElementStatement, EffectiveStatement<Boolean, YinElementStatement>> {
+ private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
+ YangStmtMapping.YIN_ELEMENT).build();
+
+ public YinElementStatementSupport() {
+ super(YangStmtMapping.YIN_ELEMENT);
+ }
+
+ @Override
+ public Boolean parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ return Utils.parseBoolean(ctx, value);
+ }
+
+ @Override
+ public YinElementStatement createDeclared(final StmtContext<Boolean, YinElementStatement, ?> ctx) {
+ return new YinElementStatementImpl(ctx);
+ }
+
+ @Override
+ public EffectiveStatement<Boolean, YinElementStatement> createEffective(
+ final StmtContext<Boolean, YinElementStatement, EffectiveStatement<Boolean, YinElementStatement>> ctx) {
+ return new YinElementEffectiveStatementImpl(ctx);
+ }
+
+ @Override
+ public String internArgument(final String rawArgument) {
+ return Utils.internBoolean(rawArgument);
+ }
+
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
+}
\ No newline at end of file
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.UnknownEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
@VisibleForTesting
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.UnknownEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
final class OpenconfigVersionEffectiveStatementImpl extends
+++ /dev/null
-/**
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.Optional;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
-import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.anyxmlschema.AnyxmlSchemaLocationNamespace;
-import org.opendaylight.yangtools.yang.parser.stmt.anyxmlschema.AnyxmlSchemaLocationStatement;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.AnyxmlEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.YangModeledAnyXmlEffectiveStatementImpl;
-
-public class AnyxmlStatementImpl extends AbstractDeclaredStatement<QName> implements AnyxmlStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .ANYXML)
- .addOptional(YangStmtMapping.CONFIG)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.MANDATORY)
- .addAny(YangStmtMapping.MUST)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addOptional(YangStmtMapping.WHEN)
- .addOptional(SupportedExtensionsMapping.ANYXML_SCHEMA_LOCATION)
- .build();
-
- protected AnyxmlStatementImpl(final StmtContext<QName, AnyxmlStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractQNameStatementSupport<AnyxmlStatement, EffectiveStatement<QName, AnyxmlStatement>> {
-
- public Definition() {
- super(YangStmtMapping.ANYXML);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public void onStatementAdded(final Mutable<QName, AnyxmlStatement,
- EffectiveStatement<QName, AnyxmlStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override
- public AnyxmlStatement createDeclared(final StmtContext<QName, AnyxmlStatement, ?> ctx) {
- return new AnyxmlStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, AnyxmlStatement> createEffective(
- final StmtContext<QName, AnyxmlStatement, EffectiveStatement<QName, AnyxmlStatement>> ctx) {
- final Map<StatementDefinition, Mutable<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement,
- EffectiveStatement<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement>>> schemaLocations =
- ctx.getAllFromCurrentStmtCtxNamespace(AnyxmlSchemaLocationNamespace.class);
- if (schemaLocations != null && !schemaLocations.isEmpty()) {
- final SchemaNodeIdentifier anyXmlSchemaNodeIdentifier = schemaLocations.values().iterator().next()
- .getStatementArgument();
- final Optional<ContainerSchemaNode> anyXmlSchema = getAnyXmlSchema(ctx, anyXmlSchemaNodeIdentifier);
- if (anyXmlSchema.isPresent()) {
- return new YangModeledAnyXmlEffectiveStatementImpl(ctx, anyXmlSchema.get());
- }
- }
- return new AnyxmlEffectiveStatementImpl(ctx);
- }
-
- private static Optional<ContainerSchemaNode> getAnyXmlSchema(
- final StmtContext<QName, AnyxmlStatement, EffectiveStatement<QName, AnyxmlStatement>> ctx,
- final SchemaNodeIdentifier contentSchemaPath) {
- final StmtContext<?, ?, ?> findNode = Utils.findNode(ctx.getRoot(), contentSchemaPath);
- if (findNode != null) {
- final EffectiveStatement<?, ?> anyXmlSchemaNode = findNode.buildEffective();
- if (anyXmlSchemaNode instanceof ContainerSchemaNode) {
- return Optional.of((ContainerSchemaNode) anyXmlSchemaNode);
- }
- }
- return Optional.empty();
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public QName getName() {
- return argument();
- }
-
- @Override
- public WhenStatement getWhenStatement() {
- return firstDeclared(WhenStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends IfFeatureStatement> getIfFeatures() {
- return allDeclared(IfFeatureStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends MustStatement> getMusts() {
- return allDeclared(MustStatement.class);
- }
-
- @Override
- public ConfigStatement getConfig() {
- return firstDeclared(ConfigStatement.class);
- }
-
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Override
- public MandatoryStatement getMandatory() {
- return firstDeclared(MandatoryStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ArgumentEffectiveStatementImpl;
-
-public class ArgumentStatementImpl extends AbstractDeclaredStatement<QName>
- implements ArgumentStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .ARGUMENT)
- .addOptional(YangStmtMapping.YIN_ELEMENT)
- .build();
-
- protected ArgumentStatementImpl(
- final StmtContext<QName, ArgumentStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends
- AbstractQNameStatementSupport<ArgumentStatement, EffectiveStatement<QName, ArgumentStatement>> {
-
- public Definition() {
- super(YangStmtMapping.ARGUMENT);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public ArgumentStatement createDeclared(
- final StmtContext<QName, ArgumentStatement, ?> ctx) {
- return new ArgumentStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, ArgumentStatement> createEffective(
- final StmtContext<QName, ArgumentStatement, EffectiveStatement<QName, ArgumentStatement>> ctx) {
- return new ArgumentEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public QName getName() {
- return argument();
- }
-
- @Override
- public YinElementStatement getYinElement() {
- return firstDeclared(YinElementStatement.class);
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import com.google.common.base.Verify;
-import com.google.common.collect.ImmutableSet;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Objects;
-import java.util.Set;
-import java.util.regex.Pattern;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.YangVersion;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
-import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.AugmentToChoiceNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StmtOrderingNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace.ValidationBundleType;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.AugmentEffectiveStatementImpl;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeIdentifier> implements AugmentStatement {
- private static final Logger LOG = LoggerFactory.getLogger(AugmentStatementImpl.class);
- private static final Pattern PATH_REL_PATTERN1 = Pattern.compile("\\.\\.?\\s*/(.+)");
- private static final Pattern PATH_REL_PATTERN2 = Pattern.compile("//.*");
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator
- .builder(YangStmtMapping.AUGMENT)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CASE)
- .addAny(YangStmtMapping.CHOICE)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addAny(YangStmtMapping.USES)
- .addOptional(YangStmtMapping.WHEN)
- .build();
-
- protected AugmentStatementImpl(final StmtContext<SchemaNodeIdentifier, AugmentStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<SchemaNodeIdentifier, AugmentStatement,
- EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> {
-
- public Definition() {
- super(YangStmtMapping.AUGMENT);
- }
-
- @Override
- public SchemaNodeIdentifier parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- SourceException.throwIf(PATH_REL_PATTERN1.matcher(value).matches()
- || PATH_REL_PATTERN2.matcher(value).matches(), ctx.getStatementSourceReference(),
- "Augment argument \'%s\' is not valid, it can be only absolute path; or descendant if used in uses",
- value);
-
- return Utils.nodeIdentifierFromPath(ctx, value);
- }
-
- @Override
- public AugmentStatement createDeclared(
- final StmtContext<SchemaNodeIdentifier, AugmentStatement, ?> ctx) {
- return new AugmentStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<SchemaNodeIdentifier, AugmentStatement> createEffective(
- final StmtContext<SchemaNodeIdentifier, AugmentStatement,
- EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> ctx) {
- return new AugmentEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onFullDefinitionDeclared(final Mutable<SchemaNodeIdentifier, AugmentStatement,
- EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> augmentNode) {
- if (!augmentNode.isSupportedByFeatures()) {
- return;
- }
-
- super.onFullDefinitionDeclared(augmentNode);
-
- if (StmtContextUtils.isInExtensionBody(augmentNode)) {
- return;
- }
-
- final ModelActionBuilder augmentAction = augmentNode.newInferenceAction(
- ModelProcessingPhase.EFFECTIVE_MODEL);
- final Prerequisite<StmtContext<SchemaNodeIdentifier, AugmentStatement,
- EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>>> sourceCtxPrereq =
- augmentAction.requiresCtx(augmentNode, ModelProcessingPhase.EFFECTIVE_MODEL);
- final Prerequisite<Mutable<?, ?, EffectiveStatement<?, ?>>> target =
- augmentAction.mutatesEffectiveCtx(getSearchRoot(augmentNode),
- SchemaNodeIdentifierBuildNamespace.class, augmentNode.getStatementArgument());
-
- augmentAction.apply(new ModelActionBuilder.InferenceAction() {
- @Override
- public void apply(final ModelActionBuilder.InferenceContext ctx) {
- final StatementContextBase<?, ?, ?> augmentTargetCtx =
- (StatementContextBase<?, ?, ?>) target.resolve(ctx);
- if (!isSupportedAugmentTarget(augmentTargetCtx)
- || StmtContextUtils.isInExtensionBody(augmentTargetCtx)) {
- augmentNode.setIsSupportedToBuildEffective(false);
- return;
- }
- /**
- * Marks case short hand in augment
- */
- if (augmentTargetCtx.getPublicDefinition() == YangStmtMapping.CHOICE) {
- augmentNode.addToNs(AugmentToChoiceNamespace.class, augmentNode, Boolean.TRUE);
- }
-
- // FIXME: this is a workaround for models which augment a node which is added via an extension
- // which we do not handle. This needs to be reworked in terms of unknown schema nodes.
- final StatementContextBase<?, ?, ?> augmentSourceCtx = (StatementContextBase<?, ?, ?>) augmentNode;
- try {
- copyFromSourceToTarget(augmentSourceCtx, augmentTargetCtx);
- augmentTargetCtx.addEffectiveSubstatement(augmentSourceCtx);
- updateAugmentOrder(augmentSourceCtx);
- } catch (final SourceException e) {
- LOG.warn("Failed to add augmentation {} defined at {}",
- augmentTargetCtx.getStatementSourceReference(),
- augmentSourceCtx.getStatementSourceReference(), e);
- }
- }
-
- private void updateAugmentOrder(final StatementContextBase<?, ?, ?> augmentSourceCtx) {
- Integer currentOrder = augmentSourceCtx.getFromNamespace(StmtOrderingNamespace.class,
- YangStmtMapping.AUGMENT);
- if (currentOrder == null) {
- currentOrder = 1;
- } else {
- currentOrder++;
- }
-
- augmentSourceCtx.addToNs(StmtOrderingNamespace.class, YangStmtMapping.AUGMENT, currentOrder);
- }
-
- @Override
- public void prerequisiteFailed(final Collection<? extends ModelActionBuilder.Prerequisite<?>> failed) {
- /*
- * Do not fail, if it is an uses-augment to an unknown node.
- */
- if (YangStmtMapping.USES == augmentNode.getParentContext().getPublicDefinition()) {
- final StatementContextBase<?, ?, ?> targetNode = Utils.findNode(getSearchRoot(augmentNode),
- augmentNode.getStatementArgument());
- if (targetNode != null && StmtContextUtils.isUnknownStatement(targetNode)) {
- augmentNode.setIsSupportedToBuildEffective(false);
- LOG.warn(
- "Uses-augment to unknown node {}. Augmentation has not been performed. At line: {}",
- augmentNode.getStatementArgument(), augmentNode.getStatementSourceReference());
- return;
- }
- }
-
- throw new InferenceException(augmentNode.getStatementSourceReference(),
- "Augment target '%s' not found", augmentNode.getStatementArgument());
- }
- });
- }
-
- private static Mutable<?, ?, ?> getSearchRoot(final Mutable<?, ?, ?> augmentContext) {
- final Mutable<?, ?, ?> parent = augmentContext.getParentContext();
- // Augment is in uses - we need to augment instantiated nodes in parent.
- if (YangStmtMapping.USES == parent.getPublicDefinition()) {
- return parent.getParentContext();
- }
- return parent;
- }
-
- public static void copyFromSourceToTarget(final StatementContextBase<?, ?, ?> sourceCtx,
- final StatementContextBase<?, ?, ?> targetCtx) {
- final CopyType typeOfCopy = UsesStatement.class.equals(sourceCtx.getParentContext().getPublicDefinition()
- .getDeclaredRepresentationClass()) ? CopyType.ADDED_BY_USES_AUGMENTATION
- : CopyType.ADDED_BY_AUGMENTATION;
- /*
- * Since Yang 1.1, if an augmentation is made conditional with a
- * "when" statement, it is allowed to add mandatory nodes.
- */
- final boolean skipCheckOfMandatoryNodes = YangVersion.VERSION_1_1.equals(sourceCtx.getRootVersion())
- && isConditionalAugmentStmt(sourceCtx);
-
- final Collection<? extends Mutable<?, ?, ?>> declared = sourceCtx.mutableDeclaredSubstatements();
- final Collection<? extends Mutable<?, ?, ?>> effective = sourceCtx.mutableEffectiveSubstatements();
- final Collection<Mutable<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
-
- for (final Mutable<?, ?, ?> originalStmtCtx : declared) {
- if (originalStmtCtx.isSupportedByFeatures()) {
- copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer, skipCheckOfMandatoryNodes);
- }
- }
- for (final Mutable<?, ?, ?> originalStmtCtx : effective) {
- copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer, skipCheckOfMandatoryNodes);
- }
-
- targetCtx.addEffectiveSubstatements(buffer);
- }
-
- /**
- * Checks whether supplied statement context is conditional augment
- * statement.
- *
- * @param ctx
- * statement context to be checked
- *
- * @return true if supplied statement context is conditional augment
- * statement, otherwise false
- */
- private static boolean isConditionalAugmentStmt(final StmtContext<?, ?, ?> ctx) {
- return ctx.getPublicDefinition() == YangStmtMapping.AUGMENT
- && StmtContextUtils.findFirstSubstatement(ctx, WhenStatement.class) != null;
- }
-
- private static void copyStatement(final Mutable<?, ?, ?> original, final StatementContextBase<?, ?, ?> target,
- final CopyType typeOfCopy, final Collection<Mutable<?, ?, ?>> buffer,
- final boolean skipCheckOfMandatoryNodes) {
- if (needToCopyByAugment(original)) {
- validateNodeCanBeCopiedByAugment(original, target, typeOfCopy, skipCheckOfMandatoryNodes);
-
- buffer.add(target.childCopyOf(original, typeOfCopy));
- } else if (isReusedByAugment(original)) {
- buffer.add(original);
- }
- }
-
- private static void validateNodeCanBeCopiedByAugment(final StmtContext<?, ?, ?> sourceCtx,
- final StatementContextBase<?, ?, ?> targetCtx, final CopyType typeOfCopy,
- final boolean skipCheckOfMandatoryNodes) {
-
- if (WhenStatement.class.equals(sourceCtx.getPublicDefinition().getDeclaredRepresentationClass())) {
- return;
- }
-
- if (!skipCheckOfMandatoryNodes && typeOfCopy == CopyType.ADDED_BY_AUGMENTATION
- && reguiredCheckOfMandatoryNodes(sourceCtx, targetCtx)) {
- checkForMandatoryNodes(sourceCtx);
- }
-
- for (final StmtContext<?, ?, ?> subStatement : targetCtx.allSubstatements()) {
- final boolean sourceIsDataNode = DataDefinitionStatement.class.isAssignableFrom(sourceCtx
- .getPublicDefinition().getDeclaredRepresentationClass());
- final boolean targetIsDataNode = DataDefinitionStatement.class.isAssignableFrom(subStatement
- .getPublicDefinition().getDeclaredRepresentationClass());
- final boolean qNamesEqual = sourceIsDataNode && targetIsDataNode
- && Objects.equals(sourceCtx.getStatementArgument(), subStatement.getStatementArgument());
-
- InferenceException.throwIf(qNamesEqual, sourceCtx.getStatementSourceReference(),
- "An augment cannot add node named '%s' because this name is already used in target",
- sourceCtx.rawStatementArgument());
- }
- }
-
- private static void checkForMandatoryNodes(final StmtContext<?, ?, ?> sourceCtx) {
- if (StmtContextUtils.isNonPresenceContainer(sourceCtx)) {
- /*
- * We need to iterate over both declared and effective sub-statements,
- * because a mandatory node can be:
- * a) declared in augment body
- * b) added to augment body also via uses of a grouping and
- * such sub-statements are stored in effective sub-statements collection.
- */
- sourceCtx.allSubstatementsStream().forEach(Definition::checkForMandatoryNodes);
- }
-
- InferenceException.throwIf(StmtContextUtils.isMandatoryNode(sourceCtx),
- sourceCtx.getStatementSourceReference(),
- "An augment cannot add node '%s' because it is mandatory and in module different than target",
- sourceCtx.rawStatementArgument());
- }
-
- private static boolean reguiredCheckOfMandatoryNodes(final StmtContext<?, ?, ?> sourceCtx,
- Mutable<?, ?, ?> targetCtx) {
- /*
- * If the statement argument is not QName, it cannot be mandatory
- * statement, therefore return false and skip mandatory nodes validation
- */
- if (!(sourceCtx.getStatementArgument() instanceof QName)) {
- return false;
- }
- final QName sourceStmtQName = (QName) sourceCtx.getStatementArgument();
-
- // RootStatementContext, for example
- final Mutable<?, ?, ?> root = targetCtx.getRoot();
- do {
- Verify.verify(targetCtx.getStatementArgument() instanceof QName,
- "Argument of augment target statement must be QName.");
- final QName targetStmtQName = (QName) targetCtx.getStatementArgument();
- /*
- * If target is from another module, return true and perform
- * mandatory nodes validation
- */
- if (!Utils.belongsToTheSameModule(targetStmtQName, sourceStmtQName)) {
- return true;
- }
-
- /*
- * If target or one of the target's ancestors from the same namespace
- * is a presence container
- * or is non-mandatory choice
- * or is non-mandatory list
- * return false and skip mandatory nodes validation, because these nodes
- * are not mandatory node containers according to RFC 6020 section 3.1.
- */
- if (StmtContextUtils.isPresenceContainer(targetCtx)
- || StmtContextUtils.isNotMandatoryNodeOfType(targetCtx, YangStmtMapping.CHOICE)
- || StmtContextUtils.isNotMandatoryNodeOfType(targetCtx, YangStmtMapping.LIST)) {
- return false;
- }
- } while ((targetCtx = targetCtx.getParentContext()) != root);
-
- /*
- * All target node's parents belong to the same module as source node,
- * therefore return false and skip mandatory nodes validation.
- */
- return false;
- }
-
- private static final Set<YangStmtMapping> NOCOPY_DEF_SET = ImmutableSet.of(YangStmtMapping.USES,
- YangStmtMapping.WHEN, YangStmtMapping.DESCRIPTION, YangStmtMapping.REFERENCE, YangStmtMapping.STATUS);
-
- public static boolean needToCopyByAugment(final StmtContext<?, ?, ?> stmtContext) {
- return !NOCOPY_DEF_SET.contains(stmtContext.getPublicDefinition());
- }
-
- private static final Set<YangStmtMapping> REUSED_DEF_SET = ImmutableSet.of(YangStmtMapping.TYPEDEF);
-
- public static boolean isReusedByAugment(final StmtContext<?, ?, ?> stmtContext) {
- return REUSED_DEF_SET.contains(stmtContext.getPublicDefinition());
- }
-
- static boolean isSupportedAugmentTarget(final StmtContext<?, ?, ?> substatementCtx) {
- /*
- * :TODO Substatement must be allowed augment target type e.g.
- * Container, etc... and must not be for example grouping, identity etc.
- * It is problem in case when more than one substatements have the same
- * QName, for example Grouping and Container are siblings and they have
- * the same QName. We must find the Container and the Grouping must be
- * ignored as disallowed augment target.
- */
- final Collection<?> allowedAugmentTargets = substatementCtx.getFromNamespace(
- ValidationBundlesNamespace.class, ValidationBundleType.SUPPORTED_AUGMENT_TARGETS);
-
- // if no allowed target is returned we consider all targets allowed
- return allowedAugmentTargets == null || allowedAugmentTargets.isEmpty()
- || allowedAugmentTargets.contains(substatementCtx.getPublicDefinition());
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public SchemaNodeIdentifier getTargetNode() {
- return argument();
- }
-
- @Nonnull
- @Override
- public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
- return allDeclared(DataDefinitionStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends ActionStatement> getActions() {
- return allDeclared(ActionStatement.class);
- }
-
- @Nonnull
- @Override
- public final Collection<? extends NotificationStatement> getNotifications() {
- return allDeclared(NotificationStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nullable
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Nullable
- @Override
- public WhenStatement getWhenStatement() {
- return firstDeclared(WhenStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends CaseStatement> getCases() {
- return allDeclared(CaseStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends IfFeatureStatement> getIfFeatures() {
- return allDeclared(IfFeatureStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
-import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.DerivedIdentitiesNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.BaseEffectiveStatementImpl;
-
-public class BaseStatementImpl extends AbstractDeclaredStatement<QName> implements BaseStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.BASE).build();
-
- protected BaseStatementImpl(final StmtContext<QName, BaseStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractQNameStatementSupport<BaseStatement, EffectiveStatement<QName, BaseStatement>> {
-
- public Definition() {
- super(YangStmtMapping.BASE);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public BaseStatement createDeclared(final StmtContext<QName, BaseStatement, ?> ctx) {
- return new BaseStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, BaseStatement> createEffective(
- final StmtContext<QName, BaseStatement, EffectiveStatement<QName, BaseStatement>> ctx) {
- return new BaseEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onStatementDefinitionDeclared(
- final Mutable<QName, BaseStatement, EffectiveStatement<QName, BaseStatement>> baseStmtCtx) {
- final Mutable<?, ?, ?> baseParentCtx = baseStmtCtx.getParentContext();
- if (StmtContextUtils.producesDeclared(baseParentCtx, IdentityStatement.class)) {
-
- final QName baseIdentityQName = baseStmtCtx.getStatementArgument();
- final ModelActionBuilder baseIdentityAction = baseStmtCtx.newInferenceAction(
- ModelProcessingPhase.STATEMENT_DEFINITION);
- final Prerequisite<StmtContext<?, ?, ?>> requiresPrereq = baseIdentityAction.requiresCtx(baseStmtCtx,
- IdentityNamespace.class, baseIdentityQName, ModelProcessingPhase.STATEMENT_DEFINITION);
- final Prerequisite<StmtContext.Mutable<?, ?, ?>> mutatesPrereq = baseIdentityAction.mutatesCtx(
- baseParentCtx, ModelProcessingPhase.STATEMENT_DEFINITION);
-
- baseIdentityAction.apply(new InferenceAction() {
- @Override
- public void apply(final InferenceContext ctx) {
- List<StmtContext<?, ?, ?>> derivedIdentities = baseStmtCtx.getFromNamespace(
- DerivedIdentitiesNamespace.class, baseStmtCtx.getStatementArgument());
- if (derivedIdentities == null) {
- derivedIdentities = new ArrayList<>(1);
- baseStmtCtx.addToNs(DerivedIdentitiesNamespace.class, baseIdentityQName, derivedIdentities);
- }
- derivedIdentities.add(baseParentCtx);
- }
-
- @Override
- public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
- throw new InferenceException(baseStmtCtx.getStatementSourceReference(),
- "Unable to resolve identity %s and base identity %s",
- baseParentCtx.getStatementArgument(), baseStmtCtx.getStatementArgument());
- }
- });
- }
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public QName getName() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
-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;
-import org.opendaylight.yangtools.yang.parser.spi.source.BelongsToModuleContext;
-import org.opendaylight.yangtools.yang.parser.spi.source.BelongsToPrefixToModuleCtx;
-import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNamespaceForBelongsTo;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.BelongsToEffectiveStatementImpl;
-
-public class BelongsToStatementImpl extends AbstractDeclaredStatement<String>
- implements BelongsToStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.BELONGS_TO).addMandatory(YangStmtMapping.PREFIX).build();
-
- protected BelongsToStatementImpl(final StmtContext<String, BelongsToStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends
- AbstractStatementSupport<String, BelongsToStatement, EffectiveStatement<String, BelongsToStatement>> {
-
- public Definition() {
- super(YangStmtMapping.BELONGS_TO);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public BelongsToStatement createDeclared(
- final StmtContext<String, BelongsToStatement, ?> ctx) {
- return new BelongsToStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, BelongsToStatement> createEffective(
- final StmtContext<String, BelongsToStatement, EffectiveStatement<String, BelongsToStatement>> ctx) {
- return new BelongsToEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onPreLinkageDeclared(final StmtContext.Mutable<String, BelongsToStatement,
- EffectiveStatement<String, BelongsToStatement>> belongsToCtx) {
- belongsToCtx.addRequiredSource(getSourceIdentifier(belongsToCtx));
- }
-
- @Override
- public void onLinkageDeclared(final Mutable<String, BelongsToStatement,
- EffectiveStatement<String, BelongsToStatement>> belongsToCtx) {
- ModelActionBuilder belongsToAction = belongsToCtx.newInferenceAction(ModelProcessingPhase.SOURCE_LINKAGE);
-
- final SourceIdentifier belongsToSourceIdentifier = getSourceIdentifier(belongsToCtx);
- final Prerequisite<StmtContext<?, ?, ?>> belongsToPrereq = belongsToAction.requiresCtx(belongsToCtx,
- ModuleNamespaceForBelongsTo.class, belongsToCtx.getStatementArgument(),
- ModelProcessingPhase.SOURCE_LINKAGE);
-
- belongsToAction.apply(new InferenceAction() {
- @Override
- public void apply(final InferenceContext ctx) {
- StmtContext<?, ?, ?> belongsToModuleCtx = belongsToPrereq.resolve(ctx);
-
- belongsToCtx.addToNs(BelongsToModuleContext.class, belongsToSourceIdentifier, belongsToModuleCtx);
- belongsToCtx.addToNs(BelongsToPrefixToModuleCtx.class,
- findFirstDeclaredSubstatement(belongsToCtx, PrefixStatement.class).getStatementArgument(),
- belongsToModuleCtx);
- }
-
- @Override
- public void prerequisiteFailed(final Collection<? extends ModelActionBuilder.Prerequisite<?>> failed) {
- if (failed.contains(belongsToPrereq)) {
- throw new InferenceException(belongsToCtx.getStatementSourceReference(),
- "Module '%s' from belongs-to was not found", belongsToCtx.getStatementArgument());
- }
- }
- });
- }
-
- private static SourceIdentifier getSourceIdentifier(final StmtContext<String, BelongsToStatement,
- EffectiveStatement<String, BelongsToStatement>> belongsToCtx) {
- return RevisionSourceIdentifier.create(belongsToCtx.getStatementArgument());
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getModule() {
- return argument();
- }
-
- @Nonnull
- @Override
- public PrefixStatement getPrefix() {
- return firstDeclared(PrefixStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BitEffectiveStatementImpl;
-
-public class BitStatementImpl extends AbstractDeclaredStatement<QName> implements BitStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .BIT)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addOptional(YangStmtMapping.POSITION)
- .build();
-
- protected BitStatementImpl(final StmtContext<QName, BitStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractQNameStatementSupport<BitStatement, EffectiveStatement<QName, BitStatement>> {
-
- public Definition() {
- super(YangStmtMapping.BIT);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public BitStatement createDeclared(final StmtContext<QName, BitStatement, ?> ctx) {
- return new BitStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, BitStatement> createEffective(
- final StmtContext<QName, BitStatement, EffectiveStatement<QName, BitStatement>> ctx) {
- return new BitEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends IfFeatureStatement> getIfFeatures() {
- return allDeclared(IfFeatureStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Nonnull
- @Override
- public String getName() {
- return argument().getLocalName();
- }
-
- @Override
- public PositionStatement getPosition() {
- return firstDeclared(PositionStatement.class);
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.BitsSpecification;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BitsSpecificationEffectiveStatementImpl;
-
-public class BitsSpecificationImpl extends AbstractDeclaredStatement<String> implements BitsSpecification {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .TYPE)
- .addMultiple(YangStmtMapping.BIT)
- .build();
-
- protected BitsSpecificationImpl(final StmtContext<String, BitsSpecification, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractStatementSupport<String, BitsSpecification, EffectiveStatement<String, BitsSpecification>> {
-
- public Definition() {
- super(YangStmtMapping.TYPE);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public BitsSpecification createDeclared(final StmtContext<String, BitsSpecification, ?> ctx) {
- return new BitsSpecificationImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, BitsSpecification> createEffective(
- final StmtContext<String, BitsSpecification, EffectiveStatement<String, BitsSpecification>> ctx) {
- return new BitsSpecificationEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
-
- @Nonnull
- @Override
- public Collection<? extends BitStatement> getBits() {
- return allDeclared(BitStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.CaseEffectiveStatementImpl;
-
-public class CaseStatementImpl extends AbstractDeclaredStatement<QName> implements CaseStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .CASE)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addAny(YangStmtMapping.USES)
- .addOptional(YangStmtMapping.WHEN)
- .build();
-
- protected CaseStatementImpl(final StmtContext<QName, CaseStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractQNameStatementSupport<CaseStatement, EffectiveStatement<QName, CaseStatement>> {
-
- public Definition() {
- super(YangStmtMapping.CASE);
- }
-
- @Override public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public void onStatementAdded(
- final Mutable<QName, CaseStatement, EffectiveStatement<QName, CaseStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override public CaseStatement createDeclared(
- final StmtContext<QName, CaseStatement, ?> ctx) {
- return new CaseStatementImpl(ctx);
- }
-
- @Override public EffectiveStatement<QName, CaseStatement> createEffective(
- final StmtContext<QName, CaseStatement, EffectiveStatement<QName, CaseStatement>> ctx) {
- return new CaseEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public QName getName() {
- return argument();
- }
-
- @Override
- public WhenStatement getWhenStatement() {
- return firstDeclared(WhenStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends IfFeatureStatement> getIfFeatures() {
- return allDeclared(IfFeatureStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
- return allDeclared(DataDefinitionStatement.class);
- }
-
- @Nullable
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
-import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ChoiceEffectiveStatementImpl;
-
-public class ChoiceStatementImpl extends AbstractDeclaredStatement<QName>
- implements ChoiceStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .CHOICE)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CASE)
- .addOptional(YangStmtMapping.CONFIG)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DEFAULT)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addOptional(YangStmtMapping.MANDATORY)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addOptional(YangStmtMapping.WHEN)
- .build();
-
- protected ChoiceStatementImpl(final StmtContext<QName, ChoiceStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractQNameStatementSupport<ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> {
- private static final StatementSupport<?, ?, ?> IMPLICIT_CASE = new CaseStatementImpl.Definition();
-
- public Definition() {
- super(YangStmtMapping.CHOICE);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public Optional<StatementSupport<?, ?, ?>> getImplicitParentFor(final StatementDefinition stmtDef) {
- if (YangValidationBundles.SUPPORTED_CASE_SHORTHANDS.contains(stmtDef)) {
- return Optional.of(implictCase());
- }
- return Optional.empty();
- }
-
- @Override
- public void onStatementAdded(
- final Mutable<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override
- public ChoiceStatement createDeclared(final StmtContext<QName, ChoiceStatement, ?> ctx) {
- return new ChoiceStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, ChoiceStatement> createEffective(
- final StmtContext<QName, ChoiceStatement, EffectiveStatement<QName, ChoiceStatement>> ctx) {
- return new ChoiceEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
- protected StatementSupport<?, ?, ?> implictCase() {
- return IMPLICIT_CASE;
- }
- }
-
- @Nonnull
- @Override
- public QName getName() {
- return argument();
- }
-
- @Nullable
- @Override
- public DefaultStatement getDefault() {
- return firstDeclared(DefaultStatement.class);
- }
-
- @Nullable
- @Override
- public ConfigStatement getConfig() {
- return firstDeclared(ConfigStatement.class);
- }
-
- @Nullable
- @Override
- public MandatoryStatement getMandatory() {
- return firstDeclared(MandatoryStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends CaseStatement> getCases() {
- return allDeclared(CaseStatement.class);
- }
-
- @Override
- public WhenStatement getWhenStatement() {
- return firstDeclared(WhenStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends IfFeatureStatement> getIfFeatures() {
- return allDeclared(IfFeatureStatement.class);
- }
-
- @Nullable
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ConfigEffectiveStatementImpl;
-
-public class ConfigStatementImpl extends AbstractDeclaredStatement<Boolean> implements ConfigStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.CONFIG).build();
-
- protected ConfigStatementImpl(final StmtContext<Boolean, ConfigStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractStatementSupport<Boolean, ConfigStatement, EffectiveStatement<Boolean, ConfigStatement>> {
-
- public Definition() {
- super(YangStmtMapping.CONFIG);
- }
-
- @Override
- public Boolean parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return Utils.parseBoolean(ctx, value);
- }
-
- @Override
- public ConfigStatement createDeclared(final StmtContext<Boolean, ConfigStatement, ?> ctx) {
- final ConfigStatement ret = new ConfigStatementImpl(ctx);
-
- if (EmptyConfigStatement.FALSE.equals(ret)) {
- return EmptyConfigStatement.FALSE;
- } else if (EmptyConfigStatement.TRUE.equals(ret)) {
- return EmptyConfigStatement.TRUE;
- } else {
- return ret;
- }
- }
-
- @Override
- public EffectiveStatement<Boolean, ConfigStatement> createEffective(
- final StmtContext<Boolean, ConfigStatement, EffectiveStatement<Boolean, ConfigStatement>> ctx) {
- final EffectiveStatement<Boolean, ConfigStatement> ret = new ConfigEffectiveStatementImpl(ctx);
- final ConfigStatement declared = ret.getDeclared();
- if (declared instanceof EmptyConfigStatement && ret.effectiveSubstatements().isEmpty()) {
- return ((EmptyConfigStatement)declared).toEffective();
- }
- return ret;
- }
-
- @Override
- public String internArgument(final String rawArgument) {
- return Utils.internBoolean(rawArgument);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public boolean getValue() {
- return argument().booleanValue();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContactEffectiveStatementImpl;
-
-public class ContactStatementImpl extends AbstractDeclaredStatement<String> implements ContactStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .CONTACT)
- .build();
-
- protected ContactStatementImpl(final StmtContext<String, ContactStatement,?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractStatementSupport<String, ContactStatement,EffectiveStatement<String, ContactStatement>> {
-
- public Definition() {
- super(YangStmtMapping.CONTACT);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public ContactStatement createDeclared(final StmtContext<String, ContactStatement, ?> ctx) {
- return new ContactStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, ContactStatement> createEffective(
- final StmtContext<String, ContactStatement, EffectiveStatement<String, ContactStatement>> ctx) {
- return new ContactEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getText() {
- return rawArgument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.Decimal64Specification;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.Decimal64SpecificationEffectiveStatementImpl;
-
-public class Decimal64SpecificationImpl extends AbstractDeclaredStatement<String> implements Decimal64Specification {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .TYPE)
- .addMandatory(YangStmtMapping.FRACTION_DIGITS)
- .addOptional(YangStmtMapping.RANGE)
- .build();
-
- protected Decimal64SpecificationImpl(final StmtContext<String, Decimal64Specification, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<String, Decimal64Specification,
- EffectiveStatement<String, Decimal64Specification>> {
-
- public Definition() {
- super(YangStmtMapping.TYPE);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public Decimal64Specification createDeclared(final StmtContext<String, Decimal64Specification, ?> ctx) {
- return new Decimal64SpecificationImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, Decimal64Specification> createEffective(final StmtContext<String,
- Decimal64Specification, EffectiveStatement<String, Decimal64Specification>> ctx) {
- return new Decimal64SpecificationEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
-
- @Nonnull
- @Override
- public FractionDigitsStatement getFractionDigits() {
- return firstDeclared(FractionDigitsStatement.class);
- }
-
- @Override
- public RangeStatement getRange() {
- return firstDeclared(RangeStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DefaultEffectiveStatementImpl;
-
-public class DefaultStatementImpl extends AbstractDeclaredStatement<String> implements
- DefaultStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .DEFAULT)
- .build();
-
- protected DefaultStatementImpl(
- final StmtContext<String, DefaultStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractStatementSupport<String, DefaultStatement, EffectiveStatement<String, DefaultStatement>> {
-
- public Definition() {
- super(YangStmtMapping.DEFAULT);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public DefaultStatement createDeclared(final StmtContext<String, DefaultStatement, ?> ctx) {
- return new DefaultStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, DefaultStatement> createEffective(
- final StmtContext<String, DefaultStatement, EffectiveStatement<String, DefaultStatement>> ctx) {
- return new DefaultEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getValue() {
- return rawArgument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DescriptionEffectiveStatementImpl;
-
-public class DescriptionStatementImpl extends AbstractDeclaredStatement<String> implements DescriptionStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .DESCRIPTION)
- .build();
-
- protected DescriptionStatementImpl(final StmtContext<String, DescriptionStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<String, DescriptionStatement,
- EffectiveStatement<String, DescriptionStatement>> {
-
- public Definition() {
- super(YangStmtMapping.DESCRIPTION);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public DescriptionStatement createDeclared(final StmtContext<String, DescriptionStatement, ?> ctx) {
- return new DescriptionStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, DescriptionStatement> createEffective(
- final StmtContext<String, DescriptionStatement, EffectiveStatement<String, DescriptionStatement>> ctx) {
- return new DescriptionEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getText() {
- return rawArgument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableMap.Builder;
-import com.google.common.collect.ImmutableSet;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.YangVersion;
-import org.opendaylight.yangtools.yang.model.api.DeviateKind;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
-import org.opendaylight.yangtools.yang.model.api.stmt.DeviateStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
-import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
-import org.opendaylight.yangtools.yang.parser.spi.source.ModulesDeviatedByModules;
-import org.opendaylight.yangtools.yang.parser.spi.source.ModulesDeviatedByModules.SupportedModules;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeviateEffectiveStatementImpl;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind> implements DeviateStatement {
- private static final Logger LOG = LoggerFactory.getLogger(DeviateStatementImpl.class);
-
- private static final SubstatementValidator DEVIATE_NOT_SUPPORTED_SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.DEVIATE).build();
-
- private static final SubstatementValidator DEVIATE_ADD_SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.DEVIATE)
- .addOptional(YangStmtMapping.CONFIG)
- .addOptional(YangStmtMapping.DEFAULT)
- .addOptional(YangStmtMapping.MANDATORY)
- .addOptional(YangStmtMapping.MAX_ELEMENTS)
- .addOptional(YangStmtMapping.MIN_ELEMENTS)
- .addAny(YangStmtMapping.MUST)
- .addAny(YangStmtMapping.UNIQUE)
- .addOptional(YangStmtMapping.UNITS)
- .build();
-
- private static final SubstatementValidator DEVIATE_REPLACE_SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.DEVIATE)
- .addOptional(YangStmtMapping.CONFIG)
- .addOptional(YangStmtMapping.DEFAULT)
- .addOptional(YangStmtMapping.MANDATORY)
- .addOptional(YangStmtMapping.MAX_ELEMENTS)
- .addOptional(YangStmtMapping.MIN_ELEMENTS)
- .addOptional(YangStmtMapping.TYPE)
- .addOptional(YangStmtMapping.UNITS)
- .build();
-
- private static final SubstatementValidator DEVIATE_DELETE_SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.DEVIATE)
- .addOptional(YangStmtMapping.DEFAULT)
- .addAny(YangStmtMapping.MUST)
- .addAny(YangStmtMapping.UNIQUE)
- .addOptional(YangStmtMapping.UNITS)
- .build();
-
- protected DeviateStatementImpl(final StmtContext<DeviateKind, DeviateStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<DeviateKind, DeviateStatement,
- EffectiveStatement<DeviateKind, DeviateStatement>> {
- private static final Map<String, DeviateKind> KEYWORD_TO_DEVIATE_MAP;
-
- static {
- final Builder<String, DeviateKind> keywordToDeviateMapBuilder = ImmutableMap.builder();
- for (final DeviateKind deviate : DeviateKind.values()) {
- keywordToDeviateMapBuilder.put(deviate.getKeyword(), deviate);
- }
- KEYWORD_TO_DEVIATE_MAP = keywordToDeviateMapBuilder.build();
- }
-
- private static final Set<YangStmtMapping> SINGLETON_STATEMENTS = ImmutableSet.of(
- YangStmtMapping.UNITS, YangStmtMapping.CONFIG, YangStmtMapping.MANDATORY,
- YangStmtMapping.MIN_ELEMENTS, YangStmtMapping.MAX_ELEMENTS);
-
- private static final Set<YangStmtMapping> IMPLICIT_STATEMENTS = ImmutableSet.of(YangStmtMapping.CONFIG,
- YangStmtMapping.MANDATORY, YangStmtMapping.MAX_ELEMENTS, YangStmtMapping.MIN_ELEMENTS);
-
- public Definition() {
- super(YangStmtMapping.DEVIATE);
- }
-
- @Override
- public DeviateKind parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return SourceException.throwIfNull(KEYWORD_TO_DEVIATE_MAP.get(value),
- ctx.getStatementSourceReference(), "String '%s' is not valid deviate argument", value);
- }
-
- @Override
- public DeviateStatement createDeclared(final StmtContext<DeviateKind, DeviateStatement, ?> ctx) {
- return new DeviateStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<DeviateKind, DeviateStatement> createEffective(
- final StmtContext<DeviateKind, DeviateStatement, EffectiveStatement<DeviateKind,
- DeviateStatement>> ctx) {
- return new DeviateEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onFullDefinitionDeclared(final Mutable<DeviateKind, DeviateStatement,
- EffectiveStatement<DeviateKind, DeviateStatement>> deviateStmtCtx) {
- final DeviateKind deviateKind = deviateStmtCtx.getStatementArgument();
- getSubstatementValidatorForDeviate(deviateKind).validate(deviateStmtCtx);
-
- final SchemaNodeIdentifier deviationTarget =
- (SchemaNodeIdentifier) deviateStmtCtx.getParentContext().getStatementArgument();
-
- if (!isDeviationSupported(deviateStmtCtx, deviationTarget)) {
- return;
- }
-
- final ModelActionBuilder deviateAction = deviateStmtCtx.newInferenceAction(
- ModelProcessingPhase.EFFECTIVE_MODEL);
-
- final Prerequisite<StmtContext<DeviateKind, DeviateStatement, EffectiveStatement<DeviateKind,
- DeviateStatement>>> sourceCtxPrerequisite =
- deviateAction.requiresCtx(deviateStmtCtx, ModelProcessingPhase.EFFECTIVE_MODEL);
-
- final Prerequisite<Mutable<?, ?, EffectiveStatement<?, ?>>> targetCtxPrerequisite =
- deviateAction.mutatesEffectiveCtx(deviateStmtCtx.getRoot(),
- SchemaNodeIdentifierBuildNamespace.class, deviationTarget);
-
- deviateAction.apply(new InferenceAction() {
- @Override
- public void apply(final InferenceContext ctx) throws InferenceException {
- // FIXME once BUG-7760 gets fixed, there will be no need for these dirty casts
- final StatementContextBase<?, ?, ?> sourceNodeStmtCtx =
- (StatementContextBase<?, ?, ?>) sourceCtxPrerequisite.resolve(ctx);
- final StatementContextBase<?, ?, ?> targetNodeStmtCtx =
- (StatementContextBase<?, ?, ?>) targetCtxPrerequisite.resolve(ctx);
-
- switch (deviateKind) {
- case NOT_SUPPORTED:
- targetNodeStmtCtx.setIsSupportedToBuildEffective(false);
- break;
- case ADD:
- performDeviateAdd(sourceNodeStmtCtx, targetNodeStmtCtx);
- break;
- case REPLACE:
- performDeviateReplace(sourceNodeStmtCtx, targetNodeStmtCtx);
- break;
- case DELETE:
- performDeviateDelete(sourceNodeStmtCtx, targetNodeStmtCtx);
- break;
- default:
- throw new IllegalStateException("Unsupported deviate " + deviateKind);
- }
- }
-
- @Override
- public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
- throw new InferenceException(deviateStmtCtx.getParentContext().getStatementSourceReference(),
- "Deviation target '%s' not found.", deviationTarget);
- }
- });
- }
-
- private static boolean isDeviationSupported(final Mutable<DeviateKind, DeviateStatement,
- EffectiveStatement<DeviateKind, DeviateStatement>> deviateStmtCtx,
- final SchemaNodeIdentifier deviationTarget) {
- final Map<QNameModule, Set<QNameModule>> modulesDeviatedByModules = deviateStmtCtx.getFromNamespace(
- ModulesDeviatedByModules.class, SupportedModules.SUPPORTED_MODULES);
- if (modulesDeviatedByModules == null) {
- return true;
- }
-
- final QNameModule currentModule = deviateStmtCtx.getFromNamespace(ModuleCtxToModuleQName.class,
- deviateStmtCtx.getRoot());
- final QNameModule targetModule = deviationTarget.getLastComponent().getModule();
-
- final Set<QNameModule> deviationModulesSupportedByTargetModule = modulesDeviatedByModules.get(targetModule);
- if (deviationModulesSupportedByTargetModule != null) {
- return deviationModulesSupportedByTargetModule.contains(currentModule);
- }
-
- return false;
- }
-
- private static void performDeviateAdd(final StatementContextBase<?, ?, ?> deviateStmtCtx,
- final StatementContextBase<?, ?, ?> targetCtx) {
- for (Mutable<?, ?, ?> originalStmtCtx : deviateStmtCtx.mutableDeclaredSubstatements()) {
- validateDeviationTarget(originalStmtCtx, targetCtx);
- addStatement(originalStmtCtx, targetCtx);
- }
- }
-
- private static void addStatement(final Mutable<?, ?, ?> stmtCtxToBeAdded,
- final StatementContextBase<?, ?, ?> targetCtx) {
- if (!StmtContextUtils.isUnknownStatement(stmtCtxToBeAdded)) {
- final StatementDefinition stmtToBeAdded = stmtCtxToBeAdded.getPublicDefinition();
- if (SINGLETON_STATEMENTS.contains(stmtToBeAdded) || YangStmtMapping.DEFAULT.equals(stmtToBeAdded)
- && YangStmtMapping.LEAF.equals(targetCtx.getPublicDefinition())) {
- for (final StmtContext<?, ?, ?> targetCtxSubstatement : targetCtx.allSubstatements()) {
- InferenceException.throwIf(stmtToBeAdded.equals(targetCtxSubstatement.getPublicDefinition()),
- stmtCtxToBeAdded.getStatementSourceReference(),
- "Deviation cannot add substatement %s to target node %s because it is already defined "
- + "in target and can appear only once.",
- stmtToBeAdded.getStatementName(), targetCtx.getStatementArgument());
- }
- }
- }
-
- copyStatement(stmtCtxToBeAdded, targetCtx);
- }
-
- private static void performDeviateReplace(final StatementContextBase<?, ?, ?> deviateStmtCtx,
- final StatementContextBase<?, ?, ?> targetCtx) {
- for (Mutable<?, ?, ?> originalStmtCtx : deviateStmtCtx.mutableDeclaredSubstatements()) {
- validateDeviationTarget(originalStmtCtx, targetCtx);
- replaceStatement(originalStmtCtx, targetCtx);
- }
- }
-
- private static void replaceStatement(final Mutable<?, ?, ?> stmtCtxToBeReplaced,
- final StatementContextBase<?, ?, ?> targetCtx) {
- final StatementDefinition stmtToBeReplaced = stmtCtxToBeReplaced.getPublicDefinition();
-
- if (YangStmtMapping.DEFAULT.equals(stmtToBeReplaced)
- && YangStmtMapping.LEAF_LIST.equals(targetCtx.getPublicDefinition())) {
- LOG.error("Deviation cannot replace substatement {} in target leaf-list {} because a leaf-list can "
- + "have multiple default statements. At line: {}", stmtToBeReplaced.getStatementName(),
- targetCtx.getStatementArgument(), stmtCtxToBeReplaced.getStatementSourceReference());
- return;
- }
-
- for (final StmtContext<?, ?, ?> targetCtxSubstatement : targetCtx.effectiveSubstatements()) {
- if (stmtToBeReplaced.equals(targetCtxSubstatement.getPublicDefinition())) {
- targetCtx.removeStatementFromEffectiveSubstatements(stmtToBeReplaced);
- copyStatement(stmtCtxToBeReplaced, targetCtx);
- return;
- }
- }
-
- for (final Mutable<?, ?, ?> targetCtxSubstatement : targetCtx.mutableDeclaredSubstatements()) {
- if (stmtToBeReplaced.equals(targetCtxSubstatement.getPublicDefinition())) {
- targetCtxSubstatement.setIsSupportedToBuildEffective(false);
- copyStatement(stmtCtxToBeReplaced, targetCtx);
- return;
- }
- }
-
- // This is a special case when deviate replace of a config/mandatory/max/min-elements substatement targets
- // a node which does not contain an explicitly declared config/mandatory/max/min-elements.
- // However, according to RFC6020/RFC7950, these properties are always implicitly present.
- if (IMPLICIT_STATEMENTS.contains(stmtToBeReplaced)) {
- addStatement(stmtCtxToBeReplaced, targetCtx);
- return;
- }
-
- throw new InferenceException(stmtCtxToBeReplaced.getStatementSourceReference(), "Deviation cannot replace "
- + "substatement %s in target node %s because it does not exist in target node.",
- stmtToBeReplaced.getStatementName(), targetCtx.getStatementArgument());
- }
-
- private static void performDeviateDelete(final StatementContextBase<?, ?, ?> deviateStmtCtx,
- final StatementContextBase<?, ?, ?> targetCtx) {
- for (Mutable<?, ?, ?> originalStmtCtx : deviateStmtCtx.mutableDeclaredSubstatements()) {
- validateDeviationTarget(originalStmtCtx, targetCtx);
- deleteStatement(originalStmtCtx, targetCtx);
- }
- }
-
- private static void deleteStatement(final StmtContext<?, ?, ?> stmtCtxToBeDeleted,
- final StatementContextBase<?, ?, ?> targetCtx) {
- final StatementDefinition stmtToBeDeleted = stmtCtxToBeDeleted.getPublicDefinition();
- final String stmtArgument = stmtCtxToBeDeleted.rawStatementArgument();
-
- for (final Mutable<?, ?, ?> targetCtxSubstatement : targetCtx.mutableEffectiveSubstatements()) {
- if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.getPublicDefinition(),
- targetCtxSubstatement.rawStatementArgument())) {
- targetCtx.removeStatementFromEffectiveSubstatements(stmtToBeDeleted, stmtArgument);
- return;
- }
- }
-
- for (final Mutable<?, ?, ?> targetCtxSubstatement : targetCtx.mutableDeclaredSubstatements()) {
- if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.getPublicDefinition(),
- targetCtxSubstatement.rawStatementArgument())) {
- targetCtxSubstatement.setIsSupportedToBuildEffective(false);
- return;
- }
- }
-
- LOG.error("Deviation cannot delete substatement {} with argument '{}' in target node {} because it does "
- + "not exist in the target node. At line: {}", stmtToBeDeleted.getStatementName(), stmtArgument,
- targetCtx.getStatementArgument(), stmtCtxToBeDeleted.getStatementSourceReference());
- }
-
- private static void copyStatement(final Mutable<?, ?, ?> stmtCtxToBeCopied,
- final StatementContextBase<?, ?, ?> targetCtx) {
- // we need to make a copy of the statement context only if it is an unknown statement, otherwise
- // we can reuse the original statement context
- if (!StmtContextUtils.isUnknownStatement(stmtCtxToBeCopied)) {
- targetCtx.addEffectiveSubstatement(stmtCtxToBeCopied);
- } else {
- targetCtx.addEffectiveSubstatement(targetCtx.childCopyOf(stmtCtxToBeCopied, CopyType.ORIGINAL));
- }
- }
-
- private static boolean statementsAreEqual(final StatementDefinition firstStmtDef, final String firstStmtArg,
- final StatementDefinition secondStmtDef, final String secondStmtArg) {
- return firstStmtDef.equals(secondStmtDef) && Objects.equals(firstStmtArg, secondStmtArg);
- }
-
- private static void validateDeviationTarget(final StmtContext<?, ?, ?> deviateSubStmtCtx,
- final StmtContext<?, ?, ?> targetCtx) {
- InferenceException.throwIf(!isSupportedDeviationTarget(deviateSubStmtCtx, targetCtx,
- targetCtx.getRootVersion()), deviateSubStmtCtx.getStatementSourceReference(),
- "%s is not a valid deviation target for substatement %s.",
- targetCtx.getStatementArgument(), deviateSubStmtCtx.getPublicDefinition().getStatementName());
- }
-
- private static boolean isSupportedDeviationTarget(final StmtContext<?, ?, ?> deviateSubstatementCtx,
- final StmtContext<?, ?, ?> deviateTargetCtx, final YangVersion yangVersion) {
- Set<StatementDefinition> supportedDeviationTargets =
- YangValidationBundles.SUPPORTED_DEVIATION_TARGETS.get(deviateTargetCtx.getRootVersion(),
- deviateSubstatementCtx.getPublicDefinition());
-
- if (supportedDeviationTargets == null) {
- supportedDeviationTargets = YangValidationBundles.SUPPORTED_DEVIATION_TARGETS.get(YangVersion.VERSION_1,
- deviateSubstatementCtx.getPublicDefinition());
- }
-
- // if supportedDeviationTargets is null, it means that the deviate substatement is an unknown statement
- return supportedDeviationTargets == null || supportedDeviationTargets.contains(
- deviateTargetCtx.getPublicDefinition());
- }
-
- protected SubstatementValidator getSubstatementValidatorForDeviate(final DeviateKind deviateKind) {
- switch (deviateKind) {
- case NOT_SUPPORTED:
- return DEVIATE_NOT_SUPPORTED_SUBSTATEMENT_VALIDATOR;
- case ADD:
- return DEVIATE_ADD_SUBSTATEMENT_VALIDATOR;
- case REPLACE:
- return DEVIATE_REPLACE_SUBSTATEMENT_VALIDATOR;
- case DELETE:
- return DEVIATE_DELETE_SUBSTATEMENT_VALIDATOR;
- default:
- throw new IllegalStateException(String.format(
- "Substatement validator for deviate %s has not been defined.", deviateKind));
- }
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return null;
- }
- }
-
- @Nonnull
- @Override
- public DeviateKind getValue() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DeviateStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeviationEffectiveStatementImpl;
-
-public class DeviationStatementImpl extends AbstractDeclaredStatement<SchemaNodeIdentifier>
- implements DeviationStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .DEVIATION)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.DEVIATE)
- .addOptional(YangStmtMapping.REFERENCE)
- .build();
-
- protected DeviationStatementImpl(final StmtContext<SchemaNodeIdentifier, DeviationStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<SchemaNodeIdentifier, DeviationStatement,
- EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> {
-
- public Definition() {
- super(YangStmtMapping.DEVIATION);
- }
-
- @Override
- public SchemaNodeIdentifier parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return Utils.nodeIdentifierFromPath(ctx, value);
- }
-
- @Override
- public DeviationStatement createDeclared(final StmtContext<SchemaNodeIdentifier, DeviationStatement, ?> ctx) {
- return new DeviationStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<SchemaNodeIdentifier, DeviationStatement> createEffective(
- final StmtContext<SchemaNodeIdentifier, DeviationStatement,
- EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> ctx) {
- return new DeviationEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onFullDefinitionDeclared(final StmtContext.Mutable<SchemaNodeIdentifier, DeviationStatement,
- EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> ctx) {
- final QNameModule currentModule = ctx.getFromNamespace(ModuleCtxToModuleQName.class,
- ctx.getRoot());
- final QNameModule targetModule = ctx.getStatementArgument().getLastComponent().getModule();
-
- if (currentModule.equals(targetModule)) {
- throw new InferenceException(ctx.getStatementSourceReference(),
- "Deviation must not target the same module as the one it is defined in: %s", currentModule);
- }
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public SchemaNodeIdentifier getTargetNode() {
- return argument();
- }
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends DeviateStatement> getDeviateStatements() {
- return allDeclared(DeviateStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.EnumSpecification;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.EnumSpecificationEffectiveStatementImpl;
-
-public class EnumSpecificationImpl extends AbstractDeclaredStatement<String> implements EnumSpecification {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .TYPE)
- .addMultiple(YangStmtMapping.ENUM)
- .build();
-
- protected EnumSpecificationImpl(final StmtContext<String, EnumSpecification, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractStatementSupport<String, EnumSpecification, EffectiveStatement<String, EnumSpecification>> {
-
- public Definition() {
- super(YangStmtMapping.TYPE);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public EnumSpecification createDeclared(final StmtContext<String, EnumSpecification, ?> ctx) {
- return new EnumSpecificationImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, EnumSpecification> createEffective(
- final StmtContext<String, EnumSpecification, EffectiveStatement<String, EnumSpecification>> ctx) {
- return new EnumSpecificationEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
-
- @Nonnull
- @Override
- public Collection<? extends EnumStatement> getEnums() {
- return allDeclared(EnumStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.EnumEffectiveStatementImpl;
-
-public class EnumStatementImpl extends AbstractDeclaredStatement<String> implements EnumStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .ENUM)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addOptional(YangStmtMapping.VALUE)
- .build();
-
- protected EnumStatementImpl(final StmtContext<String, EnumStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractStatementSupport<String, EnumStatement, EffectiveStatement<String, EnumStatement>> {
-
- public Definition() {
- super(YangStmtMapping.ENUM);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- // FIXME: Checks for real value
- return value;
- }
-
- @Override
- public EnumStatement createDeclared(final StmtContext<String, EnumStatement, ?> ctx) {
- return new EnumStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, EnumStatement> createEffective(
- final StmtContext<String, EnumStatement, EffectiveStatement<String, EnumStatement>> ctx) {
- return new EnumEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends IfFeatureStatement> getIfFeatures() {
- return allDeclared(IfFeatureStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
-
- @Override
- public ValueStatement getValue() {
- return firstDeclared(ValueStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ErrorAppTagEffectiveStatementImpl;
-
-public class ErrorAppTagStatementImpl extends AbstractDeclaredStatement<String>
- implements ErrorAppTagStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .ERROR_APP_TAG)
- .build();
-
- protected ErrorAppTagStatementImpl(
- final StmtContext<String, ErrorAppTagStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractStatementSupport<String, ErrorAppTagStatement, EffectiveStatement<String, ErrorAppTagStatement>> {
-
- public Definition() {
- super(YangStmtMapping.ERROR_APP_TAG);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public ErrorAppTagStatement createDeclared(
- final StmtContext<String, ErrorAppTagStatement, ?> ctx) {
- return new ErrorAppTagStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, ErrorAppTagStatement> createEffective(
- final StmtContext<String, ErrorAppTagStatement, EffectiveStatement<String, ErrorAppTagStatement>> ctx) {
- return new ErrorAppTagEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getValue() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ErrorMessageEffectiveStatementImpl;
-
-public class ErrorMessageStatementImpl extends
- AbstractDeclaredStatement<String> implements ErrorMessageStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .ERROR_MESSAGE)
- .build();
-
- protected ErrorMessageStatementImpl(final StmtContext<String, ErrorMessageStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractStatementSupport<String, ErrorMessageStatement, EffectiveStatement<String, ErrorMessageStatement>> {
-
- public Definition() {
- super(YangStmtMapping.ERROR_MESSAGE);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public ErrorMessageStatement createDeclared(final StmtContext<String, ErrorMessageStatement, ?> ctx) {
- return new ErrorMessageStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, ErrorMessageStatement> createEffective(
- final StmtContext<String, ErrorMessageStatement,
- EffectiveStatement<String, ErrorMessageStatement>> ctx) {
- return new ErrorMessageEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getValue() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
-import org.opendaylight.yangtools.yang.parser.spi.ExtensionNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StatementDefinitionNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ExtensionEffectiveStatementImpl;
-
-public class ExtensionStatementImpl extends AbstractDeclaredStatement<QName> implements ExtensionStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .EXTENSION)
- .addOptional(YangStmtMapping.ARGUMENT)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .build();
-
- protected ExtensionStatementImpl(final StmtContext<QName, ExtensionStatement,?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractQNameStatementSupport<ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> {
- public Definition() {
- super(YangStmtMapping.EXTENSION);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?,?,?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public ExtensionStatement createDeclared(final StmtContext<QName, ExtensionStatement,?> ctx) {
- return new ExtensionStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, ExtensionStatement> createEffective(
- final StmtContext<QName, ExtensionStatement, EffectiveStatement<QName,ExtensionStatement>> ctx) {
- return ExtensionEffectiveStatementImpl.create(ctx);
- }
-
- @Override
- public void onStatementDefinitionDeclared(
- final Mutable<QName, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> stmt) {
- super.onStatementDefinitionDeclared(stmt);
-
- QName stmtName = stmt.getStatementArgument();
- if (SupportedExtensionsMapping.OPENCONFIG_VERSION.getStatementName().isEqualWithoutRevision(stmtName)) {
- stmtName = stmtName.withoutRevision();
- }
-
- stmt.addContext(ExtensionNamespace.class, stmtName, stmt);
-
- final StmtContext<QName, ?, ?> argument = StmtContextUtils.findFirstDeclaredSubstatement(stmt,
- ArgumentStatement.class);
- final StmtContext<Boolean, ?, ?> yinElement = StmtContextUtils.findFirstDeclaredSubstatement(stmt,
- YinElementStatement.class);
-
- stmt.addToNs(StatementDefinitionNamespace.class, stmt.getStatementArgument(),
- new ModelDefinedStatementSupport(new ModelDefinedStatementDefinition(stmt.getStatementArgument(),
- argument != null ? argument.getStatementArgument() : null,
- yinElement != null ? yinElement.getStatementArgument() : false)));
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Override
- public ArgumentStatement getArgument() {
- return firstDeclared(ArgumentStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.FeatureEffectiveStatementImpl;
-
-public class FeatureStatementImpl extends AbstractDeclaredStatement<QName>
- implements FeatureStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .FEATURE)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.STATUS)
- .addOptional(YangStmtMapping.REFERENCE)
- .build();
-
- protected FeatureStatementImpl(
- final StmtContext<QName, FeatureStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractQNameStatementSupport<FeatureStatement, EffectiveStatement<QName, FeatureStatement>> {
-
- public Definition() {
- super(YangStmtMapping.FEATURE);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public FeatureStatement createDeclared(
- final StmtContext<QName, FeatureStatement, ?> ctx) {
- return new FeatureStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, FeatureStatement> createEffective(
- final StmtContext<QName, FeatureStatement, EffectiveStatement<QName, FeatureStatement>> ctx) {
- return new FeatureEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends IfFeatureStatement> getIfFeatures() {
- return allDeclared(IfFeatureStatement.class);
- }
-
- @Nonnull
- @Override
- public QName getName() {
- return argument();
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import com.google.common.collect.Range;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.FractionDigitsEffectiveStatementImpl;
-
-public class FractionDigitsStatementImpl extends AbstractDeclaredStatement<Integer> implements FractionDigitsStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .FRACTION_DIGITS)
- .build();
-
- private static final Range<Integer> FRAC_DIGITS_ALLOWED = Range.closed(1, 18);
-
- protected FractionDigitsStatementImpl(final StmtContext<Integer, FractionDigitsStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<Integer, FractionDigitsStatement,
- EffectiveStatement<Integer, FractionDigitsStatement>> {
-
- public Definition() {
- super(YangStmtMapping.FRACTION_DIGITS);
- }
-
- @Override
- public Integer parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- final Integer fractionDigits;
- try {
- fractionDigits = Integer.valueOf(value);
- } catch (NumberFormatException e) {
- throw new SourceException(ctx.getStatementSourceReference(), e,
- "%s is not valid fraction-digits integer argument", value);
- }
-
- SourceException.throwIf(!FRAC_DIGITS_ALLOWED.contains(fractionDigits), ctx.getStatementSourceReference(),
- "fraction-digits argument should be integer within %s", FRAC_DIGITS_ALLOWED);
- return fractionDigits;
- }
-
- @Override
- public FractionDigitsStatement createDeclared(final StmtContext<Integer, FractionDigitsStatement, ?> ctx) {
- return new FractionDigitsStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<Integer, FractionDigitsStatement> createEffective(
- final StmtContext<Integer, FractionDigitsStatement,
- EffectiveStatement<Integer, FractionDigitsStatement>> ctx) {
- return new FractionDigitsEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public int getValue() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
-import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.GroupingEffectiveStatementImpl;
-
-public class GroupingStatementImpl extends AbstractDeclaredStatement<QName>
- implements GroupingStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .GROUPING)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .build();
-
- protected GroupingStatementImpl(
- final StmtContext<QName, GroupingStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractQNameStatementSupport<GroupingStatement, EffectiveStatement<QName, GroupingStatement>> {
-
- public Definition() {
- super(YangStmtMapping.GROUPING);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public GroupingStatement createDeclared(
- final StmtContext<QName, GroupingStatement, ?> ctx) {
- return new GroupingStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, GroupingStatement> createEffective(
- final StmtContext<QName, GroupingStatement, EffectiveStatement<QName, GroupingStatement>> ctx) {
- return new GroupingEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onFullDefinitionDeclared(final Mutable<QName, GroupingStatement,
- EffectiveStatement<QName, GroupingStatement>> stmt) {
- super.onFullDefinitionDeclared(stmt);
-
- if (stmt != null && stmt.getParentContext() != null) {
- stmt.getParentContext().addContext(GroupingNamespace.class, stmt.getStatementArgument(), stmt);
- }
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public QName getName() {
- return argument();
- }
-
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends TypedefStatement> getTypedefs() {
- return allDeclared(TypedefStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends GroupingStatement> getGroupings() {
- return allDeclared(GroupingStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
- return allDeclared(DataDefinitionStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends ActionStatement> getActions() {
- return allDeclared(ActionStatement.class);
- }
-
- @Override
- public final Collection<? extends NotificationStatement> getNotifications() {
- return allDeclared(NotificationStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.IdentityRefSpecification;
-import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.IdentityRefSpecificationEffectiveStatementImpl;
-
-public class IdentityRefSpecificationImpl extends AbstractDeclaredStatement<String>
- implements IdentityRefSpecification {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .TYPE)
- .addMandatory(YangStmtMapping.BASE)
- .build();
-
- protected IdentityRefSpecificationImpl(final StmtContext<String, IdentityRefSpecification, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<String, IdentityRefSpecification,
- EffectiveStatement<String, IdentityRefSpecification>> {
-
- public Definition() {
- super(YangStmtMapping.TYPE);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public IdentityRefSpecification createDeclared(final StmtContext<String, IdentityRefSpecification, ?> ctx) {
- return new IdentityRefSpecificationImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, IdentityRefSpecification> createEffective(
- final StmtContext<String, IdentityRefSpecification,
- EffectiveStatement<String, IdentityRefSpecification>> ctx) {
- return new IdentityRefSpecificationEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onFullDefinitionDeclared(final Mutable<String, IdentityRefSpecification,
- EffectiveStatement<String, IdentityRefSpecification>> stmt) {
- super.onFullDefinitionDeclared(stmt);
-
- final Collection<StmtContext<QName, BaseStatement, ?>> baseStatements =
- StmtContextUtils.<QName, BaseStatement>findAllDeclaredSubstatements(stmt, BaseStatement.class);
- for (StmtContext<QName, BaseStatement, ?> baseStmt : baseStatements) {
- final QName baseIdentity = baseStmt.getStatementArgument();
- final StmtContext<?, ?, ?> stmtCtx = stmt.getFromNamespace(IdentityNamespace.class, baseIdentity);
- InferenceException.throwIfNull(stmtCtx, stmt.getStatementSourceReference(),
- "Referenced base identity '%s' doesn't exist in given scope (module, imported modules, submodules)",
- baseIdentity.getLocalName());
- }
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
-
- @Nonnull
- @Override
- public Collection<? extends BaseStatement> getBases() {
- return allDeclared(BaseStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.IdentityEffectiveStatementImpl;
-
-public class IdentityStatementImpl extends AbstractDeclaredStatement<QName> implements IdentityStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .IDENTITY)
- .addOptional(YangStmtMapping.BASE)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .build();
-
- protected IdentityStatementImpl(final StmtContext<QName, IdentityStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractQNameStatementSupport<IdentityStatement, EffectiveStatement<QName, IdentityStatement>> {
-
- public Definition() {
- super(YangStmtMapping.IDENTITY);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public IdentityStatement createDeclared(final StmtContext<QName, IdentityStatement, ?> ctx) {
- return new IdentityStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, IdentityStatement> createEffective(
- final StmtContext<QName, IdentityStatement, EffectiveStatement<QName, IdentityStatement>> ctx) {
- return new IdentityEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onStatementDefinitionDeclared(final StmtContext.Mutable<QName, IdentityStatement,
- EffectiveStatement<QName, IdentityStatement>> stmt) {
- stmt.addToNs(IdentityNamespace.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends IfFeatureStatement> getIfFeatures() {
- return allDeclared(IfFeatureStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends BaseStatement> getBases() {
- return allDeclared(BaseStatement.class);
- }
-
- @Nonnull
- @Override
- public QName getName() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import static java.util.Objects.requireNonNull;
-
-import java.util.Set;
-import java.util.function.Predicate;
-import org.antlr.v4.runtime.CharStreams;
-import org.antlr.v4.runtime.CommonTokenStream;
-import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionLexer;
-import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionParser;
-import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionParser.Identifier_ref_argContext;
-import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionParser.If_feature_exprContext;
-import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionParser.If_feature_factorContext;
-import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionParser.If_feature_termContext;
-import org.opendaylight.yangtools.antlrv4.code.gen.IfFeatureExpressionParserBaseVisitor;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.YangVersion;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.IfFeatureEffectiveStatementImpl;
-
-public class IfFeatureStatementImpl extends AbstractDeclaredStatement<Predicate<Set<QName>>>
- implements IfFeatureStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .IF_FEATURE)
- .build();
-
- protected IfFeatureStatementImpl(final StmtContext<Predicate<Set<QName>>, IfFeatureStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<Predicate<Set<QName>>, IfFeatureStatement,
- EffectiveStatement<Predicate<Set<QName>>, IfFeatureStatement>> {
-
- public Definition() {
- super(YangStmtMapping.IF_FEATURE);
- }
-
- @Override
- public Predicate<Set<QName>> parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- if (YangVersion.VERSION_1_1.equals(ctx.getRootVersion())) {
- return parseIfFeatureExpression(ctx, value);
- }
-
- final QName qname = StmtContextUtils.qnameFromArgument(ctx, value);
- return setQNames -> setQNames.contains(qname);
- }
-
- @Override
- public IfFeatureStatement createDeclared(final StmtContext<Predicate<Set<QName>>, IfFeatureStatement, ?> ctx) {
- return new IfFeatureStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<Predicate<Set<QName>>, IfFeatureStatement> createEffective(
- final StmtContext<Predicate<Set<QName>>, IfFeatureStatement,
- EffectiveStatement<Predicate<Set<QName>>, IfFeatureStatement>> ctx) {
- return new IfFeatureEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
- private static Predicate<Set<QName>> parseIfFeatureExpression(final StmtContext<?, ?, ?> ctx,
- final String value) {
- final IfFeatureExpressionLexer lexer = new IfFeatureExpressionLexer(CharStreams.fromString(value));
- final CommonTokenStream tokens = new CommonTokenStream(lexer);
- final IfFeatureExpressionParser parser = new IfFeatureExpressionParser(tokens);
-
- return new IfFeaturePredicateVisitor(ctx).visit(parser.if_feature_expr());
- }
-
- private static class IfFeaturePredicateVisitor
- extends IfFeatureExpressionParserBaseVisitor<Predicate<Set<QName>>> {
- private final StmtContext<?, ?, ?> stmtCtx;
-
- IfFeaturePredicateVisitor(final StmtContext<?, ?, ?> ctx) {
- this.stmtCtx = requireNonNull(ctx);
- }
-
- @Override
- public Predicate<Set<QName>> visitIf_feature_expr(final If_feature_exprContext ctx) {
- if (ctx.if_feature_expr() == null) {
- return visitIf_feature_term(ctx.if_feature_term());
- }
-
- return visitIf_feature_term(ctx.if_feature_term()).or(visitIf_feature_expr(ctx.if_feature_expr()));
- }
-
- @Override
- public Predicate<Set<QName>> visitIf_feature_term(final If_feature_termContext ctx) {
- if (ctx.if_feature_term() == null) {
- return visitIf_feature_factor(ctx.if_feature_factor());
- }
-
- return visitIf_feature_factor(ctx.if_feature_factor()).and(visitIf_feature_term(ctx.if_feature_term()));
- }
-
- @Override
- public Predicate<Set<QName>> visitIf_feature_factor(final If_feature_factorContext ctx) {
- if (ctx.if_feature_expr() != null) {
- return visitIf_feature_expr(ctx.if_feature_expr());
- } else if (ctx.if_feature_factor() != null) {
- return visitIf_feature_factor(ctx.if_feature_factor()).negate();
- } else if (ctx.identifier_ref_arg() != null) {
- return visitIdentifier_ref_arg(ctx.identifier_ref_arg());
- }
-
- throw new SourceException("Unexpected grammar context during parsing of IfFeature expression. "
- + "Most probably IfFeature grammar has been changed.", stmtCtx.getStatementSourceReference());
- }
-
- @Override
- public Predicate<Set<QName>> visitIdentifier_ref_arg(final Identifier_ref_argContext ctx) {
- final QName featureQName = StmtContextUtils.qnameFromArgument(stmtCtx, ctx.getText());
- return setQNames -> setQNames.contains(featureQName);
- }
- }
- }
-
- @Override
- public Predicate<Set<QName>> getIfFeaturePredicate() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import static java.util.Objects.requireNonNull;
-import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_LINKAGE;
-import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_PRE_LINKAGE;
-import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
-import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
-
-import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Verify;
-import java.net.URI;
-import java.util.Collection;
-import java.util.Optional;
-import org.opendaylight.yangtools.concepts.SemVer;
-import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.SemVerSourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.ModuleNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.PreLinkageModuleNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
-import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceKeyCriterion;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionModuleNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionNamespace;
-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;
-import org.opendaylight.yangtools.yang.parser.spi.source.ImpPrefixToNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToModuleCtx;
-import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToSemVerSourceIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.source.ImportedModuleContext;
-import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToSourceIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNameToNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ImportEffectiveStatementImpl;
-
-public class ImportStatementDefinition extends
- AbstractStatementSupport<String, ImportStatement, EffectiveStatement<String, ImportStatement>> {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator
- .builder(YangStmtMapping.IMPORT)
- .addMandatory(YangStmtMapping.PREFIX)
- .addOptional(YangStmtMapping.REVISION_DATE)
- .addOptional(SupportedExtensionsMapping.OPENCONFIG_VERSION)
- .build();
-
- public ImportStatementDefinition() {
- super(YangStmtMapping.IMPORT);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public ImportStatement createDeclared(final StmtContext<String, ImportStatement, ?> ctx) {
- return new ImportStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, ImportStatement> createEffective(
- final StmtContext<String, ImportStatement, EffectiveStatement<String, ImportStatement>> ctx) {
- return new ImportEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onPreLinkageDeclared(final Mutable<String, ImportStatement,
- EffectiveStatement<String, ImportStatement>> stmt) {
- /*
- * Add ModuleIdentifier of a module which is required by this module.
- * Based on this information, required modules are searched from library
- * sources.
- */
- stmt.addRequiredSource(RevisionImport.getImportedSourceIdentifier(stmt));
-
- final String moduleName = stmt.getStatementArgument();
- final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_PRE_LINKAGE);
- final Prerequisite<StmtContext<?, ?, ?>> imported = importAction.requiresCtx(stmt,
- PreLinkageModuleNamespace.class, moduleName, SOURCE_PRE_LINKAGE);
- final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction
- .mutatesCtx(stmt.getRoot(), SOURCE_PRE_LINKAGE);
-
- importAction.apply(new InferenceAction() {
- @Override
- public void apply(final InferenceContext ctx) {
- final StmtContext<?, ?, ?> importedModuleContext = imported.resolve(ctx);
- Verify.verify(moduleName.equals(importedModuleContext.getStatementArgument()));
- final URI importedModuleNamespace = importedModuleContext.getFromNamespace(ModuleNameToNamespace.class,
- moduleName);
- Verify.verifyNotNull(importedModuleNamespace);
- final String impPrefix = SourceException.throwIfNull(
- firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class),
- stmt.getStatementSourceReference(), "Missing prefix statement");
-
- stmt.addToNs(ImpPrefixToNamespace.class, impPrefix, importedModuleNamespace);
- }
-
- @Override
- public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
- InferenceException.throwIf(failed.contains(imported), stmt.getStatementSourceReference(),
- "Imported module [%s] was not found.", moduleName);
- }
- });
- }
-
- @Override
- public void onLinkageDeclared(
- final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
- if (stmt.isEnabledSemanticVersioning()) {
- SemanticVersionImport.onLinkageDeclared(stmt);
- } else {
- RevisionImport.onLinkageDeclared(stmt);
- }
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
- private static class RevisionImport {
-
- private RevisionImport() {
- throw new UnsupportedOperationException("Utility class");
- }
-
- private static void onLinkageDeclared(
- final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
- final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
- final Prerequisite<StmtContext<?, ?, ?>> imported;
- final String moduleName = stmt.getStatementArgument();
- final Revision revision = firstAttributeOf(stmt.declaredSubstatements(), RevisionDateStatement.class);
- if (revision == null) {
- imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
- NamespaceKeyCriterion.latestRevisionModule(moduleName), SOURCE_LINKAGE);
- } else {
- imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
- RevisionSourceIdentifier.create(moduleName, Optional.of(revision)), SOURCE_LINKAGE);
- }
-
- final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction.mutatesCtx(stmt.getRoot(),
- SOURCE_LINKAGE);
-
- importAction.apply(new InferenceAction() {
- @Override
- public void apply(final InferenceContext ctx) {
- final StmtContext<?, ?, ?> importedModule = imported.resolve(ctx);
-
- linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class,
- stmt.getFromNamespace(ModuleCtxToSourceIdentifier.class, importedModule), importedModule);
- final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class);
- final URI modNs = firstAttributeOf(importedModule.declaredSubstatements(),
- NamespaceStatement.class);
- stmt.addToNs(ImportPrefixToModuleCtx.class, impPrefix, importedModule);
- stmt.addToNs(URIStringToImpPrefix.class, modNs.toString(), impPrefix);
- }
-
- @Override
- public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
- if (failed.contains(imported)) {
- throw new InferenceException(stmt.getStatementSourceReference(),
- "Imported module [%s] was not found.", moduleName);
- }
- }
- });
- }
-
- static SourceIdentifier getImportedSourceIdentifier(final StmtContext<String, ImportStatement, ?> stmt) {
- final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
- RevisionDateStatement.class);
- return revision == null ? RevisionSourceIdentifier.create(stmt.getStatementArgument())
- : RevisionSourceIdentifier.create(stmt.getStatementArgument(), revision.getStatementArgument());
- }
- }
-
- private static class SemanticVersionImport {
-
- private abstract static class CompatibleCriterion extends NamespaceKeyCriterion<SemVerSourceIdentifier> {
- private final String moduleName;
-
- CompatibleCriterion(final String moduleName) {
- this.moduleName = requireNonNull(moduleName);
- }
-
- @Override
- public boolean match(final SemVerSourceIdentifier key) {
- return moduleName.equals(key.getName());
- }
-
- @Override
- protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
- return toStringHelper.add("moduleName", moduleName);
- }
- }
-
- private static final class NoVerCompatibleCriterion extends CompatibleCriterion {
- NoVerCompatibleCriterion(final String moduleName) {
- super(moduleName);
- }
-
- @Override
- public SemVerSourceIdentifier select(final SemVerSourceIdentifier first,
- final SemVerSourceIdentifier second) {
- // TODO Auto-generated method stub
- return null;
- }
- }
-
- private static final class SemVerCompatibleCriterion extends CompatibleCriterion {
- private final SemVer semVer;
-
- SemVerCompatibleCriterion(final String moduleName, final SemVer semVer) {
- super(moduleName);
- this.semVer = requireNonNull(semVer);
- }
-
- @Override
- public boolean match(final SemVerSourceIdentifier key) {
- if (!super.match(key)) {
- return false;
- }
- final Optional<SemVer> optKeyVer = key.getSemanticVersion();
- if (!optKeyVer.isPresent()) {
- return false;
- }
-
- final SemVer keyVer = optKeyVer.get();
- if (semVer.getMajor() != keyVer.getMajor()) {
- return false;
- }
- if (semVer.getMinor() > keyVer.getMinor()) {
- return false;
- }
- return semVer.getMinor() < keyVer.getMinor() || semVer.getPatch() <= keyVer.getPatch();
- }
-
- @Override
- public SemVerSourceIdentifier select(final SemVerSourceIdentifier first,
- final SemVerSourceIdentifier second) {
- return first.getSemanticVersion().get().compareTo(second.getSemanticVersion().get()) >= 0 ? first
- : second;
- }
-
- @Override
- protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
- return super.addToStringAttributes(toStringHelper).add("version", semVer);
- }
- }
-
-
- private SemanticVersionImport() {
- throw new UnsupportedOperationException("Utility class");
- }
-
- private static void onLinkageDeclared(
- final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
- final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
- final String moduleName = stmt.getStatementArgument();
- final SemVer semanticVersion = stmt.getFromNamespace(SemanticVersionNamespace.class, stmt);
- final CompatibleCriterion criterion = semanticVersion == null ? new NoVerCompatibleCriterion(moduleName)
- : new SemVerCompatibleCriterion(moduleName, semanticVersion);
-
- final Prerequisite<StmtContext<?, ?, ?>> imported = importAction.requiresCtx(stmt,
- SemanticVersionModuleNamespace.class, criterion, SOURCE_LINKAGE);
- final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction.mutatesCtx(stmt.getRoot(),
- SOURCE_LINKAGE);
-
- importAction.apply(new InferenceAction() {
- @Override
- public void apply(final InferenceContext ctx) {
- final StmtContext<?, ?, ?> importedModule = imported.resolve(ctx);
- final SemVer importedVersion = stmt.getFromNamespace(SemanticVersionNamespace.class, stmt);
- final SourceIdentifier importedModuleIdentifier = importedModule.getFromNamespace(
- ModuleCtxToSourceIdentifier.class, importedModule);
- final SemVerSourceIdentifier semVerModuleIdentifier = createSemVerModuleIdentifier(
- importedModuleIdentifier, importedVersion);
-
- linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class, importedModuleIdentifier,
- importedModule);
- final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class);
- stmt.addToNs(ImportPrefixToModuleCtx.class, impPrefix, importedModule);
- stmt.addToNs(ImportPrefixToSemVerSourceIdentifier.class, impPrefix, semVerModuleIdentifier);
-
- final URI modNs = firstAttributeOf(importedModule.declaredSubstatements(),
- NamespaceStatement.class);
- stmt.addToNs(URIStringToImpPrefix.class, modNs.toString(), impPrefix);
- }
-
- @Override
- public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
- if (failed.contains(imported)) {
- throw new InferenceException(stmt.getStatementSourceReference(),
- "Unable to find module compatible with requested import [%s(%s)].", moduleName,
- getRequestedImportVersionString(stmt));
- }
- }
- });
- }
-
- private static Optional<SemVer> getRequestedImportVersion(final StmtContext<?, ?, ?> stmt) {
- return Optional.ofNullable(stmt.getFromNamespace(SemanticVersionNamespace.class, stmt));
- }
-
- private static String getRequestedImportVersionString(final StmtContext<?, ?, ?> stmt) {
- return getRequestedImportVersion(stmt).map(SemVer::toString).orElse("<any>");
- }
-
- private static SemVerSourceIdentifier createSemVerModuleIdentifier(
- final SourceIdentifier importedModuleIdentifier, final SemVer semVer) {
- return SemVerSourceIdentifier.create(importedModuleIdentifier.getName(),
- importedModuleIdentifier.getRevision(), semVer);
- }
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_LINKAGE;
-import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
-
-import java.util.Collection;
-import java.util.Optional;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
-import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceKeyCriterion;
-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;
-import org.opendaylight.yangtools.yang.parser.spi.source.IncludedModuleContext;
-import org.opendaylight.yangtools.yang.parser.spi.source.IncludedSubmoduleNameToModuleCtx;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.IncludeEffectiveStatementImpl;
-
-public class IncludeStatementImpl extends AbstractDeclaredStatement<String> implements IncludeStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.INCLUDE).addOptional(YangStmtMapping.REVISION_DATE).build();
-
- protected IncludeStatementImpl(final StmtContext<String, IncludeStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractStatementSupport<String, IncludeStatement, EffectiveStatement<String, IncludeStatement>> {
-
- public Definition() {
- super(YangStmtMapping.INCLUDE);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public IncludeStatement createDeclared(final StmtContext<String, IncludeStatement, ?> ctx) {
- return new IncludeStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, IncludeStatement> createEffective(
- final StmtContext<String, IncludeStatement, EffectiveStatement<String, IncludeStatement>> ctx) {
- return new IncludeEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onPreLinkageDeclared(
- final Mutable<String, IncludeStatement, EffectiveStatement<String, IncludeStatement>> stmt) {
- final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
- RevisionDateStatement.class);
- stmt.addRequiredSource(revision == null ? RevisionSourceIdentifier.create(stmt.getStatementArgument())
- : RevisionSourceIdentifier.create(stmt.getStatementArgument(), revision.getStatementArgument()));
- }
-
- @Override
- public void onLinkageDeclared(
- final Mutable<String, IncludeStatement, EffectiveStatement<String, IncludeStatement>> stmt) {
- final String submoduleName = stmt.getStatementArgument();
- final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
- RevisionDateStatement.class);
-
- final ModelActionBuilder includeAction = stmt.newInferenceAction(SOURCE_LINKAGE);
- final Prerequisite<StmtContext<?, ?, ?>> requiresCtxPrerequisite;
- if (revision == null) {
- requiresCtxPrerequisite = includeAction.requiresCtx(stmt, SubmoduleNamespace.class,
- NamespaceKeyCriterion.latestRevisionModule(submoduleName), SOURCE_LINKAGE);
- } else {
- requiresCtxPrerequisite = includeAction.requiresCtx(stmt, SubmoduleNamespace.class,
- RevisionSourceIdentifier.create(submoduleName, Optional.of(revision.getStatementArgument())),
- SOURCE_LINKAGE);
- }
-
- includeAction.apply(new InferenceAction() {
- @Override
- public void apply(final InferenceContext ctx) {
- final StmtContext<?, ?, ?> includedSubModuleContext = requiresCtxPrerequisite.resolve(ctx);
-
- stmt.addToNs(IncludedModuleContext.class, revision != null
- ? RevisionSourceIdentifier.create(submoduleName, revision.getStatementArgument())
- : RevisionSourceIdentifier.create(submoduleName), includedSubModuleContext);
- stmt.addToNs(IncludedSubmoduleNameToModuleCtx.class, stmt.getStatementArgument(),
- includedSubModuleContext);
- }
-
- @Override
- public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
- InferenceException.throwIf(failed.contains(requiresCtxPrerequisite),
- stmt.getStatementSourceReference(),
- "Included submodule '%s' was not found: ", stmt.getStatementArgument());
- }
- });
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getModule() {
- return argument();
- }
-
- @Override
- public RevisionDateStatement getRevisionDate() {
- return firstDeclared(RevisionDateStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.InputEffectiveStatementImpl;
-
-public class InputStatementImpl extends AbstractDeclaredStatement<QName>
- implements InputStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .INPUT)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addAny(YangStmtMapping.CONTAINER)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .build();
-
- protected InputStatementImpl(final StmtContext<QName, InputStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractQNameStatementSupport<InputStatement, EffectiveStatement<QName, InputStatement>> {
-
- public Definition() {
- super(YangStmtMapping.INPUT);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, "input");
- }
-
- @Override
- public void onStatementAdded(final Mutable<QName, InputStatement,
- EffectiveStatement<QName, InputStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override
- public InputStatement createDeclared(
- final StmtContext<QName, InputStatement, ?> ctx) {
- return new InputStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, InputStatement> createEffective(
- final StmtContext<QName, InputStatement, EffectiveStatement<QName, InputStatement>> ctx) {
- return new InputEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public Collection<? extends TypedefStatement> getTypedefs() {
- return allDeclared(TypedefStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends GroupingStatement> getGroupings() {
- return allDeclared(GroupingStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
- return allDeclared(DataDefinitionStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends MustStatement> getMusts() {
- return allDeclared(MustStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.InstanceIdentifierSpecification;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.InstanceIdentifierSpecificationEffectiveStatementImpl;
-
-public class InstanceIdentifierSpecificationImpl extends AbstractDeclaredStatement<String>
- implements InstanceIdentifierSpecification {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .TYPE)
- .addOptional(YangStmtMapping.REQUIRE_INSTANCE)
- .build();
-
- protected InstanceIdentifierSpecificationImpl(final StmtContext<String, InstanceIdentifierSpecification, ?> ctx) {
- super(ctx);
- }
-
- public static class Definition extends AbstractStatementSupport<String, InstanceIdentifierSpecification,
- EffectiveStatement<String, InstanceIdentifierSpecification>> {
-
- public Definition() {
- super(YangStmtMapping.TYPE);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public InstanceIdentifierSpecification createDeclared(
- final StmtContext<String, InstanceIdentifierSpecification, ?> ctx) {
- return new InstanceIdentifierSpecificationImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, InstanceIdentifierSpecification> createEffective(
- final StmtContext<String, InstanceIdentifierSpecification,
- EffectiveStatement<String, InstanceIdentifierSpecification>> ctx) {
- return new InstanceIdentifierSpecificationEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
-
- @Override
- public RequireInstanceStatement getRequireInstance() {
- return firstDeclared(RequireInstanceStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSet.Builder;
-import java.util.Collection;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.QNameCacheNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.KeyEffectiveStatementImpl;
-
-public class KeyStatementImpl extends AbstractDeclaredStatement<Collection<SchemaNodeIdentifier>> implements
- KeyStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .KEY)
- .build();
-
- protected KeyStatementImpl(final StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends
- AbstractStatementSupport<Collection<SchemaNodeIdentifier>, KeyStatement,
- EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement>> {
-
- public Definition() {
- super(YangStmtMapping.KEY);
- }
-
- @Override
- public Collection<SchemaNodeIdentifier> parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- final Builder<SchemaNodeIdentifier> builder = ImmutableSet.builder();
- int tokens = 0;
- for (String keyToken : StmtContextUtils.LIST_KEY_SPLITTER.split(value)) {
- builder.add(SchemaNodeIdentifier.create(false, StmtContextUtils.qnameFromArgument(ctx, keyToken)));
- tokens++;
- }
-
- // Throws NPE on nulls, retains first inserted value, cannot be modified
- final Collection<SchemaNodeIdentifier> ret = builder.build();
- SourceException.throwIf(ret.size() != tokens, ctx.getStatementSourceReference(),
- "Key argument '%s' contains duplicates", value);
- return ret;
- }
-
- @Override
- public Collection<SchemaNodeIdentifier> adaptArgumentValue(
- final StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement,
- EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement>> ctx,
- final QNameModule targetModule) {
- final Builder<SchemaNodeIdentifier> builder = ImmutableSet.builder();
- boolean replaced = false;
- for (final SchemaNodeIdentifier arg : ctx.getStatementArgument()) {
- final QName qname = arg.getLastComponent();
- if (!targetModule.equals(qname.getModule())) {
- final QName newQname = ctx.getFromNamespace(QNameCacheNamespace.class,
- QName.create(targetModule, qname.getLocalName()));
- builder.add(SchemaNodeIdentifier.create(false, newQname));
- replaced = true;
- } else {
- builder.add(arg);
- }
- }
-
- // This makes sure we reuse the collection when a grouping is
- // instantiated in the same module
- return replaced ? builder.build() : ctx.getStatementArgument();
- }
-
- @Override
- public KeyStatement createDeclared(final StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement, ?> ctx) {
- return new KeyStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement> createEffective(
- final StmtContext<Collection<SchemaNodeIdentifier>, KeyStatement,
- EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement>> ctx) {
- return new KeyEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.LeafrefSpecification;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.LeafrefSpecificationEffectiveStatementImpl;
-
-public class LeafrefSpecificationImpl extends AbstractDeclaredStatement<String>
- implements LeafrefSpecification {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .TYPE)
- .addMandatory(YangStmtMapping.PATH)
- .build();
-
- protected LeafrefSpecificationImpl(
- final StmtContext<String, LeafrefSpecification, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends
- AbstractStatementSupport<String, LeafrefSpecification, EffectiveStatement<String, LeafrefSpecification>> {
-
- public Definition() {
- super(YangStmtMapping.TYPE);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public LeafrefSpecification createDeclared(final StmtContext<String, LeafrefSpecification, ?> ctx) {
- return new LeafrefSpecificationImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, LeafrefSpecification> createEffective(
- final StmtContext<String, LeafrefSpecification, EffectiveStatement<String, LeafrefSpecification>> ctx) {
- return new LeafrefSpecificationEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
-
- @Nonnull
- @Override
- public PathStatement getPath() {
- return firstDeclared(PathStatement.class);
- }
-
- @Nullable
- @Override
- public RequireInstanceStatement getRequireInstance() {
- return firstDeclared(RequireInstanceStatement.class);
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.List;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.LengthStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.LengthEffectiveStatementImpl;
-
-public class LengthStatementImpl extends AbstractDeclaredStatement<List<ValueRange>>
- implements LengthStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .LENGTH)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.ERROR_APP_TAG)
- .addOptional(YangStmtMapping.ERROR_MESSAGE)
- .addOptional(YangStmtMapping.REFERENCE)
- .build();
-
- protected LengthStatementImpl(final StmtContext<List<ValueRange>, LengthStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<List<ValueRange>, LengthStatement,
- EffectiveStatement<List<ValueRange>, LengthStatement>> {
-
- public Definition() {
- super(YangStmtMapping.LENGTH);
- }
-
- @Override
- public List<ValueRange> parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return TypeUtils.parseLengthListFromString(ctx, value);
- }
-
- @Override
- public LengthStatement createDeclared(final StmtContext<List<ValueRange>, LengthStatement, ?> ctx) {
- return new LengthStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<List<ValueRange>, LengthStatement> createEffective(
- final StmtContext<List<ValueRange>, LengthStatement, EffectiveStatement<List<ValueRange>,
- LengthStatement>> ctx) {
- return new LengthEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public ErrorAppTagStatement getErrorAppTagStatement() {
- return firstDeclared(ErrorAppTagStatement.class);
- }
-
- @Override
- public ErrorMessageStatement getErrorMessageStatement() {
- return firstDeclared(ErrorMessageStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MandatoryEffectiveStatementImpl;
-
-public class MandatoryStatementImpl extends AbstractDeclaredStatement<Boolean> implements MandatoryStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .MANDATORY)
- .build();
-
- protected MandatoryStatementImpl(final StmtContext<Boolean, MandatoryStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractStatementSupport<Boolean, MandatoryStatement, EffectiveStatement<Boolean, MandatoryStatement>> {
-
- public Definition() {
- super(YangStmtMapping.MANDATORY);
- }
-
- @Override
- public Boolean parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return Utils.parseBoolean(ctx, value);
- }
-
- @Override
- public MandatoryStatement createDeclared(final StmtContext<Boolean, MandatoryStatement, ?> ctx) {
- final MandatoryStatement ret = new MandatoryStatementImpl(ctx);
- if (EmptyMandatoryStatement.FALSE.equals(ret)) {
- return EmptyMandatoryStatement.FALSE;
- } else if (EmptyMandatoryStatement.TRUE.equals(ret)) {
- return EmptyMandatoryStatement.TRUE;
- } else {
- return ret;
- }
- }
-
- @Override
- public EffectiveStatement<Boolean, MandatoryStatement> createEffective(
- final StmtContext<Boolean, MandatoryStatement, EffectiveStatement<Boolean, MandatoryStatement>> ctx) {
- final EffectiveStatement<Boolean, MandatoryStatement> ret = new MandatoryEffectiveStatementImpl(ctx);
- final MandatoryStatement declared = ret.getDeclared();
- if (declared instanceof EmptyMandatoryStatement && ret.effectiveSubstatements().isEmpty()) {
- return ((EmptyMandatoryStatement)declared).toEffective();
- }
- return ret;
- }
-
- @Override
- public String internArgument(final String rawArgument) {
- return Utils.internBoolean(rawArgument);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- @Nonnull public Boolean getValue() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MaxElementsEffectiveStatementImpl;
-
-public class MaxElementsStatementImpl extends AbstractDeclaredStatement<String>
- implements MaxElementsStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .MAX_ELEMENTS)
- .build();
-
- protected MaxElementsStatementImpl(
- final StmtContext<String, MaxElementsStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends
- AbstractStatementSupport<String, MaxElementsStatement, EffectiveStatement<String, MaxElementsStatement>> {
-
- public Definition() {
- super(YangStmtMapping.MAX_ELEMENTS);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public MaxElementsStatement createDeclared(
- final StmtContext<String, MaxElementsStatement, ?> ctx) {
- return new MaxElementsStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, MaxElementsStatement> createEffective(
- final StmtContext<String, MaxElementsStatement, EffectiveStatement<String, MaxElementsStatement>> ctx) {
- return new MaxElementsEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getValue() {
- return argument();
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MinElementsEffectiveStatementImpl;
-
-public class MinElementsStatementImpl extends
- AbstractDeclaredStatement<Integer> implements MinElementsStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .MIN_ELEMENTS)
- .build();
-
- protected MinElementsStatementImpl(
- final StmtContext<Integer, MinElementsStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends
- AbstractStatementSupport<Integer, MinElementsStatement, EffectiveStatement<Integer, MinElementsStatement>> {
-
- public Definition() {
- super(YangStmtMapping.MIN_ELEMENTS);
- }
-
- @Override
- public Integer parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return Integer.parseInt(value);
- }
-
- @Override
- public MinElementsStatement createDeclared(
- final StmtContext<Integer, MinElementsStatement, ?> ctx) {
- return new MinElementsStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<Integer, MinElementsStatement> createEffective(
- final StmtContext<Integer, MinElementsStatement,
- EffectiveStatement<Integer, MinElementsStatement>> ctx) {
- return new MinElementsEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public Integer getValue() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MustEffectiveStatementImpl;
-
-public class MustStatementImpl extends AbstractDeclaredStatement<RevisionAwareXPath> implements MustStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .MUST)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.ERROR_APP_TAG)
- .addOptional(YangStmtMapping.ERROR_MESSAGE)
- .addOptional(YangStmtMapping.REFERENCE)
- .build();
-
- protected MustStatementImpl(final StmtContext<RevisionAwareXPath, MustStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<RevisionAwareXPath, MustStatement,
- EffectiveStatement<RevisionAwareXPath, MustStatement>> {
-
- public Definition() {
- super(YangStmtMapping.MUST);
- }
-
- @Override
- public RevisionAwareXPath parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return Utils.parseXPath(ctx, value);
- }
-
- @Override
- public MustStatement createDeclared(final StmtContext<RevisionAwareXPath, MustStatement, ?> ctx) {
- return new MustStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<RevisionAwareXPath, MustStatement> createEffective(
- final StmtContext<RevisionAwareXPath, MustStatement,
- EffectiveStatement<RevisionAwareXPath, MustStatement>> ctx) {
- return new MustEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public RevisionAwareXPath getCondition() {
- return argument();
- }
-
- @Nullable
- @Override
- public ErrorAppTagStatement getErrorAppTagStatement() {
- return firstDeclared(ErrorAppTagStatement.class);
- }
-
- @Nullable
- @Override
- public ErrorMessageStatement getErrorMessageStatement() {
- return firstDeclared(ErrorMessageStatement.class);
- }
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.net.URI;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.NamespaceEffectiveStatementImpl;
-
-public class NamespaceStatementImpl extends AbstractDeclaredStatement<URI> implements NamespaceStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .NAMESPACE)
- .build();
-
- public static class Definition extends AbstractStatementSupport<URI, NamespaceStatement,
- EffectiveStatement<URI, NamespaceStatement>> {
-
- public Definition() {
- super(org.opendaylight.yangtools.yang.model.api.YangStmtMapping.NAMESPACE);
- }
-
- @Override
- public URI parseArgumentValue(final StmtContext<?, ?,?> ctx, final String value) {
- return URI.create(value);
- }
-
- @Override
- public NamespaceStatement createDeclared(final StmtContext<URI, NamespaceStatement,?> ctx) {
- return new NamespaceStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<URI,NamespaceStatement> createEffective(
- final StmtContext<URI, NamespaceStatement, EffectiveStatement<URI, NamespaceStatement>> ctx) {
- return new NamespaceEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- NamespaceStatementImpl(final StmtContext<URI, NamespaceStatement,?> context) {
- super(context);
- }
-
- @Nonnull
- @Override
- public URI getUri() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.NotificationEffectiveStatementImpl;
-
-public class NotificationStatementImpl extends AbstractDeclaredStatement<QName>
- implements NotificationStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .NOTIFICATION)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .build();
-
- protected NotificationStatementImpl(
- final StmtContext<QName, NotificationStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends
- AbstractQNameStatementSupport<NotificationStatement, EffectiveStatement<QName, NotificationStatement>> {
-
- public Definition() {
- super(YangStmtMapping.NOTIFICATION);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public void onStatementAdded(
- final Mutable<QName, NotificationStatement, EffectiveStatement<QName, NotificationStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override
- public NotificationStatement createDeclared(
- final StmtContext<QName, NotificationStatement, ?> ctx) {
- return new NotificationStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, NotificationStatement> createEffective(
- final StmtContext<QName, NotificationStatement, EffectiveStatement<QName, NotificationStatement>> ctx) {
- return new NotificationEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public QName getName() {
- return argument();
- }
-
- @Nonnull
- @Override
- public Collection<? extends TypedefStatement> getTypedefs() {
- return allDeclared(TypedefStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends GroupingStatement> getGroupings() {
- return allDeclared(GroupingStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
- return allDeclared(DataDefinitionStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends MustStatement> getMusts() {
- return allDeclared(MustStatement.class);
- }
-
- @Nullable
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends IfFeatureStatement> getIfFeatures() {
- return allDeclared(IfFeatureStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OrderedByEffectiveStatementImpl;
-
-public class OrderedByStatementImpl extends AbstractDeclaredStatement<String> implements OrderedByStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .ORDERED_BY)
- .build();
-
- protected OrderedByStatementImpl(
- final StmtContext<String, OrderedByStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends
- AbstractStatementSupport<String, OrderedByStatement, EffectiveStatement<String, OrderedByStatement>> {
-
- public Definition() {
- super(YangStmtMapping.ORDERED_BY);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public OrderedByStatement createDeclared(final StmtContext<String, OrderedByStatement, ?> ctx) {
- return new OrderedByStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, OrderedByStatement> createEffective(
- final StmtContext<String, OrderedByStatement, EffectiveStatement<String, OrderedByStatement>> ctx) {
- return new OrderedByEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
- @Override
- public String internArgument(final String rawArgument) {
- if ("user".equals(rawArgument)) {
- return "user";
- } else if ("system".equals(rawArgument)) {
- return "system";
- } else {
- return rawArgument;
- }
- }
- }
-
- @Nonnull
- @Override
- public String getValue() {
- return argument();
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OrganizationEffectiveStatementImpl;
-
-public class OrganizationStatementImpl extends AbstractDeclaredStatement<String> implements OrganizationStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .ORGANIZATION)
- .build();
-
- protected OrganizationStatementImpl(
- final StmtContext<String, OrganizationStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends
- AbstractStatementSupport<String, OrganizationStatement, EffectiveStatement<String, OrganizationStatement>> {
-
- public Definition() {
- super(YangStmtMapping.ORGANIZATION);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public OrganizationStatement createDeclared(
- final StmtContext<String, OrganizationStatement, ?> ctx) {
- return new OrganizationStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, OrganizationStatement> createEffective(
- final StmtContext<String, OrganizationStatement,
- EffectiveStatement<String, OrganizationStatement>> ctx) {
- return new OrganizationEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getText() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OutputEffectiveStatementImpl;
-
-public class OutputStatementImpl extends AbstractDeclaredStatement<QName> implements OutputStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .OUTPUT)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.CHOICE)
- .addAny(YangStmtMapping.CONTAINER)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .build();
-
- protected OutputStatementImpl(final StmtContext<QName, OutputStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractQNameStatementSupport<OutputStatement, EffectiveStatement<QName, OutputStatement>> {
-
- public Definition() {
- super(YangStmtMapping.OUTPUT);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, "output");
- }
-
- @Override
- public void onStatementAdded(final Mutable<QName, OutputStatement,
- EffectiveStatement<QName, OutputStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override
- public OutputStatement createDeclared(final StmtContext<QName, OutputStatement, ?> ctx) {
- return new OutputStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, OutputStatement> createEffective(
- final StmtContext<QName, OutputStatement, EffectiveStatement<QName, OutputStatement>> ctx) {
- return new OutputEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public Collection<? extends TypedefStatement> getTypedefs() {
- return allDeclared(TypedefStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends GroupingStatement> getGroupings() {
- return allDeclared(GroupingStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
- return allDeclared(DataDefinitionStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends MustStatement> getMusts() {
- return allDeclared(MustStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PathEffectiveStatementImpl;
-
-public class PathStatementImpl extends AbstractDeclaredStatement<RevisionAwareXPath> implements PathStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .PATH)
- .build();
-
- protected PathStatementImpl(final StmtContext<RevisionAwareXPath, PathStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<RevisionAwareXPath, PathStatement,
- EffectiveStatement<RevisionAwareXPath, PathStatement>> {
-
- public Definition() {
- super(YangStmtMapping.PATH);
- }
-
- @Override
- public RevisionAwareXPath parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return Utils.parseXPath(ctx, value);
- }
-
- @Override
- public PathStatement createDeclared(final StmtContext<RevisionAwareXPath, PathStatement, ?> ctx) {
- return new PathStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<RevisionAwareXPath, PathStatement> createEffective(
- final StmtContext<RevisionAwareXPath, PathStatement,
- EffectiveStatement<RevisionAwareXPath, PathStatement>> ctx) {
- return new PathEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getValue() {
- return rawArgument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Optional;
-import java.util.regex.Pattern;
-import java.util.regex.PatternSyntaxException;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ModifierStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-import org.opendaylight.yangtools.yang.model.util.RegexUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.PatternConstraintEffectiveImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.PatternEffectiveStatementImpl;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class PatternStatementImpl extends AbstractDeclaredStatement<PatternConstraint> implements PatternStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .PATTERN)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.ERROR_APP_TAG)
- .addOptional(YangStmtMapping.ERROR_MESSAGE)
- .addOptional(YangStmtMapping.REFERENCE)
- .build();
- private static final Logger LOG = LoggerFactory.getLogger(PatternStatementImpl.class);
-
- protected PatternStatementImpl(final StmtContext<PatternConstraint, PatternStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<PatternConstraint, PatternStatement,
- EffectiveStatement<PatternConstraint, PatternStatement>> {
-
- public Definition() {
- super(YangStmtMapping.PATTERN);
- }
-
- @Override
- public PatternConstraint parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- final String pattern = RegexUtils.getJavaRegexFromXSD(value);
-
- try {
- Pattern.compile(pattern);
- } catch (final PatternSyntaxException e) {
- LOG.debug("Pattern \"{}\" failed to compile at {}", pattern, ctx.getStatementSourceReference(), e);
- return null;
- }
-
- return new PatternConstraintEffectiveImpl(pattern, value, Optional.empty(), Optional.empty());
- }
-
- @Override
- public PatternStatement createDeclared(final StmtContext<PatternConstraint, PatternStatement, ?> ctx) {
- return new PatternStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<PatternConstraint, PatternStatement> createEffective(
- final StmtContext<PatternConstraint, PatternStatement,
- EffectiveStatement<PatternConstraint, PatternStatement>> ctx) {
- return new PatternEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public ErrorAppTagStatement getErrorAppTagStatement() {
- return firstDeclared(ErrorAppTagStatement.class);
- }
-
- @Override
- public ErrorMessageStatement getErrorMessageStatement() {
- return firstDeclared(ErrorMessageStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Override
- public ModifierStatement getModifierStatement() {
- return firstDeclared(ModifierStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Nonnull
- @Override
- public PatternConstraint getValue() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PositionEffectiveStatementImpl;
-
-public class PositionStatementImpl extends AbstractDeclaredStatement<Long> implements PositionStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.POSITION).build();
-
- protected PositionStatementImpl(final StmtContext<Long, PositionStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<Long, PositionStatement,
- EffectiveStatement<Long, PositionStatement>> {
-
- public Definition() {
- super(YangStmtMapping.POSITION);
- }
-
- @Override
- public Long parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- try {
- return Long.parseLong(value);
- } catch (NumberFormatException e) {
- throw new SourceException(String.format("Bit position value %s is not valid integer", value),
- ctx.getStatementSourceReference(), e);
- }
- }
-
- @Override
- public PositionStatement createDeclared(final StmtContext<Long, PositionStatement, ?> ctx) {
- return new PositionStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<Long, PositionStatement> createEffective(
- final StmtContext<Long, PositionStatement, EffectiveStatement<Long, PositionStatement>> ctx) {
- return new PositionEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public long getValue() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PrefixEffectiveStatementImpl;
-
-public class PrefixStatementImpl extends AbstractDeclaredStatement<String> implements PrefixStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .PREFIX)
- .build();
-
- public static class Definition
- extends AbstractStatementSupport<String, PrefixStatement, EffectiveStatement<String, PrefixStatement>> {
-
- public Definition() {
- super(YangStmtMapping.PREFIX);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?,?> ctx, final String value) {
- return value;
- }
-
- @Override
- public PrefixStatement createDeclared(final StmtContext<String, PrefixStatement,?> ctx) {
- return new PrefixStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String,PrefixStatement> createEffective(
- final StmtContext<String, PrefixStatement, EffectiveStatement<String, PrefixStatement>> ctx) {
- return new PrefixEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- PrefixStatementImpl(final StmtContext<String, PrefixStatement,?> context) {
- super(context);
- }
-
- @Nonnull
- @Override
- public String getValue() {
- return rawArgument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PresenceEffectiveStatementImpl;
-
-public class PresenceStatementImpl extends AbstractDeclaredStatement<String> implements PresenceStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .PRESENCE)
- .build();
-
- protected PresenceStatementImpl(final StmtContext<String, PresenceStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends
- AbstractStatementSupport<String, PresenceStatement, EffectiveStatement<String, PresenceStatement>> {
-
- public Definition() {
- super(YangStmtMapping.PRESENCE);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public PresenceStatement createDeclared(final StmtContext<String, PresenceStatement, ?> ctx) {
- return new PresenceStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, PresenceStatement> createEffective(
- final StmtContext<String, PresenceStatement, EffectiveStatement<String, PresenceStatement>> ctx) {
- return new PresenceEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getValue() {
- return argument();
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.math.BigDecimal;
-import java.util.List;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.RangeEffectiveStatementImpl;
-
-public class RangeStatementImpl extends AbstractDeclaredStatement<List<ValueRange>> implements RangeStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .RANGE)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.ERROR_APP_TAG)
- .addOptional(YangStmtMapping.ERROR_MESSAGE)
- .addOptional(YangStmtMapping.REFERENCE)
- .build();
-
- // these objects are to compare whether range has MAX or MIN value
- // none of these values should appear as Yang number according to spec so they are safe to use
- public static final BigDecimal YANG_MIN_NUM = BigDecimal.valueOf(-Double.MAX_VALUE);
- public static final BigDecimal YANG_MAX_NUM = BigDecimal.valueOf(Double.MAX_VALUE);
-
- protected RangeStatementImpl(final StmtContext<List<ValueRange>, RangeStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<List<ValueRange>, RangeStatement,
- EffectiveStatement<List<ValueRange>, RangeStatement>> {
-
- public Definition() {
- super(YangStmtMapping.RANGE);
- }
-
- @Override
- public List<ValueRange> parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return TypeUtils.parseRangeListFromString(ctx, value);
- }
-
- @Override
- public RangeStatement createDeclared(final StmtContext<List<ValueRange>, RangeStatement, ?> ctx) {
- return new RangeStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<List<ValueRange>, RangeStatement> createEffective(
- final StmtContext<List<ValueRange>, RangeStatement, EffectiveStatement<List<ValueRange>,
- RangeStatement>> ctx) {
- return new RangeEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public ErrorAppTagStatement getErrorAppTagStatement() {
- return firstDeclared(ErrorAppTagStatement.class);
- }
-
- @Override
- public ErrorMessageStatement getErrorMessageStatement() {
- return firstDeclared(ErrorMessageStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ReferenceEffectiveStatementImpl;
-
-public class ReferenceStatementImpl extends AbstractDeclaredStatement<String> implements ReferenceStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .REFERENCE)
- .build();
-
- protected ReferenceStatementImpl(final StmtContext<String, ReferenceStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<String, ReferenceStatement,
- EffectiveStatement<String, ReferenceStatement>> {
-
- public Definition() {
- super(YangStmtMapping.REFERENCE);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public ReferenceStatement createDeclared(final StmtContext<String, ReferenceStatement, ?> ctx) {
- return new ReferenceStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, ReferenceStatement> createEffective(
- final StmtContext<String, ReferenceStatement, EffectiveStatement<String, ReferenceStatement>> ctx) {
- return new ReferenceEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getText() {
- return rawArgument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RequireInstanceEffectiveStatementImpl;
-
-public class RequireInstanceStatementImpl extends AbstractDeclaredStatement<Boolean>
- implements RequireInstanceStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.REQUIRE_INSTANCE).build();
-
- protected RequireInstanceStatementImpl(final StmtContext<Boolean, RequireInstanceStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<Boolean, RequireInstanceStatement,
- EffectiveStatement<Boolean, RequireInstanceStatement>> {
-
- public Definition() {
- super(YangStmtMapping.REQUIRE_INSTANCE);
- }
-
- @Override
- public Boolean parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return Utils.parseBoolean(ctx, value);
- }
-
- @Override
- public RequireInstanceStatement createDeclared(final StmtContext<Boolean, RequireInstanceStatement, ?> ctx) {
- return new RequireInstanceStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<Boolean, RequireInstanceStatement> createEffective(
- final StmtContext<Boolean, RequireInstanceStatement,
- EffectiveStatement<Boolean, RequireInstanceStatement>> ctx) {
- return new RequireInstanceEffectiveStatementImpl(ctx);
- }
-
- @Override
- public String internArgument(final String rawArgument) {
- return Utils.internBoolean(rawArgument);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public boolean getValue() {
- return argument().booleanValue();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.time.format.DateTimeParseException;
-import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RevisionDateEffectiveStatementImpl;
-
-public class RevisionDateStatementImpl extends AbstractDeclaredStatement<Revision> implements RevisionDateStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR =
- SubstatementValidator.builder(YangStmtMapping.REVISION_DATE).build();
-
- protected RevisionDateStatementImpl(final StmtContext<Revision, RevisionDateStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<Revision, RevisionDateStatement,
- EffectiveStatement<Revision, RevisionDateStatement>> {
-
- public Definition() {
- super(YangStmtMapping.REVISION_DATE);
- }
-
- @Override
- public Revision parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- try {
- return Revision.of(value);
- } catch (DateTimeParseException e) {
- throw new SourceException(ctx.getStatementSourceReference(), e,
- "Revision value %s is not in required format yyyy-MM-dd", value);
- }
- }
-
- @Override
- public RevisionDateStatement createDeclared(final StmtContext<Revision, RevisionDateStatement, ?> ctx) {
- return new RevisionDateStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<Revision, RevisionDateStatement> createEffective(final StmtContext<Revision,
- RevisionDateStatement, EffectiveStatement<Revision, RevisionDateStatement>> ctx) {
- return new RevisionDateEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public Revision getDate() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.time.format.DateTimeParseException;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RevisionEffectiveStatementImpl;
-
-public class RevisionStatementImpl extends AbstractDeclaredStatement<Revision>
- implements RevisionStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.REVISION)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.REFERENCE)
- .build();
-
- protected RevisionStatementImpl(final StmtContext<Revision, RevisionStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractStatementSupport<Revision, RevisionStatement, EffectiveStatement<Revision, RevisionStatement>> {
-
- public Definition() {
- super(YangStmtMapping.REVISION);
- }
-
- @Override
- public Revision parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- try {
- return Revision.of(value);
- } catch (DateTimeParseException e) {
- throw new SourceException(ctx.getStatementSourceReference(), e,
- "Revision value %s is not in required format yyyy-MM-dd", value);
- }
- }
-
- @Override
- public RevisionStatement createDeclared(final StmtContext<Revision, RevisionStatement, ?> ctx) {
- return new RevisionStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<Revision, RevisionStatement> createEffective(
- final StmtContext<Revision, RevisionStatement, EffectiveStatement<Revision, RevisionStatement>> ctx) {
- return new RevisionEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public Revision getDate() {
- return argument();
- }
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.ImplicitSubstatement;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementDefinitionContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RpcEffectiveStatementImpl;
-
-public class RpcStatementImpl extends AbstractDeclaredStatement<QName> implements RpcStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .RPC)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.INPUT)
- .addOptional(YangStmtMapping.OUTPUT)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addAny(YangStmtMapping.TYPEDEF)
- .build();
-
- protected RpcStatementImpl(final StmtContext<QName, RpcStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractQNameStatementSupport<RpcStatement, EffectiveStatement<QName, RpcStatement>> {
- // TODO: share instances
- private static final StatementSupport<?, ?, ?> IMPLICIT_INPUT = new InputStatementImpl.Definition();
- private static final StatementSupport<?, ?, ?> IMPLICIT_OUTPUT = new OutputStatementImpl.Definition();
-
- public Definition() {
- super(YangStmtMapping.RPC);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public void onStatementAdded(final Mutable<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override
- public RpcStatement createDeclared(
- final StmtContext<QName, RpcStatement, ?> ctx) {
- return new RpcStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, RpcStatement> createEffective(
- final StmtContext<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> ctx) {
- return new RpcEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onFullDefinitionDeclared(
- final Mutable<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> stmt) {
- super.onFullDefinitionDeclared(stmt);
-
- if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, InputStatement.class) == null) {
- addImplicitStatement((StatementContextBase<?, ?, ?>) stmt, implictInput());
- }
-
- if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, OutputStatement.class) == null) {
- addImplicitStatement((StatementContextBase<?, ?, ?>) stmt, implictOutput());
- }
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
- protected StatementSupport<?, ?, ?> implictInput() {
- return IMPLICIT_INPUT;
- }
-
- protected StatementSupport<?, ?, ?> implictOutput() {
- return IMPLICIT_OUTPUT;
- }
-
- private static void addImplicitStatement(final StatementContextBase<?, ?, ?> parent,
- final StatementSupport<?, ?, ?> statementToAdd) {
- final StatementDefinitionContext<?, ?, ?> stmtDefCtx = new StatementDefinitionContext<>(statementToAdd);
-
- parent.createSubstatement(parent.declaredSubstatements().size(), stmtDefCtx,
- ImplicitSubstatement.of(parent.getStatementSourceReference()), null);
- }
- }
-
- @Override
- public QName getName() {
- return argument();
- }
-
- @Nonnull
- @Override
- public Collection<? extends TypedefStatement> getTypedefs() {
- return allDeclared(TypedefStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends GroupingStatement> getGroupings() {
- return allDeclared(GroupingStatement.class);
- }
-
- @Nullable
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Override
- public InputStatement getInput() {
- return firstDeclared(InputStatement.class);
- }
-
- @Override
- public OutputStatement getOutput() {
- return firstDeclared(OutputStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends IfFeatureStatement> getIfFeatures() {
- return allDeclared(IfFeatureStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.StatusEffectiveStatementImpl;
-
-public class StatusStatementImpl extends AbstractDeclaredStatement<Status>
- implements StatusStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .STATUS)
- .build();
-
- protected StatusStatementImpl(
- final StmtContext<Status, StatusStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends
- AbstractStatementSupport<Status, StatusStatement, EffectiveStatement<Status, StatusStatement>> {
-
- public Definition() {
- super(YangStmtMapping.STATUS);
- }
-
- @Override
- public Status parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- switch (value) {
- case "current":
- return Status.CURRENT;
- case "deprecated":
- return Status.DEPRECATED;
- case "obsolete":
- return Status.OBSOLETE;
- default:
- throw new SourceException(ctx.getStatementSourceReference(),
- "Invalid status '%s', must be one of 'current', 'deprecated' or 'obsolete'", value);
- }
- }
-
- @Override
- public StatusStatement createDeclared(
- final StmtContext<Status, StatusStatement, ?> ctx) {
- return new StatusStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<Status, StatusStatement> createEffective(
- final StmtContext<Status, StatusStatement, EffectiveStatement<Status, StatusStatement>> ctx) {
- return new StatusEffectiveStatementImpl(ctx);
- }
-
- @Override
- public String internArgument(final String rawArgument) {
- if ("current".equals(rawArgument)) {
- return "current";
- } else if ("deprecated".equals(rawArgument)) {
- return "deprecated";
- } else if ("obsolete".equals(rawArgument)) {
- return "obsolete";
- } else {
- return rawArgument;
- }
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public Status getValue() {
- return argument();
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
-import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace;
-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.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.BelongsToPrefixToModuleName;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.SubmoduleEffectiveStatementImpl;
-
-public class SubmoduleStatementImpl extends AbstractRootStatement<SubmoduleStatement> implements SubmoduleStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .SUBMODULE)
- .addAny(YangStmtMapping.ANYXML)
- .addAny(YangStmtMapping.AUGMENT)
- .addMandatory(YangStmtMapping.BELONGS_TO)
- .addAny(YangStmtMapping.CHOICE)
- .addOptional(YangStmtMapping.CONTACT)
- .addAny(YangStmtMapping.CONTAINER)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.DEVIATION)
- .addAny(YangStmtMapping.EXTENSION)
- .addAny(YangStmtMapping.FEATURE)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IDENTITY)
- .addAny(YangStmtMapping.IMPORT)
- .addAny(YangStmtMapping.INCLUDE)
- .addAny(YangStmtMapping.LEAF)
- .addAny(YangStmtMapping.LEAF_LIST)
- .addAny(YangStmtMapping.LIST)
- .addAny(YangStmtMapping.NOTIFICATION)
- .addOptional(YangStmtMapping.ORGANIZATION)
- .addOptional(YangStmtMapping.REFERENCE)
- .addAny(YangStmtMapping.REVISION)
- .addAny(YangStmtMapping.RPC)
- .addAny(YangStmtMapping.TYPEDEF)
- .addAny(YangStmtMapping.USES)
- .addOptional(YangStmtMapping.YANG_VERSION)
- .build();
-
- protected SubmoduleStatementImpl(final StmtContext<String, SubmoduleStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<String, SubmoduleStatement,
- EffectiveStatement<String, SubmoduleStatement>> {
-
- public Definition() {
- super(YangStmtMapping.SUBMODULE);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public SubmoduleStatement createDeclared(
- final StmtContext<String, SubmoduleStatement, ?> ctx) {
- return new SubmoduleStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, SubmoduleStatement> createEffective(
- final StmtContext<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> ctx) {
- return new SubmoduleEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onPreLinkageDeclared(
- final Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> stmt) {
- stmt.setRootIdentifier(RevisionSourceIdentifier.create(stmt.getStatementArgument(),
- StmtContextUtils.getLatestRevision(stmt.declaredSubstatements())));
- }
-
- @Override
- public void onLinkageDeclared(
- final Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> stmt) {
- final SourceIdentifier submoduleIdentifier = RevisionSourceIdentifier.create(stmt.getStatementArgument(),
- StmtContextUtils.getLatestRevision(stmt.declaredSubstatements()));
-
- final StmtContext<?, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>>
- possibleDuplicateSubmodule = stmt.getFromNamespace(SubmoduleNamespace.class, submoduleIdentifier);
- if (possibleDuplicateSubmodule != null && possibleDuplicateSubmodule != stmt) {
- throw new SourceException(stmt.getStatementSourceReference(), "Submodule name collision: %s. At %s",
- stmt.getStatementArgument(), possibleDuplicateSubmodule.getStatementSourceReference());
- }
-
- stmt.addContext(SubmoduleNamespace.class, submoduleIdentifier, stmt);
-
- final String belongsToModuleName = firstAttributeOf(stmt.declaredSubstatements(), BelongsToStatement.class);
- final StmtContext<?, ?, ?> prefixSubStmtCtx = findFirstDeclaredSubstatement(stmt, 0,
- BelongsToStatement.class, PrefixStatement.class);
- SourceException.throwIfNull(prefixSubStmtCtx, stmt.getStatementSourceReference(),
- "Prefix of belongsTo statement is missing in submodule [%s]", stmt.getStatementArgument());
-
- final String prefix = (String) prefixSubStmtCtx.getStatementArgument();
-
- stmt.addToNs(BelongsToPrefixToModuleName.class, prefix, belongsToModuleName);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getName() {
- return rawArgument();
- }
-
- @Override
- public YangVersionStatement getYangVersion() {
- return firstDeclared(YangVersionStatement.class);
- }
-
- @Nonnull
- @Override
- public BelongsToStatement getBelongsTo() {
- return firstDeclared(BelongsToStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import com.google.common.base.Verify;
-import com.google.common.collect.ImmutableMap;
-import java.util.Collection;
-import java.util.Map;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
-import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
-import org.opendaylight.yangtools.yang.parser.spi.TypeNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.TypeDefEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BinaryTypeEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BitsTypeEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BooleanTypeEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BuiltinEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.DecimalTypeEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.EmptyTypeEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.EnumTypeEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.IdentityrefTypeEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.InstanceIdentifierTypeEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.IntegralTypeEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.LeafrefTypeEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.StringTypeEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.UnionTypeEffectiveStatementImpl;
-
-public class TypeStatementImpl extends AbstractDeclaredStatement<String>
- implements TypeStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .TYPE)
- .addOptional(YangStmtMapping.BASE)
- .addAny(YangStmtMapping.BIT)
- .addAny(YangStmtMapping.ENUM)
- .addOptional(YangStmtMapping.FRACTION_DIGITS)
- .addOptional(YangStmtMapping.LENGTH)
- .addOptional(YangStmtMapping.PATH)
- .addAny(YangStmtMapping.PATTERN)
- .addOptional(YangStmtMapping.RANGE)
- .addOptional(YangStmtMapping.REQUIRE_INSTANCE)
- .addAny(YangStmtMapping.TYPE)
- .build();
-
- protected TypeStatementImpl(final StmtContext<String, TypeStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractStatementSupport<String, TypeStatement, EffectiveStatement<String, TypeStatement>> {
-
- private static final Map<String, StatementSupport<?, ?, ?>> ARGUMENT_SPECIFIC_SUPPORTS =
- ImmutableMap.<String, StatementSupport<?, ?, ?>>builder()
- .put(TypeUtils.DECIMAL64, new Decimal64SpecificationImpl.Definition())
- .put(TypeUtils.UNION, new UnionSpecificationImpl.Definition())
- .put(TypeUtils.ENUMERATION, new EnumSpecificationImpl.Definition())
- .put(TypeUtils.LEAF_REF, new LeafrefSpecificationImpl.Definition())
- .put(TypeUtils.BITS, new BitsSpecificationImpl.Definition())
- .put(TypeUtils.IDENTITY_REF, new IdentityRefSpecificationImpl.Definition())
- .put(TypeUtils.INSTANCE_IDENTIFIER, new InstanceIdentifierSpecificationImpl.Definition())
- .build();
-
- public Definition() {
- super(YangStmtMapping.TYPE);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public TypeStatement createDeclared(final StmtContext<String, TypeStatement, ?> ctx) {
- return BuiltinTypeStatement.maybeReplace(new TypeStatementImpl(ctx));
- }
-
- @Override
- public TypeEffectiveStatement<TypeStatement> createEffective(
- final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx) {
-
- // First look up the proper base type
- final TypeEffectiveStatement<TypeStatement> typeStmt;
- switch (ctx.getStatementArgument()) {
- case TypeUtils.BINARY:
- typeStmt = BuiltinEffectiveStatement.BINARY;
- break;
- case TypeUtils.BOOLEAN:
- typeStmt = BuiltinEffectiveStatement.BOOLEAN;
- break;
- case TypeUtils.EMPTY:
- typeStmt = BuiltinEffectiveStatement.EMPTY;
- break;
- case TypeUtils.INSTANCE_IDENTIFIER:
- typeStmt = BuiltinEffectiveStatement.INSTANCE_IDENTIFIER;
- break;
- case TypeUtils.INT8:
- typeStmt = BuiltinEffectiveStatement.INT8;
- break;
- case TypeUtils.INT16:
- typeStmt = BuiltinEffectiveStatement.INT16;
- break;
- case TypeUtils.INT32:
- typeStmt = BuiltinEffectiveStatement.INT32;
- break;
- case TypeUtils.INT64:
- typeStmt = BuiltinEffectiveStatement.INT64;
- break;
- case TypeUtils.STRING:
- typeStmt = BuiltinEffectiveStatement.STRING;
- break;
- case TypeUtils.UINT8:
- typeStmt = BuiltinEffectiveStatement.UINT8;
- break;
- case TypeUtils.UINT16:
- typeStmt = BuiltinEffectiveStatement.UINT16;
- break;
- case TypeUtils.UINT32:
- typeStmt = BuiltinEffectiveStatement.UINT32;
- break;
- case TypeUtils.UINT64:
- typeStmt = BuiltinEffectiveStatement.UINT64;
- break;
- default:
- final QName qname = StmtContextUtils.qnameFromArgument(ctx, ctx.getStatementArgument());
- final StmtContext<?, TypedefStatement, TypedefEffectiveStatement> typedef =
- SourceException.throwIfNull(ctx.getFromNamespace(TypeNamespace.class, qname),
- ctx.getStatementSourceReference(), "Type '%s' not found", qname);
-
- final TypedefEffectiveStatement effectiveTypedef = typedef.buildEffective();
- Verify.verify(effectiveTypedef instanceof TypeDefEffectiveStatementImpl);
- typeStmt = ((TypeDefEffectiveStatementImpl) effectiveTypedef).asTypeEffectiveStatement();
- }
-
- if (ctx.declaredSubstatements().isEmpty() && ctx.effectiveSubstatements().isEmpty()) {
- return typeStmt;
- }
-
- // Now instantiate the proper effective statement for that type
- final TypeDefinition<?> baseType = typeStmt.getTypeDefinition();
- if (baseType instanceof BinaryTypeDefinition) {
- return new BinaryTypeEffectiveStatementImpl(ctx, (BinaryTypeDefinition) baseType);
- } else if (baseType instanceof BitsTypeDefinition) {
- return new BitsTypeEffectiveStatementImpl(ctx, (BitsTypeDefinition) baseType);
- } else if (baseType instanceof BooleanTypeDefinition) {
- return new BooleanTypeEffectiveStatementImpl(ctx, (BooleanTypeDefinition) baseType);
- } else if (baseType instanceof DecimalTypeDefinition) {
- return new DecimalTypeEffectiveStatementImpl(ctx, (DecimalTypeDefinition) baseType);
- } else if (baseType instanceof EmptyTypeDefinition) {
- return new EmptyTypeEffectiveStatementImpl(ctx, (EmptyTypeDefinition) baseType);
- } else if (baseType instanceof EnumTypeDefinition) {
- return new EnumTypeEffectiveStatementImpl(ctx, (EnumTypeDefinition) baseType);
- } else if (baseType instanceof IdentityrefTypeDefinition) {
- return new IdentityrefTypeEffectiveStatementImpl(ctx, (IdentityrefTypeDefinition) baseType);
- } else if (baseType instanceof InstanceIdentifierTypeDefinition) {
- return new InstanceIdentifierTypeEffectiveStatementImpl(ctx,
- (InstanceIdentifierTypeDefinition) baseType);
- } else if (baseType instanceof Int8TypeDefinition) {
- return IntegralTypeEffectiveStatementImpl.create(ctx, (Int8TypeDefinition) baseType);
- } else if (baseType instanceof Int16TypeDefinition) {
- return IntegralTypeEffectiveStatementImpl.create(ctx, (Int16TypeDefinition) baseType);
- } else if (baseType instanceof Int32TypeDefinition) {
- return IntegralTypeEffectiveStatementImpl.create(ctx, (Int32TypeDefinition) baseType);
- } else if (baseType instanceof Int64TypeDefinition) {
- return IntegralTypeEffectiveStatementImpl.create(ctx, (Int64TypeDefinition) baseType);
- } else if (baseType instanceof LeafrefTypeDefinition) {
- return new LeafrefTypeEffectiveStatementImpl(ctx, (LeafrefTypeDefinition) baseType);
- } else if (baseType instanceof StringTypeDefinition) {
- return new StringTypeEffectiveStatementImpl(ctx, (StringTypeDefinition) baseType);
- } else if (baseType instanceof Uint8TypeDefinition) {
- return IntegralTypeEffectiveStatementImpl.create(ctx, (Uint8TypeDefinition) baseType);
- } else if (baseType instanceof Uint16TypeDefinition) {
- return IntegralTypeEffectiveStatementImpl.create(ctx, (Uint16TypeDefinition) baseType);
- } else if (baseType instanceof Uint32TypeDefinition) {
- return IntegralTypeEffectiveStatementImpl.create(ctx, (Uint32TypeDefinition) baseType);
- } else if (baseType instanceof Uint64TypeDefinition) {
- return IntegralTypeEffectiveStatementImpl.create(ctx, (Uint64TypeDefinition) baseType);
- } else if (baseType instanceof UnionTypeDefinition) {
- return new UnionTypeEffectiveStatementImpl(ctx, (UnionTypeDefinition) baseType);
- } else {
- throw new IllegalStateException("Unhandled base type " + baseType);
- }
- }
-
- @Override
- public void onFullDefinitionDeclared(
- final Mutable<String, TypeStatement, EffectiveStatement<String, TypeStatement>> stmt) {
- super.onFullDefinitionDeclared(stmt);
-
- // if it is yang built-in type, no prerequisite is needed, so simply return
- if (TypeUtils.isYangBuiltInTypeString(stmt.getStatementArgument())) {
- return;
- }
-
- final QName typeQName = StmtContextUtils.qnameFromArgument(stmt, stmt.getStatementArgument());
- final ModelActionBuilder typeAction = stmt.newInferenceAction(ModelProcessingPhase.EFFECTIVE_MODEL);
- final Prerequisite<StmtContext<?, ?, ?>> typePrereq = typeAction.requiresCtx(stmt, TypeNamespace.class,
- typeQName, ModelProcessingPhase.EFFECTIVE_MODEL);
- typeAction.mutatesEffectiveCtx(stmt.getParentContext());
-
- /*
- * If the type does not exist, throw new InferenceException.
- * Otherwise perform no operation.
- */
- typeAction.apply(new InferenceAction() {
- @Override
- public void apply(final InferenceContext ctx) {
- // Intentional NOOP
- }
-
- @Override
- public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
- InferenceException.throwIf(failed.contains(typePrereq), stmt.getStatementSourceReference(),
- "Type [%s] was not found.", typeQName);
- }
- });
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
- @Override
- public boolean hasArgumentSpecificSupports() {
- return !ARGUMENT_SPECIFIC_SUPPORTS.isEmpty();
- }
-
- @Override
- public StatementSupport<?, ?, ?> getSupportSpecificForArgument(final String argument) {
- return ARGUMENT_SPECIFIC_SUPPORTS.get(argument);
- }
-
- @Override
- public String internArgument(final String rawArgument) {
- final String found = TypeUtils.findBuiltinString(rawArgument);
- return found != null ? found : rawArgument;
- }
- }
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
-}
private static final Splitter PIPE_SPLITTER = Splitter.on('|').trimResults();
private static final Splitter TWO_DOTS_SPLITTER = Splitter.on("..").trimResults();
+ // these objects are to compare whether range has MAX or MIN value
+ // none of these values should appear as Yang number according to spec so they are safe to use
+ private static final BigDecimal YANG_MIN_NUM = BigDecimal.valueOf(-Double.MAX_VALUE);
+ private static final BigDecimal YANG_MAX_NUM = BigDecimal.valueOf(Double.MAX_VALUE);
+
private TypeUtils() {
}
private static BigDecimal yangConstraintToBigDecimal(final Number number) {
if (UnresolvedNumber.max().equals(number)) {
- return RangeStatementImpl.YANG_MAX_NUM;
+ return YANG_MAX_NUM;
}
if (UnresolvedNumber.min().equals(number)) {
- return RangeStatementImpl.YANG_MIN_NUM;
+ return YANG_MIN_NUM;
}
return new BigDecimal(number.toString());
return ranges;
}
+ // Not used anywhere
+ @Deprecated
public static boolean isYangTypeBodyStmtString(final String typeName) {
return TYPE_BODY_STMTS.contains(typeName);
}
&& isAnyDefaultValueMarkedWithIfFeature(typeStmt, defaultValues);
}
- static String findBuiltinString(final String rawArgument) {
+ public static String findBuiltinString(final String rawArgument) {
return BUILT_IN_TYPES.get(rawArgument);
}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
-import org.opendaylight.yangtools.yang.parser.spi.TypeNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.TypeDefEffectiveStatementImpl;
-
-public class TypedefStatementImpl extends AbstractDeclaredStatement<QName> implements TypedefStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .TYPEDEF)
- .addOptional(YangStmtMapping.DEFAULT)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addMandatory(YangStmtMapping.TYPE)
- .addOptional(YangStmtMapping.UNITS)
- .build();
-
- protected TypedefStatementImpl(final StmtContext<QName, TypedefStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractQNameStatementSupport<TypedefStatement, EffectiveStatement<QName, TypedefStatement>> {
-
- public Definition() {
- super(YangStmtMapping.TYPEDEF);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public TypedefStatement createDeclared(final StmtContext<QName, TypedefStatement, ?> ctx) {
- return new TypedefStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, TypedefStatement> createEffective(
- final StmtContext<QName, TypedefStatement, EffectiveStatement<QName, TypedefStatement>> ctx) {
- return new TypeDefEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, TypedefStatement,
- EffectiveStatement<QName, TypedefStatement>> stmt) {
- super.onFullDefinitionDeclared(stmt);
-
- if (stmt != null && stmt.getParentContext() != null) {
- final StmtContext<?, TypedefStatement, TypedefEffectiveStatement> existing = stmt.getParentContext()
- .getFromNamespace(TypeNamespace.class, stmt.getStatementArgument());
- SourceException.throwIf(existing != null, stmt.getStatementSourceReference(),
- "Duplicate name for typedef %s", stmt.getStatementArgument());
-
- stmt.getParentContext().addContext(TypeNamespace.class, stmt.getStatementArgument(), stmt);
- }
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nullable
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Nonnull
- @Override
- public TypeStatement getType() {
- return firstDeclared(TypeStatement.class);
- }
-
- @Override
- public UnitsStatement getUnits() {
- return firstDeclared(UnitsStatement.class);
- }
-
- @Nonnull
- @Override
- public QName getName() {
- return argument();
- }
-
- @Nullable
- @Override
- public DefaultStatement getDefault() {
- return firstDeclared(DefaultStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.UnionSpecification;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.UnionSpecificationEffectiveStatementImpl;
-
-public class UnionSpecificationImpl extends AbstractDeclaredStatement<String>
- implements UnionSpecification {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .TYPE)
- .addMultiple(YangStmtMapping.TYPE)
- .build();
-
- protected UnionSpecificationImpl(
- final StmtContext<String, UnionSpecification, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractStatementSupport<String, UnionSpecification, EffectiveStatement<String, UnionSpecification>> {
-
- public Definition() {
- super(YangStmtMapping.TYPE);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public UnionSpecification createDeclared(final StmtContext<String, UnionSpecification, ?> ctx) {
- return new UnionSpecificationImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, UnionSpecification> createEffective(
- final StmtContext<String, UnionSpecification, EffectiveStatement<String, UnionSpecification>> ctx) {
- return new UnionSpecificationEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
-
- @Nonnull
- @Override
- public Collection<? extends TypeStatement> getTypes() {
- return allDeclared(TypeStatement.class);
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Relative;
-import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UniqueEffectiveStatementImpl;
-
-public class UniqueStatementImpl extends AbstractDeclaredStatement<Collection<SchemaNodeIdentifier.Relative>>
- implements UniqueStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .UNIQUE)
- .build();
-
- protected UniqueStatementImpl(
- final StmtContext<Collection<SchemaNodeIdentifier.Relative>, UniqueStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractStatementSupport<Collection<SchemaNodeIdentifier.Relative>, UniqueStatement,
- EffectiveStatement<Collection<SchemaNodeIdentifier.Relative>, UniqueStatement>> {
-
- public Definition() {
- super(YangStmtMapping.UNIQUE);
- }
-
- @Override
- public Collection<SchemaNodeIdentifier.Relative> parseArgumentValue(final StmtContext<?, ?, ?> ctx,
- final String value) {
- final Collection<Relative> uniqueConstraints = Utils.parseUniqueConstraintArgument(ctx, value);
- SourceException.throwIf(uniqueConstraints.isEmpty(), ctx.getStatementSourceReference(),
- "Invalid argument value '%s' of unique statement. The value must contains at least "
- + "one descendant schema node identifier.", value);
- return uniqueConstraints;
- }
-
- @Override
- public UniqueStatement createDeclared(final StmtContext<Collection<Relative>, UniqueStatement, ?> ctx) {
- return new UniqueStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<Collection<Relative>, UniqueStatement> createEffective(
- final StmtContext<Collection<Relative>, UniqueStatement,
- EffectiveStatement<Collection<Relative>, UniqueStatement>> ctx) {
- return new UniqueEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public Collection<Relative> getTag() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnitsEffectiveStatementImpl;
-
-public class UnitsStatementImpl extends AbstractDeclaredStatement<String>
- implements UnitsStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .UNITS)
- .build();
-
- protected UnitsStatementImpl(final StmtContext<String, UnitsStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends
- AbstractStatementSupport<String, UnitsStatement, EffectiveStatement<String, UnitsStatement>> {
-
- public Definition() {
- super(YangStmtMapping.UNITS);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public UnitsStatement createDeclared(
- final StmtContext<String, UnitsStatement, ?> ctx) {
- return new UnitsStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, UnitsStatement> createEffective(
- final StmtContext<String, UnitsStatement, EffectiveStatement<String, UnitsStatement>> ctx) {
- return new UnitsEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import java.util.Optional;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
-import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnrecognizedEffectiveStatementImpl;
-
-public final class UnrecognizedStatementImpl extends AbstractDeclaredStatement<String>
- implements UnrecognizedStatement {
-
- protected UnrecognizedStatementImpl(final StmtContext<String, ?, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<String, UnrecognizedStatement,
- EffectiveStatement<String, UnrecognizedStatement>> {
-
- public Definition(final StatementDefinition publicDefinition) {
- super(publicDefinition);
- }
-
- @Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return value;
- }
-
- @Override
- public UnrecognizedStatement createDeclared(final StmtContext<String, UnrecognizedStatement, ?> ctx) {
- return new UnrecognizedStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<String, UnrecognizedStatement> createEffective(
- final StmtContext<String, UnrecognizedStatement,
- EffectiveStatement<String, UnrecognizedStatement>> ctx) {
- return new UnrecognizedEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return null;
- }
-
- @Override
- public Optional<StatementSupport<?, ?, ?>> getUnknownStatementDefinitionOf(
- final StatementDefinition yangStmtDef) {
- final QName baseQName = getStatementName();
- final QName argumentName = yangStmtDef.getArgumentName();
- return Optional.of(new ModelDefinedStatementSupport(new ModelDefinedStatementDefinition(
- QName.create(baseQName, yangStmtDef.getStatementName().getLocalName()),
- argumentName != null ? QName.create(baseQName, argumentName.getLocalName()) : null,
- yangStmtDef.isArgumentYinElement())));
- }
- }
-
- @Nullable
- @Override
- public String getArgument() {
- return argument();
- }
-}
import com.google.common.base.CharMatcher;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
return keyNodes;
}
- static Collection<SchemaNodeIdentifier.Relative> parseUniqueConstraintArgument(final StmtContext<?, ?, ?> ctx,
- final String argumentValue) {
- final Set<SchemaNodeIdentifier.Relative> uniqueConstraintNodes = new HashSet<>();
- for (final String uniqueArgToken : SPACE_SPLITTER.split(argumentValue)) {
- final SchemaNodeIdentifier nodeIdentifier = nodeIdentifierFromPath(ctx, uniqueArgToken);
- SourceException.throwIf(nodeIdentifier.isAbsolute(), ctx.getStatementSourceReference(),
- "Unique statement argument '%s' contains schema node identifier '%s' "
- + "which is not in the descendant node identifier form.", argumentValue, uniqueArgToken);
- uniqueConstraintNodes.add((SchemaNodeIdentifier.Relative) nodeIdentifier);
- }
- return ImmutableSet.copyOf(uniqueConstraintNodes);
- }
-
private static String trimSingleLastSlashFromXPath(final String path) {
return path.endsWith("/") ? path.substring(0, path.length() - 1) : path;
}
- static RevisionAwareXPath parseXPath(final StmtContext<?, ?, ?> ctx, final String path) {
+ public static RevisionAwareXPath parseXPath(final StmtContext<?, ?, ?> ctx, final String path) {
final XPath xPath = XPATH_FACTORY.get().newXPath();
xPath.setNamespaceContext(StmtNamespaceContext.create(ctx,
ImmutableBiMap.of(RFC6020_YANG_NAMESPACE.toString(), YANG_XPATH_FUNCTIONS_PREFIX)));
node);
}
- static @Nonnull Boolean parseBoolean(final StmtContext<?, ?, ?> ctx, final String input) {
+ public static @Nonnull Boolean parseBoolean(final StmtContext<?, ?, ?> ctx, final String input) {
if ("true".equals(input)) {
return Boolean.TRUE;
} else if ("false".equals(input)) {
}
}
- static String internBoolean(final String input) {
+ public static String internBoolean(final String input) {
if ("true".equals(input)) {
return "true";
} else if ("false".equals(input)) {
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ValueEffectiveStatementImpl;
-
-public class ValueStatementImpl extends AbstractDeclaredStatement<Integer> implements ValueStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.VALUE).build();
-
- protected ValueStatementImpl(final StmtContext<Integer, ValueStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractStatementSupport<Integer, ValueStatement, EffectiveStatement<Integer, ValueStatement>> {
-
- public Definition() {
- super(YangStmtMapping.VALUE);
- }
-
- @Override
- public Integer parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- try {
- return Integer.valueOf(value);
- } catch (NumberFormatException e) {
- throw new SourceException(ctx.getStatementSourceReference(), e,
- "%s is not valid value statement integer argument in a range of -2147483648..2147483647", value);
- }
- }
-
- @Override
- public ValueStatement createDeclared(final StmtContext<Integer, ValueStatement, ?> ctx) {
- return new ValueStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<Integer, ValueStatement> createEffective(
- final StmtContext<Integer, ValueStatement, EffectiveStatement<Integer, ValueStatement>> ctx) {
- return new ValueEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public int getValue() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.WhenEffectiveStatementImpl;
-
-public class WhenStatementImpl extends AbstractDeclaredStatement<RevisionAwareXPath> implements WhenStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .WHEN)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addOptional(YangStmtMapping.REFERENCE)
- .build();
-
- protected WhenStatementImpl(final StmtContext<RevisionAwareXPath, WhenStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<RevisionAwareXPath, WhenStatement,
- EffectiveStatement<RevisionAwareXPath, WhenStatement>> {
-
- public Definition() {
- super(YangStmtMapping.WHEN);
- }
-
- @Override
- public RevisionAwareXPath parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return Utils.parseXPath(ctx, value);
- }
-
- @Override
- public WhenStatement createDeclared(final StmtContext<RevisionAwareXPath, WhenStatement, ?> ctx) {
- return new WhenStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<RevisionAwareXPath, WhenStatement> createEffective(
- final StmtContext<RevisionAwareXPath, WhenStatement,
- EffectiveStatement<RevisionAwareXPath, WhenStatement>> ctx) {
- return new WhenEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public RevisionAwareXPath getCondition() {
- return argument();
- }
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-}
import java.util.Set;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.action.ActionStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.anydata.AnydataStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.anyxml.AnyxmlStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.argument.ArgumentStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.augment.AugmentStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.augment.AugmentStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.base.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.belongs_to.BelongsToStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.bit.BitStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.bit.BitStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_.CaseStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_.CaseStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.choice.ChoiceStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.choice.ChoiceStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.config.ConfigStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.contact.ContactStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.container.ContainerStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.container.ContainerStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.default_.DefaultStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.description.DescriptionStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.deviate.DeviateStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.deviate.DeviateStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.deviation.DeviationStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.enum_.EnumStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.enum_.EnumStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_app_tag.ErrorAppTagStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_message.ErrorMessageStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension.ExtensionStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.feature.FeatureStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.fraction_digits.FractionDigitsStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.grouping.GroupingStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.grouping.GroupingStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.identity.IdentityStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.identity.IdentityStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.if_feature.IfFeatureStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.import_.ImportStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.import_.ImportStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.include.IncludeStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.include.IncludeStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input.InputStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input.InputStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.key.KeyStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf.LeafStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf_list.LeafListStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.leaf_list.LeafListStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.length.LengthStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.list.ListStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.list.ListStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.mandatory.MandatoryStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.max_elements.MaxElementsStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.min_elements.MinElementsStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.modifier.ModifierStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.module.ModuleStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.module.ModuleStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.must.MustStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.namespace.NamespaceStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification.NotificationStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification.NotificationStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ordered_by.OrderedByStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.organization.OrganizationStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output.OutputStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output.OutputStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.path.PathStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern.PatternStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern.PatternStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.position.PositionStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.prefix.PrefixStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.presence.PresenceStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.range.RangeStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.reference.ReferenceStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine.RefineStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine.RefineStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.require_instance.RequireInstanceStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.revision.RevisionStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.revision_date.RevisionDateStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.rpc.RpcStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.rpc.RpcStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.status.StatusStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule.SubmoduleStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule.SubmoduleStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.TypeStatementRFC6020Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.TypeStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.typedef.TypedefStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.unique.UniqueStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.units.UnitsStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.uses.UsesStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.value.ValueStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.when.WhenStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.yang_version.YangVersionStatementSupport;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.yin_element.YinElementStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.ExtensionNamespace;
import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace;
import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
import org.opendaylight.yangtools.yang.parser.stmt.openconfig.OpenconfigVersionSupport;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.Builder;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.ActionStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.AnydataStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.AugmentStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.BitStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.CaseStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.ChoiceStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.ContainerStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.DeviateStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.EnumStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.GroupingStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.IdentityStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.ImportStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.IncludeStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.InputStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.LeafListStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.ListStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.ModifierStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.ModuleStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.NotificationStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.OutputStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.PatternStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.RefineStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.RpcStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.SubmoduleStatementRfc7950Support;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.TypeStatementRfc7950Support;
import org.opendaylight.yangtools.yang.parser.stmt.rfc8040.YangDataStatementSupport;
public final class YangInferencePipeline {
public static final StatementSupportBundle PRE_LINKAGE_BUNDLE = StatementSupportBundle
.derivedFrom(INIT_BUNDLE)
- .addVersionSpecificSupport(VERSION_1, new ModuleStatementSupport())
- .addVersionSpecificSupport(VERSION_1_1, new ModuleStatementRfc7950Support())
- .addVersionSpecificSupport(VERSION_1, new SubmoduleStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new SubmoduleStatementRfc7950Support())
- .addSupport(new NamespaceStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1, new ImportStatementDefinition())
- .addVersionSpecificSupport(VERSION_1_1, new ImportStatementRfc7950Support())
- .addVersionSpecificSupport(VERSION_1, new IncludeStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new IncludeStatementRfc7950Support())
- .addSupport(new BelongsToStatementImpl.Definition())
- .addSupport(new PrefixStatementImpl.Definition())
- .addSupport(new YangVersionStatementImpl.Definition())
- .addSupport(new RevisionStatementImpl.Definition())
- .addSupport(new RevisionDateStatementImpl.Definition())
+ .addVersionSpecificSupport(VERSION_1, new ModuleStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new ModuleStatementRFC7950Support())
+ .addVersionSpecificSupport(VERSION_1, new SubmoduleStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new SubmoduleStatementRFC7950Support())
+ .addSupport(new NamespaceStatementSupport())
+ .addVersionSpecificSupport(VERSION_1, new ImportStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new ImportStatementRFC7950Support())
+ .addVersionSpecificSupport(VERSION_1, new IncludeStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new IncludeStatementRFC7950Support())
+ .addSupport(new BelongsToStatementSupport())
+ .addSupport(new PrefixStatementSupport())
+ .addSupport(new YangVersionStatementSupport())
+ .addSupport(new RevisionStatementSupport())
+ .addSupport(new RevisionDateStatementSupport())
.addSupport(global(ModuleNameToNamespace.class))
.addSupport(global(PreLinkageModuleNamespace.class))
.addSupport(sourceLocal(ImpPrefixToNamespace.class))
public static final StatementSupportBundle LINKAGE_BUNDLE = StatementSupportBundle
.derivedFrom(PRE_LINKAGE_BUNDLE)
- .addSupport(new DescriptionStatementImpl.Definition())
- .addSupport(new ReferenceStatementImpl.Definition())
- .addSupport(new ContactStatementImpl.Definition())
- .addSupport(new OrganizationStatementImpl.Definition())
+ .addSupport(new DescriptionStatementSupport())
+ .addSupport(new ReferenceStatementSupport())
+ .addSupport(new ContactStatementSupport())
+ .addSupport(new OrganizationStatementSupport())
.addSupport(global(ModuleNamespace.class))
.addSupport(global(ModuleNamespaceForBelongsTo.class))
.addSupport(global(SubmoduleNamespace.class))
public static final StatementSupportBundle STMT_DEF_BUNDLE = StatementSupportBundle
.derivedFrom(LINKAGE_BUNDLE)
- .addSupport(new YinElementStatementImpl.Definition())
- .addSupport(new ArgumentStatementImpl.Definition())
- .addSupport(new ExtensionStatementImpl.Definition())
+ .addSupport(new YinElementStatementSupport())
+ .addSupport(new ArgumentStatementSupport())
+ .addSupport(new ExtensionStatementSupport())
.addSupport(new ChildSchemaNodes<>())
.addSupport(new SchemaNodeIdentifierBuildNamespace())
.addSupport(global(ExtensionNamespace.class))
- .addSupport(new TypedefStatementImpl.Definition())
+ .addSupport(new TypedefStatementSupport())
.addSupport(treeScoped(TypeNamespace.class))
- .addVersionSpecificSupport(VERSION_1, new IdentityStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new IdentityStatementRfc7950Support())
+ .addVersionSpecificSupport(VERSION_1, new IdentityStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new IdentityStatementRFC7950Support())
.addSupport(global(IdentityNamespace.class))
- .addSupport(new DefaultStatementImpl.Definition())
- .addSupport(new StatusStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1, new TypeStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new TypeStatementRfc7950Support())
- .addSupport(new UnitsStatementImpl.Definition())
- .addSupport(new RequireInstanceStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1, new BitStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new BitStatementRfc7950Support())
- .addSupport(new PathStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1, new EnumStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new EnumStatementRfc7950Support())
- .addSupport(new LengthStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1, new PatternStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new PatternStatementRfc7950Support())
- .addVersionSpecificSupport(VERSION_1_1, new ModifierStatementImpl.Definition())
- .addSupport(new RangeStatementImpl.Definition())
- .addSupport(new KeyStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1, new ContainerStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new ContainerStatementRfc7950Support())
- .addVersionSpecificSupport(VERSION_1, new GroupingStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new GroupingStatementRfc7950Support())
- .addVersionSpecificSupport(VERSION_1, new ListStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new ListStatementRfc7950Support())
- .addSupport(new UniqueStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new ActionStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1, new RpcStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new RpcStatementRfc7950Support())
- .addVersionSpecificSupport(VERSION_1, new InputStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new InputStatementRfc7950Support())
- .addVersionSpecificSupport(VERSION_1, new OutputStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new OutputStatementRfc7950Support())
- .addVersionSpecificSupport(VERSION_1, new NotificationStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new NotificationStatementRfc7950Support())
- .addSupport(new FractionDigitsStatementImpl.Definition())
- .addSupport(new BaseStatementImpl.Definition())
+ .addSupport(new DefaultStatementSupport())
+ .addSupport(new StatusStatementSupport())
+ .addVersionSpecificSupport(VERSION_1, new TypeStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new TypeStatementRFC7950Support())
+ .addSupport(new UnitsStatementSupport())
+ .addSupport(new RequireInstanceStatementSupport())
+ .addVersionSpecificSupport(VERSION_1, new BitStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new BitStatementRFC7950Support())
+ .addSupport(new PathStatementSupport())
+ .addVersionSpecificSupport(VERSION_1, new EnumStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new EnumStatementRFC7950Support())
+ .addSupport(new LengthStatementSupport())
+ .addVersionSpecificSupport(VERSION_1, new PatternStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new PatternStatementRFC7950Support())
+ .addVersionSpecificSupport(VERSION_1_1, new ModifierStatementSupport())
+ .addSupport(new RangeStatementSupport())
+ .addSupport(new KeyStatementSupport())
+ .addVersionSpecificSupport(VERSION_1, new ContainerStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new ContainerStatementRFC7950Support())
+ .addVersionSpecificSupport(VERSION_1, new GroupingStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new GroupingStatementRFC7950Support())
+ .addVersionSpecificSupport(VERSION_1, new ListStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new ListStatementRFC7950Support())
+ .addSupport(new UniqueStatementSupport())
+ .addVersionSpecificSupport(VERSION_1_1, new ActionStatementSupport())
+ .addVersionSpecificSupport(VERSION_1, new RpcStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new RpcStatementRFC7950Support())
+ .addVersionSpecificSupport(VERSION_1, new InputStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new InputStatementRFC7950Support())
+ .addVersionSpecificSupport(VERSION_1, new OutputStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new OutputStatementRFC7950Support())
+ .addVersionSpecificSupport(VERSION_1, new NotificationStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new NotificationStatementRFC7950Support())
+ .addSupport(new FractionDigitsStatementSupport())
+ .addSupport(new BaseStatementSupport())
.addSupport(global(DerivedIdentitiesNamespace.class))
.addSupport(global(StatementDefinitionNamespace.class))
.build();
public static final StatementSupportBundle FULL_DECL_BUNDLE = StatementSupportBundle
.derivedFrom(STMT_DEF_BUNDLE)
- .addSupport(new LeafStatementImpl.Definition())
- .addSupport(new ConfigStatementImpl.Definition())
- .addSupport(new DeviationStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1, new DeviateStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new DeviateStatementRfc7950Support())
- .addVersionSpecificSupport(VERSION_1, new ChoiceStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new ChoiceStatementRfc7950Support())
- .addVersionSpecificSupport(VERSION_1, new CaseStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new CaseStatementRfc7950Support())
- .addSupport(new MustStatementImpl.Definition())
- .addSupport(new MandatoryStatementImpl.Definition())
- .addSupport(new AnyxmlStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new AnydataStatementImpl.Definition())
- .addSupport(new IfFeatureStatementImpl.Definition())
- .addSupport(new UsesStatementImpl.Definition())
+ .addSupport(new LeafStatementSupport())
+ .addSupport(new ConfigStatementSupport())
+ .addSupport(new DeviationStatementSupport())
+ .addVersionSpecificSupport(VERSION_1, new DeviateStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new DeviateStatementRFC7950Support())
+ .addVersionSpecificSupport(VERSION_1, new ChoiceStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new ChoiceStatementRFC7950Support())
+ .addVersionSpecificSupport(VERSION_1, new CaseStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new CaseStatementRFC7950Support())
+ .addSupport(new MustStatementSupport())
+ .addSupport(new MandatoryStatementSupport())
+ .addSupport(new AnyxmlStatementSupport())
+ .addVersionSpecificSupport(VERSION_1_1, new AnydataStatementSupport())
+ .addSupport(new IfFeatureStatementSupport())
+ .addSupport(new UsesStatementSupport())
.addSupport(treeScoped(GroupingNamespace.class)) //treeScoped
- .addSupport(new ErrorMessageStatementImpl.Definition())
- .addSupport(new ErrorAppTagStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1, new LeafListStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new LeafListStatementRfc7950Support())
- .addSupport(new PresenceStatementImpl.Definition())
- .addSupport(new MaxElementsStatementImpl.Definition())
- .addSupport(new MinElementsStatementImpl.Definition())
- .addSupport(new OrderedByStatementImpl.Definition())
- .addSupport(new WhenStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1, new AugmentStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new AugmentStatementRfc7950Support())
+ .addSupport(new ErrorMessageStatementSupport())
+ .addSupport(new ErrorAppTagStatementSupport())
+ .addVersionSpecificSupport(VERSION_1, new LeafListStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new LeafListStatementRFC7950Support())
+ .addSupport(new PresenceStatementSupport())
+ .addSupport(new MaxElementsStatementSupport())
+ .addSupport(new MinElementsStatementSupport())
+ .addSupport(new OrderedByStatementSupport())
+ .addSupport(new WhenStatementSupport())
+ .addVersionSpecificSupport(VERSION_1, new AugmentStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new AugmentStatementRFC7950Support())
.addSupport(treeScoped(AugmentToChoiceNamespace.class))
- .addVersionSpecificSupport(VERSION_1, new RefineStatementImpl.Definition())
- .addVersionSpecificSupport(VERSION_1_1, new RefineStatementRfc7950Support())
- .addSupport(new FeatureStatementImpl.Definition())
- .addSupport(new PositionStatementImpl.Definition())
- .addSupport(new ValueStatementImpl.Definition())
+ .addVersionSpecificSupport(VERSION_1, new RefineStatementRFC6020Support())
+ .addVersionSpecificSupport(VERSION_1_1, new RefineStatementRFC7950Support())
+ .addSupport(new FeatureStatementSupport())
+ .addSupport(new PositionStatementSupport())
+ .addSupport(new ValueStatementSupport())
.addSupport(AnyxmlSchemaLocationSupport.getInstance())
.addSupport(treeScoped(AnyxmlSchemaLocationNamespace.class))
.addSupport(YangDataStatementSupport.getInstance())
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.common.YangVersion;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.YangVersionEffectiveStatementImpl;
-
-public class YangVersionStatementImpl extends AbstractDeclaredStatement<YangVersion> implements YangVersionStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .YANG_VERSION)
- .build();
-
- protected YangVersionStatementImpl(final StmtContext<YangVersion, YangVersionStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<YangVersion, YangVersionStatement,
- EffectiveStatement<YangVersion, YangVersionStatement>> {
-
- public Definition() {
- super(YangStmtMapping.YANG_VERSION);
- }
-
- @Override
- public YangVersion parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return SourceException.unwrap(YangVersion.parse(value), ctx.getStatementSourceReference(),
- "Unsupported YANG version %s", value);
- }
-
- @Override
- public YangVersionStatement createDeclared(final StmtContext<YangVersion, YangVersionStatement, ?> ctx) {
- return new YangVersionStatementImpl(ctx);
- }
-
- @Override
- public void onPreLinkageDeclared(final Mutable<YangVersion, YangVersionStatement,
- EffectiveStatement<YangVersion, YangVersionStatement>> stmt) {
- stmt.setRootVersion(stmt.getStatementArgument());
- }
-
- @Override
- public EffectiveStatement<YangVersion, YangVersionStatement> createEffective(final StmtContext<YangVersion,
- YangVersionStatement, EffectiveStatement<YangVersion, YangVersionStatement>> ctx) {
- return new YangVersionEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public YangVersion getValue() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.YinElementEffectiveStatementImpl;
-
-public class YinElementStatementImpl extends AbstractDeclaredStatement<Boolean>
- implements YinElementStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.YIN_ELEMENT).build();
-
- protected YinElementStatementImpl(final StmtContext<Boolean, YinElementStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractStatementSupport<Boolean, YinElementStatement, EffectiveStatement<Boolean, YinElementStatement>> {
-
- public Definition() {
- super(YangStmtMapping.YIN_ELEMENT);
- }
-
- @Override
- public Boolean parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return Utils.parseBoolean(ctx, value);
- }
-
- @Override
- public YinElementStatement createDeclared(final StmtContext<Boolean, YinElementStatement, ?> ctx) {
- return new YinElementStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<Boolean, YinElementStatement> createEffective(
- final StmtContext<Boolean, YinElementStatement, EffectiveStatement<Boolean, YinElementStatement>> ctx) {
- return new YinElementEffectiveStatementImpl(ctx);
- }
-
- @Override
- public String internArgument(final String rawArgument) {
- return Utils.internBoolean(rawArgument);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public boolean getValue() {
- return argument().booleanValue();
- }
-}
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.AbstractEffectiveSchemaNode;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveSchemaNode;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveDocumentedDataNodeContainer;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-final class CaseShorthandImpl implements ChoiceCaseNode, DerivableSchemaNode {
+// FIXME: hide this somewhere
+public final class CaseShorthandImpl implements ChoiceCaseNode, DerivableSchemaNode {
private final DataSchemaNode caseShorthandNode;
private final ChoiceCaseNode original;
private final SchemaPath path;
private final boolean augmenting;
- CaseShorthandImpl(final DataSchemaNode caseShorthandNode) {
+ public CaseShorthandImpl(final DataSchemaNode caseShorthandNode) {
this.caseShorthandNode = requireNonNull(caseShorthandNode);
this.path = requireNonNull(caseShorthandNode.getPath().getParent());
this.original = getOriginalIfPresent(caseShorthandNode);
import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.EffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementBase;
final class EffectiveConstraintDefinitionImpl implements ConstraintDefinition {
private static final String UNBOUNDED_STR = "unbounded";
import org.opendaylight.yangtools.yang.model.api.stmt.UsesEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.AbstractEffectiveDocumentedNode;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveDocumentedNode;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine.RefineEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+++ /dev/null
-/*
- * Copyright (c) 2017 Pantheon Technologies, s.r.o. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
-
-import java.math.BigInteger;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
-import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.type.InvalidRangeConstraintException;
-import org.opendaylight.yangtools.yang.model.util.type.RangeRestrictedTypeBuilder;
-import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils;
-
-public final class IntegralTypeEffectiveStatementImpl<T extends RangeRestrictedTypeDefinition<T, N>,
- N extends Number & Comparable<N>> extends DeclaredEffectiveStatementBase<String, TypeStatement>
- implements TypeEffectiveStatement<TypeStatement> {
-
- private final T typeDefinition;
-
- private IntegralTypeEffectiveStatementImpl(
- final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
- final RangeRestrictedTypeBuilder<T, N> builder) {
- super(ctx);
-
- for (EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
- if (stmt instanceof RangeEffectiveStatementImpl) {
- final RangeEffectiveStatementImpl rangeStmt = (RangeEffectiveStatementImpl)stmt;
- builder.setRangeConstraint(rangeStmt, rangeStmt.argument());
- }
- if (stmt instanceof UnknownSchemaNode) {
- builder.addUnknownSchemaNode((UnknownSchemaNode)stmt);
- }
- }
-
- try {
- typeDefinition = builder.build();
- } catch (InvalidRangeConstraintException e) {
- throw new SourceException(ctx.getStatementSourceReference(), e, "Invalid range constraint: %s",
- e.getOffendingRanges());
- }
- }
-
- public static IntegralTypeEffectiveStatementImpl<Int8TypeDefinition, Byte> create(
- final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
- final Int8TypeDefinition baseType) {
- return new IntegralTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newInt8Builder(baseType,
- TypeUtils.typeEffectiveSchemaPath(ctx)));
- }
-
- public static IntegralTypeEffectiveStatementImpl<Int16TypeDefinition, Short> create(
- final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
- final Int16TypeDefinition baseType) {
- return new IntegralTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newInt16Builder(baseType,
- TypeUtils.typeEffectiveSchemaPath(ctx)));
- }
-
- public static IntegralTypeEffectiveStatementImpl<Int32TypeDefinition, Integer> create(
- final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
- final Int32TypeDefinition baseType) {
- return new IntegralTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newInt32Builder(baseType,
- TypeUtils.typeEffectiveSchemaPath(ctx)));
- }
-
- public static IntegralTypeEffectiveStatementImpl<Int64TypeDefinition, Long> create(
- final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
- final Int64TypeDefinition baseType) {
- return new IntegralTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newInt64Builder(baseType,
- TypeUtils.typeEffectiveSchemaPath(ctx)));
- }
-
- public static IntegralTypeEffectiveStatementImpl<Uint8TypeDefinition, Short> create(
- final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
- final Uint8TypeDefinition baseType) {
- return new IntegralTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newUint8Builder(baseType,
- TypeUtils.typeEffectiveSchemaPath(ctx)));
- }
-
- public static IntegralTypeEffectiveStatementImpl<Uint16TypeDefinition, Integer> create(
- final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
- final Uint16TypeDefinition baseType) {
- return new IntegralTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newUint16Builder(baseType,
- TypeUtils.typeEffectiveSchemaPath(ctx)));
- }
-
- public static IntegralTypeEffectiveStatementImpl<Uint32TypeDefinition, Long> create(
- final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
- final Uint32TypeDefinition baseType) {
- return new IntegralTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newUint32Builder(baseType,
- TypeUtils.typeEffectiveSchemaPath(ctx)));
- }
-
- public static IntegralTypeEffectiveStatementImpl<Uint64TypeDefinition, BigInteger> create(
- final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
- final Uint64TypeDefinition baseType) {
- return new IntegralTypeEffectiveStatementImpl<>(ctx, RestrictedTypes.newUint64Builder(baseType,
- TypeUtils.typeEffectiveSchemaPath(ctx)));
- }
-
- @Nonnull
- @Override
- public T getTypeDefinition() {
- return typeDefinition;
- }
-}
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.NumericalRestrictions;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
public class NumericalRestrictionsEffectiveStatementImpl
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.StringRestrictions;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.DeclaredEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.DeclaredEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
public class StringRestrictionsEffectiveStatementImpl
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
-
-import com.google.common.collect.ImmutableSet;
-import java.util.Collection;
-import java.util.Set;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
-import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.spi.source.ImplicitSubstatement;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementDefinitionContext;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.effective.ActionEffectiveStatementImpl;
-
-public class ActionStatementImpl extends AbstractDeclaredStatement<QName> implements ActionStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.ACTION)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.GROUPING)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.INPUT)
- .addOptional(YangStmtMapping.OUTPUT)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addAny(YangStmtMapping.TYPEDEF)
- .build();
-
- protected ActionStatementImpl(final StmtContext<QName,ActionStatement, ?> context) {
- super(context);
- }
-
- public static class Definition
- extends AbstractQNameStatementSupport<ActionStatement, EffectiveStatement<QName, ActionStatement>> {
-
- private static final Set<StatementDefinition> ILLEGAL_PARENTS = ImmutableSet.of(YangStmtMapping.NOTIFICATION,
- YangStmtMapping.RPC, YangStmtMapping.ACTION);
- private static final StatementSupport<?, ?, ?> IMPLICIT_INPUT = new InputStatementRfc7950Support();
- private static final StatementSupport<?, ?, ?> IMPLICIT_OUTPUT = new OutputStatementRfc7950Support();
-
- public Definition() {
- super(YangStmtMapping.ACTION);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public void onStatementAdded(
- final StmtContext.Mutable<QName, ActionStatement, EffectiveStatement<QName, ActionStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override
- public ActionStatement createDeclared(
- final StmtContext<QName, ActionStatement, ?> ctx) {
- return new ActionStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, ActionStatement> createEffective(
- final StmtContext<QName, ActionStatement, EffectiveStatement<QName, ActionStatement>> ctx) {
- SourceException.throwIf(StmtContextUtils.hasAncestorOfType(ctx, ILLEGAL_PARENTS),
- ctx.getStatementSourceReference(),
- "Action %s is defined within a notification, rpc or another action", ctx.getStatementArgument());
- SourceException.throwIf(!StmtContextUtils.hasAncestorOfTypeWithChildOfType(ctx, YangStmtMapping.LIST,
- YangStmtMapping.KEY), ctx.getStatementSourceReference(),
- "Action %s is defined within a list that has no key statement", ctx.getStatementArgument());
- SourceException.throwIf(StmtContextUtils.hasParentOfType(ctx, YangStmtMapping.CASE),
- ctx.getStatementSourceReference(), "Action %s is defined within a case statement",
- ctx.getStatementArgument());
- SourceException.throwIf(StmtContextUtils.hasParentOfType(ctx, YangStmtMapping.MODULE),
- ctx.getStatementSourceReference(), "Action %s is defined at the top level of a module",
- ctx.getStatementArgument());
- return new ActionEffectiveStatementImpl(ctx);
- }
-
- @Override
- public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, ActionStatement,
- EffectiveStatement<QName, ActionStatement>> stmt) {
- super.onFullDefinitionDeclared(stmt);
-
- if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, InputStatement.class) == null) {
- addImplicitStatement((StatementContextBase<?, ?, ?>) stmt, IMPLICIT_INPUT);
- }
-
- if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, OutputStatement.class) == null) {
- addImplicitStatement((StatementContextBase<?, ?, ?>) stmt, IMPLICIT_OUTPUT);
- }
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
-
- private static void addImplicitStatement(final StatementContextBase<?, ?, ?> parent,
- final StatementSupport<?, ?, ?> statementToAdd) {
- final StatementDefinitionContext<?, ?, ?> stmtDefCtx = new StatementDefinitionContext<>(statementToAdd);
-
- parent.createSubstatement(parent.declaredSubstatements().size(), stmtDefCtx,
- ImplicitSubstatement.of(parent.getStatementSourceReference()), null);
- }
- }
-
- @Override
- public QName getName() {
- return argument();
- }
-
- @Nonnull
- @Override
- public Collection<? extends TypedefStatement> getTypedefs() {
- return allDeclared(TypedefStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends GroupingStatement> getGroupings() {
- return allDeclared(GroupingStatement.class);
- }
-
- @Nullable
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Override
- public InputStatement getInput() {
- return firstDeclared(InputStatement.class);
- }
-
- @Override
- public OutputStatement getOutput() {
- return firstDeclared(OutputStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends IfFeatureStatement> getIfFeatures() {
- return allDeclared(IfFeatureStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
-
-import com.google.common.annotations.Beta;
-import java.util.Collection;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.AnydataStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ChildSchemaNodes;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.effective.AnydataEffectiveStatementImpl;
-
-/**
- * YANG 1.1 AnyData declared statement implementation.
- */
-@Beta
-public final class AnydataStatementImpl extends AbstractDeclaredStatement<QName> implements AnydataStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
- .ANYDATA)
- .addOptional(YangStmtMapping.CONFIG)
- .addOptional(YangStmtMapping.DESCRIPTION)
- .addAny(YangStmtMapping.IF_FEATURE)
- .addOptional(YangStmtMapping.MANDATORY)
- .addAny(YangStmtMapping.MUST)
- .addOptional(YangStmtMapping.REFERENCE)
- .addOptional(YangStmtMapping.STATUS)
- .addOptional(YangStmtMapping.WHEN)
- .build();
-
- protected AnydataStatementImpl(final StmtContext<QName, AnydataStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends
- AbstractQNameStatementSupport<AnydataStatement, EffectiveStatement<QName, AnydataStatement>> {
-
- public Definition() {
- super(YangStmtMapping.ANYDATA);
- }
-
- @Override
- public QName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return StmtContextUtils.qnameFromArgument(ctx, value);
- }
-
- @Override
- public void onStatementAdded(final Mutable<QName, AnydataStatement,
- EffectiveStatement<QName, AnydataStatement>> stmt) {
- stmt.getParentContext().addToNs(ChildSchemaNodes.class, stmt.getStatementArgument(), stmt);
- }
-
- @Override
- public AnydataStatement createDeclared(final StmtContext<QName, AnydataStatement, ?> ctx) {
- return new AnydataStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<QName, AnydataStatement> createEffective(
- final StmtContext<QName, AnydataStatement, EffectiveStatement<QName, AnydataStatement>> ctx) {
- return new AnydataEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Override
- public QName getName() {
- return argument();
- }
-
- @Override
- public WhenStatement getWhenStatement() {
- return firstDeclared(WhenStatement.class);
- }
-
- @Override
- public Collection<? extends IfFeatureStatement> getIfFeatures() {
- return allDeclared(IfFeatureStatement.class);
- }
-
- @Override
- public Collection<? extends MustStatement> getMusts() {
- return allDeclared(MustStatement.class);
- }
-
- @Override
- public ConfigStatement getConfig() {
- return firstDeclared(ConfigStatement.class);
- }
-
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Override
- public MandatoryStatement getMandatory() {
- return firstDeclared(MandatoryStatement.class);
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
-
-import com.google.common.annotations.Beta;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ModifierStatement;
-import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
-import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
-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;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.effective.ModifierEffectiveStatementImpl;
-
-/**
- * Class providing necessary support for processing YANG 1.1 Modifier statement.
- */
-@Beta
-public final class ModifierStatementImpl extends AbstractDeclaredStatement<ModifierKind> implements ModifierStatement {
- private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(
- YangStmtMapping.MODIFIER).build();
-
- protected ModifierStatementImpl(final StmtContext<ModifierKind, ModifierStatement, ?> context) {
- super(context);
- }
-
- public static class Definition extends AbstractStatementSupport<ModifierKind, ModifierStatement,
- EffectiveStatement<ModifierKind, ModifierStatement>> {
-
- public Definition() {
- super(YangStmtMapping.MODIFIER);
- }
-
- @Override
- public ModifierKind parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- return SourceException.unwrap(ModifierKind.parse(value), ctx.getStatementSourceReference(),
- "'%s' is not valid argument of modifier statement", value);
- }
-
- @Override
- public ModifierStatement createDeclared(final StmtContext<ModifierKind, ModifierStatement, ?> ctx) {
- return new ModifierStatementImpl(ctx);
- }
-
- @Override
- public EffectiveStatement<ModifierKind, ModifierStatement> createEffective(
- final StmtContext<ModifierKind, ModifierStatement,
- EffectiveStatement<ModifierKind, ModifierStatement>> ctx) {
- return new ModifierEffectiveStatementImpl(ctx);
- }
-
- @Override
- protected SubstatementValidator getSubstatementValidator() {
- return SUBSTATEMENT_VALIDATOR;
- }
- }
-
- @Nonnull
- @Override
- public ModifierKind getValue() {
- return argument();
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2017 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-/**
- * Contains implementation of Rfc7950 effective statements.
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950.effective;
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2017 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-/**
- * Contains implementation of statement supports for Rfc7950 statements
- * and implementation of declared statements specific to Rfc7950.
- */
-package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
\ No newline at end of file
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.UnknownEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContainerEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LeafEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnitsEffectiveStatementImpl;
public class Bug6972Test {
final QName barFooCont = QName.create("bar-ns", "bar-foo", revision);
final QName barFooLeaf = QName.create("bar-ns", "foo", revision);
- final UnitsEffectiveStatementImpl unitsBar1 = getEffectiveUnits(bar, barExportCont, barFooLeaf);
- final UnitsEffectiveStatementImpl unitsBar2 = getEffectiveUnits(bar, barFooCont, barFooLeaf);
+ final UnitsEffectiveStatement unitsBar1 = getEffectiveUnits(bar, barExportCont, barFooLeaf);
+ final UnitsEffectiveStatement unitsBar2 = getEffectiveUnits(bar, barFooCont, barFooLeaf);
final QName bazExportCont = QName.create("baz-ns", "baz-export", revision);
final QName bazFooCont = QName.create("baz-ns", "baz-foo", revision);
final QName bazFooLeaf = QName.create("baz-ns", "foo", revision);
- final UnitsEffectiveStatementImpl unitsBaz1 = getEffectiveUnits(baz, bazExportCont, bazFooLeaf);
- final UnitsEffectiveStatementImpl unitsBaz2 = getEffectiveUnits(baz, bazFooCont, bazFooLeaf);
+ final UnitsEffectiveStatement unitsBaz1 = getEffectiveUnits(baz, bazExportCont, bazFooLeaf);
+ final UnitsEffectiveStatement unitsBaz2 = getEffectiveUnits(baz, bazFooCont, bazFooLeaf);
assertTrue(unitsBar1 == unitsBar2 && unitsBar1 == unitsBaz1 && unitsBar1 == unitsBaz2);
}
- private static UnitsEffectiveStatementImpl getEffectiveUnits(final Module module, final QName containerQName,
+ private static UnitsEffectiveStatement getEffectiveUnits(final Module module, final QName containerQName,
final QName leafQName) {
- UnitsEffectiveStatementImpl units = null;
+ UnitsEffectiveStatement units = null;
final ContainerSchemaNode cont = (ContainerSchemaNode) module.getDataChildByName(containerQName);
assertNotNull(cont);
for (EffectiveStatement<?, ?> effStmt : ((LeafEffectiveStatement) leaf).effectiveSubstatements()) {
if (effStmt instanceof UnitsEffectiveStatement) {
- units = (UnitsEffectiveStatementImpl) effStmt;
+ units = (UnitsEffectiveStatement) effStmt;
break;
}
}
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.Status;
+import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.AugmentEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ConfigStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ContainerEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.AnyxmlEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.AugmentEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ChoiceEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContainerEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ModuleEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.SubmoduleEffectiveStatementImpl;
public class DeclaredStatementsTest {
final AnyXmlSchemaNode anyxmlSchemaNode = (AnyXmlSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "foobar"));
assertNotNull(anyxmlSchemaNode);
- final AnyxmlStatement anyxmlStatement = ((AnyxmlEffectiveStatementImpl) anyxmlSchemaNode).getDeclared();
+ final AnyxmlStatement anyxmlStatement = ((AnyxmlEffectiveStatement) anyxmlSchemaNode).getDeclared();
final QName name = anyxmlStatement.getName();
assertNotNull(name);
final ChoiceSchemaNode choiceSchemaNode = (ChoiceSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-choice"));
assertNotNull(choiceSchemaNode);
- final ChoiceStatement choiceStatement = ((ChoiceEffectiveStatementImpl) choiceSchemaNode).getDeclared();
+ final ChoiceStatement choiceStatement = ((ChoiceEffectiveStatement) choiceSchemaNode).getDeclared();
final QName name = choiceStatement.getName();
assertNotNull(name);
assertEquals(1, augmentationSchemas.size());
final AugmentationSchemaNode augmentationSchema = augmentationSchemas.iterator().next();
- final AugmentStatement augmentStatement = ((AugmentEffectiveStatementImpl) augmentationSchema).getDeclared();
+ final AugmentStatement augmentStatement = ((AugmentEffectiveStatement) augmentationSchema).getDeclared();
final SchemaNodeIdentifier targetNode = augmentStatement.getTargetNode();
assertNotNull(targetNode);
final Module testModule = schemaContext.findModules("parent-module-declared-test").iterator().next();
assertNotNull(testModule);
- final ModuleStatement moduleStatement = ((ModuleEffectiveStatementImpl) testModule).getDeclared();
+ final ModuleStatement moduleStatement = ((ModuleEffectiveStatement) testModule).getDeclared();
final String moduleStatementName = moduleStatement.getName();
assertNotNull(moduleStatementName);
assertEquals(1, submodules.size());
final Module submodule = submodules.iterator().next();
- final SubmoduleStatement submoduleStatement = ((SubmoduleEffectiveStatementImpl) submodule).getDeclared();
+ final SubmoduleStatement submoduleStatement = ((SubmoduleEffectiveStatement) submodule).getDeclared();
final String submoduleStatementName = submoduleStatement.getName();
assertNotNull(submoduleStatementName);
final Module testModule = schemaContext.findModule("root-module-declared-test", revision).get();
assertNotNull(testModule);
- final ModuleStatement moduleStatement = ((ModuleEffectiveStatementImpl) testModule).getDeclared();
+ final ModuleStatement moduleStatement = ((ModuleEffectiveStatement) testModule).getDeclared();
assertEquals(1, moduleStatement.getImports().size());
final ImportStatement importStatement = moduleStatement.getImports().iterator().next();
QName.create(testModule.getQNameModule(), "test-container"));
assertNotNull(containerSchemaNode);
final ContainerStatement containerStatement =
- ((ContainerEffectiveStatementImpl) containerSchemaNode).getDeclared();
+ ((ContainerEffectiveStatement) containerSchemaNode).getDeclared();
final QName name = containerStatement.getName();
assertNotNull(name);
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.Status;
+import org.opendaylight.yangtools.yang.model.api.stmt.LeafEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
+import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
import org.opendaylight.yangtools.yang.parser.impl.DefaultReactors;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.BitsSpecificationEffectiveStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.Decimal64SpecificationEffectiveStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.EnumSpecificationEffectiveStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.IdentityRefSpecificationEffectiveStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.LeafrefSpecificationEffectiveStatement;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type.UnionSpecificationEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BitsSpecificationEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.Decimal64SpecificationEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.EnumSpecificationEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.IdentityRefSpecificationEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.LeafrefSpecificationEffectiveStatementImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.PatternConstraintEffectiveImpl;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.UnionSpecificationEffectiveStatementImpl;
public class EffectiveStatementTypeTest {
private static SchemaContext effectiveSchemaContext;
assertNotNull(currentLeaf.getType());
final BinaryTypeDefinition binaryEff = (BinaryTypeDefinition)
- ((TypeEffectiveStatement<?>) ((LeafEffectiveStatementImpl) currentLeaf)
+ ((TypeEffectiveStatement<?>) ((LeafEffectiveStatement) currentLeaf)
.effectiveSubstatements().iterator().next()).getTypeDefinition();
assertNull(binaryEff.getBaseType());
final Bit bitEff = bitsEffIter.get(0);
final Bit bitEffSecond = bitsEffIter.get(1);
- final BitsTypeDefinition bitsEff = ((BitsSpecificationEffectiveStatementImpl)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next())
+ final BitsTypeDefinition bitsEff = ((BitsSpecificationEffectiveStatement)
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
.getTypeDefinition();
assertNull(bitsEff.getBaseType());
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-boolean"));
assertNotNull(currentLeaf.getType());
final BooleanTypeDefinition booleanEff = (BooleanTypeDefinition) ((TypeEffectiveStatement<?>)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next())
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
.getTypeDefinition();
assertNull(booleanEff.getBaseType());
public void testDecimal64() {
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-decimal64"));
assertNotNull(currentLeaf.getType());
- final DecimalTypeDefinition decimal64Eff = ((Decimal64SpecificationEffectiveStatementImpl)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next())
+ final DecimalTypeDefinition decimal64Eff = ((Decimal64SpecificationEffectiveStatement)
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
.getTypeDefinition();
assertNull(decimal64Eff.getBaseType());
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-empty"));
assertNotNull(currentLeaf.getType());
final EmptyTypeDefinition emptyEff = (EmptyTypeDefinition) ((TypeEffectiveStatement<?>)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next())
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
.getTypeDefinition();
assertEquals(Optional.empty(), emptyEff.getUnits());
final List<EnumTypeDefinition.EnumPair> enumEffIter = ((EnumTypeDefinition) currentLeaf.getType()).getValues();
final EnumPair enumEff = enumEffIter.iterator().next();
- final EnumTypeDefinition enumSpecEff = ((EnumSpecificationEffectiveStatementImpl)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next())
+ final EnumTypeDefinition enumSpecEff = ((EnumSpecificationEffectiveStatement)
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
.getTypeDefinition();
assertEquals("enumeration", enumSpecEff.getQName().getLocalName());
currentLeaf = (LeafSchemaNode) types
.getDataChildByName(QName.create(types.getQNameModule(), "leaf-identityref"));
assertNotNull(currentLeaf.getType());
- final IdentityrefTypeDefinition identityRefEff = ((IdentityRefSpecificationEffectiveStatementImpl)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next())
+ final IdentityrefTypeDefinition identityRefEff = ((IdentityRefSpecificationEffectiveStatement)
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
.getTypeDefinition();
assertEquals(Optional.empty(), identityRefEff.getDefaultValue());
"leaf-instance-identifier"));
assertNotNull(currentLeaf.getType());
final InstanceIdentifierTypeDefinition instanceIdentEff = (InstanceIdentifierTypeDefinition)
- ((TypeEffectiveStatement<?>) ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements()
+ ((TypeEffectiveStatement<?>) ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements()
.iterator().next()).getTypeDefinition();
assertNotNull(instanceIdentEff.toString());
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-leafref"));
assertNotNull(currentLeaf.getType());
- final LeafrefTypeDefinition leafrefEff = ((LeafrefSpecificationEffectiveStatementImpl)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next())
+ final LeafrefTypeDefinition leafrefEff = ((LeafrefSpecificationEffectiveStatement)
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
.getTypeDefinition();
assertEquals("/container-test/leaf-test", leafrefEff.getPathStatement().toString());
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int8"));
assertNotNull(currentLeaf.getType());
final TypeEffectiveStatement<?> int8Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next();
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
assertNotNull(int8Eff.toString());
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int16"));
assertNotNull(currentLeaf.getType());
final TypeEffectiveStatement<?> int16Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next();
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
assertNotNull(int16Eff.toString());
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int32"));
assertNotNull(currentLeaf.getType());
final TypeEffectiveStatement<?> int32Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next();
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
assertNotNull(int32Eff.toString());
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int64"));
assertNotNull(currentLeaf.getType());
final TypeEffectiveStatement<?> int64Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next();
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
assertNotNull(int64Eff.toString());
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint8"));
assertNotNull(currentLeaf.getType());
final TypeEffectiveStatement<?> uint8Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next();
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
assertNotNull(uint8Eff.toString());
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint16"));
assertNotNull(currentLeaf.getType());
final TypeEffectiveStatement<?> uint16Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next();
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
assertNotNull(uint16Eff.toString());
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint32"));
assertNotNull(currentLeaf.getType());
final TypeEffectiveStatement<?> uint32Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next();
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
assertNotNull(uint32Eff.toString());
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint64"));
assertNotNull(currentLeaf.getType());
final TypeEffectiveStatement<?> uint64Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next();
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
assertNotNull(uint64Eff.toString());
}
public void testUnion() {
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-union"));
assertNotNull(currentLeaf.getType());
- final UnionTypeDefinition unionEff = ((UnionSpecificationEffectiveStatementImpl)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next())
+ final UnionTypeDefinition unionEff = ((UnionSpecificationEffectiveStatement)
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
.getTypeDefinition();
assertEquals(2, unionEff.getTypes().size());
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(),
"leaf-length-pattern"));
assertNotNull(currentLeaf.getType());
- final PatternConstraintEffectiveImpl patternConstraint = (PatternConstraintEffectiveImpl)
- ((StringTypeDefinition) currentLeaf.getType()).getPatternConstraints().get(0);
- final PatternConstraintEffectiveImpl patternConstraintThird = (PatternConstraintEffectiveImpl)
- ((StringTypeDefinition) currentLeaf.getType()).getPatternConstraints().get(0);
+ final PatternConstraint patternConstraint = ((StringTypeDefinition) currentLeaf.getType())
+ .getPatternConstraints().get(0);
+ final PatternConstraint patternConstraintThird = ((StringTypeDefinition) currentLeaf.getType())
+ .getPatternConstraints().get(0);
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(),
"leaf-length-pattern-second"));
assertNotNull(currentLeaf.getType());
- final PatternConstraintEffectiveImpl patternConstraintSecond = (PatternConstraintEffectiveImpl)
- ((StringTypeDefinition) currentLeaf.getType()).getPatternConstraints().get(0);
+ final PatternConstraint patternConstraintSecond = ((StringTypeDefinition) currentLeaf.getType())
+ .getPatternConstraints().get(0);
assertEquals("^[0-9a-fA-F]*$", patternConstraint.getJavaPatternString());
assertFalse(patternConstraint.getReference().isPresent());
currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-string"));
assertNotNull(currentLeaf.getType());
final StringTypeDefinition stringEff = (StringTypeDefinition) ((TypeEffectiveStatement<?>)
- ((LeafEffectiveStatementImpl) currentLeaf).effectiveSubstatements().iterator().next())
+ ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
.getTypeDefinition();
assertEquals("string", stringEff.getQName().getLocalName());
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.parser.rfc6020.util.UnknownEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
final class ThirdPartyExtensionEffectiveStatementImpl
Code Review / yangtools.git / commitdiff