import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
-import javax.annotation.concurrent.ThreadSafe;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
*/
@Beta
@NonNullByDefault
-@ThreadSafe
public class CheckedValue<T, E extends Exception> extends Variant<T, E> {
protected CheckedValue(final T value) {
super(value);
package org.opendaylight.yangtools.concepts;
import java.io.Serializable;
-import javax.annotation.concurrent.ThreadSafe;
/**
* General identifier interface. It is primarily a marker for all things that identify concepts -- such as names,
* of their serialization format. For further efficiency, implementations should consider implementing
* {@link WritableObject}, so they can be efficiently embedded in other {@link Serializable} and {@code WritableObject}s
* objects.
- *
- * <p>Note that this class is annotated as {@link ThreadSafe}, hence all implementations are expected to be
- * thread-safe. This is an implication of {@link Immutable} interface contract.
*/
-@ThreadSafe
public interface Identifier extends Serializable, Immutable {
@Override
boolean equals(Object obj);
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Objects;
import java.util.Optional;
-import javax.annotation.concurrent.ThreadSafe;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
*/
@Beta
@NonNullByDefault
-@ThreadSafe
-public class Variant<T, U> {
+public class Variant<T, U> implements Immutable {
private final @Nullable T first;
private final @Nullable U second;
import com.google.common.annotations.Beta;
import java.lang.reflect.Modifier;
-import javax.annotation.concurrent.ThreadSafe;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
*/
@Beta
@NonNullByDefault
-@ThreadSafe
public abstract class AbstractCanonicalValueSupport<T extends CanonicalValue<T>> implements CanonicalValueSupport<T> {
private static final ClassValue<Boolean> SUPPORTS = new ClassValue<Boolean>() {
@Override
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
-import javax.annotation.concurrent.ThreadSafe;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.concepts.Variant;
*/
@Beta
@NonNullByDefault
-@ThreadSafe
public abstract class AbstractCanonicalValueValidator<T extends DerivedString<T>, V extends T>
implements CanonicalValueValidator<T, V> {
private static final ClassValue<Boolean> IMPLEMENTATIONS = new AbstractCanonicalValueImplementationValidator() {
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
-import javax.annotation.concurrent.ThreadSafe;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.concepts.Variant;
*/
@Beta
@NonNullByDefault
-@ThreadSafe
public interface CanonicalValueSupport<T extends CanonicalValue<T>> extends CanonicalValueValidator<T, T> {
/**
* Create a instance for a string representation. Implementations of this method are required to perform checks
package org.opendaylight.yangtools.yang.common;
import com.google.common.annotations.Beta;
-import javax.annotation.concurrent.ThreadSafe;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
*/
@Beta
@NonNullByDefault
-@ThreadSafe
public abstract class DerivedString<T extends DerivedString<T>> implements CanonicalValue<T> {
private static final long serialVersionUID = 1L;
import static java.util.Objects.requireNonNull;
import java.util.Arrays;
-import javax.annotation.concurrent.NotThreadSafe;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.concepts.Mutable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
@NonNullByDefault
-@NotThreadSafe
final class ModificationPath implements Mutable {
private static final int DEFAULT_ALLOC_SIZE = 8;
private static final int ALLOC_SIZE = Integer.getInteger(
import java.util.Map;
import java.util.Optional;
import java.util.function.Predicate;
-import javax.annotation.concurrent.NotThreadSafe;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
* reconstruct the effective data node presentation, it is sufficient to perform a depth-first pre-order traversal of
* the tree.
*/
-@NotThreadSafe
final class ModifiedNode extends NodeModification implements StoreTreeNode<ModifiedNode> {
static final Predicate<ModifiedNode> IS_TERMINAL_PREDICATE = input -> {
requireNonNull(input);
import com.google.common.annotations.Beta;
import java.util.Optional;
import java.util.function.Function;
-import javax.annotation.concurrent.ThreadSafe;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
*/
@Beta
@NonNullByDefault
-@ThreadSafe
public final class IdentityCodecUtil {
private IdentityCodecUtil() {
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
-import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.parser.api.YangParser;
*
* @author Robert Varga
*/
-@NotThreadSafe
final class ProcessorModuleReactor {
private static final Logger LOG = LoggerFactory.getLogger(ProcessorModuleReactor.class);
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import javax.annotation.concurrent.ThreadSafe;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
*/
@Beta
@NonNullByDefault
-@ThreadSafe
public final class DefaultStatementDefinition<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
implements StatementDefinition {
private final Class<E> effectiveRepresentation;
import com.google.common.collect.ImmutableSet;
import java.util.HashSet;
import java.util.Set;
-import javax.annotation.concurrent.NotThreadSafe;
-import javax.annotation.concurrent.ThreadSafe;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
* @author Robert Varga
*/
@Beta
-@ThreadSafe
@NonNullByDefault
public final class DeclaredStatementFormatter implements Immutable {
private static final DeclaredStatementFormatter DEFAULT = new DeclaredStatementFormatter(ImmutableSet.of(), true);
* Builder class for instantiation of a customized {@link DeclaredStatementFormatter}.
*/
@Beta
- @NotThreadSafe
public static final class Builder
implements org.opendaylight.yangtools.concepts.Builder<DeclaredStatementFormatter> {
private final Set<StatementDefinition> ignoredStatements = new HashSet<>(4);
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
-import javax.annotation.concurrent.ThreadSafe;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.concepts.Immutable;
* @author Robert Varga
*/
@Beta
-@ThreadSafe
@NonNullByDefault({ PARAMETER, RETURN_TYPE })
public final class YangTextSnippet implements Immutable, Iterable<@NonNull String> {
private final Set<@NonNull StatementDefinition> ignoredStatements;