if (path.isWildcarded()) {
return Optional.absent();
}
- return (Optional<DataObject>) getCodec().deserializeFunction(path).apply(
- Optional.<NormalizedNode<?, ?>>of(data));
+ return (Optional<DataObject>) getCodec().deserializeFunction(path).apply(Optional.of(data));
}
@Override
@Override
public final T build() {
checkAllRequiredServices();
- return createInstance(ImmutableClassToInstanceMap.<D,D>copyOf(delegates));
+ return createInstance(ImmutableClassToInstanceMap.copyOf(delegates));
}
}
for (final Class<? extends D> reqDeleg : builder.getRequiredDelegates()) {
final D deleg = getDelegate(reqDeleg);
if (deleg != null) {
- builder.addDelegate(reqDeleg,deleg);
+ builder.addDelegate(reqDeleg, deleg);
} else {
return Optional.absent();
}
}
- return Optional.<T>of(builder.build());
+ return Optional.of(builder.build());
}
@Nullable
@Nonnull
protected abstract AdapterBuilder<? extends T, D> createBuilder(Class<? extends T> key);
-
}
public class BindingDOMCursorAwareWriteTransactionAdapter<T extends DOMDataTreeCursorAwareTransaction>
implements CursorAwareWriteTransaction {
- private T delegate;
- private BindingToNormalizedNodeCodec codec;
+ private final T delegate;
+ private final BindingToNormalizedNodeCodec codec;
public BindingDOMCursorAwareWriteTransactionAdapter(final T delegate, final BindingToNormalizedNodeCodec codec) {
import org.opendaylight.mdsal.dom.api.DOMDataTreeService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-class BindingDOMDataTreeServiceAdapter implements DataTreeService {
+final class BindingDOMDataTreeServiceAdapter implements DataTreeService {
private final DOMDataTreeService delegate;
private final BindingToNormalizedNodeCodec codec;
@Override
public ListenableFuture<? extends Object> offerNotification(final Notification notification,
- final int timeout, final TimeUnit unit) throws InterruptedException {
+ final int timeout, final TimeUnit unit) throws InterruptedException {
ListenableFuture<?> offerResult = domPublishService.offerNotification(
toDomNotification(notification), timeout, unit);
return DOMNotificationPublishService.REJECTED.equals(offerResult)
@Override
public Set<Class<? extends DOMService>> getRequiredDelegates() {
- return ImmutableSet.<Class<? extends DOMService>>of(DOMNotificationPublishService.class);
+ return ImmutableSet.of(DOMNotificationPublishService.class);
}
@Override
public class BindingMountPointAdapter implements MountPoint {
private final InstanceIdentifier<?> identifier;
- private LoadingCache<Class<? extends BindingService>, Optional<BindingService>> services;
+ private final LoadingCache<Class<? extends BindingService>, Optional<BindingService>> services;
public BindingMountPointAdapter(final BindingToNormalizedNodeCodec codec, final DOMMountPoint domMountPoint) {
identifier = codec.getCodecRegistry().fromYangInstanceIdentifier(domMountPoint.getIdentifier());
*/
package org.opendaylight.mdsal.binding.dom.adapter;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
}
public NormalizedNode<?, ?> getDefaultNodeFor(final YangInstanceIdentifier parentMapPath) {
- final BindingCodecTreeNode<?> mapCodec = codecRegistry.getCodecContext().getSubtreeCodec(parentMapPath);
+ final BindingCodecTreeNode<?> mapCodec = requireNonNull(
+ codecRegistry.getCodecContext().getSubtreeCodec(parentMapPath),
+ "Codec not found for yang instance identifier: " + parentMapPath);
final Object schema = mapCodec.getSchema();
if (schema instanceof ListSchemaNode) {
final ListSchemaNode castedSchema = (ListSchemaNode) schema;
final Collection<DataTreeCandidate> domChanges, final LogicalDatastoreType datastoreType) {
final List<DataTreeModification<T>> result = new ArrayList<>(domChanges.size());
for (final DataTreeCandidate domChange : domChanges) {
- result.add(LazyDataTreeModification.<T>create(codec, domChange, datastoreType));
+ result.add(LazyDataTreeModification.create(codec, domChange, datastoreType));
}
return result;
}
* accessing it.
*/
if (contextRef.getIdentifier().equals(child)) {
- return Optional.<DataContainerChild<? extends PathArgument, ?>>of(contextRef);
+ return Optional.of(contextRef);
}
return super.getChild(child);
}
import org.junit.Assert;
-public class AssertCollections {
+public final class AssertCollections {
+
+ private AssertCollections() {
+ }
public static void assertEmpty(final Collection<?> set) {
Assert.assertTrue(set.isEmpty());
private SchemaContext schemaContext;
- ListenerRegistry<SchemaContextListener> listeners = ListenerRegistry.create();
+ final ListenerRegistry<SchemaContextListener> listeners = ListenerRegistry.create();
@Override
public synchronized SchemaContext getGlobalContext() {