package org.opendaylight.yangtools.yang.model.spi.meta;
import com.google.common.annotations.Beta;
-import com.google.common.base.MoreObjects;
import com.google.common.base.Strings;
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableSet;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.concepts.Mutable;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.CopyableNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.InputSchemaNode;
import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.UserOrderedAware;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.model.api.WhenConditionAware;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByAwareEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
import org.opendaylight.yangtools.yang.xpath.api.YangXPathExpression.QualifiedBound;
/**
*
* @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
+ * @deprecated See deprecation notice in {@link AddedByUsesAware}
*/
+ @Deprecated(since = "7.0.9", forRemoval = true)
public interface AddedByUsesMixin<A, D extends DeclaredStatement<A>>
extends EffectiveStatementWithFlags<A, D>, AddedByUsesAware {
@Override
+ @Deprecated(since = "7.0.9", forRemoval = true)
default boolean isAddedByUses() {
return (flags() & FlagsBuilder.ADDED_BY_USES) != 0;
}
*
* @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
+ * @deprecated Scheduled for removal with {@link CopyableNode}.
*/
+ @Deprecated(since = "8.0.0")
public interface CopyableMixin<A, D extends DeclaredStatement<A>> extends AddedByUsesMixin<A, D>, CopyableNode {
@Override
+ @Deprecated(since = "8.0.0")
default boolean isAugmenting() {
return (flags() & FlagsBuilder.AUGMENTING) != 0;
}
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link DataSchemaNode}.
*
- * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
- public interface DataSchemaNodeMixin<A, D extends DeclaredStatement<A>>
- extends DataSchemaNode, CopyableMixin<A, D>, SchemaNodeMixin<A, D>, WhenConditionMixin<A, D> {
+ public interface DataSchemaNodeMixin<D extends DeclaredStatement<QName>>
+ extends DataSchemaNode, CopyableMixin<QName, D>, SchemaNodeMixin<D>, WhenConditionMixin<QName, D> {
@Override
default Optional<Boolean> effectiveConfig() {
final int fl = flags() & FlagsBuilder.MASK_CONFIG;
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link SchemaNode}.
*
- * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
- public interface SchemaNodeMixin<A, D extends DeclaredStatement<A>>
- extends DocumentedNodeMixin.WithStatus<A, D>, SchemaNode {
- // FIXME: ditch all this complexity once we do not require SchemaPath
+ public interface SchemaNodeMixin<D extends DeclaredStatement<QName>>
+ extends DocumentedNodeMixin.WithStatus<QName, D>, SchemaNode {
@Override
default QName getQName() {
- return SchemaNodeDefaults.extractQName(pathObject());
- }
-
- @Override
- @Deprecated
- default SchemaPath getPath() {
- return SchemaNodeDefaults.extractPath(this, pathObject());
+ return argument();
}
-
- @NonNull Immutable pathObject();
}
/**
* @param <D> Class representing declared version of this statement.
*/
public interface UnknownSchemaNodeMixin<A, D extends DeclaredStatement<A>>
- extends SchemaNodeMixin<A, D>, CopyableMixin<A, D>, UnknownSchemaNode {
-
+ extends DocumentedNodeMixin.WithStatus<A, D>, CopyableMixin<A, D>, UnknownSchemaNode {
@Override
default String getNodeParameter() {
return Strings.nullToEmpty(getDeclared().rawArgument());
*
* @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
+ * @param <E> Class representing effective version of this statement.
*/
- public interface UserOrderedMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
- default boolean userOrdered() {
+ // FIXME: 9.0.0: remove this mixin once we have a properly-cached DataTree and JSON/XML codec tree and the speed
+ // of isUserOrdered() is not really critical.
+ public interface UserOrderedAwareMixin<A, D extends DeclaredStatement<A>,
+ E extends OrderedByAwareEffectiveStatement<A, D>>
+ extends EffectiveStatementWithFlags<A, D>, UserOrderedAware<E> {
+ @Override
+ default boolean isUserOrdered() {
return (flags() & FlagsBuilder.USER_ORDERED) != 0;
}
}
public interface OperationContainerMixin<D extends DeclaredStatement<QName>>
extends ContainerLike, DocumentedNodeMixin.WithStatus<QName, D>, DataNodeContainerMixin<QName, D>,
MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D>, AugmentationTargetMixin<QName, D>,
- SchemaNodeMixin<QName, D>, CopyableMixin<QName, D> {
- @Override
- default @NonNull QName argument() {
- return getQName();
- }
-
+ SchemaNodeMixin<D>, CopyableMixin<QName, D> {
@Override
default Optional<ActionDefinition> findAction(final QName qname) {
return Optional.empty();
default Optional<Boolean> effectiveConfig() {
return Optional.empty();
}
-
- default String defaultToString() {
- return MoreObjects.toStringHelper(this).add("qname", getQName()).toString();
- }
}
/**
* @param <D> Class representing declared version of this statement.
*/
public interface OpaqueDataSchemaNodeMixin<D extends DeclaredStatement<QName>>
- extends DerivableSchemaNode, DataSchemaNodeMixin<QName, D>, DocumentedNodeMixin.WithStatus<QName, D>,
- MandatoryMixin<QName, D>, MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D> {
+ extends DataSchemaNodeMixin<D>, DocumentedNodeMixin.WithStatus<QName, D>, MandatoryMixin<QName, D>,
+ MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D> {
@Override
- default @NonNull QName argument() {
- return getQName();
+ default QName getQName() {
+ return argument();
}
}
* @param <D> Class representing declared version of this statement.
*/
public interface OperationDefinitionMixin<D extends DeclaredStatement<QName>>
- extends SchemaNodeMixin<QName, D>, OperationDefinition {
- @Override
- default @NonNull QName argument() {
- return getQName();
- }
-
+ extends SchemaNodeMixin<D>, OperationDefinition {
@Override
default Collection<? extends @NonNull TypeDefinition<?>> getTypeDefinitions() {
return filterTypeDefinitions(this);
static final int MANDATORY = 0x0004;
static final int AUGMENTING = 0x0010;
+ @Deprecated(since = "7.0.9", forRemoval = true)
static final int ADDED_BY_USES = 0x0020;
private static final int MASK_HISTORY = 0x0030;
}
private EffectiveStatementMixins() {
+ // Hidden on purpose
}
static <T extends ContainerLike> T findAsContainer(final EffectiveStatement<?, ?> stmt,
return Collections2.transform(stmt.filterEffectiveStatements(TypedefEffectiveStatement.class),
TypedefEffectiveStatement::getTypeDefinition);
}
-
- public static int historyAndStatusFlags(final CopyableNode history,
- final Collection<? extends EffectiveStatement<?, ?>> substatements) {
- return new FlagsBuilder()
- .setHistory(history)
- .setStatus(substatements.stream()
- .filter(StatusEffectiveStatement.class::isInstance)
- .findAny()
- .map(stmt -> ((StatusEffectiveStatement) stmt).argument())
- .orElse(Status.CURRENT))
- .toFlags();
- }
}
Code Review / yangtools.git / blobdiff