}
@Override
- public int compareTo(final SemVer other) {
+ public int compareTo(@Nonnull final SemVer other) {
int cmp = Integer.compare(major, other.major);
if (cmp == 0) {
cmp = Integer.compare(minor, other.minor);
import com.google.common.cache.Cache;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.ProductAwareBuilder;
import org.opendaylight.yangtools.objcache.ObjectCache;
import org.slf4j.Logger;
}
@Override
- public final <B extends ProductAwareBuilder<P>, P> P getProduct(final B builder) {
+ public final <B extends ProductAwareBuilder<P>, P> P getProduct(@Nonnull final B builder) {
throw new UnsupportedOperationException();
// LOG.debug("Looking up product for {}", builder);
//
*/
package org.opendaylight.yangtools.objcache.spi;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.ProductAwareBuilder;
import org.opendaylight.yangtools.objcache.ObjectCache;
}
@Override
- public <B extends ProductAwareBuilder<P>, P> P getProduct(final B builder) {
+ public <B extends ProductAwareBuilder<P>, P> P getProduct(@Nonnull final B builder) {
return builder.build();
}
}
package org.opendaylight.yangtools.objcache.guava;
import com.google.common.base.FinalizableReferenceQueue;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.objcache.ObjectCache;
import org.opendaylight.yangtools.objcache.spi.IObjectCacheFactory;
}
@Override
- public ObjectCache getObjectCache(final Class<?> objClass) {
+ public ObjectCache getObjectCache(@Nonnull final Class<?> objClass) {
return cache;
}
import com.google.common.annotations.Beta;
import java.util.UUID;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Identifier;
/**
}
@Override
- public final int compareTo(final T o) {
+ public final int compareTo(@Nonnull final T o) {
return getValue().compareTo(o.getValue());
}
}
import com.google.common.annotations.Beta;
import java.util.UUID;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Identifier;
/**
}
@Override
- public final int compareTo(final T o) {
+ public final int compareTo(@Nonnull final T o) {
return getValue().compareTo(o.getValue());
}
}
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
+import javax.annotation.Nonnull;
/**
* Internal array-backed {@link List}. It assumes the array does not contain nulls and it does not get modified
return false;
}
+ @Nonnull
@Override
public Iterator<E> iterator() {
return new UnmodifiableIterator<E>() {
};
}
+ @Nonnull
@Override
public Object[] toArray() {
return array.clone();
}
+ @Nonnull
@SuppressWarnings("unchecked")
@Override
- public <T> T[] toArray(final T[] a) {
+ public <T> T[] toArray(@Nonnull final T[] a) {
if (a.length < array.length) {
return Arrays.copyOf(array, array.length, (Class<T[]>)a.getClass().getComponentType());
}
}
@Override
- public boolean containsAll(final Collection<?> c) {
+ public boolean containsAll(@Nonnull final Collection<?> c) {
for (Object o : c) {
if (!contains(o)) {
return false;
}
@Override
- public boolean addAll(final Collection<? extends E> c) {
+ public boolean addAll(@Nonnull final Collection<? extends E> c) {
throw new UnsupportedOperationException();
}
@Override
- public boolean removeAll(final Collection<?> c) {
+ public boolean removeAll(@Nonnull final Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
- public boolean retainAll(final Collection<?> c) {
+ public boolean retainAll(@Nonnull final Collection<?> c) {
throw new UnsupportedOperationException();
}
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
+import javax.annotation.Nonnull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public static <E> BlockingQueue<E> offerFailingBlockingQueue(final BlockingQueue<E> delegate) {
return new ForwardingBlockingQueue<E>() {
@Override
- public boolean offer(final E o) {
+ public boolean offer(@Nonnull final E o) {
return false;
}
super(offsets, objects);
}
+ @Nonnull
@Override
public MutableOffsetMap<K, V> toModifiableMap() {
return MutableOffsetMap.orderedCopyOf(this);
super(offsets, objects);
}
+ @Nonnull
@Override
public MutableOffsetMap<K, V> toModifiableMap() {
return MutableOffsetMap.unorderedCopyOf(this);
Preconditions.checkArgument(offsets.size() == objects.length);
}
+ @Nonnull
@Override
public abstract MutableOffsetMap<K, V> toModifiableMap();
}
@Override
- public final void putAll(final Map<? extends K, ? extends V> m) {
+ public final void putAll(@Nonnull final Map<? extends K, ? extends V> m) {
throw new UnsupportedOperationException();
}
return offsets.keySet();
}
+ @Nonnull
@Override
public final Collection<V> values() {
return new ConstantArrayCollection<>(objects);
}
+ @Nonnull
@Override
public final Set<Entry<K, V>> entrySet() {
return new EntrySet();
}
private final class EntrySet extends AbstractSet<Entry<K, V>> {
+ @Nonnull
@Override
public Iterator<Entry<K, V>> iterator() {
final Iterator<Entry<K, Integer>> it = offsets.entrySet().iterator();
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
+import javax.annotation.Nonnull;
/**
* A mutable version of {@link ImmutableOffsetMap}. It inherits the set of mappings from the immutable version and
}
}
+ @Nonnull
@Override
public final Set<Entry<K, V>> entrySet() {
return new EntrySet();
}
+ @Nonnull
@Override
public Map<K, V> toUnmodifiableMap() {
if (removed == 0 && newKeys.isEmpty()) {
return true;
}
+ @Nonnull
@Override
public final Set<K> keySet() {
return new KeySet();
}
private final class EntrySet extends AbstractSet<Entry<K, V>> {
+ @Nonnull
@Override
public Iterator<Entry<K, V>> iterator() {
return new AbstractSetIterator<Entry<K, V>>() {
}
private final class KeySet extends AbstractSet<K> {
+ @Nonnull
@Override
public Iterator<K> iterator() {
return new AbstractSetIterator<K>() {
import java.util.List;
import java.util.Map;
import java.util.Set;
+import javax.annotation.Nonnull;
final class OffsetMapCache {
/*
private static final LoadingCache<List<?>, Map<?, Integer>> ORDERED_CACHE =
CacheBuilder.newBuilder().weakValues().build(new CacheLoader<List<?>, Map<?, Integer>>() {
@Override
- public Map<?, Integer> load(final List<?> key) {
+ public Map<?, Integer> load(@Nonnull final List<?> key) {
return createMap(key);
}
});
import java.util.Collections;
import java.util.Map;
import java.util.Set;
+import javax.annotation.Nonnull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- public void putAll(final Map<? extends K, ? extends V> m) {
+ public void putAll(@Nonnull final Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> e : m.entrySet()) {
put(e.getKey(), e.getValue());
}
import java.io.Serializable;
import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.Map;
+import javax.annotation.Nonnull;
/**
* Implementation of the {@link Map} interface which stores a single mapping. The key set is shared among all instances
super(key, value);
}
+ @Nonnull
@Override
public ModifiableMapPhase<K, V> toModifiableMap() {
return MutableOffsetMap.orderedCopyOf(this);
super(key, value);
}
+ @Nonnull
@Override
public ModifiableMapPhase<K, V> toModifiableMap() {
return MutableOffsetMap.unorderedCopyOf(this);
private static final LoadingCache<Object, SingletonSet<Object>> CACHE = CacheBuilder.newBuilder().weakValues()
.build(new CacheLoader<Object, SingletonSet<Object>>() {
@Override
- public SingletonSet<Object> load(final Object key) {
+ public SingletonSet<Object> load(@Nonnull final Object key) {
return SingletonSet.of(key);
}
});
return new Unordered<>(e.getKey(), e.getValue());
}
+ @Nonnull
@Override
public final SingletonSet<Entry<K, V>> entrySet() {
return SingletonSet.of(new SimpleImmutableEntry<>(keySet.getElement(), value));
}
+ @Nonnull
@Override
public final SingletonSet<K> keySet() {
return keySet;
}
+ @Nonnull
@Override
public final SingletonSet<V> values() {
return SingletonSet.of(value);
}
@Override
- public final void putAll(final Map<? extends K, ? extends V> m) {
+ public final void putAll(@Nonnull final Map<? extends K, ? extends V> m) {
throw new UnsupportedOperationException();
}
return Iterators.singletonIterator(getElement());
}
+ @Nonnull
@Override
public final Object[] toArray() {
return new Object[] { getElement() };
}
+ @Nonnull
@SuppressWarnings("unchecked")
@Override
- public final <T> T[] toArray(final T[] a) {
+ public final <T> T[] toArray(@Nonnull final T[] a) {
if (a.length > 0) {
a[0] = (T)getElement();
return a;
}
@Override
- public final boolean containsAll(final Collection<?> c) {
+ public final boolean containsAll(@Nonnull final Collection<?> c) {
if (c.isEmpty()) {
return true;
}
}
@Override
- public final boolean addAll(final Collection<? extends E> c) {
+ public final boolean addAll(@Nonnull final Collection<? extends E> c) {
throw new UnsupportedOperationException();
}
@Override
- public final boolean retainAll(final Collection<?> c) {
+ public final boolean retainAll(@Nonnull final Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
- public final boolean removeAll(final Collection<?> c) {
+ public final boolean removeAll(@Nonnull final Collection<?> c) {
throw new UnsupportedOperationException();
}
return new UnmodifiableCollection<>(collection);
}
+ @Nonnull
@Override
public Iterator<E> iterator() {
return Iterators.unmodifiableIterator(delegate.iterator());
}
@Override
- public <T> T[] toArray(final T[] a) {
+ public <T> T[] toArray(@Nonnull final T[] a) {
return delegate.toArray(a);
}
@Override
- public boolean containsAll(final Collection<?> c) {
+ public boolean containsAll(@Nonnull final Collection<?> c) {
return delegate.containsAll(c);
}
}
@Override
- public boolean addAll(final Collection<? extends E> c) {
+ public boolean addAll(@Nonnull final Collection<? extends E> c) {
throw new UnsupportedOperationException();
}
}
@Override
- public boolean removeAll(final Collection<?> c) {
+ public boolean removeAll(@Nonnull final Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
- public boolean retainAll(final Collection<?> c) {
+ public boolean retainAll(@Nonnull final Collection<?> c) {
throw new UnsupportedOperationException();
}
}
@Override
- public void addListener(final Runnable listener, final Executor executor) {
+ public void addListener(@Nonnull final Runnable listener, @Nonnull final Executor executor) {
// Wrap the listener Runnable in a DelegatingRunnable. If the specified executor is one that
// runs tasks in the same thread as the caller submitting the task
// (e.g. {@link com.google.common.util.concurrent.MoreExecutors#sameThreadExecutor}) and the
}
@Override
- public void addListener(@Nonnull final Runnable listener, final Executor executor) {
+ public void addListener(@Nonnull final Runnable listener, @Nonnull final Executor executor) {
executionList.add(listener, executor);
}
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
/**
}
@Override
- public boolean awaitTermination( final long timeout, final TimeUnit unit ) throws InterruptedException {
+ public boolean awaitTermination( final long timeout, @Nonnull final TimeUnit unit ) throws InterruptedException {
return delegate.awaitTermination( timeout, unit );
}
delegate.shutdown();
}
+ @Nonnull
@Override
public List<Runnable> shutdownNow() {
return delegate.shutdownNow();
}
@Override
- public void execute( final Runnable command ) {
+ public void execute( @Nonnull final Runnable command ) {
delegate.execute( command );
}
+ @Nonnull
@Override
public <T> ListenableFuture<T> submit( final Callable<T> task ) {
AsyncNotifyingListenableFutureTask<T> futureTask = newFutureTask( task );
return futureTask;
}
+ @Nonnull
@Override
public ListenableFuture<?> submit( final Runnable task ) {
AsyncNotifyingListenableFutureTask<Void> futureTask = newFutureTask( task, null );
return futureTask;
}
+ @Nonnull
@Override
public <T> ListenableFuture<T> submit( final Runnable task, final T result ) {
AsyncNotifyingListenableFutureTask<T> futureTask = newFutureTask( task, result );
}
@Override
- public void execute(final Runnable command) {
+ public void execute(@Nonnull final Runnable command) {
getDelegate().execute(wrapRunnable(command));
}
+ @Nonnull
@Override
public <T> ListenableFuture<T> submit(final Callable<T> task) {
return wrapListenableFuture(super.submit(wrapCallable(task)));
}
+ @Nonnull
@Override
public ListenableFuture<?> submit(final Runnable task) {
return wrapListenableFuture(super.submit(wrapRunnable(task)));
}
+ @Nonnull
@Override
public <T> ListenableFuture<T> submit(final Runnable task, final T result) {
return wrapListenableFuture(super.submit(wrapRunnable(task), result));
}
@Override
- public T get(final long timeout, final TimeUnit unit)
+ public T get(final long timeout, @Nonnull final TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
checkDeadLockDetectorTL();
return super.get(timeout, unit);
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
+import javax.annotation.Nonnull;
/**
* An implementation of CheckedFuture that provides similar behavior for the <code>get</code> methods
}
@Override
- protected X mapException( final Exception e ) {
+ protected X mapException( @Nonnull final Exception e ) {
return mapper.apply( e );
}
}
@Override
- public V get( final long timeout, final TimeUnit unit )
+ public V get( final long timeout, @Nonnull final TimeUnit unit )
throws InterruptedException, ExecutionException, TimeoutException {
try {
return super.get( timeout, unit );
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+import javax.annotation.Nonnull;
/**
* A {@link LinkedBlockingQueue} that tracks the largest queue size for debugging.
}
@Override
- public boolean offer(final E e) {
+ public boolean offer(@Nonnull final E e) {
if (super.offer( e ) ) {
updateLargestQueueSize();
return true;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nonnull;
import org.junit.After;
import org.junit.Test;
import org.opendaylight.yangtools.util.concurrent.CommonTestUtils.Invoker;
}
@Override
- public void onFailure( Throwable t ) {
+ public void onFailure( @Nonnull Throwable t ) {
// Shouldn't happen
t.printStackTrace();
}
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nonnull;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
}
@Override
- public void onFailure(final Throwable t) {
+ public void onFailure(@Nonnull final Throwable t) {
caughtEx.set(t);
futureCompletedLatch.countDown();
}
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+import javax.annotation.Nonnull;
import javax.annotation.RegEx;
import org.opendaylight.yangtools.concepts.Immutable;
}
@Override
- public int compareTo(final QName other) {
+ public int compareTo(@Nonnull final QName other) {
// compare mandatory localName parameter
int result = localName.compareTo(other.localName);
if (result != 0) {
import com.google.common.collect.ImmutableList;
import java.io.ObjectStreamException;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.util.HashCodeBuilder;
final class FixedYangInstanceIdentifier extends YangInstanceIdentifier implements Cloneable {
return ret;
}
+ @Nonnull
@Override
public YangInstanceIdentifier getAncestor(final int depth) {
Preconditions.checkArgument(depth >= 0, "Negative depth is not allowed");
return path.reverse();
}
+ @Nonnull
@Override
List<PathArgument> tryPathArguments() {
return path;
}
+ @Nonnull
@Override
List<PathArgument> tryReversePathArguments() {
return path.reverse();
return path.isEmpty()? null : path.get(path.size() - 1);
}
+ @Nonnull
@Override
YangInstanceIdentifier createRelativeIdentifier(final int skipFromRoot) {
if (skipFromRoot == path.size()) {
import com.google.common.collect.UnmodifiableIterator;
import java.util.AbstractList;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
abstract class PathArgumentList extends AbstractList<PathArgument> {
+ @Nonnull
@Override
public abstract UnmodifiableIterator<PathArgument> iterator();
}
@Override
- public final boolean addAll(final Collection<? extends PathArgument> c) {
+ public final boolean addAll(@Nonnull final Collection<? extends PathArgument> c) {
throw new UnsupportedOperationException();
}
@Override
- public final boolean removeAll(final Collection<?> c) {
+ public final boolean removeAll(@Nonnull final Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
- public final boolean retainAll(final Collection<?> c) {
+ public final boolean retainAll(@Nonnull final Collection<?> c) {
throw new UnsupportedOperationException();
}
return base.lastIndexOf(srch);
}
+ @Nonnull
@Override
public UnmodifiableIterator<PathArgument> iterator() {
return new IteratorImpl(base, stack);
import com.google.common.collect.UnmodifiableIterator;
import java.util.Collection;
import java.util.Iterator;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
final class StackedReversePathArguments extends PathArgumentList {
return ret;
}
+ @Nonnull
@Override
public UnmodifiableIterator<PathArgument> iterator() {
return new IteratorImpl(identifier);
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
+import javax.annotation.Nonnull;
final class StackedYangInstanceIdentifier extends YangInstanceIdentifier implements Cloneable {
private static final long serialVersionUID = 1L;
return parent;
}
+ @Nonnull
@Override
public YangInstanceIdentifier getAncestor(final int depth) {
Preconditions.checkArgument(depth >= 0, "Steps cannot be negative");
return pathArgument;
}
+ @Nonnull
@Override
StackedPathArguments tryPathArguments() {
return pathArguments;
}
+ @Nonnull
@Override
StackedReversePathArguments tryReversePathArguments() {
return reversePathArguments;
}
+ @Nonnull
@Override
YangInstanceIdentifier createRelativeIdentifier(final int skipFromRoot) {
// TODO: can we optimize this one?
}
@Override
- public final boolean contains(final YangInstanceIdentifier other) {
+ public final boolean contains(@Nonnull final YangInstanceIdentifier other) {
if (this == other) {
return true;
}
}
@Override
- public int compareTo(final PathArgument o) {
+ public int compareTo(@Nonnull final PathArgument o) {
return nodeType.compareTo(o.getNodeType());
}
private static final LoadingCache<QName, NodeIdentifier> CACHE = CacheBuilder.newBuilder().weakValues()
.build(new CacheLoader<QName, NodeIdentifier>() {
@Override
- public NodeIdentifier load(final QName key) {
+ public NodeIdentifier load(@Nonnull final QName key) {
return new NodeIdentifier(key);
}
});
}
@Override
- public int compareTo(final PathArgument o) {
+ public int compareTo(@Nonnull final PathArgument o) {
if (!(o instanceof AugmentationIdentifier)) {
return -1;
}
this.data = Preconditions.checkNotNull(data);
}
+ @Nonnull
@Override
public PathArgument getIdentifier() {
return data.getIdentifier();
}
+ @Nonnull
@Override
public Collection<DataTreeCandidateNode> getChildNodes() {
if (data instanceof NormalizedNodeContainer) {
return null;
}
+ @Nonnull
@Override
public ModificationType getModificationType() {
return ModificationType.WRITE;
}
+ @Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataAfter() {
return Optional.of(data);
}
+ @Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataBefore() {
return Optional.absent();
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
}
@Override
- public synchronized void applyToCursor(final DataTreeModificationCursor cursor) {
+ public synchronized void applyToCursor(@Nonnull final DataTreeModificationCursor cursor) {
delegate.applyToCursor(cursor);
}
}
import java.text.ParseException;
import java.util.HashMap;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import com.google.common.cache.LoadingCache;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
private final LoadingCache<DataSchemaNode, JSONCodec<?>> codecs =
CacheBuilder.newBuilder().softValues().build(new CacheLoader<DataSchemaNode, JSONCodec<?>>() {
@Override
- public JSONCodec<?> load(final DataSchemaNode key) throws Exception {
+ public JSONCodec<?> load(@Nonnull final DataSchemaNode key) throws Exception {
final TypeDefinition<?> type;
if (key instanceof LeafSchemaNode) {
type = ((LeafSchemaNode) key).getType();
import java.net.URI;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
/**
return qname;
}
+ @Nonnull
@Override
protected final URI getNamespace() {
return qname.getNamespace();
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.net.URI;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
this.namespace = namespace;
}
+ @Nonnull
@Override
protected final URI getNamespace() {
return namespace;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.util.ModuleStringIdentityrefCodec;
}
@Override
- protected Module moduleForPrefix(final String prefix) {
+ protected Module moduleForPrefix(@Nonnull final String prefix) {
if (prefix.isEmpty()) {
return context.findModuleByNamespaceAndRevision(parentModuleQname.getNamespace(),
parentModuleQname.getRevision());
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.net.URI;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
}
@Override
- protected Module moduleForPrefix(final String prefix) {
+ protected Module moduleForPrefix(@Nonnull final String prefix) {
return context.findModuleByName(prefix, null);
}
@Override
- protected String prefixForNamespace(final URI namespace) {
+ protected String prefixForNamespace(@Nonnull final URI namespace) {
final Module module = context.findModuleByNamespaceAndRevision(namespace, null);
return module == null ? null : module.getName();
}
+ @Nonnull
@Override
protected DataSchemaContextTree getDataContextTree() {
return dataContextTree;
import java.net.URI;
import java.util.Map.Entry;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.util.AbstractStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
}
@Override
- protected String prefixForNamespace(final URI namespace) {
+ protected String prefixForNamespace(@Nonnull final URI namespace) {
return prefixes.encodePrefix(namespace);
}
@Override
- protected QName createQName(final String prefix, final String localName) {
+ protected QName createQName(@Nonnull final String prefix, @Nonnull final String localName) {
throw new UnsupportedOperationException("Not implemented");
}
+ @Nonnull
@Override
protected DataSchemaContextTree getDataContextTree() {
return schemaTree;
}
@Override
- protected void writeValue(final XMLStreamWriter xmlWriter, final QName qname, final Object value,
+ protected void writeValue(final XMLStreamWriter xmlWriter, final QName qname, @Nonnull final Object value,
final SchemaNode schemaNode) throws IOException, XMLStreamException {
streamUtils.writeValue(xmlWriter, schemaNode, value, qname.getModule());
}
}
@Override
- protected void writeValue(XMLStreamWriter xmlWriter, QName qname, Object value, Object context)
+ protected void writeValue(XMLStreamWriter xmlWriter, QName qname, @Nonnull Object value, Object context)
throws XMLStreamException {
xmlWriter.writeCharacters(value.toString());
}
import com.google.common.cache.LoadingCache;
import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.Map.Entry;
+import javax.annotation.Nonnull;
import javax.annotation.concurrent.ThreadSafe;
import javax.xml.namespace.NamespaceContext;
import javax.xml.stream.XMLStreamException;
CacheBuilder.newBuilder().softValues().build(
new CacheLoader<Entry<DataSchemaNode, NamespaceContext>, XmlCodec<?>>() {
@Override
- public XmlCodec<?> load(final Entry<DataSchemaNode, NamespaceContext> schemaNodeAndNamespaceCtxPair)
+ public XmlCodec<?> load(@Nonnull final Entry<DataSchemaNode, NamespaceContext> schemaNodeAndNamespaceCtxPair)
throws Exception {
final DataSchemaNode schemaNode = schemaNodeAndNamespaceCtxPair.getKey();
final TypeDefinition<?> type;
import com.google.common.base.Preconditions;
import java.net.URI;
+import javax.annotation.Nonnull;
import javax.xml.namespace.NamespaceContext;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
}
@Override
- protected Module moduleForPrefix(final String prefix) {
+ protected Module moduleForPrefix(@Nonnull final String prefix) {
if (prefix.isEmpty()) {
return context.findModuleByNamespaceAndRevision(parentModuleQname.getNamespace(),
parentModuleQname.getRevision());
import com.google.common.base.Preconditions;
import java.net.URI;
+import javax.annotation.Nonnull;
import javax.xml.namespace.NamespaceContext;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
}
@Override
- protected Module moduleForPrefix(final String prefix) {
+ protected Module moduleForPrefix(@Nonnull final String prefix) {
final String prefixedNS = namespaceContext.getNamespaceURI(prefix);
return context.findModuleByNamespaceAndRevision(URI.create(prefixedNS), null);
}
@Override
- protected String prefixForNamespace(final URI namespace) {
+ protected String prefixForNamespace(@Nonnull final URI namespace) {
final Module module = context.findModuleByNamespaceAndRevision(namespace, null);
return module == null ? null : module.getName();
}
+ @Nonnull
@Override
protected DataSchemaContextTree getDataContextTree() {
return dataContextTree;
import java.net.URI;
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;
import org.junit.Before;
return null;
}
+ @Nonnull
@Override
public QName getQName() {
return qName;
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return null;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return null;
return null;
}
+ @Nonnull
@Override
public Status getStatus() {
return null;
}
+ @Nonnull
@Override
public ContainerSchemaNode getSchemaOfAnyXmlData() {
return contentSchema;
import com.google.common.base.Preconditions;
import java.net.URI;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.util.AbstractStringIdentityrefCodec;
import org.opendaylight.yangtools.yang.model.api.Module;
}
@Override
- protected String prefixForNamespace(final URI namespace) {
+ protected String prefixForNamespace(@Nonnull final URI namespace) {
return element.lookupPrefix(namespace.toString());
}
@Override
- protected QName createQName(final String prefix, final String localName) {
+ protected QName createQName(@Nonnull final String prefix, @Nonnull final String localName) {
final String namespace = element.lookupNamespaceURI(!prefix.isEmpty() ? prefix : null);
Preconditions.checkArgument(namespace != null, "Failed to lookup prefix %s", prefix);
import com.google.common.base.Preconditions;
import java.net.URI;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
import org.opendaylight.yangtools.yang.data.util.AbstractStringInstanceIdentifierCodec;
}
@Override
- protected String prefixForNamespace(final URI namespace) {
+ protected String prefixForNamespace(@Nonnull final URI namespace) {
return element.lookupPrefix(namespace.toString());
}
@Override
- protected QName createQName(final String prefix, final String localName) {
+ protected QName createQName(@Nonnull final String prefix, @Nonnull final String localName) {
final String namespace = element.lookupNamespaceURI(prefix);
Preconditions.checkArgument(namespace != null, "Failed to lookup prefix %s", prefix);
return QName.create(module.getQNameModule(), localName);
}
+ @Nonnull
@Override
protected DataSchemaContextTree getDataContextTree() {
return dataContextTree;
import java.net.URI;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.util.AbstractStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
}
@Override
- protected String prefixForNamespace(final URI namespace) {
+ protected String prefixForNamespace(@Nonnull final URI namespace) {
return prefixes.encodePrefix(namespace);
}
@Override
- protected QName createQName(final String prefix, final String localName) {
+ protected QName createQName(@Nonnull final String prefix, @Nonnull final String localName) {
throw new UnsupportedOperationException("Not implemented");
}
+ @Nonnull
@Override
protected DataSchemaContextTree getDataContextTree() {
return schemaTree;
import java.io.IOException;
import java.util.Collections;
import java.util.Map;
+import javax.annotation.Nonnull;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import org.opendaylight.yangtools.yang.common.QName;
}
@Override
- protected void writeValue(final XMLStreamWriter xmlWriter, final QName qname, final Object value,
+ protected void writeValue(final XMLStreamWriter xmlWriter, final QName qname, @Nonnull final Object value,
final SchemaNode schemaNode) throws IOException, XMLStreamException {
streamUtils.writeValue(xmlWriter, schemaNode, value, qname.getModule());
}
import java.util.Collections;
import java.util.Deque;
import java.util.Map;
+import javax.annotation.Nonnull;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import org.opendaylight.yangtools.yang.common.QName;
}
@Override
- protected void writeValue(XMLStreamWriter xmlWriter, QName qname, Object value, Object context)
+ protected void writeValue(XMLStreamWriter xmlWriter, QName qname, @Nonnull Object value, Object context)
throws XMLStreamException {
xmlWriter.writeCharacters(value.toString());
}
import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Deque;
+import javax.annotation.Nonnull;
import javax.xml.transform.dom.DOMSource;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
}
@Override
- public void nextDataSchemaNode(final DataSchemaNode schema) {
+ public void nextDataSchemaNode(@Nonnull final DataSchemaNode schema) {
nextSchema = Preconditions.checkNotNull(schema);
}
}
import com.google.common.base.Preconditions;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
this.contentSchema = Preconditions.checkNotNull(contentSchema, "Schema of yang modeled anyXml content cannot be null.");
}
+ @Nonnull
@Override
public ContainerSchemaNode getSchemaOfAnyXmlData() {
return contentSchema;
@Nullable
private final V value;
- protected AbstractImmutableNormalizedValueNode(final K nodeIdentifier, final V value) {
+ protected AbstractImmutableNormalizedValueNode(final K nodeIdentifier, @Nullable final V value) {
super(nodeIdentifier);
if (value == null) {
/*
this.value = value;
}
+ @Nullable
@Override
public final V getValue() {
return value;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
}
@Override
- public void putAll(final Map<? extends PathArgument, ? extends DataContainerChild<? extends PathArgument, ?>> m) {
+ public void putAll(@Nonnull final Map<? extends PathArgument, ? extends DataContainerChild<? extends PathArgument, ?>> m) {
throw new UnsupportedOperationException();
}
return Collections.unmodifiableSet(delegate.keySet());
}
+ @Nonnull
@Override
public Collection<DataContainerChild<? extends PathArgument, ?>> values() {
if (values == null) {
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import com.google.common.base.Optional;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
abstract class AbstractAvailableLeafCandidateNode extends AbstractLeafCandidateNode {
super(dataAfter);
}
+ @Nonnull
@Override
public final Optional<NormalizedNode<?, ?>> getDataAfter() {
return dataOptional();
return Optional.of(data);
}
+ @Nonnull
@Override
public final Collection<DataTreeCandidateNode> getChildNodes() {
return Collections.emptyList();
import com.google.common.base.Optional;
import com.google.common.collect.Collections2;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
return null;
}
+ @Nonnull
@Override
public final Collection<DataTreeCandidateNode> getChildNodes() {
return Collections2.transform(getData().getValue(), this::createChild);
return ModificationType.UNMODIFIED;
}
+ @Nonnull
@Override
public Collection<DataTreeCandidateNode> getChildNodes() {
return Collections.emptyList();
return Optional.absent();
}
+ @Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataBefore() {
return dataOptional();
return ModificationType.WRITE;
}
+ @Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataAfter() {
return super.dataOptional();
}
+ @Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataBefore() {
return Optional.of(oldData);
return ModificationType.UNMODIFIED;
}
+ @Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataAfter() {
return dataOptional();
}
+ @Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataBefore() {
return dataOptional();
return new WriteLeafCandidateNode(childData);
}
+ @Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataAfter() {
return dataOptional();
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
final class ReplaceLeafCandidateNode extends AbstractWriteCandidate {
this.oldData = Preconditions.checkNotNull(oldData);
}
+ @Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataBefore() {
return Optional.of(oldData);
return ModificationType.UNMODIFIED;
}
+ @Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataBefore() {
return dataOptional();
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import javax.annotation.Nonnull;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
return null;
}
+ @Nonnull
@Override
public QName getQName() {
return qName;
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return null;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return null;
return null;
}
+ @Nonnull
@Override
public Status getStatus() {
return null;
}
+ @Nonnull
@Override
public ContainerSchemaNode getSchemaOfAnyXmlData() {
return contentSchema;
import com.google.common.base.Converter;
import com.google.common.base.Preconditions;
+import javax.annotation.Nonnull;
import org.jaxen.NamespaceContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
}
@Override
- protected QNameModule doForward(final String a) {
+ protected QNameModule doForward(@Nonnull final String a) {
return delegate.convert(a);
}
@Override
- protected String doBackward(final QNameModule b) {
+ protected String doBackward(@Nonnull final QNameModule b) {
return delegate.reverse().convert(b);
}
package org.opendaylight.yangtools.yang.data.jaxen;
import com.google.common.base.Preconditions;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.xpath.XPathDocument;
this.root = Preconditions.checkNotNull(root);
}
+ @Nonnull
@Override
public NormalizedNode<?, ?> getRootNode() {
return root;
import com.google.common.base.Converter;
import com.google.common.base.Preconditions;
+import javax.annotation.Nonnull;
import javax.xml.xpath.XPathExpressionException;
import org.jaxen.JaxenException;
import org.opendaylight.yangtools.yang.common.QNameModule;
this.context = Preconditions.checkNotNull(context);
}
+ @Nonnull
@Override
- public XPathExpression compileExpression(final SchemaPath schemaPath,
- final Converter<String, QNameModule> prefixes, final String xpath) throws XPathExpressionException {
+ public XPathExpression compileExpression(@Nonnull final SchemaPath schemaPath,
+ final Converter<String, QNameModule> prefixes, @Nonnull final String xpath) throws XPathExpressionException {
try {
return JaxenXPath.create(prefixes, schemaPath, xpath);
} catch (JaxenException e) {
}
}
+ @Nonnull
@Override
- public XPathDocument createDocument(final NormalizedNode<?, ?> documentRoot) {
+ public XPathDocument createDocument(@Nonnull final NormalizedNode<?, ?> documentRoot) {
return new JaxenDocument(this, documentRoot);
}
}
*/
package org.opendaylight.yangtools.yang.data.jaxen;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.schema.xpath.XPathSchemaContext;
import org.opendaylight.yangtools.yang.data.api.schema.xpath.XPathSchemaContextFactory;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public final class JaxenSchemaContextFactory implements XPathSchemaContextFactory {
+ @Nonnull
@Override
- public XPathSchemaContext createContext(final SchemaContext context) {
+ public XPathSchemaContext createContext(@Nonnull final SchemaContext context) {
return new JaxenSchemaContext(context);
}
}
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import java.util.List;
+import javax.annotation.Nonnull;
import javax.xml.xpath.XPathExpressionException;
import org.jaxen.BaseXPath;
import org.jaxen.ContextSupport;
}
@Override
- public Optional<? extends XPathResult<?>> evaluate(final XPathDocument document, final YangInstanceIdentifier path)
+ public Optional<? extends XPathResult<?>> evaluate(@Nonnull final XPathDocument document, @Nonnull final YangInstanceIdentifier path)
throws XPathExpressionException {
Preconditions.checkArgument(document instanceof JaxenDocument);
}
}
+ @Nonnull
@Override
public SchemaPath getEvaluationPath() {
return schemaPath;
}
+ @Nonnull
@Override
public SchemaPath getApexPath() {
// TODO: improve this
return delegate;
}
+ @Nonnull
@Override
- protected QName transform(final QName key) {
+ protected QName transform(@Nonnull final QName key) {
return transformation.apply(key);
}
protected abstract Module moduleForPrefix(@Nonnull String prefix);
@Override
- protected final QName createQName(final String prefix, final String localName) {
+ protected final QName createQName(@Nonnull final String prefix, @Nonnull final String localName) {
final Module module = moduleForPrefix(prefix);
Preconditions.checkArgument(module != null, "Failed to lookup prefix %s", prefix);
return QName.create(module.getQNameModule(), localName);
protected abstract Module moduleForPrefix(@Nonnull String prefix);
@Override
- protected final QName createQName(final String prefix, final String localName) {
+ protected final QName createQName(@Nonnull final String prefix, @Nonnull final String localName) {
final Module module = moduleForPrefix(prefix);
Preconditions.checkArgument(module != null, "Failed to lookup prefix %s", prefix);
return QName.create(module.getQNameModule(), localName);
return schemaNode.getStatus();
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return ImmutableList.of();
private static final LoadingCache<SchemaContext, DataSchemaContextTree> TREES = CacheBuilder.newBuilder()
.weakKeys().weakValues().build(new CacheLoader<SchemaContext, DataSchemaContextTree>() {
@Override
- public DataSchemaContextTree load(final SchemaContext key) throws Exception {
+ public DataSchemaContextTree load(@Nonnull final SchemaContext key) throws Exception {
return new DataSchemaContextTree(key);
}
});
}
@Override
- protected String prefixForNamespace(final URI namespace) {
+ protected String prefixForNamespace(@Nonnull final URI namespace) {
final Module module = context.findModuleByNamespaceAndRevision(namespace, null);
return module == null ? null : module.getName();
}
import java.util.Collections;
import java.util.List;
import java.util.Set;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
return delegate.getGroupings();
}
+ @Nonnull
@Override
public Status getStatus() {
return delegate.getStatus();
delegate = parentNode;
}
+ @Nonnull
@Override
public QName getQName() {
return delegate.getQName();
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return delegate.getPath();
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return Collections.emptyList();
import java.util.List;
import java.util.Set;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
import org.opendaylight.yangtools.concepts.SemVer;
*
* @return unknown nodes in lexicographical order
*/
+ @Nonnull
List<UnknownSchemaNode> getUnknownSchemaNodes();
/**
return QName.create(YangConstants.RFC6020_YIN_MODULE, nameStr).intern();
}
+ @Nonnull
@Override
public QName getStatementName() {
return name;
return type;
}
+ @Nonnull
@Override
public Class<? extends EffectiveStatement<?,?>> getEffectiveRepresentationClass() {
return effectiveType;
*/
package org.opendaylight.yangtools.yang.model.repo.api;
+import javax.annotation.Nonnull;
+
/**
* A YANG {@link SchemaSourceRepresentation}.
*/
*
* @return The type of representation.
*/
+ @Nonnull
@Override
Class<? extends YangSchemaSourceRepresentation> getType();
}
import java.io.IOException;
import java.io.InputStream;
import java.util.Map.Entry;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Delegator;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.common.YangNames;
/**
* {@inheritDoc}
*/
+ @Nonnull
@Override
public Class<? extends YangTextSchemaSource> getType() {
return YangTextSchemaSource.class;
this.source = Preconditions.checkNotNull(source);
}
+ @Nonnull
@Override
public DOMSource getSource() {
return source;
this.xmlSchemaSource = Preconditions.checkNotNull(xmlSchemaSource);
}
+ @Nonnull
@Override
public DOMSource getSource() {
DOMSource ret = source;
*/
package org.opendaylight.yangtools.yang.model.repo.api;
+import javax.annotation.Nonnull;
+
/**
* A YIN {@link SchemaSourceRepresentation}.
*/
*
* @return The type of representation.
*/
+ @Nonnull
@Override
Class<? extends YinSchemaSourceRepresentation> getType();
}
import java.io.IOException;
import java.io.InputStream;
import java.util.Map.Entry;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Delegator;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.common.YangNames;
/**
* {@inheritDoc}
*/
+ @Nonnull
@Override
public Class<? extends YinTextSchemaSource> getType() {
return YinTextSchemaSource.class;
*/
@Beta
public interface YinXmlSchemaSource extends YinSchemaSourceRepresentation {
+ @Nonnull
@Override
Class<? extends YinXmlSchemaSource> getType();
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
return argumentName;
}
+ @Nonnull
@Override
public QName getStatementName() {
return statementName;
return yinElement;
}
+ @Nonnull
@Override
public Class<? extends DeclaredStatement<?>> getDeclaredRepresentationClass() {
throw new UnsupportedOperationException("Not defined");
}
+ @Nonnull
@Override
public Class<? extends EffectiveStatement<?,?>> getEffectiveRepresentationClass() {
throw new UnsupportedOperationException("Not defined");
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
+import javax.annotation.Nonnull;
import javax.annotation.concurrent.GuardedBy;
import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
import org.opendaylight.yangtools.util.concurrent.ReflectiveExceptionMapper;
return Futures.makeChecked(Futures.withFallback(f, new FutureFallback<T>() {
@Override
- public ListenableFuture<T> create(final Throwable t) throws SchemaSourceException {
+ public ListenableFuture<T> create(@Nonnull final Throwable t) throws SchemaSourceException {
LOG.debug("Failed to acquire source from {}", reg, t);
if (it.hasNext()) {
}
@Override
- public <T extends SchemaSourceRepresentation> CheckedFuture<T, SchemaSourceException> getSchemaSource(final SourceIdentifier id, final Class<T> representation) {
+ public <T extends SchemaSourceRepresentation> CheckedFuture<T, SchemaSourceException> getSchemaSource(@Nonnull final SourceIdentifier id, @Nonnull final Class<T> representation) {
final ArrayList<AbstractSchemaSourceRegistration<?>> sortedSchemaSourceRegistrations;
synchronized (this) {
}
@Override
- public void onFailure(final Throwable t) {
+ public void onFailure(@Nonnull final Throwable t) {
LOG.trace("Skipping notification for encountered source {}, fetching source failed", id, t);
}
});
import com.google.common.util.concurrent.Futures;
import java.util.HashMap;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
import org.opendaylight.yangtools.util.concurrent.ReflectiveExceptionMapper;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
@FunctionalInterface
public interface Transformation<S extends SchemaSourceRepresentation, D extends SchemaSourceRepresentation> extends AsyncFunction<S, D> {
@Override
- CheckedFuture<D, SchemaSourceException> apply(final S input) throws Exception;
+ CheckedFuture<D, SchemaSourceException> apply(@Nonnull final S input) throws Exception;
}
private final Map<PotentialSchemaSource<?>, RefcountedRegistration> sources = new HashMap<>();
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
return null;
}
+ @Nonnull
@Override
public QName getQName() {
return SchemaContext.NAME;
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return SchemaPath.ROOT;
return null;
}
+ @Nonnull
@Override
public Status getStatus() {
return Status.CURRENT;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
final List<UnknownSchemaNode> result = new ArrayList<>();
import com.google.common.collect.ImmutableList;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
return null;
}
+ @Nonnull
@Override
public final Status getStatus() {
return Status.CURRENT;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
return reference;
}
+ @Nonnull
@Override
public final Status getStatus() {
return status;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
this.rangeConstraints = ImmutableList.copyOf(rangeConstraints);
}
+ @Nonnull
public final List<RangeConstraint> getRangeConstraints() {
return rangeConstraints;
}
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
this.rangeConstraints = ImmutableList.copyOf(rangeConstraints);
}
+ @Nonnull
public final List<RangeConstraint> getRangeConstraints() {
return rangeConstraints;
}
import com.google.common.base.Preconditions;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
return baseType.getReference();
}
+ @Nonnull
@Override
public final Status getStatus() {
return baseType.getStatus();
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
this.unknownSchemaNodes = ImmutableList.copyOf(unknownSchemaNodes);
}
+ @Nonnull
@Override
public final QName getQName() {
return path.getLastComponent();
}
+ @Nonnull
@Override
public final SchemaPath getPath() {
return path;
}
+ @Nonnull
@Override
public final List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
this.bits = ImmutableList.copyOf(bits);
}
+ @Nonnull
@Override
public List<Bit> getBits() {
return bits;
import com.google.common.collect.ImmutableList.Builder;
import java.math.BigDecimal;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
this.fractionDigits = fractionDigits;
}
+ @Nonnull
@Override
public Integer getFractionDigits() {
return fractionDigits;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
this.values = ImmutableList.copyOf(values);
}
+ @Nonnull
@Override
public List<EnumPair> getValues() {
return values;
import com.google.common.base.Preconditions;
import java.util.List;
import java.util.Objects;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
this.unknownNodes = Preconditions.checkNotNull(unknownNodes);
}
+ @Nonnull
@Override
public QName getQName() {
return schemaPath.getLastComponent();
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return schemaPath;
return reference;
}
+ @Nonnull
@Override
public Status getStatus() {
return status;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
return position;
}
+ @Nonnull
@Override
public String getName() {
return getQName().getLocalName();
private static ConcreteTypeBuilder<BinaryTypeDefinition> concreteBinaryBuilder(@Nonnull final BinaryTypeDefinition baseType, @Nonnull final SchemaPath path) {
return new ConcreteTypeBuilder<BinaryTypeDefinition>(baseType, path) {
+ @Nonnull
@Override
public BinaryTypeDefinition buildType() {
return new DerivedBinaryType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
private static ConcreteTypeBuilder<BitsTypeDefinition> concreteBitsBuilder(final BitsTypeDefinition baseType, final SchemaPath path) {
return new ConcreteTypeBuilder<BitsTypeDefinition>(baseType, path) {
+ @Nonnull
@Override
public BitsTypeDefinition buildType() {
return new DerivedBitsType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
private static ConcreteTypeBuilder<BooleanTypeDefinition> concreteBooleanBuilder(@Nonnull final BooleanTypeDefinition baseType, @Nonnull final SchemaPath path) {
return new ConcreteTypeBuilder<BooleanTypeDefinition>(baseType, path) {
+ @Nonnull
@Override
public BooleanTypeDefinition buildType() {
return new DerivedBooleanType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
private static ConcreteTypeBuilder<DecimalTypeDefinition> concreteDecimalBuilder(final DecimalTypeDefinition baseType, final SchemaPath path) {
return new ConcreteTypeBuilder<DecimalTypeDefinition>(baseType, path) {
+ @Nonnull
@Override
public DecimalTypeDefinition buildType() {
return new DerivedDecimalType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
private static ConcreteTypeBuilder<EmptyTypeDefinition> concreteEmptyBuilder(final EmptyTypeDefinition baseType, final SchemaPath path) {
return new ConcreteTypeBuilder<EmptyTypeDefinition>(baseType, path) {
+ @Nonnull
@Override
public EmptyTypeDefinition buildType() {
return new DerivedEmptyType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
private static ConcreteTypeBuilder<EnumTypeDefinition> concreteEnumerationBuilder(final EnumTypeDefinition baseType, final SchemaPath path) {
return new ConcreteTypeBuilder<EnumTypeDefinition>(baseType, path) {
+ @Nonnull
@Override
public EnumTypeDefinition buildType() {
return new DerivedEnumerationType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
private static ConcreteTypeBuilder<IdentityrefTypeDefinition> concreteIdentityrefBuilder(final IdentityrefTypeDefinition baseType, final SchemaPath path) {
return new ConcreteTypeBuilder<IdentityrefTypeDefinition>(baseType, path) {
+ @Nonnull
@Override
public IdentityrefTypeDefinition buildType() {
return new DerivedIdentityrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
private static ConcreteTypeBuilder<InstanceIdentifierTypeDefinition> concreteInstanceIdentifierBuilder(final InstanceIdentifierTypeDefinition baseType, final SchemaPath path) {
return new ConcreteTypeBuilder<InstanceIdentifierTypeDefinition>(baseType, path) {
+ @Nonnull
@Override
public InstanceIdentifierTypeDefinition buildType() {
return new DerivedInstanceIdentifierType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
private static ConcreteTypeBuilder<IntegerTypeDefinition> concreteIntegerBuilder(final IntegerTypeDefinition baseType, final SchemaPath path) {
return new ConcreteTypeBuilder<IntegerTypeDefinition>(baseType, path) {
+ @Nonnull
@Override
public IntegerTypeDefinition buildType() {
return new DerivedIntegerType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
private static ConcreteTypeBuilder<LeafrefTypeDefinition> concreteLeafrefBuilder(final LeafrefTypeDefinition baseType, final SchemaPath path) {
return new ConcreteTypeBuilder<LeafrefTypeDefinition>(baseType, path) {
+ @Nonnull
@Override
public LeafrefTypeDefinition buildType() {
return new DerivedLeafrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
private static ConcreteTypeBuilder<StringTypeDefinition> concreteStringBuilder(final StringTypeDefinition baseType, final SchemaPath path) {
return new ConcreteTypeBuilder<StringTypeDefinition>(baseType, path) {
+ @Nonnull
@Override
public StringTypeDefinition buildType() {
return new DerivedStringType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
private static ConcreteTypeBuilder<UnionTypeDefinition> concreteUnionBuilder(final UnionTypeDefinition baseType, final SchemaPath path) {
return new ConcreteTypeBuilder<UnionTypeDefinition>(baseType, path) {
+ @Nonnull
@Override
public DerivedUnionType buildType() {
return new DerivedUnionType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
private static ConcreteTypeBuilder<UnsignedIntegerTypeDefinition> concreteUnsignedBuilder(final UnsignedIntegerTypeDefinition baseType, final SchemaPath path) {
return new ConcreteTypeBuilder<UnsignedIntegerTypeDefinition>(baseType, path) {
+ @Nonnull
@Override
public UnsignedIntegerTypeDefinition buildType() {
return new DerivedUnsignedType(getBaseType(), getPath(), getDefaultValue(), getDescription(), getReference(),
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
}
+ @Nonnull
@Override
public List<Bit> getBits() {
return baseType().getBits();
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
}
+ @Nonnull
@Override
public Integer getFractionDigits() {
return baseType().getFractionDigits();
}
+ @Nonnull
@Override
public List<RangeConstraint> getRangeConstraints() {
return baseType().getRangeConstraints();
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
}
+ @Nonnull
@Override
public List<EnumPair> getValues() {
return baseType().getValues();
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ @Nonnull
@Override
public List<RangeConstraint> getRangeConstraints() {
return baseType().getRangeConstraints();
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
+ @Nonnull
@Override
public List<RangeConstraint> getRangeConstraints() {
return baseType().getRangeConstraints();
import com.google.common.base.Preconditions;
import java.util.List;
import java.util.Objects;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
this.unknownSchemaNodes = Preconditions.checkNotNull(unknownSchemaNodes);
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
return reference;
}
+ @Nonnull
@Override
public Status getStatus() {
return status;
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
super(baseType, path, unknownSchemaNodes);
}
+ @Nonnull
@Override
public List<Bit> getBits() {
return getBaseType().getBits();
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
super(baseType, path, unknownSchemaNodes, rangeConstraints);
}
+ @Nonnull
@Override
public Integer getFractionDigits() {
return getBaseType().getFractionDigits();
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
super(baseType, path, unknownSchemaNodes);
}
+ @Nonnull
@Override
public List<EnumPair> getValues() {
return getBaseType().getValues();
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
this.rangeConstraints = ImmutableList.copyOf(rangeConstraints);
}
+ @Nonnull
@Override
public List<RangeConstraint> getRangeConstraints() {
return rangeConstraints;
*/
package org.opendaylight.yangtools.yang.model.repo.util;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import com.google.common.util.concurrent.AsyncFunction;
private class Provider extends AbstractSchemaRepository {
@Override
- public SchemaContextFactory createSchemaContextFactory(final SchemaSourceFilter filter) {
+ public SchemaContextFactory createSchemaContextFactory(@Nonnull final SchemaSourceFilter filter) {
return null;
}
private class Consumer extends AbstractSchemaRepository {
@Override
- public SchemaContextFactory createSchemaContextFactory(final SchemaSourceFilter filter) {
+ public SchemaContextFactory createSchemaContextFactory(@Nonnull final SchemaSourceFilter filter) {
return null;
}
import java.util.Map.Entry;
import java.util.Set;
import java.util.function.Predicate;
+import javax.annotation.Nonnull;
import org.antlr.v4.runtime.ParserRuleContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangStatementParser.StatementContext;
import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
}
@Override
- public void onFailure(final Throwable t) {
+ public void onFailure(@Nonnull final Throwable t) {
LOG.debug("Failed to assemble sources", t);
}
});
}
@Override
- public ListenableFuture<SchemaContext> apply(final List<ASTSchemaSource> sources) throws SchemaResolutionException,
+ public ListenableFuture<SchemaContext> apply(
@Nonnull final List<ASTSchemaSource> sources) throws SchemaResolutionException,
SourceException, ReactorException {
final Map<SourceIdentifier, ASTSchemaSource> srcs = Maps.uniqueIndex(sources, getIdentifier);
final Map<SourceIdentifier, YangModelDependencyInfo> deps =
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactory;
private final LoadingCache<SchemaSourceFilter, SchemaContextFactory> cache =
CacheBuilder.newBuilder().softValues().build(new CacheLoader<SchemaSourceFilter, SchemaContextFactory>() {
@Override
- public SchemaContextFactory load(final SchemaSourceFilter key) {
+ public SchemaContextFactory load(@Nonnull final SchemaSourceFilter key) {
return new SharedSchemaContextFactory(SharedSchemaRepository.this, key);
}
});
}
@Override
- public SchemaContextFactory createSchemaContextFactory(final SchemaSourceFilter filter) {
+ public SchemaContextFactory createSchemaContextFactory(@Nonnull final SchemaSourceFilter filter) {
return cache.getUnchecked(filter);
}
import com.google.common.cache.LoadingCache;
import java.net.URI;
import java.net.URISyntaxException;
+import javax.annotation.Nonnull;
import javax.xml.transform.TransformerException;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.common.QName;
private static final LoadingCache<String, URI> URI_CACHE = CacheBuilder.newBuilder().weakValues().build(
new CacheLoader<String, URI>() {
@Override
- public URI load(final String key) throws URISyntaxException {
+ public URI load(@Nonnull final String key) throws URISyntaxException {
return new URI(key);
}
});
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
return argument;
}
+ @Nonnull
@Override
public StatementDefinition statementDefinition() {
return definition;
}
+ @Nonnull
@Override
public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
return substatements;
}
+ @Nonnull
@Override
public StatementSource getStatementSource() {
return source;
package org.opendaylight.yangtools.yang.parser.spi.meta;
import com.google.common.base.Preconditions;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
this.type = Preconditions.checkNotNull(publicDefinition);
}
+ @Nonnull
@Override
public final QName getStatementName() {
return type.getStatementName();
return type.getArgumentName();
}
+ @Nonnull
@Override
public final Class<? extends DeclaredStatement<?>> getDeclaredRepresentationClass() {
return type.getDeclaredRepresentationClass();
}
+ @Nonnull
@Override
public final Class<? extends EffectiveStatement<?,?>> getEffectiveRepresentationClass() {
return type.getEffectiveRepresentationClass();
@Nullable
<K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromLocalStorage(Class<N> type);
- @Nullable
<K, V, N extends IdentifierNamespace<K, V>> void addToLocalStorage(Class<N> type, K key, V value);
}
package org.opendaylight.yangtools.yang.parser.spi.meta;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
}
@Override
- public QName get(final QName identifier) {
+ public QName get(@Nonnull final QName identifier) {
throw new UnsupportedOperationException("Identifier/implementation API borkage");
}
*/
package org.opendaylight.yangtools.yang.parser.spi.meta;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
IdentifierNamespace<K, StmtContext<?, D, E>> {
@Override
@Nullable
- StmtContext<?, D, E> get(K key);
+ StmtContext<?, D, E> get(@Nonnull K key);
interface TreeScoped<K, D extends DeclaredStatement<?>, E extends EffectiveStatement<?, D>> extends
StatementNamespace<K, D, E> {
Class<N> type, KT key, VT value)
throws NamespaceNotAvailableException;
+ @Nonnull
@Override
StmtContext.Mutable<?, ?, ?> getRoot();
package org.opendaylight.yangtools.yang.parser.spi.source;
import java.net.URISyntaxException;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
*
*/
@Override
- @Nullable QNameModule get(String prefix);
+ @Nullable QNameModule get(@Nonnull String prefix);
/**
* Returns QNameModule (namespace + revision) associated with XML namespace
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QNameModule;
@Nullable
@Override
- public QNameModule get(String prefix) {
+ public QNameModule get(@Nonnull String prefix) {
return prefixToModuleMap.get(prefix);
}
@Nullable
@Override
- public StatementDefinition getByNamespaceAndLocalName(final URI namespace, @Nonnull final String localName) {
+ public StatementDefinition getByNamespaceAndLocalName(@Nonnull final URI namespace, @Nonnull final String localName) {
return noRevQNameToSupport.get(QName.create(namespace, null, localName));
}
import java.util.Iterator;
import java.util.Set;
import java.util.function.Function;
+import javax.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 false;
}
+ @Nonnull
@Override
public <C extends Mutable<?, ?, ?>, CT extends C> Prerequisite<C> mutatesCtx(final CT context, final ModelProcessingPhase phase) {
try {
}
}
+ @Nonnull
@Override
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, final ModelProcessingPhase phase) {
return requiresCtxImpl(context, namespace, key, 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, ?>> AbstractPrerequisite<StmtContext<?, D, ?>> requiresDeclaredCtx(
final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key) {
return requiresCtxImpl(context, namespace, key, FULL_DECLARATION);
}
+ @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 <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>> AbstractPrerequisite<StmtContext<?, ?, E>> requiresEffectiveCtx(
final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key) {
return requiresCtxImpl(contextImpl(context), namespace,key, EFFECTIVE_MODEL);
}
+ @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) {
}
+ @Nonnull
@Override
public <N extends IdentifierNamespace<?, ?>> Prerequisite<Mutable<?, ?, ?>> mutatesNs(final Mutable<?, ?, ?> context,
final Class<N> namespace) {
}
}
+ @Nonnull
@Override
public <T extends Mutable<?, ?, ?>> Prerequisite<T> mutatesEffectiveCtx(final T stmt) {
return mutatesCtx(stmt, EFFECTIVE_MODEL);
}
+ @Nonnull
@Override
public <K, E extends EffectiveStatement<?, ?>, N extends IdentifierNamespace<K, ? extends StmtContext<?, ?, ?>>> AbstractPrerequisite<Mutable<?, ?, E>> mutatesEffectiveCtx(
final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key) {
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
// NOOP
}
+ @Nonnull
public final <K,V, KT extends K, N extends IdentifierNamespace<K, V>> V getFromNamespace(final Class<N> type, final KT key)
throws NamespaceNotAvailableException {
return getBehaviourRegistry().getNamespaceBehaviour(type).getFrom(this,key);
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
/**
* @return this as its own root
*/
+ @Nonnull
@Override
public RootStatementContext<?, ?, ?> getRoot() {
return this;
return copy;
}
+ @Nonnull
@Override
public Optional<SchemaPath> getSchemaPath() {
return Optional.of(SchemaPath.ROOT);
/**
* @return root context of statement
*/
+ @Nonnull
@Override
public abstract RootStatementContext<?, ?, ?> getRoot();
/**
* @return origin of statement
*/
+ @Nonnull
@Override
public StatementSource getStatementSource() {
return statementDeclSource.getStatementSource();
/**
* @return reference of statement source
*/
+ @Nonnull
@Override
public StatementSourceReference getStatementSourceReference() {
return statementDeclSource;
return Collections.unmodifiableCollection(input);
}
+ @Nonnull
@Override
public Collection<StatementContextBase<?, ?, ?>> declaredSubstatements() {
return maybeWrap(declared);
}
+ @Nonnull
@Override
public Collection<StatementContextBase<?, ?, ?>> effectiveSubstatements() {
return maybeWrap(effective);
/**
* @see StatementSupport#getPublicView()
*/
+ @Nonnull
@Override
public StatementDefinition getPublicDefinition() {
return definition().getPublicView();
}
@Override
- public void startStatement(final int childId, final QName name, final String argument,
- final StatementSourceReference ref) {
+ public void startStatement(final int childId, @Nonnull final QName name, final String argument,
+ @Nonnull final StatementSourceReference ref) {
deferredCreate();
current = ctx.createDeclaredChild(parent, childId, name, argument, ref);
}
@Override
- public void endStatement(final StatementSourceReference ref) {
+ public void endStatement(@Nonnull final StatementSourceReference ref) {
deferredCreate();
Preconditions.checkState(parent != null);
parent.endDeclared(ref,phase);
import java.util.ArrayList;
import java.util.Collection;
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.model.api.Rfc6020Mapping;
return parent.getBehaviourRegistry();
}
+ @Nonnull
@Override
public RootStatementContext<?, ?, ?> getRoot() {
return parent.getRoot();
return maybeParentPath.orNull();
}
+ @Nonnull
@Override
public Optional<SchemaPath> getSchemaPath() {
SchemaPath local = schemaPath;
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
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;
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);
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);
import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
}
}
+ @Nonnull
@Override
public QName getName() {
return argument();
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);
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
}
}
+ @Nonnull
@Override
public QName getName() {
return argument();
return argument();
}
+ @Nonnull
@Override
public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
return allDeclared(DataDefinitionStatement.class);
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
}
}
+ @Nonnull
@Override
public QName getName() {
return argument();
import java.util.Collection;
import java.util.Optional;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
}
}
+ @Nonnull
@Override
public String getModule() {
return argument();
}
+ @Nonnull
@Override
public PrefixStatement getPrefix() {
return firstDeclared(PrefixStatement.class);
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
return firstDeclared(ReferenceStatement.class);
}
+ @Nonnull
@Override
public String getName() {
return argument().getLocalName();
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
}
}
+ @Nonnull
@Override
public String getName() {
return argument();
}
+ @Nonnull
@Override
public Collection<? extends BitStatement> getBits() {
return allDeclared(BitStatement.class);
import com.google.common.collect.ImmutableMap.Builder;
import java.util.Collection;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
return argument;
}
+ @Nonnull
@Override
public Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
return ImmutableList.of();
}
+ @Nonnull
@Override
public StatementDefinition statementDefinition() {
return Rfc6020Mapping.TYPE;
}
+ @Nonnull
@Override
public String getName() {
return argument;
}
+ @Nonnull
@Override
public StatementSource getStatementSource() {
return StatementSource.DECLARATION;
return allDeclared(IfFeatureStatement.class);
}
+ @Nonnull
@Override
public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
return allDeclared(DataDefinitionStatement.class);
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
}
@Override
- public StmtContext<?, D, E> get(final QName key) {
+ public StmtContext<?, D, E> get(@Nonnull final QName key) {
// TODO Auto-generated method stub
return null;
}
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
}
}
+ @Nonnull
@Override
public QName getName() {
return argument();
return firstDeclared(WhenStatement.class);
}
+ @Nonnull
@Override
public Collection<? extends IfFeatureStatement> getIfFeatures() {
return allDeclared(IfFeatureStatement.class);
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);
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
}
}
+ @Nonnull
@Override
public String getName() {
return argument();
}
+ @Nonnull
@Override
public FractionDigitsStatement getFractionDigits() {
return firstDeclared(FractionDigitsStatement.class);
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
// Hidden
}
+ @Nonnull
@Override
public final StatementDefinition statementDefinition() {
return getDeclared().statementDefinition();
return getDeclared().argument();
}
+ @Nonnull
@Override
public final StatementSource getStatementSource() {
return getDeclared().getStatementSource();
}
@Override
- public final <K, V, N extends IdentifierNamespace<K, V>> V get(final Class<N> namespace, final K identifier) {
+ public final <K, V, N extends IdentifierNamespace<K, V>> V get(@Nonnull final Class<N> namespace, @Nonnull final K identifier) {
throw new UnsupportedOperationException("Not implemented yet.");
}
@Override
- public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(final Class<N> namespace) {
+ public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(@Nonnull final Class<N> namespace) {
throw new UnsupportedOperationException("Not implemented yet.");
}
+ @Nonnull
@Override
public final Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
return ImmutableList.of();
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.Objects;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
abstract EffectiveStatement<Boolean, ConfigStatement> toEffective();
+ @Nonnull
@Override
public final Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
return ImmutableList.of();
}
+ @Nonnull
@Override
public final StatementDefinition statementDefinition() {
return Rfc6020Mapping.CONFIG;
return Boolean.valueOf(getValue());
}
+ @Nonnull
@Override
public final StatementSource getStatementSource() {
return StatementSource.DECLARATION;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
// Hidden
}
+ @Nonnull
@Override
public final StatementDefinition statementDefinition() {
return getDeclared().statementDefinition();
return getDeclared().argument();
}
+ @Nonnull
@Override
public final StatementSource getStatementSource() {
return getDeclared().getStatementSource();
}
@Override
- public final <K, V, N extends IdentifierNamespace<K, V>> V get(final Class<N> namespace, final K identifier) {
+ public final <K, V, N extends IdentifierNamespace<K, V>> V get(@Nonnull final Class<N> namespace, @Nonnull final K identifier) {
throw new UnsupportedOperationException("Not implemented yet.");
}
@Override
- public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(final Class<N> namespace) {
+ public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(@Nonnull final Class<N> namespace) {
throw new UnsupportedOperationException("Not implemented yet.");
}
+ @Nonnull
@Override
public final Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
return ImmutableList.of();
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.Objects;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
abstract class EmptyMandatoryStatement implements MandatoryStatement {
static final MandatoryStatement FALSE = new EmptyMandatoryStatement() {
+ @Nonnull
@Override
public Boolean getValue() {
return Boolean.FALSE;
};
static final MandatoryStatement TRUE = new EmptyMandatoryStatement() {
+ @Nonnull
@Override
public Boolean getValue() {
return Boolean.TRUE;
abstract EffectiveStatement<Boolean, MandatoryStatement> toEffective();
+ @Nonnull
@Override
public final Collection<? extends DeclaredStatement<?>> declaredSubstatements() {
return ImmutableList.of();
}
+ @Nonnull
@Override
public final StatementDefinition statementDefinition() {
return Rfc6020Mapping.MANDATORY;
return getValue();
}
+ @Nonnull
@Override
public final StatementSource getStatementSource() {
return StatementSource.DECLARATION;
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
}
}
+ @Nonnull
@Override
public String getName() {
return argument();
}
+ @Nonnull
@Override
public Collection<? extends EnumStatement> getEnums() {
return allDeclared(EnumStatement.class);
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
return firstDeclared(ReferenceStatement.class);
}
+ @Nonnull
@Override
public String getName() {
return argument();
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
}
}
+ @Nonnull
@Override
public String getValue() {
return argument();
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
}
}
+ @Nonnull
@Override
public String getValue() {
return argument();
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
return firstDeclared(ReferenceStatement.class);
}
+ @Nonnull
@Override
public Collection<? extends IfFeatureStatement> getIfFeatures() {
return allDeclared(IfFeatureStatement.class);
}
+ @Nonnull
@Override
public QName getName() {
return argument();
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
}
+ @Nonnull
@Override
public QName getName() {
return argument();
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 String getName() {
return argument();
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
return firstDeclared(BaseStatement.class);
}
+ @Nonnull
@Override
public QName getName() {
return argument();
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
}
}
+ @Nonnull
@Override
public QName getName() {
return argument();
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
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.RevisionDateStatement;
super(context);
}
+ @Nonnull
@Override
public String getModule() {
return rawArgument();
}
+ @Nonnull
@Override
public PrefixStatement getPrefix() {
return firstDeclared(PrefixStatement.class);
import java.util.Collection;
import java.util.Date;
import java.util.Optional;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
}
}
+ @Nonnull
@Override
public String getModule() {
return argument();
}
+ @Nonnull
@Override
public PrefixStatement getPrefix() {
return firstDeclared(PrefixStatement.class);
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
}
}
+ @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);
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement;
}
}
+ @Nonnull
@Override
public String getName() {
return argument();
return allDeclared(MustStatement.class);
}
+ @Nonnull
@Override
public TypeStatement getType() {
return firstDeclared(TypeStatement.class);
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
}
}
+ @Nonnull
@Override
public String getName() {
return argument();
}
+ @Nonnull
@Override
public PathStatement getPath() {
return firstDeclared(PathStatement.class);
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
return firstDeclared(ReferenceStatement.class);
}
+ @Nonnull
@Override
public List<LengthConstraint> getValue() {
return argument();
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);
return firstDeclared(KeyStatement.class);
}
+ @Nonnull
@Override
public Collection<? extends UniqueStatement> getUnique() {
return allDeclared(UniqueStatement.class);
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
}
}
+ @Nonnull
@Override
public String getValue() {
return argument();
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement;
}
}
+ @Nonnull
@Override
public Integer getValue() {
return argument();
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+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;
super(context);
}
+ @Nonnull
@Override
public String getName() {
return rawArgument();
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.stmt.rfc6020;
import java.net.URI;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
super(context);
}
+ @Nonnull
@Override
public URI getUri() {
return argument();
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
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.Rfc6020Mapping;
}
}
+ @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);
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RangeStatement;
}
}
+ @Nonnull
@Override
public String getName() {
return argument();
}
+ @Nonnull
@Override
public RangeStatement getRange() {
return firstDeclared(RangeStatement.class);
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
}
}
+ @Nonnull
@Override
public String getValue() {
return argument();
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement;
}
}
+ @Nonnull
@Override
public String getText() {
return argument();
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
}
}
+ @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);
import com.google.common.base.Optional;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
return firstDeclared(ReferenceStatement.class);
}
+ @Nonnull
@Override
public PatternConstraint getValue() {
return argument();
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
super(context);
}
+ @Nonnull
@Override
public String getValue() {
return rawArgument();
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement;
}
}
+ @Nonnull
@Override
public String getValue() {
return argument();
import java.math.BigDecimal;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
return firstDeclared(ReferenceStatement.class);
}
+ @Nonnull
@Override
public List<RangeConstraint> getRange() {
return argument();
import java.text.ParseException;
import java.util.Date;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
}
}
+ @Nonnull
@Override
public Date getDate() {
return argument();
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
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.Rfc6020Mapping;
return argument();
}
+ @Nonnull
@Override
public Collection<? extends TypedefStatement> getTypedefs() {
return allDeclared(TypedefStatement.class);
}
+ @Nonnull
@Override
public Collection<? extends GroupingStatement> getGroupings() {
return allDeclared(GroupingStatement.class);
return firstDeclared(OutputStatement.class);
}
+ @Nonnull
@Override
public Collection<? extends IfFeatureStatement> getIfFeatures() {
return allDeclared(IfFeatureStatement.class);
import java.util.Collection;
import java.util.Iterator;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
@Override
public StmtContext.Mutable<?, ?, EffectiveStatement<?, ?>> get(
- final SchemaNodeIdentifier key) {
+ @Nonnull final SchemaNodeIdentifier key) {
throw new UnsupportedOperationException("Direct access to namespace is not supported");
}
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
}
}
+ @Nonnull
@Override
public Status getValue() {
return argument();
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LengthStatement;
}
}
+ @Nonnull
@Override
public String getName() {
return argument();
return firstDeclared(LengthStatement.class);
}
+ @Nonnull
@Override
public Collection<? extends PatternStatement> getPatterns() {
return allDeclared(PatternStatement.class);
import java.util.Date;
import java.util.Optional;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
}
}
+ @Nonnull
@Override
public String getName() {
return rawArgument();
return firstDeclared(YangVersionStatement.class);
}
+ @Nonnull
@Override
public BelongsToStatement getBelongsTo() {
return firstDeclared(BelongsToStatement.class);
return QName.create(namespace, revision, localName).intern();
}
+ @Nonnull
@Override
public QName getStatementName() {
return name;
return type;
}
+ @Nonnull
@Override
public Class<? extends EffectiveStatement<?, ?>> getEffectiveRepresentationClass() {
return effectiveType;
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
return firstDeclared(ReferenceStatement.class);
}
+ @Nonnull
@Override
public TypeStatement getType() {
return firstDeclared(TypeStatement.class);
return firstDeclared(UnitsStatement.class);
}
+ @Nonnull
@Override
public QName getName() {
return argument();
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
import java.util.Collection;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
}
}
+ @Nonnull
@Override
public String getName() {
return argument();
}
+ @Nonnull
@Override
public Collection<? extends TypeStatement> getTypes() {
return allDeclared(TypeStatement.class);
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
}
}
+ @Nonnull
@Override
public String getName() {
return argument();
import java.util.ArrayList;
import java.util.Collection;
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.model.api.Rfc6020Mapping;
}
+ @Nonnull
@Override
public QName getName() {
return argument();
return firstDeclared(WhenStatement.class);
}
+ @Nonnull
@Override
public Collection<? extends IfFeatureStatement> getIfFeatures() {
return allDeclared(IfFeatureStatement.class);
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);
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
return reference;
}
+ @Nonnull
@Override
public final Status getStatus() {
return status;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.common.QName;
return identities;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import java.util.NavigableSet;
import java.util.Set;
import java.util.TreeSet;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
return null;
}
+ @Nonnull
@Override
public QName getQName() {
return SchemaContext.NAME;
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return SchemaPath.ROOT;
return null;
}
+ @Nonnull
@Override
public Status getStatus() {
return Status.CURRENT;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
final List<UnknownSchemaNode> result = new ArrayList<>();
import com.google.common.collect.ImmutableList;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
this.unknownNodes = listBuilder.build();
}
+ @Nonnull
@Override
public QName getQName() {
return path.getLastComponent();
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return path;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
}
}
+ @Nonnull
@Override
public QName getQName() {
return path.getLastComponent();
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return path;
return augmentations;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import com.google.common.annotations.Beta;
import java.util.Objects;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
path = ctx.getParentContext().getSchemaPath().get().createChild(getNodeType());
}
+ @Nonnull
@Override
public QName getQName() {
return getNodeType();
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return path;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
return whenCondition;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
}
@Override
- public int compareTo(final AugmentEffectiveStatementImpl o) {
+ public int compareTo(@Nonnull final AugmentEffectiveStatementImpl o) {
checkNotNull(o);
Iterator<QName> thisIt = this.targetPath.getPathFromRoot().iterator();
Iterator<QName> otherIt = o.getTargetPath().getPathFromRoot().iterator();
import java.util.List;
import java.util.Objects;
import java.util.Set;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
return caseShorthandNode.getConstraints();
}
+ @Nonnull
@Override
public QName getQName() {
return caseShorthandNode.getQName();
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return path;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return ImmutableList.of();
return caseShorthandNode.getReference();
}
+ @Nonnull
@Override
public Status getStatus() {
return caseShorthandNode.getStatus();
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
import com.google.common.base.Verify;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
ctx);
}
+ @Nonnull
@Override
public final StatementDefinition statementDefinition() {
return declaredInstance.statementDefinition();
return argument;
}
+ @Nonnull
@Override
public final StatementSource getStatementSource() {
return statementSource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
}
@Override
- public final <K, V, N extends IdentifierNamespace<K, V>> V get(final Class<N> namespace, final K identifier) {
+ public final <K, V, N extends IdentifierNamespace<K, V>> V get(@Nonnull final Class<N> namespace, @Nonnull final K identifier) {
throw new UnsupportedOperationException("Not implemented yet.");
}
@Override
- public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(final Class<N> namespace) {
+ public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(@Nonnull final Class<N> namespace) {
throw new UnsupportedOperationException("Not implemented yet.");
}
+ @Nonnull
@Override
public final Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
return substatements;
import java.util.Deque;
import java.util.List;
import java.util.Objects;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
return super.initSubstatements(substatementsInit);
}
+ @Nonnull
@Override
public QName getQName() {
return qname;
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return schemaPath;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import com.google.common.collect.ImmutableList.Builder;
import java.util.List;
import java.util.Objects;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
unknownNodes = b.build();
}
+ @Nonnull
@Override
public QName getQName() {
return qname;
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return path;
return addedByUses;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import java.util.List;
import java.util.Objects;
import java.util.Set;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
this.augmentations = ImmutableSet.copyOf(augmentationsInit);
}
+ @Nonnull
@Override
public QName getQName() {
return qname;
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return path;
return augmentations;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
return refineTargetNode;
}
+ @Nonnull
@Override
public QName getQName() {
return qname;
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return path;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
import com.google.common.annotations.Beta;
import java.util.Objects;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
path = ctx.getParentContext().getSchemaPath().get().createChild(getNodeType());
}
+ @Nonnull
@Override
public QName getQName() {
return getNodeType();
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return path;
import java.util.Collection;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
typeDefinition = builder.build();
}
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return typeDefinition;
}
@Override
- public <K, V, N extends IdentifierNamespace<K, V>> V get(final Class<N> namespace, final K identifier) {
+ public <K, V, N extends IdentifierNamespace<K, V>> V get(@Nonnull final Class<N> namespace, @Nonnull final K identifier) {
return TypeDefEffectiveStatementImpl.this.get(namespace, identifier);
}
@Override
- public <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(final Class<N> namespace) {
+ public <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(@Nonnull final Class<N> namespace) {
return TypeDefEffectiveStatementImpl.this.getAll(namespace);
}
+ @Nonnull
@Override
public Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
// FIXME: this is tricky
throw new UnsupportedOperationException("Not implemented yet");
}
+ @Nonnull
@Override
public StatementDefinition statementDefinition() {
return Rfc6020Mapping.TYPE;
return getQName().getLocalName();
}
+ @Nonnull
@Override
public StatementSource getStatementSource() {
return StatementSource.CONTEXT;
}
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return TypeDefEffectiveStatementImpl.this.getTypeDefinition();
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
import com.google.common.base.Verify;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
Verify.verify(declareInstance == null, "Statement %s resulted in declared statement %s", declareInstance);
}
+ @Nonnull
@Override
public final StatementDefinition statementDefinition() {
return statementDefinition;
return argument;
}
+ @Nonnull
@Override
public final StatementSource getStatementSource() {
return statementSource;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
return extension;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
import java.util.Objects;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
path = ctx.getParentContext().getSchemaPath().get().createChild(maybeQNameArgument);
}
+ @Nonnull
@Override
public QName getQName() {
return maybeQNameArgument;
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return path;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
this.whenCondition = (whenStmt == null) ? null : whenStmt.argument();
}
+ @Nonnull
@Override
public SchemaPath getGroupingPath() {
return groupingPath;
}
+ @Nonnull
@Override
public Set<AugmentationSchema> getAugmentations() {
return augmentations;
return addedByUses;
}
+ @Nonnull
@Override
public Map<SchemaPath, SchemaNode> getRefines() {
return refines;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownNodes;
}
+ @Nonnull
@Override
public Optional<RevisionAwareXPath> getWhenCondition() {
return Optional.fromNullable(whenCondition);
import com.google.common.base.Preconditions;
import java.util.Objects;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.YangModeledAnyXmlSchemaNode;
schemaOfAnyXmlData = Preconditions.checkNotNull(contentSchema);
}
+ @Nonnull
@Override
public ContainerSchemaNode getSchemaOfAnyXmlData() {
return schemaOfAnyXmlData;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.Map;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
}
@Override
- public final <K, V, N extends IdentifierNamespace<K, V>> V get(final Class<N> namespace, final K identifier) {
+ public final <K, V, N extends IdentifierNamespace<K, V>> V get(@Nonnull final Class<N> namespace,
+ @Nonnull final K identifier) {
// TODO Auto-generated method stub
return null;
}
@Override
- public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(final Class<N> namespace) {
+ public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(@Nonnull final Class<N> namespace) {
// TODO Auto-generated method stub
return null;
}
+ @Nonnull
@Override
public final Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
return ImmutableList.of();
}
+ @Nonnull
@Override
public final StatementDefinition statementDefinition() {
return Rfc6020Mapping.TYPE;
return getTypeDefinition().getQName().getLocalName();
}
+ @Nonnull
@Override
public final StatementSource getStatementSource() {
return StatementSource.CONTEXT;
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
typeDefinition = builder.build();
}
+ @Nonnull
@Override
public final T getTypeDefinition() {
return typeDefinition;
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
}
}
+ @Nonnull
@Override
public BinaryTypeDefinition getTypeDefinition() {
return typeDefinition;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
return schemaPath;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.BitsSpecification;
typeDefinition = builder.build();
}
+ @Nonnull
@Override
public BitsTypeDefinition getTypeDefinition() {
return typeDefinition;
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
}
public static final TypeEffectiveStatement<TypeStatement> BINARY = new AbstractBuiltinEffectiveStatement() {
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return BaseTypes.binaryType();
}
};
public static final TypeEffectiveStatement<TypeStatement> BOOLEAN = new AbstractBuiltinEffectiveStatement() {
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return BaseTypes.booleanType();
}
};
public static final TypeEffectiveStatement<TypeStatement> EMPTY = new AbstractBuiltinEffectiveStatement() {
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return BaseTypes.emptyType();
}
};
public static final TypeEffectiveStatement<TypeStatement> INSTANCE_IDENTIFIER = new AbstractBuiltinEffectiveStatement() {
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return BaseTypes.instanceIdentifierType();
}
};
public static final TypeEffectiveStatement<TypeStatement> INT8 = new AbstractBuiltinEffectiveStatement() {
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return BaseTypes.int8Type();
}
};
public static final TypeEffectiveStatement<TypeStatement> INT16 = new AbstractBuiltinEffectiveStatement() {
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return BaseTypes.int16Type();
}
};
public static final TypeEffectiveStatement<TypeStatement> INT32 = new AbstractBuiltinEffectiveStatement() {
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return BaseTypes.int32Type();
}
};
public static final TypeEffectiveStatement<TypeStatement> INT64 = new AbstractBuiltinEffectiveStatement() {
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return BaseTypes.int64Type();
}
};
public static final TypeEffectiveStatement<TypeStatement> STRING = new AbstractBuiltinEffectiveStatement() {
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return BaseTypes.stringType();
}
};
public static final TypeEffectiveStatement<TypeStatement> UINT8 = new AbstractBuiltinEffectiveStatement() {
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return BaseTypes.uint8Type();
}
};
public static final TypeEffectiveStatement<TypeStatement> UINT16 = new AbstractBuiltinEffectiveStatement() {
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return BaseTypes.uint16Type();
}
};
public static final TypeEffectiveStatement<TypeStatement> UINT32 = new AbstractBuiltinEffectiveStatement() {
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return BaseTypes.uint32Type();
}
};
public static final TypeEffectiveStatement<TypeStatement> UINT64 = new AbstractBuiltinEffectiveStatement() {
+ @Nonnull
@Override
public TypeDefinition<?> getTypeDefinition() {
return BaseTypes.uint64Type();
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.Decimal64Specification;
typeDefinition = builder.build();
}
+ @Nonnull
@Override
public DecimalTypeDefinition getTypeDefinition() {
return typeDefinition;
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
typeDefinition = builder.build();
}
+ @Nonnull
@Override
public DecimalTypeDefinition getTypeDefinition() {
return typeDefinition;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.List;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
return declaredValue;
}
+ @Nonnull
@Override
public List<UnknownSchemaNode> getUnknownSchemaNodes() {
return unknownSchemaNodes;
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.EnumSpecification;
typeDefinition = builder.build();
}
+ @Nonnull
@Override
public EnumTypeDefinition getTypeDefinition() {
return typeDefinition;
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
typeDefinition = builder.build();
}
+ @Nonnull
@Override
public IdentityrefTypeDefinition getTypeDefinition() {
return typeDefinition;
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.InstanceIdentifierSpecification;
typeDefinition = builder.build();
}
+ @Nonnull
@Override
public InstanceIdentifierTypeDefinition getTypeDefinition() {
return typeDefinition;
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
typeDefinition = builder.build();
}
+ @Nonnull
@Override
public InstanceIdentifierTypeDefinition getTypeDefinition() {
return typeDefinition;
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
}
}
+ @Nonnull
@Override
public IntegerTypeDefinition getTypeDefinition() {
return typeDefinition;
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.LeafrefSpecification;
typeDefinition = builder.build();
}
+ @Nonnull
@Override
public LeafrefTypeDefinition getTypeDefinition() {
return typeDefinition;
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
}
}
+ @Nonnull
@Override
public StringTypeDefinition getTypeDefinition() {
return typeDefinition;
*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.UnionSpecification;
typeDefinition = builder.build();
}
+ @Nonnull
@Override
public UnionTypeDefinition getTypeDefinition() {
return typeDefinition;
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
typeDefinition = builder.build();
}
+ @Nonnull
@Override
public UnsignedIntegerTypeDefinition getTypeDefinition() {
return typeDefinition;
return semVerId;
}
+ @Nonnull
@Override
public Class<? extends SchemaSourceRepresentation> getType() {
return ASTSchemaSource.class;
import com.google.common.util.concurrent.Futures;
import java.io.IOException;
import java.io.InputStream;
+import javax.annotation.Nonnull;
import org.antlr.v4.runtime.ParserRuleContext;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
public static final class TextToASTTransformation implements Transformation<YangTextSchemaSource, ASTSchemaSource> {
@Override
- public CheckedFuture<ASTSchemaSource, SchemaSourceException> apply(final YangTextSchemaSource input) throws IOException, YangSyntaxErrorException {
+ public CheckedFuture<ASTSchemaSource, SchemaSourceException> apply(@Nonnull final YangTextSchemaSource input) throws IOException, YangSyntaxErrorException {
try (InputStream is = input.openStream()) {
final ParserRuleContext ctx = new YangStatementSourceImpl(is).getYangAST();
LOG.debug("Model {} parsed successfully", input);
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;
+import javax.annotation.Nonnull;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
}
@Override
- public void onFailure(final Throwable t) {
+ public void onFailure(@Nonnull final Throwable t) {
// Creation of schema context fails, since we do not provide regular sources, but we just want to check cache
final List<File> cachedSchemas = Arrays.asList(storageDir.listFiles());
assertEquals(1, cachedSchemas.size());
import com.google.common.annotations.Beta;
import java.util.Objects;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
return valueFromNamespace;
}
+ @Nonnull
@Override
public QName getQName() {
return getNodeType();
}
+ @Nonnull
@Override
public SchemaPath getPath() {
return path;
return QName.create(namespace, revision, localName).intern();
}
+ @Nonnull
@Override
public QName getStatementName() {
return name;
return type;
}
+ @Nonnull
@Override
public Class<? extends EffectiveStatement<?, ?>> getEffectiveRepresentationClass() {
return effectiveType;
Code Review / yangtools.git / commitdiff