Migrate away from JSR-305 annotations to JDT annotations.
Change-Id: I268808a6da501eedce9bc34df0d9c5f70b145230
JIRA: YANGTOOLS-907
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
import java.util.Optional;
import java.util.Set;
import java.util.SortedMap;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.RecursiveObjectLeaker;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
return supports.get(phase);
}
- void addSource(@Nonnull final StatementStreamSource source) {
+ void addSource(final @NonNull StatementStreamSource source) {
sources.add(new SourceSpecificContext(this, source));
}
- void addLibSource(@Nonnull final StatementStreamSource libSource) {
+ void addLibSource(final @NonNull StatementStreamSource libSource) {
checkState(!isEnabledSemanticVersioning(),
"Library sources are not supported in semantic version mode currently.");
checkState(currentPhase == ModelProcessingPhase.INIT,
import java.util.EnumMap;
import java.util.Map;
import java.util.Set;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
*
* @return A new builder.
*/
- public static Builder builder() {
+ public static @NonNull Builder builder() {
return new Builder();
}
*
* @return A new {@link BuildAction}.
*/
- public BuildAction newBuild() {
+ public @NonNull BuildAction newBuild() {
return newBuild(StatementParserMode.DEFAULT_MODE);
}
* @return A new {@link BuildAction}.
* @throws NullPointerException if statementParserMode is null
*/
- public BuildAction newBuild(final StatementParserMode statementParserMode) {
+ public @NonNull BuildAction newBuild(final StatementParserMode statementParserMode) {
return new BuildAction(statementParserMode);
}
private final Map<ModelProcessingPhase, StatementSupportBundle> bundles =
new EnumMap<>(ModelProcessingPhase.class);
- public Builder setBundle(final ModelProcessingPhase phase, final StatementSupportBundle bundle) {
+ public @NonNull Builder setBundle(final ModelProcessingPhase phase, final StatementSupportBundle bundle) {
bundles.put(phase, bundle);
return this;
}
- public Builder setValidationBundle(final ValidationBundleType type, final Collection<?> validationBundle) {
+ public @NonNull Builder setValidationBundle(final ValidationBundleType type,
+ final Collection<?> validationBundle) {
validationBundles.put(type, validationBundle);
return this;
}
private boolean supportedFeaturesSet = false;
private boolean modulesDeviatedByModulesSet = false;
- BuildAction(@Nonnull final StatementParserMode statementParserMode) {
+ BuildAction(final @NonNull StatementParserMode statementParserMode) {
this.context = new BuildGlobalContext(supportedTerminology, supportedValidation,
requireNonNull(statementParserMode));
}
* which should be added into main sources
* @return This build action, for fluent use.
*/
- public BuildAction addSource(final StatementStreamSource source) {
+ public @NonNull BuildAction addSource(final StatementStreamSource source) {
context.addSource(source);
return this;
}
* which should be added into main sources
* @return This build action, for fluent use.
*/
- public BuildAction addSources(final StatementStreamSource... sources) {
+ public @NonNull BuildAction addSources(final StatementStreamSource... sources) {
addSources(Arrays.asList(sources));
return this;
}
- public BuildAction addSources(final Collection<? extends StatementStreamSource> sources) {
+ public @NonNull BuildAction addSources(final @NonNull Collection<? extends StatementStreamSource> sources) {
for (final StatementStreamSource source : sources) {
- context.addSource(source);
+ context.addSource(requireNonNull(source));
}
return this;
}
* <p>
* Library sources are not supported in semantic version mode currently.
*
- * @param libSources
- * yang sources which should be added into library sources
+ * @param libSources yang sources which should be added into library sources
* @return This build action, for fluent use.
*/
- public BuildAction addLibSources(final StatementStreamSource... libSources) {
+ public @NonNull BuildAction addLibSources(final StatementStreamSource... libSources) {
addLibSources(Arrays.asList(libSources));
return this;
}
- public BuildAction addLibSources(final Collection<StatementStreamSource> libSources) {
+ public @NonNull BuildAction addLibSources(final Collection<StatementStreamSource> libSources) {
for (final StatementStreamSource libSource : libSources) {
context.addLibSource(libSource);
}
* If the set is empty, no features encountered will be supported.
* @return This build action, for fluent use.
*/
- public BuildAction setSupportedFeatures(@Nonnull final Set<QName> supportedFeatures) {
+ public @NonNull BuildAction setSupportedFeatures(final @NonNull Set<QName> supportedFeatures) {
checkState(!supportedFeaturesSet, "Supported features should be set only once.");
context.setSupportedFeatures(requireNonNull(supportedFeatures));
supportedFeaturesSet = true;
* SchemaContext. If the map is empty, no deviations encountered will be supported.
* @return This build action, for fluent use.
*/
- public BuildAction setModulesWithSupportedDeviations(
- @Nonnull final SetMultimap<QNameModule, QNameModule> modulesDeviatedByModules) {
+ public @NonNull BuildAction setModulesWithSupportedDeviations(
+ final @NonNull SetMultimap<QNameModule, QNameModule> modulesDeviatedByModules) {
checkState(!modulesDeviatedByModulesSet, "Modules with supported deviations should be set only once.");
context.setModulesDeviatedByModules(requireNonNull(modulesDeviatedByModules));
modulesDeviatedByModulesSet = true;
import java.util.Iterator;
import java.util.Set;
import java.util.function.Function;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
return prereq;
}
- private <T> AbstractPrerequisite<T> addMutation(final AbstractPrerequisite<T> mutation) {
+ private <T> @NonNull AbstractPrerequisite<T> addMutation(final @NonNull AbstractPrerequisite<T> mutation) {
LOG.trace("Modifier {} adding mutation {}", this, mutation);
mutations.add(mutation);
return mutation;
actionApplied = true;
}
- private <K, C extends StmtContext<?, ?, ?>, N extends StatementNamespace<K, ?, ?>> AbstractPrerequisite<C>
+ private <K, C extends StmtContext<?, ?, ?>, N extends StatementNamespace<K, ?, ?>> @NonNull AbstractPrerequisite<C>
requiresCtxImpl(final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key,
final ModelProcessingPhase phase) {
checkNotRegistered();
return addedToNs;
}
- private <K, C extends StmtContext<?, ?, ?>, N extends StatementNamespace<K, ?, ?>> AbstractPrerequisite<C>
+ private <K, C extends StmtContext<?, ?, ?>, N extends StatementNamespace<K, ?, ?>> @NonNull AbstractPrerequisite<C>
requiresCtxImpl(final StmtContext<?, ?, ?> context, final Class<N> namespace,
final NamespaceKeyCriterion<K> criterion, final ModelProcessingPhase phase) {
checkNotRegistered();
return addedToNs;
}
- private <C extends StmtContext<?, ?, ?>> AbstractPrerequisite<C> requiresCtxImpl(final C context,
+ private <C extends StmtContext<?, ?, ?>> @NonNull AbstractPrerequisite<C> requiresCtxImpl(final C context,
final ModelProcessingPhase phase) {
checkNotRegistered();
return false;
}
- @Nonnull
@Override
public <C extends Mutable<?, ?, ?>, T extends C> Prerequisite<C> mutatesCtx(final T context,
final ModelProcessingPhase phase) {
return addMutation(new PhaseMutation<>(contextImpl(context), phase));
}
- @Nonnull
@Override
- public <A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A, D>>
+ public <A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
AbstractPrerequisite<StmtContext<A, D, E>> requiresCtx(final StmtContext<A, D, E> context,
final ModelProcessingPhase phase) {
return requiresCtxImpl(context, phase);
}
- @Nonnull
@Override
public <K, N extends StatementNamespace<K, ?, ?>> Prerequisite<StmtContext<?, ?, ?>> requiresCtx(
final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key,
return requiresCtxImpl(context, namespace, key, phase);
}
- @Nonnull
@Override
public <K, N extends StatementNamespace<K, ?, ?>> Prerequisite<StmtContext<?, ?, ?>> requiresCtx(
final StmtContext<?, ?, ?> context, final Class<N> namespace, final NamespaceKeyCriterion<K> criterion,
return requiresCtxImpl(context, namespace, criterion, phase);
}
- @Nonnull
@Override
public <D extends DeclaredStatement<?>> Prerequisite<D> requiresDeclared(
final StmtContext<?, ? extends D, ?> context) {
return requiresCtxImpl(context, FULL_DECLARATION).transform(StmtContext::buildDeclared);
}
- @Nonnull
@Override
public <K, D extends DeclaredStatement<?>, N extends StatementNamespace<K, ? extends D, ?>> Prerequisite<D>
requiresDeclared(final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key) {
return rawContext.transform(StmtContext::buildDeclared);
}
- @Nonnull
@Override
public <K, D extends DeclaredStatement<?>, N extends StatementNamespace<K, ? extends D, ?>>
AbstractPrerequisite<StmtContext<?, D, ?>> requiresDeclaredCtx(final StmtContext<?, ?, ?> context,
return requiresCtxImpl(context, namespace, key, FULL_DECLARATION);
}
- @Nonnull
@Override
public <E extends EffectiveStatement<?, ?>> Prerequisite<E> requiresEffective(
final StmtContext<?, ?, ? extends E> stmt) {
return requiresCtxImpl(stmt, EFFECTIVE_MODEL).transform(StmtContext::buildEffective);
}
- @Nonnull
@Override
public <K, E extends EffectiveStatement<?, ?>, N extends StatementNamespace<K, ?, ? extends E>> Prerequisite<E>
requiresEffective(final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key) {
return rawContext.transform(StmtContext::buildEffective);
}
- @Nonnull
@Override
public <K, E extends EffectiveStatement<?, ?>, N extends StatementNamespace<K, ?, ? extends E>>
AbstractPrerequisite<StmtContext<?, ?, E>> requiresEffectiveCtx(final StmtContext<?, ?, ?> context,
return requiresCtxImpl(contextImpl(context), namespace, key, EFFECTIVE_MODEL);
}
- @Nonnull
@Override
public <N extends IdentifierNamespace<?, ?>> Prerequisite<Mutable<?, ?, ?>> mutatesNs(
final Mutable<?, ?, ?> context, final Class<N> namespace) {
return addMutation(new NamespaceMutation<>(contextImpl(context), namespace));
}
- @Nonnull
@Override
public <K, E extends EffectiveStatement<?, ?>, N extends IdentifierNamespace<K, ? extends StmtContext<?, ?, ?>>>
AbstractPrerequisite<Mutable<?, ?, E>> mutatesEffectiveCtx(final StmtContext<?, ?, ?> context,
return mutatesCtxImpl(context, namespace, key, EFFECTIVE_MODEL);
}
- @Nonnull
@Override
public <K, E extends EffectiveStatement<?, ?>, N extends IdentifierNamespace<K, ? extends StmtContext<?, ?, ?>>>
AbstractPrerequisite<Mutable<?, ?, E>> mutatesEffectiveCtxPath(final StmtContext<?, ?, ?> context,
return isApplied();
}
- final <O> Prerequisite<O> transform(final Function<? super T, O> transformation) {
+ final <O> @NonNull Prerequisite<O> transform(final Function<? super T, O> transformation) {
return context -> transformation.apply(resolve(context));
}
import java.util.Iterator;
import java.util.List;
import java.util.Map;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
super(contextNode);
}
- abstract boolean onValueAdded(@Nonnull K key, @Nonnull V value);
+ abstract boolean onValueAdded(@NonNull K key, @NonNull V value);
}
protected final NamespaceBehaviour<K, V, N> delegate;
*/
package org.opendaylight.yangtools.yang.parser.stmt.reactor;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
import java.util.Optional;
-import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
private StatementContextBase<?, ?, ?> current;
StatementContextWriter(final SourceSpecificContext ctx, final ModelProcessingPhase phase) {
- this.ctx = Preconditions.checkNotNull(ctx);
- this.phase = Preconditions.checkNotNull(phase);
+ this.ctx = requireNonNull(ctx);
+ this.phase = requireNonNull(phase);
}
@Override
@Override
public void storeStatement(final int expectedChildren, final boolean fullyDefined) {
- Preconditions.checkState(current != null);
- Preconditions.checkArgument(expectedChildren >= 0);
+ checkState(current != null);
+ checkArgument(expectedChildren >= 0);
current.resizeSubstatements(expectedChildren);
if (fullyDefined) {
}
@Override
- public void startStatement(final int childId, @Nonnull final QName name, final String argument,
- @Nonnull final StatementSourceReference ref) {
+ public void startStatement(final int childId, final QName name, final String argument,
+ final StatementSourceReference ref) {
final Optional<StatementContextBase<?, ?, ?>> existing = ctx.lookupDeclaredChild(current, childId);
current = existing.isPresent() ? existing.get()
- : Verify.verifyNotNull(ctx.createDeclaredChild(current, childId, name, argument, ref));
+ : verifyNotNull(ctx.createDeclaredChild(current, childId, name, argument, ref));
}
@Override
- public void endStatement(@Nonnull final StatementSourceReference ref) {
- Preconditions.checkState(current != null);
+ public void endStatement(final StatementSourceReference ref) {
+ checkState(current != null);
current.endDeclared(phase);
exitStatement();
}
- @Nonnull
@Override
public ModelProcessingPhase getPhase() {
return phase;
import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.EFFECTIVE_MODEL;
import java.util.Collection;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
* @param context Statement context which needs to complete the transition.
* @return A {@link Prerequisite} returning the declared statement of the requested context.
*/
- @Nonnull <D extends DeclaredStatement<?>> Prerequisite<D> requiresDeclared(StmtContext<?, ? extends D, ?> context);
+ <D extends DeclaredStatement<?>> @NonNull Prerequisite<D> requiresDeclared(StmtContext<?, ? extends D, ?> context);
/**
* Create a requirement on specified statement to be declared.
* @deprecated Undocumented method. Use at your own risk.
*/
@Deprecated
- @Nonnull <K, D extends DeclaredStatement<?>, N extends StatementNamespace<K, ? extends D, ?>>
- Prerequisite<D> requiresDeclared(StmtContext<?, ?, ?> context, Class<N> namespace, K key);
+ <K, D extends DeclaredStatement<?>, N extends StatementNamespace<K, ? extends D, ?>>
+ @NonNull Prerequisite<D> requiresDeclared(StmtContext<?, ?, ?> context, Class<N> namespace, K key);
/**
* Action requires that the specified context completes specified phase before {@link #apply(InferenceAction)}
* @param phase ModelProcessingPhase which must have completed
* @return A {@link Prerequisite} returning the requested context.
*/
- @Nonnull <A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
- Prerequisite<StmtContext<A, D, E>> requiresCtx(StmtContext<A, D, E> context, ModelProcessingPhase phase);
+ <A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>> @NonNull Prerequisite<StmtContext<A, D, E>>
+ requiresCtx(StmtContext<A, D, E> context, ModelProcessingPhase phase);
- @Nonnull <K, N extends StatementNamespace<K, ?, ?>> Prerequisite<StmtContext<?, ?, ?>> requiresCtx(
+ <K, N extends StatementNamespace<K, ?, ?>> @NonNull Prerequisite<StmtContext<?, ?, ?>> requiresCtx(
StmtContext<?, ?, ?> context, Class<N> namespace, K key, ModelProcessingPhase phase);
- @Nonnull <K, N extends StatementNamespace<K, ?, ?>> Prerequisite<StmtContext<?, ?, ?>> requiresCtx(
+ <K, N extends StatementNamespace<K, ?, ?>> @NonNull Prerequisite<StmtContext<?, ?, ?>> requiresCtx(
StmtContext<?, ?, ?> context, Class<N> namespace, NamespaceKeyCriterion<K> criterion,
ModelProcessingPhase phase);
* @param context Target statement context
* @return A {@link Prerequisite} returning the requested context.
*/
- default @Nonnull <T extends Mutable<?, ?, ?>> Prerequisite<T> mutatesEffectiveCtx(final T context) {
+ default <T extends Mutable<?, ?, ?>> @NonNull Prerequisite<T> mutatesEffectiveCtx(final T context) {
return mutatesCtx(context, EFFECTIVE_MODEL);
}
- @Nonnull <K, E extends EffectiveStatement<?, ?>, N extends IdentifierNamespace<K, ? extends StmtContext<?, ?, ?>>>
- Prerequisite<Mutable<?, ?, E>> mutatesEffectiveCtx(StmtContext<?, ?, ?> context, Class<N> namespace, K key);
+ <K, E extends EffectiveStatement<?, ?>, N extends IdentifierNamespace<K, ? extends StmtContext<?, ?, ?>>>
+ @NonNull Prerequisite<Mutable<?, ?, E>> mutatesEffectiveCtx(StmtContext<?, ?, ?> context, Class<N> namespace,
+ K key);
- default @Nonnull <K, E extends EffectiveStatement<?, ?>,
- N extends IdentifierNamespace<K, ? extends StmtContext<?, ?, ?>>> Prerequisite<Mutable<?, ?, E>>
- mutatesEffectiveCtxPath(final StmtContext<?, ?, ?> context, final Class<N> namespace,
- final Iterable<K> keys) {
+ default <K, E extends EffectiveStatement<?, ?>, N extends IdentifierNamespace<K, ? extends StmtContext<?, ?, ?>>>
+ @NonNull Prerequisite<Mutable<?, ?, E>> mutatesEffectiveCtxPath(final StmtContext<?, ?, ?> context,
+ final Class<N> namespace, final Iterable<K> keys) {
throw new UnsupportedOperationException(getClass() + " does not implement mutatesEffectiveCtxPath()");
}
* @param context Target statement context
* @return A {@link Prerequisite} returning the requested context.
*/
- @Nonnull <C extends Mutable<?, ?, ?>, T extends C> Prerequisite<C> mutatesCtx(T context,
+ <C extends Mutable<?, ?, ?>, T extends C> @NonNull Prerequisite<C> mutatesCtx(T context,
ModelProcessingPhase phase);
/**
* @deprecated Undocumented method. Use at your own risk.
*/
@Deprecated
- @Nonnull <K, D extends DeclaredStatement<?>, N extends StatementNamespace<K, ? extends D, ?>>
- Prerequisite<StmtContext<?, D, ?>> requiresDeclaredCtx(StmtContext<?, ?, ?> context, Class<N> namespace, K key);
+ <K, D extends DeclaredStatement<?>, N extends StatementNamespace<K, ? extends D, ?>>
+ @NonNull Prerequisite<StmtContext<?, D, ?>> requiresDeclaredCtx(StmtContext<?, ?, ?> context,
+ Class<N> namespace, K key);
/**
* Create a requirement on specified statement to become effective.
* @deprecated Undocumented method. Use at your own risk.
*/
@Deprecated
- @Nonnull <E extends EffectiveStatement<?, ?>> Prerequisite<E> requiresEffective(
+ <E extends EffectiveStatement<?, ?>> @NonNull Prerequisite<E> requiresEffective(
StmtContext<?, ?, ? extends E> stmt);
/**
* @deprecated Undocumented method. Use at your own risk.
*/
@Deprecated
- @Nonnull <K, E extends EffectiveStatement<?, ?>, N extends StatementNamespace<K, ?, ? extends E>>
- Prerequisite<E> requiresEffective(StmtContext<?, ?, ?> context, Class<N> namespace, K key);
+ <K, E extends EffectiveStatement<?, ?>, N extends StatementNamespace<K, ?, ? extends E>>
+ @NonNull Prerequisite<E> requiresEffective(StmtContext<?, ?, ?> context, Class<N> namespace, K key);
/**
* Create a requirement on specified statement context to become effective.
* @deprecated Undocumented method. Use at your own risk.
*/
@Deprecated
- @Nonnull <K, E extends EffectiveStatement<?, ?>, N extends StatementNamespace<K, ?, ? extends E>>
- Prerequisite<StmtContext<?, ?, E>> requiresEffectiveCtx(StmtContext<?, ?, ?> context, Class<N> namespace,
- K key);
+ <K, E extends EffectiveStatement<?, ?>, N extends StatementNamespace<K, ?, ? extends E>>
+ @NonNull Prerequisite<StmtContext<?, ?, E>> requiresEffectiveCtx(StmtContext<?, ?, ?> context,
+ Class<N> namespace, K key);
/**
* Mark the fact that this action is mutating a namespace.
* @deprecated Undocumented method. Use at your own risk.
*/
@Deprecated
- @Nonnull <N extends IdentifierNamespace<?, ?>> Prerequisite<Mutable<?,?,?>> mutatesNs(
- Mutable<?,?, ?> ctx, Class<N> namespace);
+ <N extends IdentifierNamespace<?, ?>> @NonNull Prerequisite<Mutable<?,?,?>> mutatesNs(Mutable<?,?, ?> ctx,
+ Class<N> namespace);
}
*/
package org.opendaylight.yangtools.yang.parser.spi.meta;
-import javax.annotation.Nullable;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+@NonNullByDefault
+@SuppressFBWarnings("NP_NULL_PARAM_DEREF_NONVIRTUAL")
public enum ModelProcessingPhase {
INIT(null),
/**
- * Preliminary cross-source relationship resolution phase which collects
- * available module names and module namespaces. It is necessary in order to
- * correct resolution of unknown statements used in linkage phase (e.g.
+ * Preliminary cross-source relationship resolution phase which collects available module names and module
+ * namespaces. It is necessary in order to correct resolution of unknown statements used in linkage phase (e.g.
* semantic version of yang modules).
*/
SOURCE_PRE_LINKAGE(INIT),
FULL_DECLARATION(STATEMENT_DEFINITION),
EFFECTIVE_MODEL(FULL_DECLARATION);
- private final ModelProcessingPhase previousPhase;
+ private final @Nullable ModelProcessingPhase previousPhase;
- ModelProcessingPhase(@Nullable ModelProcessingPhase previous) {
+ ModelProcessingPhase(final @Nullable ModelProcessingPhase previous) {
this.previousPhase = previous;
}
- public ModelProcessingPhase getPreviousPhase() {
+ public @Nullable ModelProcessingPhase getPreviousPhase() {
return previousPhase;
}
}
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
* For common behaviour models please use static factories {@link #global(Class)}, {@link #sourceLocal(Class)} and
* {@link #treeScoped(Class)}.
*
- * @param <K>
- * Key type
- * @param <V>
- * Value type
- * @param <N>
- * Namespace Type
+ * @param <K> Key type
+ * @param <V> Value type
+ * @param <N> Namespace Type
*/
public abstract class NamespaceBehaviour<K, V, N extends IdentifierNamespace<K, V>> implements Identifiable<Class<N>> {
*/
StorageNodeType getStorageNodeType();
- @Nullable
- NamespaceStorageNode getParentNamespaceStorage();
+ @Nullable NamespaceStorageNode getParentNamespaceStorage();
- @Nullable
- <K, V, N extends IdentifierNamespace<K, V>> V getFromLocalStorage(Class<N> type, K key);
+ <K, V, N extends IdentifierNamespace<K, V>> @Nullable V getFromLocalStorage(Class<N> type, K key);
- @Nullable
- <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromLocalStorage(Class<N> type);
+ <K, V, N extends IdentifierNamespace<K, V>> @Nullable Map<K, V> getAllFromLocalStorage(Class<N> type);
/**
* Populate specified namespace with a key/value pair, overwriting previous contents. Similar to
* @param value Value
* @return Previously-stored value, or null if the key was not present
*/
- @Nullable
- <K, V, N extends IdentifierNamespace<K, V>> V putToLocalStorage(Class<N> type, K key, V value);
+ <K, V, N extends IdentifierNamespace<K, V>> @Nullable V putToLocalStorage(Class<N> type, K key, V value);
/**
* Populate specified namespace with a key/value pair unless the key is already associated with a value. Similar
* @param value Value
* @return Preexisting value or null if there was no previous mapping
*/
- @Nullable
- <K, V, N extends IdentifierNamespace<K, V>> V putToLocalStorageIfAbsent(Class<N> type, K key, V value);
+ <K, V, N extends IdentifierNamespace<K, V>> @Nullable V putToLocalStorageIfAbsent(Class<N> type, K key,
+ V value);
}
private final @NonNull Class<N> identifier;
* Creates a global namespace behaviour for supplied namespace type. Global behaviour stores and loads all values
* from root {@link NamespaceStorageNode} with type of {@link StorageNodeType#GLOBAL}.
*
- * @param identifier
- * Namespace identifier.
+ * @param identifier Namespace identifier.
* @param <K> type parameter
* @param <V> type parameter
* @param <N> type parameter
* @return global namespace behaviour for supplied namespace type.
*/
- public static @Nonnull <K, V, N extends IdentifierNamespace<K, V>> NamespaceBehaviour<K, V, N> global(
+ public static <K, V, N extends IdentifierNamespace<K, V>> @NonNull NamespaceBehaviour<K, V, N> global(
final Class<N> identifier) {
return new StorageSpecific<>(identifier, StorageNodeType.GLOBAL);
}
* and loads all values from closest {@link NamespaceStorageNode} ancestor with type
* of {@link StorageNodeType#SOURCE_LOCAL_SPECIAL}.
*
- * @param identifier
- * Namespace identifier.
+ * @param identifier Namespace identifier.
* @param <K> type parameter
* @param <V> type parameter
* @param <N> type parameter
* @return source-local namespace behaviour for supplied namespace type.
*/
- public static <K, V, N extends IdentifierNamespace<K, V>> NamespaceBehaviour<K, V, N> sourceLocal(
+ public static <K, V, N extends IdentifierNamespace<K, V>> @NonNull NamespaceBehaviour<K, V, N> sourceLocal(
final Class<N> identifier) {
return new StorageSpecific<>(identifier, StorageNodeType.SOURCE_LOCAL_SPECIAL);
}
- public static <K, V, N extends IdentifierNamespace<K, V>> NamespaceBehaviour<K, V, N> statementLocal(
+ public static <K, V, N extends IdentifierNamespace<K, V>> @NonNull NamespaceBehaviour<K, V, N> statementLocal(
final Class<N> identifier) {
return new StorageSpecific<>(identifier, StorageNodeType.STATEMENT_LOCAL);
}
* behaviour stores and loads all values from closest {@link NamespaceStorageNode} ancestor with type
* of {@link StorageNodeType#ROOT_STATEMENT_LOCAL}.
*
- * @param identifier
- * Namespace identifier.
+ * @param identifier Namespace identifier.
* @param <K> type parameter
* @param <V> type parameter
* @param <N> type parameter
* @return root-statement-local namespace behaviour for supplied namespace type.
*/
- public static <K, V, N extends IdentifierNamespace<K, V>> NamespaceBehaviour<K, V, N> rootStatementLocal(
+ public static <K, V, N extends IdentifierNamespace<K, V>> @NonNull NamespaceBehaviour<K, V, N> rootStatementLocal(
final Class<N> identifier) {
return new StorageSpecific<>(identifier, StorageNodeType.ROOT_STATEMENT_LOCAL);
}
* @param <N> type parameter
* @return tree-scoped namespace behaviour for supplied namespace type.
*/
- public static <K, V, N extends IdentifierNamespace<K, V>> NamespaceBehaviour<K, V, N> treeScoped(
+ public static <K, V, N extends IdentifierNamespace<K, V>> @NonNull NamespaceBehaviour<K, V, N> treeScoped(
final Class<N> identifier) {
return new TreeScoped<>(identifier);
}
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
* @param key Key to be matched
* @return True if the key matches this criterion, false otherwise.
*/
- public abstract boolean match(@Nonnull K key);
+ public abstract boolean match(@NonNull K key);
/**
* Select the better match from two candidate keys.
* @param second Second key
* @return Selected key, must be either first or second key, by identity.
*/
- public abstract K select(@Nonnull K first, @Nonnull K second);
+ public abstract K select(@NonNull K first, @NonNull K second);
@Override
public final String toString() {
import com.google.common.annotations.Beta;
import java.util.Optional;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
* error.
* @throws SourceException if statement is not valid according to current context.
*/
- void startStatement(int childId, @Nonnull QName name, @Nullable String argument,
- @Nonnull StatementSourceReference ref);
+ void startStatement(int childId, @NonNull QName name, @Nullable String argument,
+ @NonNull StatementSourceReference ref);
/**
* Ends current opened statement.
* error.
* @throws SourceException if closed statement is not valid in current context, or there is no such statement
*/
- void endStatement(@Nonnull StatementSourceReference ref);
+ void endStatement(@NonNull StatementSourceReference ref);
/**
* Return current model processing phase.
*
* @return current processing phase
*/
- @Nonnull ModelProcessingPhase getPhase();
+ @NonNull ModelProcessingPhase getPhase();
}