return actionApplied;
}
- void failModifier() throws InferenceException {
+ void failModifier() {
removeSatisfied();
action.prerequisiteFailed(unsatisfied);
action = null;
}
- private void applyAction() throws InferenceException {
+ private void applyAction() {
Preconditions.checkState(!actionApplied);
action.apply();
actionApplied = true;
@Override
- public void apply(final InferenceAction action) throws InferenceException {
+ public void apply(final InferenceAction action) {
this.action = Preconditions.checkNotNull(action);
}
return done;
}
- protected boolean resolvePrereq(final T value) throws InferenceException {
+ protected boolean resolvePrereq(final T value) {
this.value = value;
this.done = true;
return isApplied();
private class PhaseMutation<C> extends AbstractPrerequisite<C> implements ContextMutation {
@SuppressWarnings("unchecked")
- public PhaseMutation(final StatementContextBase<?, ?, ?> context, final ModelProcessingPhase phase) throws InferenceException {
+ public PhaseMutation(final StatementContextBase<?, ?, ?> context, final ModelProcessingPhase phase) {
context.addMutation(phase, this);
resolvePrereq((C) context);
}
@SuppressWarnings("unchecked")
@Override
- public boolean phaseFinished(final StatementContextBase<?, ?, ?> context, final ModelProcessingPhase phase) throws SourceException {
+ public boolean phaseFinished(final StatementContextBase<?, ?, ?> context, final ModelProcessingPhase phase) {
return resolvePrereq((C) (context));
}
}
private class NamespaceMutation<N extends IdentifierNamespace<?,?>> extends AbstractPrerequisite<StmtContext.Mutable<?, ?, ?>> {
- public NamespaceMutation(final StatementContextBase<?, ?, ?> ctx, final Class<N> namespace) throws InferenceException {
+ public NamespaceMutation(final StatementContextBase<?, ?, ?> ctx, final Class<N> namespace) {
resolvePrereq(ctx);
}
@Override
public void namespaceItemAdded(final StatementContextBase<?, ?, ?> context, final Class<?> namespace, final Object key,
- final Object value) throws SourceException {
+ final Object value) {
StatementContextBase<?, ?, ?> targetContext = (StatementContextBase<?, ?, ?>) value;
targetContext.addPhaseCompletedListener(phase, this);
}
@SuppressWarnings("unchecked")
@Override
- public boolean phaseFinished(final StatementContextBase<?, ?, ?> context, final ModelProcessingPhase phase) throws SourceException {
+ public boolean phaseFinished(final StatementContextBase<?, ?, ?> context, final ModelProcessingPhase phase) {
return resolvePrereq((C) context);
}
private final ModelProcessingPhase modPhase;
- public <K, N extends StatementNamespace<K, ?, ?>> PhaseModificationInNamespace(final ModelProcessingPhase phase) throws SourceException {
+ public <K, N extends StatementNamespace<K, ?, ?>> PhaseModificationInNamespace(final ModelProcessingPhase phase) {
Preconditions.checkArgument(phase != null, "Model processing phase must not be null");
this.modPhase = phase;
}
@SuppressWarnings("unchecked")
@Override
public void namespaceItemAdded(final StatementContextBase<?, ?, ?> context, final Class<?> namespace, final Object key,
- final Object value) throws SourceException {
+ final Object value) {
StatementContextBase<?, ?, ?> targetCtx = contextImpl(value);
targetCtx.addMutation(modPhase,this);
resolvePrereq((C) targetCtx);
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.AnyxmlSchemaLocationNamespace;
-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.AnyXmlEffectiveStatementImpl;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.YangModeledAnyXmlEffectiveStatementImpl;
@Override
public void onFullDefinitionDeclared(Mutable<QName, AnyxmlStatement,
- EffectiveStatement<QName, AnyxmlStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, AnyxmlStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ArgumentEffectiveStatementImpl;
public class ArgumentStatementImpl extends AbstractDeclaredStatement<QName>
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<QName, ArgumentStatement,
- EffectiveStatement<QName, ArgumentStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, ArgumentStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
return firstDeclared(YinElementStatement.class);
}
-}
\ No newline at end of file
+}
@Override
public void onFullDefinitionDeclared(
- final StmtContext.Mutable<SchemaNodeIdentifier, AugmentStatement, EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> augmentNode)
- throws SourceException {
+ final StmtContext.Mutable<SchemaNodeIdentifier, AugmentStatement, EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> augmentNode) {
SUBSTATEMENT_VALIDATOR.validate(augmentNode);
if (StmtContextUtils.isInExtensionBody(augmentNode)) {
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.TypeOfCopy;
-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;
}
public static void copyFromSourceToTarget(final StatementContextBase<?, ?, ?> sourceCtx,
- final StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
+ final StatementContextBase<?, ?, ?> targetCtx) {
copyDeclaredStmts(sourceCtx, targetCtx);
copyEffectiveStmts(sourceCtx, targetCtx);
}
// FIXME: Declared statements should not be copied.
private static void copyDeclaredStmts(final StatementContextBase<?, ?, ?> sourceCtx,
- final StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
+ final StatementContextBase<?, ?, ?> targetCtx) {
final List<StatementContextBase<?, ?, ?>> subStatements = new Builder<StatementContextBase<?, ?, ?>>()
.addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build();
}
private static void copyEffectiveStmts(final StatementContextBase<?, ?, ?> sourceCtx,
- final StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
+ final StatementContextBase<?, ?, ?> targetCtx) {
final List<StatementContextBase<?, ?, ?>> subStatements = new Builder<StatementContextBase<?, ?, ?>>()
.addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build();
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BitEffectiveStatementImpl;
public class BitStatementImpl extends AbstractDeclaredStatement<QName> implements BitStatement {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<QName, BitStatement,
- EffectiveStatement<QName, BitStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, BitStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
return firstDeclared(PositionStatement.class);
}
-}
\ No newline at end of file
+}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.BitsSpecificationEffectiveStatementImpl;
public class BitsSpecificationImpl extends AbstractDeclaredStatement<String> implements TypeStatement.BitsSpecification {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, BitsSpecification,
- EffectiveStatement<String, BitsSpecification>> stmt) throws SourceException {
+ EffectiveStatement<String, BitsSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
return allDeclared(BitStatement.class);
}
-}
\ No newline at end of file
+}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.CaseEffectiveStatementImpl;
public class CaseStatementImpl extends AbstractDeclaredStatement<QName> implements CaseStatement {
@Override
public void onFullDefinitionDeclared(Mutable<QName, CaseStatement,
- EffectiveStatement<QName, CaseStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, CaseStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ChoiceEffectiveStatementImpl;
public class ChoiceStatementImpl extends AbstractDeclaredStatement<QName>
}
@Override
- public QName parseArgumentValue(StmtContext<?, ?, ?> ctx, String value)
- throws SourceException {
+ public QName parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return Utils.qNameFromArgument(ctx, value);
}
@Override
public void onFullDefinitionDeclared(Mutable<QName, ChoiceStatement,
- EffectiveStatement<QName, ChoiceStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, ChoiceStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ConfigEffectiveStatementImpl;
public class ConfigStatementImpl extends AbstractDeclaredStatement<Boolean> implements ConfigStatement {
}
@Override
- public Boolean parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) throws SourceException {
+ public Boolean parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return Boolean.valueOf(value);
}
@Override
public void onFullDefinitionDeclared(final StmtContext.Mutable<Boolean, ConfigStatement,
- EffectiveStatement<Boolean, ConfigStatement>> stmt) throws SourceException {
+ EffectiveStatement<Boolean, ConfigStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContactEffectiveStatementImpl;
public class ContactStatementImpl extends AbstractDeclaredStatement<String> implements ContactStatement{
}
@Override
- public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) throws SourceException {
+ public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return value;
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, ContactStatement,
- EffectiveStatement<String, ContactStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, ContactStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContainerEffectiveStatementImpl;
public class ContainerStatementImpl extends AbstractDeclaredStatement<QName> implements ContainerStatement {
@Override
public void onFullDefinitionDeclared(Mutable<QName, ContainerStatement,
- EffectiveStatement<QName, ContainerStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, ContainerStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.Decimal64SpecificationEffectiveStatementImpl;
public class Decimal64SpecificationImpl extends AbstractDeclaredStatement<String> implements Decimal64Specification {
}
@Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) throws SourceException {
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return value;
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, Decimal64Specification,
- EffectiveStatement<String, Decimal64Specification>> stmt) throws SourceException {
+ EffectiveStatement<String, Decimal64Specification>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
return firstDeclared(RangeStatement.class);
}
-}
\ No newline at end of file
+}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DefaultEffectiveStatementImpl;
public class DefaultStatementImpl extends AbstractDeclaredStatement<String> implements
}
@Override public String parseArgumentValue(
- StmtContext<?, ?, ?> ctx, String value) throws SourceException {
+ StmtContext<?, ?, ?> ctx, String value) {
return value;
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, DefaultStatement,
- EffectiveStatement<String, DefaultStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, DefaultStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DescriptionEffectiveStatementImpl;
public class DescriptionStatementImpl extends AbstractDeclaredStatement<String> implements DescriptionStatement {
}
@Override
- public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) throws SourceException {
+ public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return value;
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, DescriptionStatement,
- EffectiveStatement<String, DescriptionStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, DescriptionStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeviateEffectiveStatementImpl;
public class DeviateStatementImpl extends AbstractDeclaredStatement<Deviation.Deviate> implements DeviateStatement {
}
@Override public Deviation.Deviate parseArgumentValue(
- StmtContext<?, ?, ?> ctx, String value) throws SourceException {
+ StmtContext<?, ?, ?> ctx, String value) {
return Utils.parseDeviateFromString(ctx, value);
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<Deviation.Deviate, DeviateStatement,
- EffectiveStatement<Deviation.Deviate, DeviateStatement>> stmt) throws SourceException {
+ EffectiveStatement<Deviation.Deviate, DeviateStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeviationEffectiveStatementImpl;
public class DeviationStatementImpl extends AbstractDeclaredStatement<SchemaNodeIdentifier> implements DeviationStatement {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<SchemaNodeIdentifier, DeviationStatement,
- EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> stmt) throws SourceException {
+ EffectiveStatement<SchemaNodeIdentifier, DeviationStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.EnumSpecificationEffectiveStatementImpl;
public class EnumSpecificationImpl extends AbstractDeclaredStatement<String> implements TypeStatement.EnumSpecification {
}
@Override
- public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) throws SourceException {
+ public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return value;
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, EnumSpecification,
- EffectiveStatement<String, EnumSpecification>> stmt) throws SourceException {
+ EffectiveStatement<String, EnumSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.EnumEffectiveStatementImpl;
public class EnumStatementImpl extends AbstractDeclaredStatement<String> implements EnumStatement {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, EnumStatement,
- EffectiveStatement<String, EnumStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, EnumStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ErrorAppTagEffectiveStatementImpl;
public class ErrorAppTagStatementImpl extends AbstractDeclaredStatement<String>
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, ErrorAppTagStatement,
- EffectiveStatement<String, ErrorAppTagStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, ErrorAppTagStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
public String getValue() {
return argument();
}
-}
\ No newline at end of file
+}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ErrorMessageEffectiveStatementImpl;
public class ErrorMessageStatementImpl extends
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, ErrorMessageStatement,
- EffectiveStatement<String, ErrorMessageStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, ErrorMessageStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ExtensionEffectiveStatementImpl;
public class ExtensionStatementImpl extends AbstractDeclaredStatement<QName> implements ExtensionStatement {
}
@Override
- public void onStatementDefinitionDeclared(final StmtContext.Mutable<QName, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> stmt) throws SourceException {
+ public void onStatementDefinitionDeclared(final StmtContext.Mutable<QName, ExtensionStatement, EffectiveStatement<QName, ExtensionStatement>> stmt) {
stmt.addContext(ExtensionNamespace.class, stmt.getStatementArgument(), stmt);
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<QName, ExtensionStatement,
- EffectiveStatement<QName, ExtensionStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, ExtensionStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.FeatureEffectiveStatementImpl;
public class FeatureStatementImpl extends AbstractDeclaredStatement<QName>
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<QName, FeatureStatement,
- EffectiveStatement<QName, FeatureStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, FeatureStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
@Override
public void onFullDefinitionDeclared(final StmtContext.Mutable<Integer, FractionDigitsStatement,
- EffectiveStatement<Integer, FractionDigitsStatement>> stmt) throws SourceException {
+ EffectiveStatement<Integer, FractionDigitsStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.GroupingEffectiveStatementImpl;
public class GroupingStatementImpl extends AbstractDeclaredStatement<QName>
@Override
public void onFullDefinitionDeclared(Mutable<QName, GroupingStatement,
- EffectiveStatement<QName, GroupingStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, GroupingStatement>> stmt) {
SUBSTATEMENT_VALIDATOR.validate(stmt);
if (stmt != null && stmt.getParentContext() != null) {
*/
public static void copyFromSourceToTarget(final StatementContextBase<?, ?, ?> sourceGrpStmtCtx,
final StatementContextBase<?, ?, ?> targetCtx,
- final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode)
- throws SourceException {
+ final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode) {
QNameModule newQNameModule = getNewQNameModule(targetCtx,
sourceGrpStmtCtx);
public static void copyDeclaredStmts(final StatementContextBase<?, ?, ?> sourceGrpStmtCtx,
final StatementContextBase<?, ?, ?> targetCtx,
final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode,
- final QNameModule newQNameModule) throws SourceException {
+ final QNameModule newQNameModule) {
for (StatementContextBase<?, ?, ?> originalStmtCtx : sourceGrpStmtCtx.declaredSubstatements()) {
if (needToCopyByUses(originalStmtCtx)) {
StatementContextBase<?, ?, ?> copy = originalStmtCtx.createCopy(newQNameModule, targetCtx,
public static void copyEffectiveStmts(final StatementContextBase<?, ?, ?> sourceGrpStmtCtx,
final StatementContextBase<?, ?, ?> targetCtx,
final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode,
- final QNameModule newQNameModule) throws SourceException {
+ final QNameModule newQNameModule) {
for (StatementContextBase<?, ?, ?> originalStmtCtx : sourceGrpStmtCtx.effectiveSubstatements()) {
if (needToCopyByUses(originalStmtCtx)) {
StatementContextBase<?, ?, ?> copy = originalStmtCtx.createCopy(newQNameModule, targetCtx,
public static void resolveUsesNode(
final Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode,
- final StatementContextBase<?, ?, ?> targetNodeStmtCtx) throws SourceException {
+ final StatementContextBase<?, ?, ?> targetNodeStmtCtx) {
for (StatementContextBase<?, ?, ?> subStmtCtx : usesNode.declaredSubstatements()) {
if (StmtContextUtils.producesDeclared(subStmtCtx, RefineStatement.class)) {
performRefine(subStmtCtx, targetNodeStmtCtx);
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.IdentityRefSpecificationEffectiveStatementImpl;
public class IdentityRefSpecificationImpl extends AbstractDeclaredStatement<String> implements TypeStatement.IdentityRefSpecification {
}
@Override
- public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value)
- throws SourceException {
+ public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return value;
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, IdentityRefSpecification,
- EffectiveStatement<String, IdentityRefSpecification>> stmt) throws SourceException {
+ EffectiveStatement<String, IdentityRefSpecification>> stmt) {
final StmtContext<QName, ?, ?> baseStmt = StmtContextUtils.findFirstDeclaredSubstatement(stmt,
BaseStatement.class);
Preconditions.checkArgument(baseStmt != null, "The \"base\" statement, which is a substatement to the " +
@Override
public void onStatementDefinitionDeclared(StmtContext.Mutable<String, IdentityRefSpecification,
- EffectiveStatement<String, IdentityRefSpecification>> stmt) throws SourceException {
+ EffectiveStatement<String, IdentityRefSpecification>> stmt) {
super.onStatementDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.IdentityEffectiveStatementImpl;
public class IdentityStatementImpl extends AbstractDeclaredStatement<QName>
}
@Override
- public void onStatementDefinitionDeclared(final StmtContext.Mutable<QName, IdentityStatement, EffectiveStatement<QName, IdentityStatement>> stmt) throws SourceException {
+ public void onStatementDefinitionDeclared(final StmtContext.Mutable<QName, IdentityStatement, EffectiveStatement<QName, IdentityStatement>> stmt) {
stmt.addToNs(IdentityNamespace.class, stmt.getStatementArgument(), stmt);
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<QName, IdentityStatement,
- EffectiveStatement<QName, IdentityStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, IdentityStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.IfFeatureEffectiveStatementImpl;
public class IfFeatureStatementImpl extends AbstractDeclaredStatement<QName>
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<QName, IfFeatureStatement,
- EffectiveStatement<QName, IfFeatureStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, IfFeatureStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.IncludedSubmoduleNameToIdentifier;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.IncludeEffectiveStatementImpl;
public class IncludeStatementImpl extends AbstractDeclaredStatement<String> implements IncludeStatement {
@Override
public void onFullDefinitionDeclared(final Mutable<String, IncludeStatement,
- EffectiveStatement<String, IncludeStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, IncludeStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
return firstDeclared(RevisionDateStatement.class);
}
-}
\ No newline at end of file
+}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.InputEffectiveStatementImpl;
public class InputStatementImpl extends AbstractDeclaredStatement<QName>
}
@Override
- public QName parseArgumentValue(StmtContext<?, ?, ?> ctx, String value)
- throws SourceException {
+ public QName parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return Utils.qNameFromArgument(ctx, "input");
}
@Override
public void onFullDefinitionDeclared(Mutable<QName, InputStatement,
- EffectiveStatement<QName, InputStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, InputStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.InstanceIdentifierSpecificationEffectiveStatementImpl;
public class InstanceIdentifierSpecificationImpl extends
}
@Override
- public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value)
- throws SourceException {
+ public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return value;
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, InstanceIdentifierSpecification,
- EffectiveStatement<String, InstanceIdentifierSpecification>> stmt) throws SourceException {
+ EffectiveStatement<String, InstanceIdentifierSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.KeyEffectiveStatementImpl;
public class KeyStatementImpl extends AbstractDeclaredStatement<Collection<SchemaNodeIdentifier>> implements
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<Collection<SchemaNodeIdentifier>, KeyStatement,
- EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement>> stmt) throws SourceException {
+ EffectiveStatement<Collection<SchemaNodeIdentifier>, KeyStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafListEffectiveStatementImpl;
public class LeafListStatementImpl extends AbstractDeclaredStatement<QName>
@Override
public QName parseArgumentValue(StmtContext<?, ?, ?> ctx, String value)
- throws SourceException {
+ {
return Utils.qNameFromArgument(ctx, value);
}
@Override
public void onFullDefinitionDeclared(Mutable<QName, LeafListStatement,
- EffectiveStatement<QName, LeafListStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, LeafListStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafEffectiveStatementImpl;
public class LeafStatementImpl extends AbstractDeclaredStatement<QName> implements LeafStatement {
super(Rfc6020Mapping.LEAF);
}
- @Override public QName parseArgumentValue(StmtContext<?, ?, ?> ctx,
- String value) throws SourceException {
+ @Override public QName parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return Utils.qNameFromArgument(ctx,value);
}
@Override
public void onFullDefinitionDeclared(Mutable<QName, LeafStatement,
- EffectiveStatement<QName, LeafStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, LeafStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.LeafrefSpecificationEffectiveStatementImpl;
public class LeafrefSpecificationImpl extends AbstractDeclaredStatement<String>
}
@Override
- public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value)
- throws SourceException {
+ public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return value;
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, LeafrefSpecification,
- EffectiveStatement<String, LeafrefSpecification>> stmt) throws SourceException {
+ EffectiveStatement<String, LeafrefSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.LengthEffectiveStatementImpl;
public class LengthStatementImpl extends AbstractDeclaredStatement<List<LengthConstraint>> implements LengthStatement {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<List<LengthConstraint>,
- LengthStatement, EffectiveStatement<List<LengthConstraint>, LengthStatement>> stmt) throws SourceException {
+ LengthStatement, EffectiveStatement<List<LengthConstraint>, LengthStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
public List<LengthConstraint> getValue() {
return argument();
}
-}
\ No newline at end of file
+}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ListEffectiveStatementImpl;
public class ListStatementImpl extends AbstractDeclaredStatement<QName>
}
@Override
- public QName parseArgumentValue(StmtContext<?, ?, ?> ctx, String value)
- throws SourceException {
+ public QName parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return Utils.qNameFromArgument(ctx, value);
}
@Override
public void onFullDefinitionDeclared(Mutable<QName, ListStatement,
- EffectiveStatement<QName, ListStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, ListStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MandatoryEffectiveStatementImpl;
public class MandatoryStatementImpl extends AbstractDeclaredStatement<Boolean> implements MandatoryStatement {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<Boolean, MandatoryStatement,
- EffectiveStatement<Boolean, MandatoryStatement>> stmt) throws SourceException {
+ EffectiveStatement<Boolean, MandatoryStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MaxElementsEffectiveStatementImpl;
public class MaxElementsStatementImpl extends AbstractDeclaredStatement<String>
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, MaxElementsStatement,
- EffectiveStatement<String, MaxElementsStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, MaxElementsStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MinElementsEffectiveStatementImpl;
public class MinElementsStatementImpl extends
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<Integer, MinElementsStatement,
- EffectiveStatement<Integer, MinElementsStatement>> stmt) throws SourceException {
+ EffectiveStatement<Integer, MinElementsStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
@Override
public void onFullDefinitionDeclared(final Mutable<String, ModuleStatement,
- EffectiveStatement<String, ModuleStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, ModuleStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.MustEffectiveStatementImpl;
public class MustStatementImpl extends AbstractDeclaredStatement<RevisionAwareXPath> implements MustStatement {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<RevisionAwareXPath, MustStatement,
- EffectiveStatement<RevisionAwareXPath, MustStatement>> stmt) throws SourceException {
+ EffectiveStatement<RevisionAwareXPath, MustStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.NamespaceEffectiveStatementImpl;
public class NamespaceStatementImpl extends AbstractDeclaredStatement<URI> implements NamespaceStatement {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<URI, NamespaceStatement,
- EffectiveStatement<URI, NamespaceStatement>> stmt) throws SourceException {
+ EffectiveStatement<URI, NamespaceStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.NotificationEffectiveStatementImpl;
public class NotificationStatementImpl extends AbstractDeclaredStatement<QName>
@Override
public void onFullDefinitionDeclared(Mutable<QName, NotificationStatement,
- EffectiveStatement<QName, NotificationStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, NotificationStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.NumericalRestrictionsEffectiveStatementImpl;
public class NumericalRestrictionsImpl extends AbstractDeclaredStatement<String> implements
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, NumericalRestrictions,
- EffectiveStatement<String, NumericalRestrictions>> stmt) throws SourceException {
+ EffectiveStatement<String, NumericalRestrictions>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
return firstDeclared(RangeStatement.class);
}
-}
\ No newline at end of file
+}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OrderedByEffectiveStatementImpl;
public class OrderedByStatementImpl extends AbstractDeclaredStatement<String>
}
@Override
- public OrderedByStatement createDeclared(
- StmtContext<String, OrderedByStatement, ?> ctx) {
+ public OrderedByStatement createDeclared(StmtContext<String, OrderedByStatement, ?> ctx) {
return new OrderedByStatementImpl(ctx);
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, OrderedByStatement,
- EffectiveStatement<String, OrderedByStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, OrderedByStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OrganizationEffectiveStatementImpl;
public class OrganizationStatementImpl extends
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, OrganizationStatement,
- EffectiveStatement<String, OrganizationStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, OrganizationStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OutputEffectiveStatementImpl;
public class OutputStatementImpl extends AbstractDeclaredStatement<QName> implements OutputStatement {
@Override
public void onFullDefinitionDeclared(Mutable<QName, OutputStatement,
- EffectiveStatement<QName, OutputStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, OutputStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PathEffectiveStatementImpl;
public class PathStatementImpl extends AbstractDeclaredStatement<RevisionAwareXPath> implements PathStatement {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<RevisionAwareXPath, PathStatement,
- EffectiveStatement<RevisionAwareXPath, PathStatement>> stmt) throws SourceException {
+ EffectiveStatement<RevisionAwareXPath, PathStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
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;
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<PatternConstraint, PatternStatement,
- EffectiveStatement<PatternConstraint, PatternStatement>> stmt) throws SourceException {
+ EffectiveStatement<PatternConstraint, PatternStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PrefixEffectiveStatementImpl;
public class PrefixStatementImpl extends AbstractDeclaredStatement<String> implements PrefixStatement {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, PrefixStatement,
- EffectiveStatement<String, PrefixStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, PrefixStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PresenceEffectiveStatementImpl;
-public class PresenceStatementImpl extends AbstractDeclaredStatement<String>
- implements PresenceStatement {
+public class PresenceStatementImpl extends AbstractDeclaredStatement<String> implements PresenceStatement {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(Rfc6020Mapping
.PRESENCE)
.build();
- protected PresenceStatementImpl(
- StmtContext<String, PresenceStatement, ?> context) {
+ protected PresenceStatementImpl(StmtContext<String, PresenceStatement, ?> context) {
super(context);
}
}
@Override
- public PresenceStatement createDeclared(
- StmtContext<String, PresenceStatement, ?> ctx) {
+ public PresenceStatement createDeclared(StmtContext<String, PresenceStatement, ?> ctx) {
return new PresenceStatementImpl(ctx);
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, PresenceStatement,
- EffectiveStatement<String, PresenceStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, PresenceStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.RangeEffectiveStatementImpl;
public class RangeStatementImpl extends AbstractDeclaredStatement<List<RangeConstraint>> implements RangeStatement {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<List<RangeConstraint>, RangeStatement,
- EffectiveStatement<List<RangeConstraint>, RangeStatement>> stmt) throws SourceException {
+ EffectiveStatement<List<RangeConstraint>, RangeStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ReferenceEffectiveStatementImpl;
public class ReferenceStatementImpl extends AbstractDeclaredStatement<String> implements ReferenceStatement {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, ReferenceStatement,
- EffectiveStatement<String, ReferenceStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, ReferenceStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RefineEffectiveStatementImpl;
public class RefineStatementImpl extends AbstractDeclaredStatement<SchemaNodeIdentifier> implements RefineStatement {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<SchemaNodeIdentifier, RefineStatement,
- EffectiveStatement<SchemaNodeIdentifier, RefineStatement>> stmt) throws SourceException {
+ EffectiveStatement<SchemaNodeIdentifier, RefineStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
}
@Override
- public Date parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) throws SourceException {
+ public Date parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
try {
return SimpleDateFormatUtil.getRevisionFormat().parse(value);
} catch (ParseException e) {
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RpcEffectiveStatementImpl;
public class RpcStatementImpl extends AbstractDeclaredStatement<QName>
}
@Override
- public void onFullDefinitionDeclared(Mutable<QName, RpcStatement,
- EffectiveStatement<QName, RpcStatement>> stmt) throws SourceException {
+ public void onFullDefinitionDeclared(Mutable<QName, RpcStatement, EffectiveStatement<QName, RpcStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.StatusEffectiveStatementImpl;
public class StatusStatementImpl extends AbstractDeclaredStatement<Status>
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<Status, StatusStatement,
- EffectiveStatement<Status, StatusStatement>> stmt) throws SourceException {
+ EffectiveStatement<Status, StatusStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.StringRestrictionsEffectiveStatementImpl;
public class StringRestrictionsImpl extends AbstractDeclaredStatement<String> implements
}
@Override
- public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) throws SourceException {
+ public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return value;
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, StringRestrictions,
- EffectiveStatement<String, StringRestrictions>> stmt) throws SourceException {
+ EffectiveStatement<String, StringRestrictions>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
@Override
public void onLinkageDeclared(
- final Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> stmt)
- throws SourceException {
+ final Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> stmt) {
final Optional<Date> revisionDate = Optional.fromNullable(
Utils.getLatestRevision(stmt.declaredSubstatements())).or(DEFAULT_REVISION);
@Override
public void onFullDefinitionDeclared(final Mutable<String, SubmoduleStatement,
- EffectiveStatement<String, SubmoduleStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, SubmoduleStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
}
@Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value)
- throws SourceException {
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return value;
}
public String getName() {
return argument();
}
-}
\ No newline at end of file
+}
@Override
public void onFullDefinitionDeclared(final StmtContext.Mutable<QName, TypedefStatement,
- EffectiveStatement<QName, TypedefStatement>> stmt) throws SourceException {
+ EffectiveStatement<QName, TypedefStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type.UnionSpecificationEffectiveStatementImpl;
public class UnionSpecificationImpl extends AbstractDeclaredStatement<String>
}
@Override
- public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value)
- throws SourceException {
+ public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return value;
}
}
@Override
- public void onFullDefinitionDeclared(StmtContext.Mutable<String, UnionSpecification, EffectiveStatement<String, UnionSpecification>> stmt) throws SourceException {
+ public void onFullDefinitionDeclared(StmtContext.Mutable<String, UnionSpecification, EffectiveStatement<String, UnionSpecification>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UniqueEffectiveStatementImpl;
public class UniqueStatementImpl extends AbstractDeclaredStatement<Collection<SchemaNodeIdentifier.Relative>> implements UniqueStatement {
}
@Override
- public Collection<SchemaNodeIdentifier.Relative> parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) throws
- SourceException {
+ public Collection<SchemaNodeIdentifier.Relative> parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return Utils.transformKeysStringToKeyNodes(ctx, value);
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<Collection<Relative>, UniqueStatement,
- EffectiveStatement<Collection<Relative>, UniqueStatement>> stmt) throws SourceException {
+ EffectiveStatement<Collection<Relative>, UniqueStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnitsEffectiveStatementImpl;
public class UnitsStatementImpl extends AbstractDeclaredStatement<String>
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, UnitsStatement,
- EffectiveStatement<String, UnitsStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, UnitsStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnknownEffectiveStatementImpl;
public class UnknownStatementImpl extends AbstractDeclaredStatement<String> implements UnknownStatement<String> {
}
@Override
- public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) throws SourceException {
+ public String parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
return value;
}
@Override
public void onFullDefinitionDeclared(
- final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode)
- throws SourceException {
+ final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode) {
SUBSTATEMENT_VALIDATOR.validate(usesNode);
if (StmtContextUtils.isInExtensionBody(usesNode)) {
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.WhenEffectiveStatementImpl;
public class WhenStatementImpl extends AbstractDeclaredStatement<RevisionAwareXPath> implements WhenStatement {
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<RevisionAwareXPath, WhenStatement,
- EffectiveStatement<RevisionAwareXPath, WhenStatement>> stmt) throws SourceException {
+ EffectiveStatement<RevisionAwareXPath, WhenStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
import org.opendaylight.yangtools.yang.parser.impl.YangStatementParserListenerImpl;
import org.opendaylight.yangtools.yang.parser.spi.source.PrefixToModule;
import org.opendaylight.yangtools.yang.parser.spi.source.QNameToStatementDefinition;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementWriter;
import org.opendaylight.yangtools.yang.parser.util.NamedFileInputStream;
}
@Override
- public void writeLinkage(final StatementWriter writer, final QNameToStatementDefinition stmtDef) throws SourceException {
+ public void writeLinkage(final StatementWriter writer, final QNameToStatementDefinition stmtDef) {
yangStatementModelParser.setAttributes(writer, stmtDef);
walker.walk(yangStatementModelParser, statementContext);
}
@Override
- public void writeLinkageAndStatementDefinitions(final StatementWriter writer, final QNameToStatementDefinition stmtDef, final PrefixToModule prefixes) throws SourceException {
+ public void writeLinkageAndStatementDefinitions(final StatementWriter writer, final QNameToStatementDefinition stmtDef, final PrefixToModule prefixes) {
yangStatementModelParser.setAttributes(writer, stmtDef, prefixes);
walker.walk(yangStatementModelParser, statementContext);
}
@Override
- public void writeFull(final StatementWriter writer, final QNameToStatementDefinition stmtDef, final PrefixToModule prefixes) throws SourceException {
+ public void writeFull(final StatementWriter writer, final QNameToStatementDefinition stmtDef, final PrefixToModule prefixes) {
yangStatementModelParser.setAttributes(writer, stmtDef, prefixes);
walker.walk(yangStatementModelParser, statementContext);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.YangVersionEffectiveStatementImpl;
public class YangVersionStatementImpl extends AbstractDeclaredStatement<String> implements YangVersionStatement {
}
@Override
- public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) throws SourceException {
+ public String parseArgumentValue(StmtContext<?, ?, ?> ctx, String value) {
return value;
}
@Override
public void onFullDefinitionDeclared(StmtContext.Mutable<String, YangVersionStatement,
- EffectiveStatement<String, YangVersionStatement>> stmt) throws SourceException {
+ EffectiveStatement<String, YangVersionStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
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.source.SourceException;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.YinElementEffectiveStatementImpl;
public class YinElementStatementImpl extends AbstractDeclaredStatement<Boolean>
@Override
public void onFullDefinitionDeclared(final StmtContext.Mutable<Boolean, YinElementStatement,
- EffectiveStatement<Boolean, YinElementStatement>> stmt) throws SourceException {
+ EffectiveStatement<Boolean, YinElementStatement>> stmt) {
super.onFullDefinitionDeclared(stmt);
SUBSTATEMENT_VALIDATOR.validate(stmt);
}
import org.opendaylight.yangtools.yang.parser.impl.YinStatementParserImpl;
import org.opendaylight.yangtools.yang.parser.spi.source.PrefixToModule;
import org.opendaylight.yangtools.yang.parser.spi.source.QNameToStatementDefinition;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementWriter;
import org.opendaylight.yangtools.yang.parser.util.NamedFileInputStream;
}
@Override
- public void writeLinkage(StatementWriter writer, QNameToStatementDefinition stmtDef) throws SourceException {
+ public void writeLinkage(StatementWriter writer, QNameToStatementDefinition stmtDef) {
initializeReader();
yinStatementModelParser.setAttributes(writer, stmtDef);
yinStatementModelParser.walk(streamReader);
@Override
public void writeLinkageAndStatementDefinitions(StatementWriter writer, QNameToStatementDefinition stmtDef,
- PrefixToModule prefixes) throws SourceException {
+ PrefixToModule prefixes) {
initializeReader();
yinStatementModelParser.setAttributes(writer, stmtDef, prefixes);
yinStatementModelParser.walk(streamReader);
}
@Override
- public void writeFull(StatementWriter writer, QNameToStatementDefinition stmtDef, PrefixToModule prefixes) throws
- SourceException {
+ public void writeFull(StatementWriter writer, QNameToStatementDefinition stmtDef, PrefixToModule prefixes) {
initializeReader();
yinStatementModelParser.setAttributes(writer, stmtDef, prefixes);
yinStatementModelParser.walk(streamReader);
return new NamedFileInputStream(file, fileName);
}
-}
\ No newline at end of file
+}
Code Review / yangtools.git / commitdiff