import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
+import com.google.common.collect.Collections2;
import java.util.Collection;
import java.util.Optional;
import java.util.stream.Stream;
@Nullable String rawArgument();
/**
- * Returns collection of explicitly declared child statements, while preserving its original
- * ordering from original source.
+ * Returns collection of explicitly declared child statements, while preserving its original ordering from original
+ * source.
*
- * @return Collection of statements, which were explicitly declared in
- * source of model.
+ * @return Collection of statements, which were explicitly declared in source of model.
*/
@Nonnull Collection<? extends DeclaredStatement<?>> declaredSubstatements();
+ /**
+ * Returns collection of explicitly declared child statements, while preserving its original ordering from original
+ * source.
+ *
+ * @param type {@link DeclaredStatement} type
+ * @return Collection of statements, which were explicitly declared in source of model.
+ * @throws NullPointerException if {@code type} is null
+ */
+ default <S extends DeclaredStatement<?>> @NonNull Collection<? extends S> declaredSubstatements(
+ final Class<S> type) {
+ requireNonNull(type);
+ return Collections2.transform(Collections2.filter(declaredSubstatements(), type::isInstance), type::cast);
+ }
+
/**
* Find the first effective substatement of specified type.
*
* @param type {@link DeclaredStatement} type
* @return First declared substatement, or empty if no match is found.
+ * @throws NullPointerException if {@code type} is null
*/
@Beta
default <T extends DeclaredStatement<?>> @NonNull Optional<T> findFirstDeclaredSubstatement(
package org.opendaylight.yangtools.yang.model.api.stmt;
import com.google.common.annotations.Beta;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
/**
* Represents YANG action statement.
* detailed action information. The argument is the name of the action.
*/
@Beta
-public interface ActionStatement extends DeclaredStatement<QName>, OperationGroup {
+public interface ActionStatement extends OperationDeclaredStatement {
}
--- /dev/null
+/*
+ * Copyright (c) 2018 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+
+/**
+ * Statement which can contain action statements.
+ */
+@Beta
+public interface ActionStatementAwareDeclaredStatement<A> extends DeclaredStatement<A>, ActionStatementContainer {
+ @Override
+ default @Nonnull Collection<? extends ActionStatement> getActions() {
+ return declaredSubstatements(ActionStatement.class);
+ }
+}
* Statement which can contain action statements.
*/
@Beta
+@Deprecated
public interface ActionStatementContainer {
/**
* Return actions in this container. Since actions were introduced in RFC7950, hence RFC6020 semantics always
* of this document.
*/
@Beta
-public interface AnydataStatement extends DataDefinitionStatement, ConfigStatementContainerDeclaredStatement<QName>,
- MandatoryStatementContainer, MustStatementContainer {
+public interface AnydataStatement extends DataDefinitionStatement, ConfigStatementAwareDeclaredStatement<QName>,
+ MandatoryStatementAwareDeclaredStatement<QName>, MustStatementAwareDeclaredStatement<QName> {
}
import org.opendaylight.yangtools.yang.common.QName;
-public interface AnyxmlStatement extends DataDefinitionStatement, ConfigStatementContainerDeclaredStatement<QName>,
- MandatoryStatementContainer, MustStatementContainer {
+public interface AnyxmlStatement extends DataDefinitionStatement, ConfigStatementAwareDeclaredStatement<QName>,
+ MandatoryStatementAwareDeclaredStatement<QName>, MustStatementAwareDeclaredStatement<QName> {
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
@Rfc6020AbnfRule("argument-stmt")
public interface ArgumentStatement extends DeclaredStatement<QName> {
+ default @Nonnull QName getName() {
+ return argument();
+ }
- @Nonnull QName getName();
-
- @Nullable YinElementStatement getYinElement();
+ default @Nullable YinElementStatement getYinElement() {
+ final Optional<YinElementStatement> opt = findFirstDeclaredSubstatement(YinElementStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
import java.util.Collection;
import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DocumentedDeclaredStatement.WithStatus;
-public interface AugmentStatement
- extends DeclaredStatement<SchemaNodeIdentifier>, DataDefinitionContainer, NotificationStatementContainer,
- ActionStatementContainer, DocumentationGroup.WithStatus, ConditionalDataDefinition, ConditionalFeature {
+public interface AugmentStatement extends WithStatus<SchemaNodeIdentifier>,
+ DataDefinitionAwareDeclaredStatement<SchemaNodeIdentifier>,
+ NotificationStatementAwareDeclaredStatement<SchemaNodeIdentifier>,
+ ActionStatementAwareDeclaredStatement<SchemaNodeIdentifier>,
+ WhenStatementAwareDeclaredStatement<SchemaNodeIdentifier> {
- @Nonnull
- SchemaNodeIdentifier getTargetNode();
+ default @Nonnull SchemaNodeIdentifier getTargetNode() {
+ return argument();
+ }
- @Nonnull
- Collection<? extends CaseStatement> getCases();
+ default @Nonnull Collection<? extends CaseStatement> getCases() {
+ return declaredSubstatements(CaseStatement.class);
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface BaseStatement extends DeclaredStatement<QName> {
-
- @Nonnull QName getName();
+ default @Nonnull QName getName() {
+ return argument();
+ }
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface BelongsToStatement extends DeclaredStatement<String> {
+ default @Nonnull String getModule() {
+ return argument();
+ }
- @Nonnull String getModule();
-
- @Nonnull PrefixStatement getPrefix();
+ default @Nonnull PrefixStatement getPrefix() {
+ final Optional<PrefixStatement> opt = findFirstDeclaredSubstatement(PrefixStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+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.meta.DeclaredStatement;
-
-public interface BitStatement extends DeclaredStatement<QName>, DocumentationGroup.WithStatus, ConditionalFeature {
- @Nonnull
- String getName();
+public interface BitStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
+ IfFeatureAwareDeclaredStatement<QName> {
+ default @Nonnull String getName() {
+ return argument().getLocalName();
+ }
- @Nullable
- PositionStatement getPosition();
+ default PositionStatement getPosition() {
+ final Optional<PositionStatement> opt = findFirstDeclaredSubstatement(PositionStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+
+@Beta
+public interface BodyDeclaredStatement extends NotificationStatementAwareDeclaredStatement<String>,
+ DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<String>, BodyGroup {
+ @Override
+ default @Nonnull Collection<? extends ExtensionStatement> getExtensions() {
+ return declaredSubstatements(ExtensionStatement.class);
+ }
+
+ @Override
+ default @Nonnull Collection<? extends FeatureStatement> getFeatures() {
+ return declaredSubstatements(FeatureStatement.class);
+ }
+
+ @Override
+ default @Nonnull Collection<? extends IdentityStatement> getIdentities() {
+ return declaredSubstatements(IdentityStatement.class);
+ }
+
+ @Override
+ default @Nonnull Collection<? extends AugmentStatement> getAugments() {
+ return declaredSubstatements(AugmentStatement.class);
+ }
+
+ @Override
+ default @Nonnull Collection<? extends RpcStatement> getRpcs() {
+ return declaredSubstatements(RpcStatement.class);
+ }
+
+ @Override
+ default @Nonnull Collection<? extends DeviationStatement> getDeviations() {
+ return declaredSubstatements(DeviationStatement.class);
+ }
+}
import javax.annotation.Nonnull;
@Rfc6020AbnfRule("body-stmts")
+@Deprecated
public interface BodyGroup extends DataDefinitionContainer.WithReusableDefinitions, NotificationStatementContainer {
@Nonnull Collection<? extends ExtensionStatement> getExtensions();
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface CaseStatement extends DeclaredStatement<QName>, DataDefinitionContainer,
- DocumentationGroup.WithStatus, ConditionalDataDefinition {
-
- @Nonnull QName getName();
+public interface CaseStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
+ DataDefinitionAwareDeclaredStatement<QName>, WhenStatementAwareDeclaredStatement<QName> {
+ default @Nonnull QName getName() {
+ return argument();
+ }
}
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
-public interface ChoiceStatement extends DataDefinitionStatement, ConfigStatementContainerDeclaredStatement<QName>,
- DefaultStatementContainer, MandatoryStatementContainer {
+public interface ChoiceStatement extends DataDefinitionStatement, ConfigStatementAwareDeclaredStatement<QName>,
+ DefaultStatementAwareDeclaredStatement, MandatoryStatementAwareDeclaredStatement<QName> {
- @Nonnull Collection<? extends CaseStatement> getCases();
+ default @Nonnull Collection<? extends CaseStatement> getCases() {
+ return declaredSubstatements(CaseStatement.class);
+ }
}
import javax.annotation.Nullable;
+@Deprecated
public interface ConditionalDataDefinition extends ConditionalFeature {
@Nullable WhenStatement getWhenStatement();
import javax.annotation.Nonnull;
@Rfc6020AbnfRule("*(if-feature-stmt)")
+@Deprecated
public interface ConditionalFeature {
/**
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface ConfigStatement extends DeclaredStatement<Boolean> {
-
- boolean getValue();
+ default boolean getValue() {
+ return argument().booleanValue();
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Beta
-public interface ConfigStatement
ContainerDeclaredStatement<A> extends DeclaredStatement<A>, ConfigStatementContainer {
+public interface ConfigStatement
AwareDeclaredStatement<A> extends DeclaredStatement<A>, ConfigStatementContainer {
@Override
default ConfigStatement getConfig() {
final Optional<ConfigStatement> opt = findFirstDeclaredSubstatement(ConfigStatement.class);
/**
* Marker interface for statements which may contain a 'config' statement, as defined in RFC7950.
*
- * @deprecated Use {@link ConfigStatementContainerDeclaredStatement} instead.
+ * @deprecated Use {@link ConfigStatementAwareDeclaredStatement} instead.
*/
@Deprecated
public interface ConfigStatementContainer {
--- /dev/null
+/*
+ * Copyright (c) 2018 Pantheon Technoglogies, 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Optional;
+
+/**
+ * Common interface for statements which contain either a description/reference or a description/reference/status combo.
+ */
+@Beta
+public interface ConstrainedDocumentedDeclaredStatement<T> extends DocumentedDeclaredStatement<T>,
+ DocumentedConstraintGroup {
+
+ @Override
+ default ErrorAppTagStatement getErrorAppTagStatement() {
+ final Optional<ErrorAppTagStatement> opt = findFirstDeclaredSubstatement(ErrorAppTagStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+
+ @Override
+ default ErrorMessageStatement getErrorMessageStatement() {
+ final Optional<ErrorMessageStatement> opt = findFirstDeclaredSubstatement(ErrorMessageStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+
+ interface WithStatus<T> extends ConstrainedDocumentedDeclaredStatement<T>,
+ DocumentedDeclaredStatement.WithStatus<T> {
+
+ }
+}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface ContactStatement extends DeclaredStatement<String> {
-
- @Nonnull String getText();
+ default @Nonnull String getText() {
+ return rawArgument();
+ }
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import java.util.Optional;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-public interface ContainerStatement extends DataDefinitionStatement, DataDefinitionContainer.WithReusableDefinitions,
- ActionStatementContainer, ConfigStatementContainerDeclaredStatement<QName>, NotificationStatementContainer,
- MustStatementContainer {
-
- @Nullable PresenceStatement getPresence();
+public interface ContainerStatement extends DataDefinitionStatement,
+ DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<QName>,
+ ActionStatementAwareDeclaredStatement<QName>, ConfigStatementAwareDeclaredStatement<QName>,
+ NotificationStatementAwareDeclaredStatement<QName>, MustStatementAwareDeclaredStatement<QName> {
+ default @Nullable PresenceStatement getPresence() {
+ final Optional<PresenceStatement> opt = findFirstDeclaredSubstatement(PresenceStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+
+@Beta
+public interface DataDefinitionAwareDeclaredStatement<A> extends DeclaredStatement<A>, DataDefinitionContainer {
+ @Override
+ default @Nonnull Collection<? extends DataDefinitionStatement> getDataDefinitions() {
+ return declaredSubstatements(DataDefinitionStatement.class);
+ }
+
+ interface WithReusableDefinitions<A> extends DataDefinitionAwareDeclaredStatement<A>,
+ DataDefinitionContainer.WithReusableDefinitions {
+ @Override
+ default @Nonnull Collection<? extends TypedefStatement> getTypedefs() {
+ return declaredSubstatements(TypedefStatement.class);
+ }
+
+ @Override
+ default @Nonnull Collection<? extends GroupingStatement> getGroupings() {
+ return declaredSubstatements(GroupingStatement.class);
+ }
+ }
+
+}
import java.util.Collection;
import javax.annotation.Nonnull;
+@Deprecated
public interface DataDefinitionContainer {
@Nonnull Collection<? extends DataDefinitionStatement> getDataDefinitions();
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
/**
* Statement that defines new data nodes.
* Defined in: <a href="https://tools.ietf.org/html/rfc6020#section-3">RFC6020, Section 3</a>
*/
@Rfc6020AbnfRule("data-def-stmt")
-public interface DataDefinitionStatement extends DeclaredStatement<QName>, DocumentationGroup.WithStatus,
- ConditionalDataDefinition {
-
- @Nonnull QName getName();
+public interface DataDefinitionStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
+ WhenStatementAwareDeclaredStatement<QName> {
+ default @Nonnull QName getName() {
+ return argument();
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface DefaultStatement extends DeclaredStatement<String> {
-
- @Nonnull String getValue();
+ default @Nonnull String getValue() {
+ return argument();
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Optional;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+
+/**
+ * Marker interface for statements which may contain a 'default' statement, as defined in RFC7950.
+ */
+@Beta
+public interface DefaultStatementAwareDeclaredStatement extends DeclaredStatement<QName>, DefaultStatementContainer {
+ @Override
+ default DefaultStatement getDefault() {
+ final Optional<DefaultStatement> opt = findFirstDeclaredSubstatement(DefaultStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+}
/**
* Marker interface for statements which may contain a 'default' statement, as defined in RFC7950.
+ *
+ * @deprecated Use {@link DefaultStatementAwareDeclaredStatement} instead.
*/
+@Deprecated
public interface DefaultStatementContainer {
/**
* Return a {@link DefaultStatement} child, if present.
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface DescriptionStatement extends DeclaredStatement<String> {
-
- @Nonnull String getText();
+ default @Nonnull String getText() {
+ return argument();
+ }
}
package org.opendaylight.yangtools.yang.model.api.stmt;
import javax.annotation.Nonnull;
-
import org.opendaylight.yangtools.yang.model.api.DeviateKind;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface DeviateStatement extends DeclaredStatement<DeviateKind> {
-
- @Nonnull
- DeviateKind getValue();
+ default @Nonnull DeviateKind getValue() {
+ return argument();
+ }
}
import java.util.Collection;
import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface DeviationStatement extends DeclaredStatement<SchemaNodeIdentifier>, DocumentationGroup {
+public interface DeviationStatement extends DocumentedDeclaredStatement<SchemaNodeIdentifier> {
+ default @Nonnull SchemaNodeIdentifier getTargetNode() {
+ return argument();
+ }
- @Nonnull SchemaNodeIdentifier getTargetNode();
-
- @Nonnull Collection<? extends DeviateStatement> getDeviateStatements();
+ default @Nonnull Collection<? extends DeviateStatement> getDeviateStatements() {
+ return declaredSubstatements(DeviateStatement.class);
+ }
}
/**
* Common interface for statements which contain either a description/reference or a description/reference/status combo.
+ *
+ * @deprecated Use {@link DocumentedDeclaredStatement} instead.
*/
+@Deprecated
public interface DocumentationGroup {
/**
* Return description statement, if available.
import javax.annotation.Nullable;
+/**
+ * Documented constraints.
+ *
+ * @deprecated Use {@link ConstrainedDocumentedDeclaredStatement} instead.
+ */
+@Deprecated
public interface DocumentedConstraintGroup extends DocumentationGroup {
@Nullable ErrorAppTagStatement getErrorAppTagStatement();
--- /dev/null
+/*
+ * Copyright (c) 2018 Pantheon Technoglogies, 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Optional;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+
+/**
+ * Common interface for statements which contain either a description/reference or a description/reference/status combo.
+ */
+@Beta
+public interface DocumentedDeclaredStatement<T> extends DeclaredStatement<T>, DocumentationGroup {
+ @Override
+ default DescriptionStatement getDescription() {
+ final Optional<DescriptionStatement> opt = findFirstDeclaredSubstatement(DescriptionStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+
+ @Override
+ default ReferenceStatement getReference() {
+ final Optional<ReferenceStatement> opt = findFirstDeclaredSubstatement(ReferenceStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+
+ interface WithStatus<T> extends DocumentedDeclaredStatement<T>, DocumentationGroup.WithStatus {
+ @Override
+ default @Nullable StatusStatement getStatus() {
+ final Optional<StatusStatement> opt = findFirstDeclaredSubstatement(StatusStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+ }
+}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface EnumStatement extends DeclaredStatement<String>, DocumentationGroup.WithStatus, ConditionalFeature {
+public interface EnumStatement extends DocumentedDeclaredStatement.WithStatus<String>,
+ IfFeatureAwareDeclaredStatement<String> {
+ default @Nonnull String getName() {
+ return argument();
+ }
- @Nonnull
- String getName();
-
- @Nullable
- ValueStatement getValue();
+ default @Nullable ValueStatement getValue() {
+ final Optional<ValueStatement> opt = findFirstDeclaredSubstatement(ValueStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface ErrorMessageStatement extends DeclaredStatement<String> {
-
- @Nonnull String getValue();
+ default @Nonnull String getValue() {
+ return argument();
+ }
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import java.util.Optional;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface ExtensionStatement extends DeclaredStatement<QName>, DocumentationGroup.WithStatus {
-
- @Nullable ArgumentStatement getArgument();
+public interface ExtensionStatement extends DocumentedDeclaredStatement.WithStatus<QName> {
+ default @Nullable ArgumentStatement getArgument() {
+ final Optional<ArgumentStatement> opt = findFirstDeclaredSubstatement(ArgumentStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface FeatureStatement extends DeclaredStatement<QName>, DocumentationGroup.WithStatus, ConditionalFeature {
-
- @Nonnull QName getName();
+public interface FeatureStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
+ IfFeatureAwareDeclaredStatement<QName> {
+ default @Nonnull QName getName() {
+ return argument();
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface FractionDigitsStatement extends DeclaredStatement<Integer> {
-
- int getValue();
+ default int getValue() {
+ return argument().intValue();
+ }
}
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface GroupingStatement extends DeclaredStatement<QName>, DocumentationGroup.WithStatus,
- DataDefinitionContainer.WithReusableDefinitions, NotificationStatementContainer, ActionStatementContainer {
-
- @Nonnull QName getName();
+public interface GroupingStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
+ DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<QName>,
+ NotificationStatementAwareDeclaredStatement<QName>, ActionStatementAwareDeclaredStatement<QName> {
+ default @Nonnull QName getName() {
+ return argument();
+ }
}
import java.util.Collection;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface IdentityStatement extends DeclaredStatement<QName>, DocumentationGroup.WithStatus, ConditionalFeature {
-
- @Nonnull QName getName();
+public interface IdentityStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
+ IfFeatureAwareDeclaredStatement<QName> {
+ default @Nonnull QName getName() {
+ return argument();
+ }
/**
* Returns the base identities of this identity.
*
* @return base identities, empty if there are none.
*/
- @Nonnull Collection<? extends BaseStatement> getBases();
+ default @Nonnull Collection<? extends BaseStatement> getBases() {
+ return declaredSubstatements(BaseStatement.class);
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 Pantheon Technoglogies, 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+
+@Beta
+public interface IfFeatureAwareDeclaredStatement<A> extends DeclaredStatement<A>, ConditionalFeature {
+ @Override
+ default @Nonnull Collection<? extends IfFeatureStatement> getIfFeatures() {
+ return declaredSubstatements(IfFeatureStatement.class);
+ }
+}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface ImportStatement extends DeclaredStatement<String>, DocumentationGroup {
+public interface ImportStatement extends DocumentedDeclaredStatement<String> {
+ default @Nonnull String getModule() {
+ return rawArgument();
+ }
- @Nonnull String getModule();
+ default @Nonnull PrefixStatement getPrefix() {
+ final Optional<PrefixStatement> opt = findFirstDeclaredSubstatement(PrefixStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
- @Nonnull PrefixStatement getPrefix();
-
- @Nullable RevisionDateStatement getRevisionDate();
+ default @Nullable RevisionDateStatement getRevisionDate() {
+ final Optional<RevisionDateStatement> opt = findFirstDeclaredSubstatement(RevisionDateStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
-
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface IncludeStatement extends DeclaredStatement<String>, DocumentationGroup {
+public interface IncludeStatement extends DocumentedDeclaredStatement<String> {
+ default @Nonnull String getModule() {
+ return argument();
+ }
- @Nonnull String getModule();
-
- @Nullable RevisionDateStatement getRevisionDate();
+ default @Nullable RevisionDateStatement getRevisionDate() {
+ final Optional<RevisionDateStatement> opt = findFirstDeclaredSubstatement(RevisionDateStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface InputStatement extends DeclaredStatement<QName>, DataDefinitionContainer.WithReusableDefinitions,
- MustStatementContainer {
+public interface InputStatement extends DeclaredStatement<QName>,
+ DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<QName>,
+ MustStatementAwareDeclaredStatement<QName> {
}
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
-public interface LeafListStatement extends DataDefinitionStatement, MultipleElementsGroup, TypeGroup,
- ConfigStatementContainerDeclaredStatement<QName>, MustStatementContainer {
+public interface LeafListStatement extends MultipleElementsDeclaredStatement, TypeAwareDeclaredStatement,
+ ConfigStatementAwareDeclaredStatement<QName>, MustStatementAwareDeclaredStatement<QName> {
/**
* Return default statements defined in this leaf-list. For RFC6020 semantics, this method returns an empty
* collection.
*
* @return collection of default statements
*/
- @Nonnull Collection<? extends DefaultStatement> getDefaults();
+ default @Nonnull Collection<? extends DefaultStatement> getDefaults() {
+ return declaredSubstatements(DefaultStatement.class);
+ }
}
import org.opendaylight.yangtools.yang.common.QName;
-public interface LeafStatement extends DataDefinitionStatement, TypeGroup,
- ConfigStatementContainerDeclaredStatement<QName>, DefaultStatementContainer, MandatoryStatementContainer,
- MustStatementContainer {
+public interface LeafStatement extends DataDefinitionStatement, TypeAwareDeclaredStatement,
+ ConfigStatementAwareDeclaredStatement<QName>, DefaultStatementAwareDeclaredStatement,
+ MandatoryStatementAwareDeclaredStatement<QName>, MustStatementAwareDeclaredStatement<QName> {
}
import java.util.List;
import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface LengthStatement extends DeclaredStatement<List<ValueRange>>, DocumentedConstraintGroup {
+public interface LengthStatement extends ConstrainedDocumentedDeclaredStatement<List<ValueRange>> {
@Nonnull
@Override
List<ValueRange> argument();
--- /dev/null
+/*
+ * Copyright (c) 2018 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+
+@Beta
+public interface LinkageDeclaredStatement extends DeclaredStatement<String>, LinkageGroup {
+ @Override
+ default @Nonnull Collection<? extends ImportStatement> getImports() {
+ return declaredSubstatements(ImportStatement.class);
+ }
+
+ @Override
+ default @Nonnull Collection<? extends IncludeStatement> getIncludes() {
+ return declaredSubstatements(IncludeStatement.class);
+ }
+}
import javax.annotation.Nonnull;
@Rfc6020AbnfRule("linkage-stms")
+@Deprecated
public interface LinkageGroup {
@Nonnull Collection<? extends ImportStatement> getImports();
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Collection;
+import java.util.Optional;
import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-public interface ListStatement extends DataDefinitionStatement, MultipleElementsGroup,
- DataDefinitionContainer.WithReusableDefinitions, ConfigStatementContainerDeclaredStatement<QName>,
- ActionStatementContainer, MustStatementContainer, NotificationStatementContainer {
+public interface ListStatement extends MultipleElementsDeclaredStatement,
+ DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<QName>,
+ ConfigStatementAwareDeclaredStatement<QName>, ActionStatementAwareDeclaredStatement<QName>,
+ MustStatementAwareDeclaredStatement<QName>, NotificationStatementAwareDeclaredStatement<QName> {
+ default KeyStatement getKey() {
+ final Optional<KeyStatement> opt = findFirstDeclaredSubstatement(KeyStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
- @Nullable KeyStatement getKey();
-
- @Nonnull Collection<? extends UniqueStatement> getUnique();
+ default @Nonnull Collection<? extends UniqueStatement> getUnique() {
+ return declaredSubstatements(UniqueStatement.class);
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface MandatoryStatement extends DeclaredStatement<Boolean> {
-
- @Nonnull Boolean getValue();
+ default @Nonnull Boolean getValue() {
+ return argument();
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Optional;
+import javax.annotation.Nullable;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+
+/**
+ * Marker interface for statements which may contain a 'mandatory' statement, as defined in RFC7950.
+ */
+@Beta
+public interface MandatoryStatementAwareDeclaredStatement<T> extends DeclaredStatement<T>,
+ MandatoryStatementContainer {
+ /**
+ * Return a {@link MandatoryStatement} child, if present.
+ *
+ * @return A {@link MandatoryStatement}, or null if none is present.
+ */
+ @Override
+ default @Nullable MandatoryStatement getMandatory() {
+ final Optional<MandatoryStatement> opt = findFirstDeclaredSubstatement(MandatoryStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+}
import javax.annotation.Nullable;
/**
- * Marker interface for statements which may contain a 'mandaotry' statement, as defined in RFC7950.
+ * Marker interface for statements which may contain a 'mandatory' statement, as defined in RFC7950.
+ *
+ * @deprecated Use {@link MandatoryStatementAwareDeclaredStatement} instead.
*/
+@Deprecated
public interface MandatoryStatementContainer {
/**
* Return a {@link MandatoryStatement} child, if present.
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface MaxElementsStatement extends DeclaredStatement<String> {
-
- @Nonnull String getValue();
+ default @Nonnull String getValue() {
+ return argument();
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 Pantheon Technoglogies, 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Optional;
+
+/**
+ * Common interface for statements which contain either a description/reference or a description/reference/status combo.
+ */
+@Beta
+public interface MetaDeclaredStatement<T> extends DocumentedDeclaredStatement<T>, MetaGroup {
+ @Override
+ default OrganizationStatement getOrganization() {
+ final Optional<OrganizationStatement> opt = findFirstDeclaredSubstatement(OrganizationStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+
+ @Override
+ default ContactStatement getContact() {
+ final Optional<ContactStatement> opt = findFirstDeclaredSubstatement(ContactStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+}
import javax.annotation.Nullable;
@Rfc6020AbnfRule("meta-stmts")
+@Deprecated
public interface MetaGroup extends DocumentationGroup {
@Nullable OrganizationStatement getOrganization();
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface MinElementsStatement extends DeclaredStatement<Integer> {
-
- @Nonnull Integer getValue();
+ default @Nonnull Integer getValue() {
+ return argument();
+ }
}
*/
@Beta
public interface ModifierStatement extends DeclaredStatement<ModifierKind> {
-
- @Nonnull ModifierKind getValue();
+ default @Nonnull ModifierKind getValue() {
+ return argument();
+ }
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import java.util.Optional;
import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface ModuleStatement extends DeclaredStatement<String>, ModuleHeaderGroup, LinkageGroup, MetaGroup,
- RevisionGroup, BodyGroup {
+public interface ModuleStatement extends MetaDeclaredStatement<String>, ModuleHeaderGroup, LinkageDeclaredStatement,
+ RevisionAwareDeclaredStatement, BodyDeclaredStatement {
+ default @Nonnull String getName() {
+ return rawArgument();
+ }
- @Nonnull String getName();
+ @Override
+ default YangVersionStatement getYangVersion() {
+ final Optional<YangVersionStatement> opt = findFirstDeclaredSubstatement(YangVersionStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+
+ @Nonnull
+ @Override
+ default NamespaceStatement getNamespace() {
+ final Optional<NamespaceStatement> opt = findFirstDeclaredSubstatement(NamespaceStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+
+ @Override
+ default PrefixStatement getPrefix() {
+ final Optional<PrefixStatement> opt = findFirstDeclaredSubstatement(PrefixStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 Pantheon Technoglogies, 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Optional;
+
+@Beta
+public interface MultipleElementsDeclaredStatement extends DataDefinitionStatement, MultipleElementsGroup {
+ @Override
+ default MinElementsStatement getMinElements() {
+ final Optional<MinElementsStatement> opt = findFirstDeclaredSubstatement(MinElementsStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+
+ @Override
+ default MaxElementsStatement getMaxElements() {
+ final Optional<MaxElementsStatement> opt = findFirstDeclaredSubstatement(MaxElementsStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+
+ @Override
+ default OrderedByStatement getOrderedBy() {
+ final Optional<OrderedByStatement> opt = findFirstDeclaredSubstatement(OrderedByStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+}
import javax.annotation.Nullable;
+/**
+ * Common statements of collection-like statements.
+ *
+ * @deprecated Use {@link MultipleElementsDeclaredStatement} instead.
+ */
+@Deprecated
public interface MultipleElementsGroup {
@Nullable MinElementsStatement getMinElements();
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface MustStatement extends DeclaredStatement<RevisionAwareXPath>, DocumentedConstraintGroup {
-
- @Nonnull RevisionAwareXPath getCondition();
+public interface MustStatement extends ConstrainedDocumentedDeclaredStatement<RevisionAwareXPath> {
+ default @Nonnull RevisionAwareXPath getCondition() {
+ return argument();
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+
+@Beta
+public interface MustStatementAwareDeclaredStatement<A> extends DeclaredStatement<A>,
+ MustStatementContainer {
+ @Override
+ default @Nonnull Collection<? extends MustStatement> getMusts() {
+ return declaredSubstatements(MustStatement.class);
+ }
+}
/**
* Marker interface for statements which may contain a 'must' statement, as defined in RFC7950. There is a significant
* difference RFC6020 (YANG 1) and RFC7590 (YANG 1.1) in which statements sport this feature.
+ *
+ * @deprecated Use {@link MustStatementAwareDeclaredStatement} instead.
*/
+@Deprecated
public interface MustStatementContainer {
/**
* Return collection of {@link MustStatement}. For RFC6020, this method returns an empty collection for statements
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface NamespaceStatement extends DeclaredStatement<URI> {
-
- @Nonnull URI getUri();
+ default @Nonnull URI getUri() {
+ return argument();
+ }
}
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface NotificationStatement extends DeclaredStatement<QName>,
- DataDefinitionContainer.WithReusableDefinitions, DocumentationGroup.WithStatus, ConditionalFeature,
- MustStatementContainer {
-
- @Nonnull QName getName();
+public interface NotificationStatement extends DocumentedDeclaredStatement.WithStatus<QName>,
+ DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<QName>, IfFeatureAwareDeclaredStatement<QName>,
+ MustStatementAwareDeclaredStatement<QName> {
+ default @Nonnull QName getName() {
+ return argument();
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+
+@Beta
+public interface NotificationStatementAwareDeclaredStatement<A> extends DeclaredStatement<A>,
+ NotificationStatementContainer {
+ @Override
+ default @Nonnull Collection<? extends NotificationStatement> getNotifications() {
+ return declaredSubstatements(NotificationStatement.class);
+ }
+}
/**
* Marker interface for statements which may contain a 'notification' statement, as defined in RFC7950. There is
* a significant difference RFC6020 (YANG 1) and RFC7590 (YANG 1.1) in which statements sport this feature.
+ *
+ * @deprecated Use {@link NotificationStatementAwareDeclaredStatement} instead.
*/
+@Deprecated
public interface NotificationStatementContainer {
/**
* Return collection of {@link NotificationStatement}. For RFC6020, this method returns an empty collection for
--- /dev/null
+/*
+ * Copyright (c) 2018 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Collection;
+import java.util.Optional;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.common.QName;
+
+/**
+ * Common interface for action and rpc statements.
+ */
+@Beta
+public interface OperationDeclaredStatement extends DocumentedDeclaredStatement.WithStatus<QName>, OperationGroup,
+ IfFeatureAwareDeclaredStatement<QName> {
+ @Override
+ default @Nonnull QName getName() {
+ return argument();
+ }
+
+ @Override
+ default InputStatement getInput() {
+ final Optional<InputStatement> opt = findFirstDeclaredSubstatement(InputStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+
+ @Override
+ default OutputStatement getOutput() {
+ final Optional<OutputStatement> opt = findFirstDeclaredSubstatement(OutputStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+
+ @Override
+ default @Nonnull Collection<? extends TypedefStatement> getTypedefs() {
+ return declaredSubstatements(TypedefStatement.class);
+ }
+
+ @Override
+ default @Nonnull Collection<? extends GroupingStatement> getGroupings() {
+ return declaredSubstatements(GroupingStatement.class);
+ }
+}
/**
* Common interface for action and rpc statements.
+ *
+ * @deprecated Use {@link OperationDeclaredStatement} instead.
*/
+@Deprecated
@Beta
public interface OperationGroup extends DocumentationGroup.WithStatus, ConditionalFeature {
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface OrderedByStatement extends DeclaredStatement<String> {
-
- @Nonnull String getValue();
+ default @Nonnull String getValue() {
+ return argument();
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface OrganizationStatement extends DeclaredStatement<String> {
-
- @Nonnull String getText();
+ default @Nonnull String getText() {
+ return argument();
+ }
}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface OutputStatement extends DeclaredStatement<QName>, DataDefinitionContainer.WithReusableDefinitions,
- MustStatementContainer {
+public interface OutputStatement extends DeclaredStatement<QName>,
+ DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<QName>,
+ MustStatementAwareDeclaredStatement<QName> {
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface PathStatement extends DeclaredStatement<RevisionAwareXPath> {
-
// FIXME: Introduce proper type representing parsed leafref
- @Nonnull String getValue();
+ default @Nonnull String getValue() {
+ return rawArgument();
+ }
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-public interface PatternStatement extends DeclaredStatement<PatternConstraint>, DocumentedConstraintGroup {
-
- @Nonnull
- PatternConstraint getValue();
+public interface PatternStatement extends ConstrainedDocumentedDeclaredStatement<PatternConstraint> {
+ default @Nonnull PatternConstraint getValue() {
+ return argument();
+ }
/**
* Return a modifier statement, if present. In RFC6020 semantics, there are no modifiers and this methods always
*
* @return modifier statement, nul if not present.
*/
- @Nullable ModifierStatement getModifierStatement();
+ default @Nullable ModifierStatement getModifierStatement() {
+ final Optional<ModifierStatement> opt = findFirstDeclaredSubstatement(ModifierStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface PositionStatement extends DeclaredStatement<Long> {
-
- long getValue();
+ default long getValue() {
+ return argument().longValue();
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface PrefixStatement extends DeclaredStatement<String> {
-
- @Nonnull String getValue();
+ default @Nonnull String getValue() {
+ return rawArgument();
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface PresenceStatement extends DeclaredStatement<String> {
-
- @Nonnull String getValue();
+ default @Nonnull String getValue() {
+ return argument();
+ }
}
import java.util.List;
import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface RangeStatement extends DeclaredStatement<List<ValueRange>>, DocumentedConstraintGroup {
+public interface RangeStatement extends ConstrainedDocumentedDeclaredStatement<List<ValueRange>> {
@Nonnull
@Override
List<ValueRange> argument();
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface ReferenceStatement extends DeclaredStatement<String> {
-
- @Nonnull String getText();
+ default @Nonnull String getText() {
+ return rawArgument();
+ }
}
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Collection;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-public interface RefineStatement extends ConfigStatementContainerDeclaredStatement<SchemaNodeIdentifier>,
- DocumentationGroup, ConditionalFeature, MandatoryStatementContainer, MustStatementContainer {
- String getTargetNode();
+public interface RefineStatement extends ConfigStatementAwareDeclaredStatement<SchemaNodeIdentifier>,
+ DocumentedDeclaredStatement<SchemaNodeIdentifier>, IfFeatureAwareDeclaredStatement<SchemaNodeIdentifier>,
+ MandatoryStatementAwareDeclaredStatement<SchemaNodeIdentifier>,
+ MustStatementAwareDeclaredStatement<SchemaNodeIdentifier> {
+ default @Nonnull String getTargetNode() {
+ return rawArgument();
+ }
- @Nonnull
- Collection<? extends DefaultStatement> getDefaults();
+ default @Nonnull Collection<? extends DefaultStatement> getDefaults() {
+ return declaredSubstatements(DefaultStatement.class);
+ }
- @Nullable
- PresenceStatement getPresence();
+ default @Nullable PresenceStatement getPresence() {
+ final Optional<PresenceStatement> opt = findFirstDeclaredSubstatement(PresenceStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
- @Nullable
- MinElementsStatement getMinElements();
+ default @Nullable MinElementsStatement getMinElements() {
+ final Optional<MinElementsStatement> opt = findFirstDeclaredSubstatement(MinElementsStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
- @Nullable
- MaxElementsStatement getMaxElements();
+ default @Nullable MaxElementsStatement getMaxElements() {
+ final Optional<MaxElementsStatement> opt = findFirstDeclaredSubstatement(MaxElementsStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface RequireInstanceStatement extends DeclaredStatement<Boolean> {
-
- boolean getValue();
+ default boolean getValue() {
+ return argument().booleanValue();
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 Pantheon Technoglogies, 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+
+@Beta
+public interface RevisionAwareDeclaredStatement extends DeclaredStatement<String>, RevisionGroup {
+ @Override
+ default @Nonnull Collection<? extends RevisionStatement> getRevisions() {
+ return declaredSubstatements(RevisionStatement.class);
+ }
+}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface RevisionDateStatement extends DeclaredStatement<Revision> {
-
- Revision getDate();
+ default Revision getDate() {
+ return argument();
+ }
}
-
import javax.annotation.Nonnull;
@Rfc6020AbnfRule("revision-stmts")
+@Deprecated
public interface RevisionGroup {
@Nonnull Collection<? extends RevisionStatement> getRevisions();
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface RevisionStatement extends DeclaredStatement<Revision>, DocumentationGroup {
-
- @Nonnull Revision getDate();
+public interface RevisionStatement extends DocumentedDeclaredStatement<Revision> {
+ default @Nonnull Revision getDate() {
+ return argument();
+ }
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-
-public interface RpcStatement extends DeclaredStatement<QName>, OperationGroup {
+public interface RpcStatement extends OperationDeclaredStatement {
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface StatusStatement extends DeclaredStatement<Status> {
-
- @Nonnull Status getValue();
+ default @Nonnull Status getValue() {
+ return argument();
+ }
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface SubmoduleStatement extends DeclaredStatement<String>, LinkageGroup, MetaGroup, RevisionGroup,
- BodyGroup {
+public interface SubmoduleStatement extends MetaDeclaredStatement<String>, LinkageDeclaredStatement,
+ RevisionAwareDeclaredStatement, BodyDeclaredStatement {
+ default @Nonnull String getName() {
+ return rawArgument();
+ }
- @Nonnull String getName();
+ default @Nullable YangVersionStatement getYangVersion() {
+ final Optional<YangVersionStatement> opt = findFirstDeclaredSubstatement(YangVersionStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
- @Nullable YangVersionStatement getYangVersion();
-
- @Nonnull BelongsToStatement getBelongsTo();
+ default @Nonnull BelongsToStatement getBelongsTo() {
+ return findFirstDeclaredSubstatement(BelongsToStatement.class).get();
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 Pantheon Technoglogies, 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+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.meta.DeclaredStatement;
+
+@Beta
+public interface TypeAwareDeclaredStatement extends DeclaredStatement<QName>, TypeGroup {
+ @Override
+ default @Nonnull TypeStatement getType() {
+ return findFirstDeclaredSubstatement(TypeStatement.class).get();
+ }
+
+ @Override
+ default @Nullable UnitsStatement getUnits() {
+ final Optional<UnitsStatement> opt = findFirstDeclaredSubstatement(UnitsStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+}
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
+@Deprecated
public interface TypeGroup {
@Nonnull TypeStatement getType();
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Collection;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Rfc6020AbnfRule("type-stmt")
public interface TypeStatement extends DeclaredStatement<String> {
-
- @Nonnull String getName();
+ default @Nonnull String getName() {
+ return argument();
+ }
@Rfc6020AbnfRule("numerical-restrictions")
interface NumericalRestrictions extends TypeStatement {
- @Nonnull RangeStatement getRange();
+ default @Nonnull RangeStatement getRange() {
+ return findFirstDeclaredSubstatement(RangeStatement.class).get();
+ }
}
@Rfc6020AbnfRule("decimal64-specification")
interface Decimal64Specification extends TypeStatement {
-
- @Nonnull FractionDigitsStatement getFractionDigits();
-
- @Nullable RangeStatement getRange();
+ default @Nonnull FractionDigitsStatement getFractionDigits() {
+ return findFirstDeclaredSubstatement(FractionDigitsStatement.class).get();
+ }
+
+ default @Nullable RangeStatement getRange() {
+ final Optional<RangeStatement> opt = findFirstDeclaredSubstatement(RangeStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
@Rfc6020AbnfRule("string-restrictions")
interface StringRestrictions extends TypeStatement {
-
- @Nullable LengthStatement getLength();
-
- @Nonnull Collection<? extends PatternStatement> getPatterns();
+ default @Nullable LengthStatement getLength() {
+ final Optional<LengthStatement> opt = findFirstDeclaredSubstatement(LengthStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+
+ default @Nonnull Collection<? extends PatternStatement> getPatterns() {
+ return declaredSubstatements(PatternStatement.class);
+ }
}
@Rfc6020AbnfRule("enum-specification")
interface EnumSpecification extends TypeStatement {
- @Nonnull Collection<? extends EnumStatement> getEnums();
+ default @Nonnull Collection<? extends EnumStatement> getEnums() {
+ return declaredSubstatements(EnumStatement.class);
+ }
}
@Rfc6020AbnfRule("leafref-specification")
interface LeafrefSpecification extends TypeStatement {
-
- @Nonnull PathStatement getPath();
+ default @Nonnull PathStatement getPath() {
+ return findFirstDeclaredSubstatement(PathStatement.class).get();
+ }
/**
* Return require-instance statement child, if present. For RFC6020 semantics, this method always returns
*
* @return require-instance statement, if present.
*/
- @Nullable RequireInstanceStatement getRequireInstance();
+ default @Nullable RequireInstanceStatement getRequireInstance() {
+ final Optional<RequireInstanceStatement> opt =
+ findFirstDeclaredSubstatement(RequireInstanceStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
@Rfc6020AbnfRule("instanceidentifier-specification")
interface InstanceIdentifierSpecification extends TypeStatement {
-
- @Nullable RequireInstanceStatement getRequireInstance();
+ /**
+ * Return require-instance statement child, if present. For RFC6020 semantics, this method always returns
+ * null.
+ *
+ * @return require-instance statement, if present.
+ */
+ default @Nullable RequireInstanceStatement getRequireInstance() {
+ final Optional<RequireInstanceStatement> opt =
+ findFirstDeclaredSubstatement(RequireInstanceStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
}
@Rfc6020AbnfRule("identityref-specification")
* @return collection of base statements (in YANG 1.1 models) or a collection containing just one base
* statement (in YANG 1.0 models)
*/
- @Nonnull Collection<? extends BaseStatement> getBases();
+ default @Nonnull Collection<? extends BaseStatement> getBases() {
+ return declaredSubstatements(BaseStatement.class);
+ }
}
@Rfc6020AbnfRule("bits-specification")
interface BitsSpecification extends TypeStatement {
-
- @Nonnull Collection<? extends BitStatement> getBits();
+ default @Nonnull Collection<? extends BitStatement> getBits() {
+ return declaredSubstatements(BitStatement.class);
+ }
}
@Rfc6020AbnfRule("union-specification")
interface UnionSpecification extends TypeStatement {
-
- @Nonnull Collection<? extends TypeStatement> getTypes();
+ default @Nonnull Collection<? extends TypeStatement> getTypes() {
+ return declaredSubstatements(TypeStatement.class);
+ }
}
@Rfc6020AbnfRule("binary-specification")
interface BinarySpecification extends TypeStatement {
-
- @Nullable LengthStatement getLength();
+ default @Nonnull Collection<? extends LengthStatement> getLength() {
+ return declaredSubstatements(LengthStatement.class);
+ }
}
}
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface TypedefStatement extends DeclaredStatement<QName>, DocumentationGroup.WithStatus, TypeGroup,
- DefaultStatementContainer {
-
- @Nonnull QName getName();
+public interface TypedefStatement extends DocumentedDeclaredStatement.WithStatus<QName>, TypeAwareDeclaredStatement,
+ DefaultStatementAwareDeclaredStatement {
+ default @Nonnull QName getName() {
+ return argument();
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface UnitsStatement extends DeclaredStatement<String> {
-
- @Nonnull String getName();
+ default @Nonnull String getName() {
+ return argument();
+ }
}
-
* @param <A> Argument type ({@link Void} if statement does not have argument.)
*/
public interface UnknownStatement<A> extends DeclaredStatement<A> {
-
- @Nullable A getArgument();
+ default @Nullable A getArgument() {
+ return argument();
+ }
}
import javax.annotation.Nonnull;
public interface UsesStatement extends DataDefinitionStatement {
+ default @Nonnull Collection<? extends RefineStatement> getRefines() {
+ return declaredSubstatements(RefineStatement.class);
+ }
- @Nonnull Collection<? extends RefineStatement> getRefines();
-
- @Nonnull Collection<? extends AugmentStatement> getAugments();
+ default @Nonnull Collection<? extends AugmentStatement> getAugments() {
+ return declaredSubstatements(AugmentStatement.class);
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface ValueStatement extends DeclaredStatement<Integer> {
-
- int getValue();
+ default int getValue() {
+ return argument().intValue();
+ }
}
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
-import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-public interface WhenStatement extends DeclaredStatement<RevisionAwareXPath>, DocumentationGroup {
-
- @Nonnull RevisionAwareXPath getCondition();
+public interface WhenStatement extends DocumentedDeclaredStatement<RevisionAwareXPath> {
+ default @Nonnull RevisionAwareXPath getCondition() {
+ return argument();
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 Pantheon Technoglogies, 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.model.api.stmt;
+
+import com.google.common.annotations.Beta;
+import java.util.Optional;
+import javax.annotation.Nullable;
+
+@Beta
+public interface WhenStatementAwareDeclaredStatement<A> extends IfFeatureAwareDeclaredStatement<A>,
+ ConditionalDataDefinition {
+ @Override
+ default @Nullable WhenStatement getWhenStatement() {
+ final Optional<WhenStatement> opt = findFirstDeclaredSubstatement(WhenStatement.class);
+ return opt.isPresent() ? opt.get() : null;
+ }
+}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface YangVersionStatement extends DeclaredStatement<YangVersion> {
-
- @Nonnull YangVersion getValue();
+ default @Nonnull YangVersion getValue() {
+ return argument();
+ }
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
public interface YinElementStatement extends DeclaredStatement<Boolean> {
-
- boolean getValue();
+ default boolean getValue() {
+ return argument().booleanValue();
+ }
}
OpenConfigVersionStatementImpl(final StmtContext<SemVer, OpenConfigVersionStatement, ?> context) {
super(context);
}
-
- @Override
- public SemVer getArgument() {
- return argument();
- }
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
-import java.util.Collection;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.BodyGroup;
-import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement;
-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.DeviationStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.FeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
-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.LinkageGroup;
-import org.opendaylight.yangtools.yang.model.api.stmt.MetaGroup;
-import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.RevisionGroup;
-import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.BodyDeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.LinkageDeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.MetaDeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.RevisionAwareDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
public abstract class AbstractRootStatement<T extends DeclaredStatement<String>>
- extends AbstractDeclaredStatement<String> implements LinkageGroup, MetaGroup, RevisionGroup, BodyGroup {
+ extends AbstractDeclaredStatement<String> implements LinkageDeclaredStatement, MetaDeclaredStatement<String>,
+ RevisionAwareDeclaredStatement, BodyDeclaredStatement {
protected AbstractRootStatement(final StmtContext<String, T,?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public final Collection<? extends ImportStatement> getImports() {
- return allDeclared(ImportStatement.class);
- }
-
- @Nonnull
- @Override
- public final Collection<? extends IncludeStatement> getIncludes() {
- return allDeclared(IncludeStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Override
- public final OrganizationStatement getOrganization() {
- return firstDeclared(OrganizationStatement.class);
- }
-
- @Override
- public final ContactStatement getContact() {
- return firstDeclared(ContactStatement.class);
- }
-
- @Nonnull
- @Override
- public final Collection<? extends RevisionStatement> getRevisions() {
- return allDeclared(RevisionStatement.class);
- }
-
- @Nonnull
- @Override
- public final Collection<? extends ExtensionStatement> getExtensions() {
- return allDeclared(ExtensionStatement.class);
- }
-
- @Nonnull
- @Override
- public final Collection<? extends FeatureStatement> getFeatures() {
- return allDeclared(FeatureStatement.class);
- }
-
- @Nonnull
- @Override
- public final Collection<? extends IdentityStatement> getIdentities() {
- return allDeclared(IdentityStatement.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 final Collection<? extends AugmentStatement> getAugments() {
- return allDeclared(AugmentStatement.class);
- }
-
- @Nonnull
- @Override
- public final Collection<? extends RpcStatement> getRpcs() {
- return allDeclared(RpcStatement.class);
- }
-
- @Nonnull
- @Override
- public final Collection<? extends NotificationStatement> getNotifications() {
- return allDeclared(NotificationStatement.class);
- }
-
- @Nonnull
- @Override
- public final Collection<? extends DeviationStatement> getDeviations() {
- return allDeclared(DeviationStatement.class);
- }
}
*/
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) {
+ 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);
- }
}
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.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;
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 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);
- }
}
*/
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.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;
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 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);
- }
}
*/
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;
ArgumentStatementImpl(final StmtContext<QName, ArgumentStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public QName getName() {
- return argument();
- }
-
- @Override
- public YinElementStatement getYinElement() {
- return firstDeclared(YinElementStatement.class);
- }
}
*/
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;
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);
- }
}
*/
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;
BaseStatementImpl(final StmtContext<QName, BaseStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public QName getName() {
- return argument();
- }
}
*/
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;
BelongsToStatementImpl(final StmtContext<String, BelongsToStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getModule() {
- return argument();
- }
-
- @Nonnull
- @Override
- public PrefixStatement getPrefix() {
- return firstDeclared(PrefixStatement.class);
- }
}
*/
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;
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);
- }
}
*/
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;
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);
- }
}
*/
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.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;
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 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);
- }
}
ConfigStatementImpl(final StmtContext<Boolean, ConfigStatement, ?> context) {
super(context);
}
-
- @Override
- public boolean getValue() {
- return argument().booleanValue();
- }
}
abstract class EmptyConfigStatement implements ConfigStatement {
static final ConfigStatement FALSE = new EmptyConfigStatement() {
@Override
- public boolean getValue() {
- return false;
+ public Boolean argument() {
+ return Boolean.FALSE;
}
@Override
static final ConfigStatement TRUE = new EmptyConfigStatement() {
@Override
- public boolean getValue() {
- return true;
+ public Boolean argument() {
+ return Boolean.TRUE;
}
@Override
return Boolean.toString(getValue());
}
- @Override
- public final Boolean argument() {
- return Boolean.valueOf(getValue());
- }
-
@Nonnull
@Override
public final StatementSource getStatementSource() {
*/
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;
ContactStatementImpl(final StmtContext<String, ContactStatement,?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getText() {
- return rawArgument();
- }
}
*/
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.stmt.ActionStatement;
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.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.PresenceStatement;
-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.model.api.stmt.WhenStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
ContainerStatementImpl(final StmtContext<QName, ContainerStatement,?> 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);
- }
-
- @Override
- public Collection<? extends MustStatement> getMusts() {
- return allDeclared(MustStatement.class);
- }
-
- @Override
- public PresenceStatement getPresence() {
- return firstDeclared(PresenceStatement.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);
- }
-
- @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 Collection<? extends NotificationStatement> getNotifications() {
- return allDeclared(NotificationStatement.class);
- }
}
*/
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;
DefaultStatementImpl(final StmtContext<String, DefaultStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getValue() {
- return rawArgument();
- }
}
*/
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;
DescriptionStatementImpl(final StmtContext<String, DescriptionStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getText() {
- return rawArgument();
- }
}
*/
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;
DeviateStatementImpl(final StmtContext<DeviateKind, DeviateStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public DeviateKind getValue() {
- return argument();
- }
}
*/
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;
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);
- }
}
*/
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;
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);
- }
}
*/
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;
ErrorMessageStatementImpl(final StmtContext<String, ErrorMessageStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getValue() {
- return argument();
- }
}
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;
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);
- }
}
*/
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;
UnrecognizedStatementImpl(final StmtContext<String, ?, ?> context) {
super(context);
}
-
- @Nullable
- @Override
- public String getArgument() {
- return argument();
- }
}
*/
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;
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();
- }
-
}
FractionDigitsStatementImpl(final StmtContext<Integer, FractionDigitsStatement, ?> context) {
super(context);
}
-
- @Override
- public int getValue() {
- return argument();
- }
}
*/
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;
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);
- }
}
*/
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;
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();
- }
}
*/
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.model.api.stmt.ImportStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
-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 ImportStatementImpl extends AbstractDeclaredStatement<String> implements ImportStatement {
-
ImportStatementImpl(final StmtContext<String, ImportStatement,?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getModule() {
- return rawArgument();
- }
-
- @Nonnull
- @Override
- public PrefixStatement getPrefix() {
- return firstDeclared(PrefixStatement.class);
- }
-
- @Override
- public RevisionDateStatement getRevisionDate() {
- return firstDeclared(RevisionDateStatement.class);
- }
-
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
}
*/
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;
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);
- }
}
*/
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;
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);
- }
}
*/
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.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.LeafStatement;
-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.TypeStatement;
-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.StmtContext;
LeafStatementImpl(final StmtContext<QName, LeafStatement, ?> context) {
super(context);
}
-
- @Nullable
- @Override
- public Collection<? extends MustStatement> getMusts() {
- return allDeclared(MustStatement.class);
- }
-
- @Nullable
- @Override
- public DefaultStatement getDefault() {
- return firstDeclared(DefaultStatement.class);
- }
-
- @Nullable
- @Override
- public MandatoryStatement getMandatory() {
- return firstDeclared(MandatoryStatement.class);
- }
-
- @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);
- }
-
- @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);
- }
-
- @Nullable
- @Override
- public UnitsStatement getUnits() {
- return firstDeclared(UnitsStatement.class);
- }
-
- @Nullable
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
}
*/
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.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.LeafListStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
-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.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.StmtContext;
LeafListStatementImpl(final StmtContext<QName, LeafListStatement, ?> 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);
- }
-
- @Nullable
- @Override
- public StatusStatement getStatus() {
- return firstDeclared(StatusStatement.class);
- }
-
- @Override
- public Collection<? extends DefaultStatement> getDefaults() {
- return allDeclared(DefaultStatement.class);
- }
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Override
- public MinElementsStatement getMinElements() {
- return firstDeclared(MinElementsStatement.class);
- }
-
- @Override
- public MaxElementsStatement getMaxElements() {
- return firstDeclared(MaxElementsStatement.class);
- }
-
- @Override
- public OrderedByStatement getOrderedBy() {
- return firstDeclared(OrderedByStatement.class);
- }
-
- @Override
- public Collection<? extends MustStatement> getMusts() {
- return allDeclared(MustStatement.class);
- }
-
- @Nonnull
- @Override
- public TypeStatement getType() {
- return firstDeclared(TypeStatement.class);
- }
-
- @Override
- public UnitsStatement getUnits() {
- return firstDeclared(UnitsStatement.class);
- }
}
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;
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);
- }
}
*/
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.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.IfFeatureStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
-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.OrderedByStatement;
-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.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.StmtContext;
ListStatementImpl(final StmtContext<QName, ListStatement, ?> 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);
- }
-
- @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 MinElementsStatement getMinElements() {
- return firstDeclared(MinElementsStatement.class);
- }
-
- @Override
- public MaxElementsStatement getMaxElements() {
- return firstDeclared(MaxElementsStatement.class);
- }
-
- @Override
- public OrderedByStatement getOrderedBy() {
- return firstDeclared(OrderedByStatement.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 MustStatement> getMusts() {
- return allDeclared(MustStatement.class);
- }
-
- @Override
- public KeyStatement getKey() {
- return firstDeclared(KeyStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends UniqueStatement> getUnique() {
- return allDeclared(UniqueStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends ActionStatement> getActions() {
- return allDeclared(ActionStatement.class);
- }
-
- @Override
- public Collection<? extends NotificationStatement> getNotifications() {
- return allDeclared(NotificationStatement.class);
- }
}
abstract class EmptyMandatoryStatement implements MandatoryStatement {
static final MandatoryStatement FALSE = new EmptyMandatoryStatement() {
- @Nonnull
@Override
- public Boolean getValue() {
+ public Boolean argument() {
return Boolean.FALSE;
}
};
static final MandatoryStatement TRUE = new EmptyMandatoryStatement() {
- @Nonnull
@Override
- public Boolean getValue() {
+ public Boolean argument() {
return Boolean.TRUE;
}
return getValue().toString();
}
- @Override
- public final Boolean argument() {
- return getValue();
- }
-
@Nonnull
@Override
public final StatementSource getStatementSource() {
*/
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;
MandatoryStatementImpl(final StmtContext<Boolean, MandatoryStatement, ?> context) {
super(context);
}
-
- @Override
- @Nonnull public Boolean getValue() {
- return argument();
- }
}
*/
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;
MaxElementsStatementImpl(final StmtContext<String, MaxElementsStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getValue() {
- return argument();
- }
}
*/
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;
MinElementsStatementImpl(final StmtContext<Integer, MinElementsStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public Integer getValue() {
- return argument();
- }
}
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;
ModifierStatementImpl(final StmtContext<ModifierKind, ModifierStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public ModifierKind getValue() {
- return argument();
- }
}
*/
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;
ModuleStatementImpl(final StmtContext<String, ModuleStatement,?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getName() {
- return rawArgument();
- }
-
- @Override
- public YangVersionStatement getYangVersion() {
- return firstDeclared(YangVersionStatement.class);
- }
-
- @Nonnull
- @Override
- public NamespaceStatement getNamespace() {
- return firstDeclared(NamespaceStatement.class);
- }
-
- @Nonnull
- @Override
- public PrefixStatement getPrefix() {
- return firstDeclared(PrefixStatement.class);
- }
-
}
*/
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;
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);
- }
}
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;
NamespaceStatementImpl(final StmtContext<URI, NamespaceStatement,?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public URI getUri() {
- return argument();
- }
}
*/
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;
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);
- }
}
*/
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;
OrderedByStatementImpl(final StmtContext<String, OrderedByStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getValue() {
- return argument();
- }
}
*/
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;
OrganizationStatementImpl(final StmtContext<String, OrganizationStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getText() {
- return argument();
- }
}
*/
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;
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);
- }
}
*/
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;
PathStatementImpl(final StmtContext<RevisionAwareXPath, PathStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getValue() {
- return rawArgument();
- }
}
*/
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();
- }
}
PositionStatementImpl(final StmtContext<Long, PositionStatement, ?> context) {
super(context);
}
-
- @Override
- public long getValue() {
- return argument();
- }
}
*/
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;
PrefixStatementImpl(final StmtContext<String, PrefixStatement,?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getValue() {
- return rawArgument();
- }
}
*/
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;
PresenceStatementImpl(final StmtContext<String, PresenceStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getValue() {
- return argument();
- }
}
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;
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);
- }
}
*/
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;
ReferenceStatementImpl(final StmtContext<String, ReferenceStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getText() {
- return rawArgument();
- }
}
*/
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.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.MaxElementsStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
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;
RefineStatementImpl(final StmtContext<SchemaNodeIdentifier, RefineStatement, ?> context) {
super(context);
}
-
- @Override
- public String getTargetNode() {
- return rawArgument();
- }
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends IfFeatureStatement> getIfFeatures() {
- return allDeclared(IfFeatureStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends MustStatement> getMusts() {
- return allDeclared(MustStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends DefaultStatement> getDefaults() {
- return allDeclared(DefaultStatement.class);
- }
-
- @Nullable
- @Override
- public PresenceStatement getPresence() {
- return firstDeclared(PresenceStatement.class);
- }
-
- @Nullable
- @Override
- public MandatoryStatement getMandatory() {
- return firstDeclared(MandatoryStatement.class);
- }
-
- @Nullable
- @Override
- public MinElementsStatement getMinElements() {
- return firstDeclared(MinElementsStatement.class);
- }
-
- @Nullable
- @Override
- public MaxElementsStatement getMaxElements() {
- return firstDeclared(MaxElementsStatement.class);
- }
}
RequireInstanceStatementImpl(final StmtContext<Boolean, RequireInstanceStatement, ?> context) {
super(context);
}
-
- @Override
- public boolean getValue() {
- return argument().booleanValue();
- }
}
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;
public Revision getDate() {
return argument();
}
-
- @Nullable
- @Override
- public DescriptionStatement getDescription() {
- return firstDeclared(DescriptionStatement.class);
- }
-
- @Nullable
- @Override
- public ReferenceStatement getReference() {
- return firstDeclared(ReferenceStatement.class);
- }
}
RevisionDateStatementImpl(final StmtContext<Revision, RevisionDateStatement, ?> context) {
super(context);
}
-
- @Override
- public Revision getDate() {
- return argument();
- }
}
*/
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;
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);
- }
}
*/
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;
StatusStatementImpl(final StmtContext<Status, StatusStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public Status getValue() {
- return argument();
- }
}
*/
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;
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);
- }
}
*/
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;
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);
- }
}
return YangStmtMapping.TYPE;
}
- @Nonnull
- @Override
- public String getName() {
- return argument;
- }
-
@Nonnull
@Override
public StatementSource getStatementSource() {
*/
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;
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);
- }
}
*/
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;
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);
- }
}
*/
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;
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);
- }
}
*/
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;
InstanceIdentifierSpecificationImpl(final StmtContext<String, InstanceIdentifierSpecification, ?> ctx) {
super(ctx);
}
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
-
- @Override
- public RequireInstanceStatement getRequireInstance() {
- return firstDeclared(RequireInstanceStatement.class);
- }
}
*/
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;
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);
- }
-
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.NumericalRestrictions;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
NumericalRestrictionsImpl(final StmtContext<String, NumericalRestrictions, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
-
- @Nonnull
- @Override
- public RangeStatement getRange() {
- return firstDeclared(RangeStatement.class);
- }
}
*/
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.LengthStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
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;
StringRestrictionsImpl(final StmtContext<String, StringRestrictions, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
-
- @Override
- public LengthStatement getLength() {
- return firstDeclared(LengthStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends PatternStatement> getPatterns() {
- return allDeclared(PatternStatement.class);
- }
}
*/
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;
TypeStatementImpl(final StmtContext<String, TypeStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
}
*/
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;
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);
- }
-
}
*/
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;
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);
- }
}
*/
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;
UnitsStatementImpl(final StmtContext<String, UnitsStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public String getName() {
- return argument();
- }
}
import java.util.Collection;
import java.util.Optional;
import java.util.Set;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
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.meta.StatementDefinition;
-import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
-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.RefineStatement;
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.rfc7950.namespace.SchemaNodeIdentifierBuildNamespace;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.YangValidationBundles;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement;
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);
- }
-
- @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 AugmentStatement> getAugments() {
- return allDeclared(AugmentStatement.class);
- }
-
- @Nonnull
- @Override
- public Collection<? extends RefineStatement> getRefines() {
- return allDeclared(RefineStatement.class);
- }
-
/**
* Copy statements from a grouping to a target node.
*
ValueStatementImpl(final StmtContext<Integer, ValueStatement, ?> context) {
super(context);
}
-
- @Override
- public int getValue() {
- return argument();
- }
}
*/
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;
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);
- }
}
*/
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;
YangVersionStatementImpl(final StmtContext<YangVersion, YangVersionStatement, ?> context) {
super(context);
}
-
- @Nonnull
- @Override
- public YangVersion getValue() {
- return argument();
- }
}
YinElementStatementImpl(final StmtContext<Boolean, YinElementStatement, ?> context) {
super(context);
}
-
- @Override
- public boolean getValue() {
- return argument().booleanValue();
- }
}
ThirdPartyExtensionStatementImpl(final StmtContext<String, ThirdPartyExtensionStatement, ?> context) {
super(context);
}
-
- @Override
- public String getArgument() {
- return argument();
- }
}
return source;
}
+ /**
+ * Returns collection of explicitly declared child statements, while preserving its original ordering from original
+ * source.
+ *
+ * @param type {@link DeclaredStatement} type
+ * @return Collection of statements, which were explicitly declared in source of model.
+ * @throws NullPointerException if {@code type} is null
+ * @deprecated Use {@link #declaredSubstatements(Class)} instead.
+ */
+ @Deprecated
protected final <S extends DeclaredStatement<?>> Collection<? extends S> allDeclared(final Class<S> type) {
- return Collections2.transform(Collections2.filter(substatements, type::isInstance), type::cast);
+ return declaredSubstatements(type);
}
}
Code Review / yangtools.git / commitdiff