The correct type to use for no argument is Empty, not Void.
Change-Id: I68456096336d7e0d93139600375c9d8479dbb6ab
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.concepts.Mutable;
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.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
/**
* Bridge between {@link EffectiveStatement} and {@link AugmentationTarget}.
*
/**
* Bridge between {@link EffectiveStatement} and {@link AugmentationTarget}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface AugmentationTargetMixin<A, D extends DeclaredStatement<A>>
* @param <D> Class representing declared version of this statement.
*/
public interface AugmentationTargetMixin<A, D extends DeclaredStatement<A>>
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link AddedByUsesAware}.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link AddedByUsesAware}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface AddedByUsesMixin<A, D extends DeclaredStatement<A>>
* @param <D> Class representing declared version of this statement.
*/
public interface AddedByUsesMixin<A, D extends DeclaredStatement<A>>
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link ActionNodeContainer}.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link ActionNodeContainer}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface ActionNodeContainerMixin<A, D extends DeclaredStatement<A>>
* @param <D> Class representing declared version of this statement.
*/
public interface ActionNodeContainerMixin<A, D extends DeclaredStatement<A>>
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link NotificationNodeContainer}.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link NotificationNodeContainer}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface NotificationNodeContainerMixin<A, D extends DeclaredStatement<A>>
* @param <D> Class representing declared version of this statement.
*/
public interface NotificationNodeContainerMixin<A, D extends DeclaredStatement<A>>
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link MustConstraintAware}.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link MustConstraintAware}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface MustConstraintMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, MustConstraintAware {
* @param <D> Class representing declared version of this statement.
*/
public interface MustConstraintMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, MustConstraintAware {
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link CopyableNode}.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link CopyableNode}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface CopyableMixin<A, D extends DeclaredStatement<A>> extends AddedByUsesMixin<A, D>, CopyableNode {
* @param <D> Class representing declared version of this statement.
*/
public interface CopyableMixin<A, D extends DeclaredStatement<A>> extends AddedByUsesMixin<A, D>, CopyableNode {
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link DataNodeContainer}.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link DataNodeContainer}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface DataNodeContainerMixin<A, D extends DeclaredStatement<A>> extends DataNodeContainer, Mixin<A, D> {
* @param <D> Class representing declared version of this statement.
*/
public interface DataNodeContainerMixin<A, D extends DeclaredStatement<A>> extends DataNodeContainer, Mixin<A, D> {
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link DataSchemaNode}.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link DataSchemaNode}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @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>>
* @param <D> Class representing declared version of this statement.
*/
public interface DataSchemaNodeMixin<A, D extends DeclaredStatement<A>>
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link DocumentedNode}.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link DocumentedNode}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface DocumentedNodeMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, DocumentedNode {
* @param <D> Class representing declared version of this statement.
*/
public interface DocumentedNodeMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, DocumentedNode {
* Bridge between {@link EffectiveStatementWithFlags} and
* {@link org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus}.
*
* Bridge between {@link EffectiveStatementWithFlags} and
* {@link org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
interface WithStatus<A, D extends DeclaredStatement<A>>
* @param <D> Class representing declared version of this statement.
*/
interface WithStatus<A, D extends DeclaredStatement<A>>
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link ConstraintMetaDefinition}.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link ConstraintMetaDefinition}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface ConstraintMetaDefinitionMixin<A, D extends DeclaredStatement<A>> extends DocumentedNodeMixin<A, D>,
* @param <D> Class representing declared version of this statement.
*/
public interface ConstraintMetaDefinitionMixin<A, D extends DeclaredStatement<A>> extends DocumentedNodeMixin<A, D>,
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link MandatoryAware}.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link MandatoryAware}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface MandatoryMixin<A, D extends DeclaredStatement<A>>
* @param <D> Class representing declared version of this statement.
*/
public interface MandatoryMixin<A, D extends DeclaredStatement<A>>
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@code presence} statement.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@code presence} statement.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface PresenceMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
* @param <D> Class representing declared version of this statement.
*/
public interface PresenceMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link SchemaNode}.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link SchemaNode}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @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>>
* @param <D> Class representing declared version of this statement.
*/
public interface SchemaNodeMixin<A, D extends DeclaredStatement<A>>
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link UnknownSchemaNode}.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@link UnknownSchemaNode}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface UnknownSchemaNodeMixin<A, D extends DeclaredStatement<A>>
* @param <D> Class representing declared version of this statement.
*/
public interface UnknownSchemaNodeMixin<A, D extends DeclaredStatement<A>>
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@code ordered-by} statement.
*
/**
* Bridge between {@link EffectiveStatementWithFlags} and {@code ordered-by} statement.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface UserOrderedMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
* @param <D> Class representing declared version of this statement.
*/
public interface UserOrderedMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
* Helper used to locate the effective {@code when} statement and exposing its argument as per
* {@link WhenConditionAware}.
*
* Helper used to locate the effective {@code when} statement and exposing its argument as per
* {@link WhenConditionAware}.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface WhenConditionMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, WhenConditionAware {
* @param <D> Class representing declared version of this statement.
*/
public interface WhenConditionMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, WhenConditionAware {
* Support interface for various mixins. Implementations are required to store 32bits worth of flags, which are
* globally assigned to sub-interfaces -- thus providing storage for many low-cardinality properties.
*
* Support interface for various mixins. Implementations are required to store 32bits worth of flags, which are
* globally assigned to sub-interfaces -- thus providing storage for many low-cardinality properties.
*
- * @param <A> Argument type ({@link Void} if statement does not have argument.)
+ * @param <A> Argument type ({@link Empty} if statement does not have argument.)
* @param <D> Class representing declared version of this statement.
*/
public interface EffectiveStatementWithFlags<A, D extends DeclaredStatement<A>> extends Mixin<A, D> {
* @param <D> Class representing declared version of this statement.
*/
public interface EffectiveStatementWithFlags<A, D extends DeclaredStatement<A>> extends Mixin<A, D> {