--- /dev/null
+/*
+ * Copyright (c) 2018 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.dom.adapter;
+
+import static java.util.Objects.requireNonNull;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.opendaylight.yangtools.concepts.Delegator;
+
+@NonNullByDefault
+abstract class AbstractBindingAdapter<T> implements Delegator<T> {
+ private final BindingToNormalizedNodeCodec codec;
+ private final T delegate;
+
+ AbstractBindingAdapter(final BindingToNormalizedNodeCodec codec, final T delegate) {
+ this.codec = requireNonNull(codec);
+ this.delegate = requireNonNull(delegate);
+ }
+
+ @Override
+ public final T getDelegate() {
+ return delegate;
+ }
+
+ protected final BindingToNormalizedNodeCodec getCodec() {
+ return codec;
+ }
+}
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.yangtools.concepts.Delegator;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public abstract class AbstractForwardedDataBroker implements Delegator<DOMDataBroker> {
+public abstract class AbstractForwardedDataBroker extends AbstractBindingAdapter<@NonNull DOMDataBroker> {
private static final Logger LOG = LoggerFactory.getLogger(AbstractForwardedDataBroker.class);
- // The Broker to whom we do all forwarding
- private final DOMDataBroker domDataBroker;
- private final BindingToNormalizedNodeCodec codec;
-
protected AbstractForwardedDataBroker(final DOMDataBroker domDataBroker, final BindingToNormalizedNodeCodec codec) {
- this.domDataBroker = requireNonNull(domDataBroker);
- this.codec = requireNonNull(codec);
- }
-
- protected BindingToNormalizedNodeCodec getCodec() {
- return codec;
- }
-
- @Override
- public DOMDataBroker getDelegate() {
- return domDataBroker;
+ super(codec, domDataBroker);
}
protected Map<InstanceIdentifier<?>, DataObject> toBinding(final InstanceIdentifier<?> path,
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.mdsal.binding.dom.adapter;
import com.google.common.util.concurrent.CheckedFuture;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class BindingDOMCursorAwareWriteTransactionAdapter<T extends DOMDataTreeCursorAwareTransaction>
- implements CursorAwareWriteTransaction {
-
- private final T delegate;
- private final BindingToNormalizedNodeCodec codec;
+ extends AbstractBindingAdapter<T> implements CursorAwareWriteTransaction {
public BindingDOMCursorAwareWriteTransactionAdapter(final T delegate, final BindingToNormalizedNodeCodec codec) {
-
- this.delegate = delegate;
- this.codec = codec;
+ super(codec, delegate);
}
@Nullable
@Override
public <P extends DataObject> DataTreeWriteCursor createCursor(final DataTreeIdentifier<P> path) {
- final YangInstanceIdentifier yPath = codec.toNormalized(path.getRootIdentifier());
- final DOMDataTreeWriteCursor cursor = delegate.createCursor(
+ final YangInstanceIdentifier yPath = getCodec().toNormalized(path.getRootIdentifier());
+ final DOMDataTreeWriteCursor cursor = getDelegate().createCursor(
new DOMDataTreeIdentifier(path.getDatastoreType(), yPath));
- return new BindingDOMDataTreeWriteCursorAdapter<>(path, cursor, codec);
+ return new BindingDOMDataTreeWriteCursorAdapter<>(path, cursor, getCodec());
}
@Override
public boolean cancel() {
- return delegate.cancel();
+ return getDelegate().cancel();
}
@Override
public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- return delegate.submit();
+ return getDelegate().submit();
}
-
}
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Preconditions;
import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeChangeService;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
- * Adapter exposing Binding {@link DataTreeChangeService} and wrapping
- * {@link DOMDataTreeChangeService} and is responsible for translation
- * and instantiation of {@link BindingDOMDataTreeChangeListenerAdapter}
- * adapters.
+ * Adapter exposing Binding {@link DataTreeChangeService} and wrapping a {@link DOMDataTreeChangeService} and is
+ * responsible for translation and instantiation of {@link BindingDOMDataTreeChangeListenerAdapter} adapters.
*
* <p>
- * Each registered {@link DataTreeChangeListener} is wrapped using
- * adapter and registered directly to DOM service.
+ * Each registered {@link DataTreeChangeListener} is wrapped using adapter and registered directly to DOM service.
*/
-final class BindingDOMDataTreeChangeServiceAdapter implements DataTreeChangeService {
-
- private final BindingToNormalizedNodeCodec codec;
- private final DOMDataTreeChangeService dataTreeChangeService;
+final class BindingDOMDataTreeChangeServiceAdapter extends AbstractBindingAdapter<DOMDataTreeChangeService>
+ implements DataTreeChangeService {
private BindingDOMDataTreeChangeServiceAdapter(final BindingToNormalizedNodeCodec codec,
final DOMDataTreeChangeService dataTreeChangeService) {
- this.codec = Preconditions.checkNotNull(codec);
- this.dataTreeChangeService = Preconditions.checkNotNull(dataTreeChangeService);
+ super(codec, dataTreeChangeService);
}
static DataTreeChangeService create(final BindingToNormalizedNodeCodec codec,
public <T extends DataObject, L extends DataTreeChangeListener<T>> ListenerRegistration<L>
registerDataTreeChangeListener(final DataTreeIdentifier<T> treeId, final L listener) {
final DOMDataTreeIdentifier domIdentifier = toDomTreeIdentifier(treeId);
-
- @SuppressWarnings({ "rawtypes", "unchecked" })
+ final LogicalDatastoreType storeType = treeId.getDatastoreType();
final BindingDOMDataTreeChangeListenerAdapter<T> domListener =
listener instanceof ClusteredDataTreeChangeListener
? new BindingClusteredDOMDataTreeChangeListenerAdapter<>(
- codec, (ClusteredDataTreeChangeListener) listener, treeId.getDatastoreType())
- : new BindingDOMDataTreeChangeListenerAdapter<>(codec, listener, treeId.getDatastoreType());
+ getCodec(), (ClusteredDataTreeChangeListener<T>) listener, storeType)
+ : new BindingDOMDataTreeChangeListenerAdapter<>(getCodec(), listener, storeType);
final ListenerRegistration<BindingDOMDataTreeChangeListenerAdapter<T>> domReg =
- dataTreeChangeService.registerDataTreeChangeListener(domIdentifier, domListener);
+ getDelegate().registerDataTreeChangeListener(domIdentifier, domListener);
return new BindingDataTreeChangeListenerRegistration<>(listener, domReg);
}
private DOMDataTreeIdentifier toDomTreeIdentifier(final DataTreeIdentifier<?> treeId) {
- final YangInstanceIdentifier domPath = codec.toYangInstanceIdentifierBlocking(treeId.getRootIdentifier());
+ final YangInstanceIdentifier domPath = getCodec().toYangInstanceIdentifierBlocking(treeId.getRootIdentifier());
return new DOMDataTreeIdentifier(treeId.getDatastoreType(), domPath);
}
}
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.CheckedFuture;
import org.opendaylight.mdsal.binding.api.DataTreeCommitCohort;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-class BindingDOMDataTreeCommitCohortAdapter<T extends DataObject> implements DOMDataTreeCommitCohort {
+class BindingDOMDataTreeCommitCohortAdapter<T extends DataObject>
+ extends AbstractBindingAdapter<DataTreeCommitCohort<T>> implements DOMDataTreeCommitCohort {
- private final BindingToNormalizedNodeCodec codec;
- private final DataTreeCommitCohort<T> cohort;
-
- BindingDOMDataTreeCommitCohortAdapter(BindingToNormalizedNodeCodec codec, DataTreeCommitCohort<T> cohort) {
- this.codec = Preconditions.checkNotNull(codec);
- this.cohort = Preconditions.checkNotNull(cohort);
+ BindingDOMDataTreeCommitCohortAdapter(final BindingToNormalizedNodeCodec codec,
+ final DataTreeCommitCohort<T> cohort) {
+ super(codec, cohort);
}
@Override
- public CheckedFuture<PostCanCommitStep, DataValidationFailedException> canCommit(Object txId,
- DOMDataTreeCandidate candidate, SchemaContext ctx) {
- DataTreeModification<T> modification = LazyDataTreeModification.create(codec, candidate);
- return cohort.canCommit(txId, modification);
+ public CheckedFuture<PostCanCommitStep, DataValidationFailedException> canCommit(final Object txId,
+ final DOMDataTreeCandidate candidate, final SchemaContext ctx) {
+ DataTreeModification<T> modification = LazyDataTreeModification.create(getCodec(), candidate);
+ return getDelegate().canCommit(txId, modification);
}
}
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Preconditions;
import org.opendaylight.mdsal.binding.api.DataTreeCommitCohort;
import org.opendaylight.mdsal.binding.api.DataTreeCommitCohortRegistry;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
-public class BindingDOMDataTreeCommitCohortRegistryAdapter implements DataTreeCommitCohortRegistry {
-
- private final BindingToNormalizedNodeCodec codec;
- private final DOMDataTreeCommitCohortRegistry registry;
+public class BindingDOMDataTreeCommitCohortRegistryAdapter
+ extends AbstractBindingAdapter<DOMDataTreeCommitCohortRegistry> implements DataTreeCommitCohortRegistry {
BindingDOMDataTreeCommitCohortRegistryAdapter(final BindingToNormalizedNodeCodec codec,
final DOMDataTreeCommitCohortRegistry registry) {
- this.codec = Preconditions.checkNotNull(codec);
- this.registry = Preconditions.checkNotNull(registry);
+ super(codec, registry);
}
static DataTreeCommitCohortRegistry from(final BindingToNormalizedNodeCodec codec,
public <D extends DataObject, T extends DataTreeCommitCohort<D>> ObjectRegistration<T> registerCommitCohort(
final DataTreeIdentifier<D> subtree, final T cohort) {
final BindingDOMDataTreeCommitCohortAdapter<D> adapter =
- new BindingDOMDataTreeCommitCohortAdapter<>(codec, cohort);
- final DOMDataTreeIdentifier domPath = codec.toDOMDataTreeIdentifier(subtree);
- final DOMDataTreeCommitCohortRegistration<?> domReg = registry.registerCommitCohort(domPath, adapter);
+ new BindingDOMDataTreeCommitCohortAdapter<>(getCodec(), cohort);
+ final DOMDataTreeIdentifier domPath = getCodec().toDOMDataTreeIdentifier(subtree);
+ final DOMDataTreeCommitCohortRegistration<?> domReg = getDelegate().registerCommitCohort(domPath, adapter);
return new ObjectRegistration<T>() {
@Override
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
-public class BindingDOMDataTreeListenerAdapter implements DOMDataTreeListener {
+public class BindingDOMDataTreeListenerAdapter extends AbstractBindingAdapter<DataTreeListener>
+ implements DOMDataTreeListener {
- private final DataTreeListener delegate;
- private final BindingToNormalizedNodeCodec codec;
private final LogicalDatastoreType store;
-
protected BindingDOMDataTreeListenerAdapter(final DataTreeListener delegate,
final BindingToNormalizedNodeCodec codec, final LogicalDatastoreType store) {
- this.delegate = Preconditions.checkNotNull(delegate, "delegate");
- this.codec = Preconditions.checkNotNull(codec, "codec");
+ super(codec, delegate);
this.store = Preconditions.checkNotNull(store, "store");
}
final Collection<DataTreeModification<?>> changes = toBinding(domChanges);
final Map<DataTreeIdentifier<?>, DataObject> subtrees = toBinding(domSubtrees);
- delegate.onDataTreeChanged(changes, subtrees);
+ getDelegate().onDataTreeChanged(changes, subtrees);
}
private Map<DataTreeIdentifier<?>, DataObject> toBinding(
final Map<DataTreeIdentifier<?>, DataObject> ret = Maps.newHashMapWithExpectedSize(domSubtrees.size());
for (final Entry<DOMDataTreeIdentifier, NormalizedNode<?, ?>> domEntry : domSubtrees.entrySet()) {
final Entry<InstanceIdentifier<?>, DataObject> bindingEntry =
- codec.fromNormalizedNode(domEntry.getKey().getRootIdentifier(), domEntry.getValue());
+ getCodec().fromNormalizedNode(domEntry.getKey().getRootIdentifier(), domEntry.getValue());
ret.put(DataTreeIdentifier.create(store, bindingEntry.getKey()), bindingEntry.getValue());
}
return ret;
@SuppressWarnings("unchecked")
private Collection<DataTreeModification<?>> toBinding(final Collection<DataTreeCandidate> domChanges) {
- return Collection.class.cast(LazyDataTreeModification.from(codec, domChanges, store));
+ return Collection.class.cast(LazyDataTreeModification.from(getCodec(), domChanges, store));
}
@Override
bindingCauses.add(mapException(cause));
}
- delegate.onDataTreeFailed(bindingCauses);
+ getDelegate().onDataTreeFailed(bindingCauses);
}
private static DataTreeListeningException mapException(final DOMDataTreeListeningException cause) {
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Preconditions;
import java.util.Collection;
import org.opendaylight.mdsal.binding.api.CursorAwareWriteTransaction;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMDataTreeProducer;
import org.opendaylight.mdsal.dom.api.DOMDataTreeProducerException;
-class BindingDOMDataTreeProducerAdapter implements DataTreeProducer {
+class BindingDOMDataTreeProducerAdapter extends AbstractBindingAdapter<DOMDataTreeProducer>
+ implements DataTreeProducer {
- private final DOMDataTreeProducer delegate;
- private final BindingToNormalizedNodeCodec codec;
-
- protected BindingDOMDataTreeProducerAdapter(final DOMDataTreeProducer delegate,
- final BindingToNormalizedNodeCodec codec) {
- this.delegate = Preconditions.checkNotNull(delegate);
- this.codec = codec;
+ BindingDOMDataTreeProducerAdapter(final BindingToNormalizedNodeCodec codec, final DOMDataTreeProducer delegate) {
+ super(codec, delegate);
}
@Override
public CursorAwareWriteTransaction createTransaction(final boolean isolated) {
- final DOMDataTreeCursorAwareTransaction domTx = delegate.createTransaction(isolated);
- return new BindingDOMCursorAwareWriteTransactionAdapter<>(domTx, codec);
+ final DOMDataTreeCursorAwareTransaction domTx = getDelegate().createTransaction(isolated);
+ return new BindingDOMCursorAwareWriteTransactionAdapter<>(domTx, getCodec());
}
- static DataTreeProducer create(final DOMDataTreeProducer domProducer,
- final BindingToNormalizedNodeCodec codec) {
- return new BindingDOMDataTreeProducerAdapter(domProducer, codec);
+ static DataTreeProducer create(final DOMDataTreeProducer domProducer, final BindingToNormalizedNodeCodec codec) {
+ return new BindingDOMDataTreeProducerAdapter(codec, domProducer);
}
@Override
public DataTreeProducer createProducer(final Collection<DataTreeIdentifier<?>> subtrees) {
- final Collection<DOMDataTreeIdentifier> domSubtrees = codec.toDOMDataTreeIdentifiers(subtrees);
- final DOMDataTreeProducer domChildProducer = delegate.createProducer(domSubtrees);
- return BindingDOMDataTreeProducerAdapter.create(domChildProducer, codec);
+ final Collection<DOMDataTreeIdentifier> domSubtrees = getCodec().toDOMDataTreeIdentifiers(subtrees);
+ final DOMDataTreeProducer domChildProducer = getDelegate().createProducer(domSubtrees);
+ return BindingDOMDataTreeProducerAdapter.create(domChildProducer, getCodec());
}
@Override
public void close() throws DataTreeProducerException {
try {
- delegate.close();
+ getDelegate().close();
} catch (final DOMDataTreeProducerException e) {
throw new DataTreeProducerException(e.getMessage(), e);
}
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Preconditions;
import java.util.Collection;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeListener;
import org.opendaylight.mdsal.dom.api.DOMDataTreeService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-public final class BindingDOMDataTreeServiceAdapter implements DataTreeService {
- private final DOMDataTreeService delegate;
- private final BindingToNormalizedNodeCodec codec;
-
- private BindingDOMDataTreeServiceAdapter(final DOMDataTreeService delegate,
- final BindingToNormalizedNodeCodec codec) {
- this.delegate = Preconditions.checkNotNull(delegate, "delegate");
- this.codec = Preconditions.checkNotNull(codec, "codec");
+public final class BindingDOMDataTreeServiceAdapter extends AbstractBindingAdapter<DOMDataTreeService>
+ implements DataTreeService {
+ private BindingDOMDataTreeServiceAdapter(final BindingToNormalizedNodeCodec codec,
+ final DOMDataTreeService delegate) {
+ super(codec, delegate);
}
public static BindingDOMDataTreeServiceAdapter create(final DOMDataTreeService domService,
final BindingToNormalizedNodeCodec codec) {
- return new BindingDOMDataTreeServiceAdapter(domService, codec);
+ return new BindingDOMDataTreeServiceAdapter(codec, domService);
}
@Override
public DataTreeProducer createProducer(final Collection<DataTreeIdentifier<?>> subtrees) {
- final Collection<DOMDataTreeIdentifier> domSubtrees = codec.toDOMDataTreeIdentifiers(subtrees);
- final DOMDataTreeProducer domChildProducer = delegate.createProducer(domSubtrees);
- return BindingDOMDataTreeProducerAdapter.create(domChildProducer, codec);
+ final Collection<DOMDataTreeIdentifier> domSubtrees = getCodec().toDOMDataTreeIdentifiers(subtrees);
+ final DOMDataTreeProducer domChildProducer = getDelegate().createProducer(domSubtrees);
+ return BindingDOMDataTreeProducerAdapter.create(domChildProducer, getCodec());
}
@Override
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public class BindingDOMDataTreeWriteCursorAdapter<T extends DOMDataTreeWriteCursor> implements DataTreeWriteCursor {
+public class BindingDOMDataTreeWriteCursorAdapter<T extends DOMDataTreeWriteCursor>
+ extends AbstractBindingAdapter<T> implements DataTreeWriteCursor {
private final Deque<PathArgument> stack = new ArrayDeque<>();
- private final T delegate;
- private final BindingToNormalizedNodeCodec codec;
-
public BindingDOMDataTreeWriteCursorAdapter(final DataTreeIdentifier<?> path, final T delegate,
final BindingToNormalizedNodeCodec codec) {
-
- this.delegate = delegate;
- this.codec = codec;
+ super(codec, delegate);
path.getRootIdentifier().getPathArguments().forEach(stack::push);
}
private YangInstanceIdentifier.PathArgument convertToNormalized(final PathArgument child) {
stack.push(child);
final InstanceIdentifier<?> iid = InstanceIdentifier.create(stack);
- final YangInstanceIdentifier ret = codec.toNormalized(iid);
+ final YangInstanceIdentifier ret = getCodec().toNormalized(iid);
stack.pop();
return ret.getLastPathArgument();
}
final PathArgument child, final P data) {
stack.push(child);
final InstanceIdentifier<?> iid = InstanceIdentifier.create(stack);
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry
- = codec.toNormalizedNode(new SimpleEntry<>(iid, data));
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = getCodec()
+ .toNormalizedNode(new SimpleEntry<>(iid, data));
stack.pop();
return entry;
}
@Override
public void delete(final PathArgument child) {
- delegate.delete(convertToNormalized(child));
+ getDelegate().delete(convertToNormalized(child));
}
@Override
public <P extends DataObject> void merge(final PathArgument child, final P data) {
final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = convertToNormalized(child, data);
- delegate.merge(entry.getKey().getLastPathArgument(), entry.getValue());
+ getDelegate().merge(entry.getKey().getLastPathArgument(), entry.getValue());
}
@Override
public <P extends DataObject> void write(final PathArgument child, final P data) {
final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = convertToNormalized(child, data);
- delegate.write(entry.getKey().getLastPathArgument(), entry.getValue());
+ getDelegate().write(entry.getKey().getLastPathArgument(), entry.getValue());
}
@Override
@Override
public void close() {
- delegate.close();
+ getDelegate().close();
}
@VisibleForTesting
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class BindingDOMMountPointServiceAdapter implements MountPointService {
- public static final Logger LOG = LoggerFactory.getLogger(BindingDOMMountPointServiceAdapter.class);
+public class BindingDOMMountPointServiceAdapter extends AbstractBindingAdapter<DOMMountPointService>
+ implements MountPointService {
+ // FIXME: this really should be hidden
+ static final Logger LOG = LoggerFactory.getLogger(BindingDOMMountPointServiceAdapter.class);
- private final BindingToNormalizedNodeCodec codec;
- private final DOMMountPointService mountService;
private final LoadingCache<DOMMountPoint, BindingMountPointAdapter> bindingMountpoints = CacheBuilder.newBuilder()
.weakKeys().build(new CacheLoader<DOMMountPoint, BindingMountPointAdapter>() {
@Override
public BindingMountPointAdapter load(final DOMMountPoint key) {
- return new BindingMountPointAdapter(codec,key);
+ return new BindingMountPointAdapter(getCodec(), key);
}
});
public BindingDOMMountPointServiceAdapter(final DOMMountPointService mountService,
final BindingToNormalizedNodeCodec codec) {
- this.codec = codec;
- this.mountService = mountService;
+ super(codec, mountService);
}
@Override
public Optional<MountPoint> getMountPoint(final InstanceIdentifier<?> mountPoint) {
- YangInstanceIdentifier domPath = codec.toYangInstanceIdentifierBlocking(mountPoint);
- Optional<DOMMountPoint> domMount = mountService.getMountPoint(domPath);
+ YangInstanceIdentifier domPath = getCodec().toYangInstanceIdentifierBlocking(mountPoint);
+ Optional<DOMMountPoint> domMount = getDelegate().getMountPoint(domPath);
if (domMount.isPresent()) {
return Optional.fromNullable(bindingMountpoints.getUnchecked(domMount.get()));
}
@Override
public <T extends MountPointListener> ListenerRegistration<T> registerListener(final InstanceIdentifier<?> path,
final T listener) {
- return new BindingDOMMountPointListenerAdapter<>(listener, codec, mountService);
+ return new BindingDOMMountPointListenerAdapter<>(listener, getCodec(), getDelegate());
}
}
import org.opendaylight.mdsal.dom.api.DOMService;
import org.opendaylight.yangtools.yang.binding.Notification;
-public class BindingDOMNotificationPublishServiceAdapter implements NotificationPublishService {
+public class BindingDOMNotificationPublishServiceAdapter extends AbstractBindingAdapter<DOMNotificationPublishService>
+ implements NotificationPublishService {
static final Factory<NotificationPublishService> BUILDER_FACTORY = Builder::new;
- private final BindingToNormalizedNodeCodec codecRegistry;
- private final DOMNotificationPublishService domPublishService;
-
public BindingDOMNotificationPublishServiceAdapter(final DOMNotificationPublishService domPublishService,
final BindingToNormalizedNodeCodec codec) {
- this.codecRegistry = codec;
- this.domPublishService = domPublishService;
+ super(codec, domPublishService);
}
@Deprecated
}
public BindingToNormalizedNodeCodec getCodecRegistry() {
- return codecRegistry;
+ return getCodec();
}
public DOMNotificationPublishService getDomPublishService() {
- return domPublishService;
+ return getDelegate();
}
@Override
public void putNotification(final Notification notification) throws InterruptedException {
- domPublishService.putNotification(toDomNotification(notification));
+ getDelegate().putNotification(toDomNotification(notification));
}
@Override
public ListenableFuture<? extends Object> offerNotification(final Notification notification) {
- ListenableFuture<?> offerResult = domPublishService.offerNotification(toDomNotification(notification));
+ ListenableFuture<?> offerResult = getDelegate().offerNotification(toDomNotification(notification));
return DOMNotificationPublishService.REJECTED.equals(offerResult)
? NotificationPublishService.REJECTED
: offerResult;
@Override
public ListenableFuture<? extends Object> offerNotification(final Notification notification,
final int timeout, final TimeUnit unit) throws InterruptedException {
- ListenableFuture<?> offerResult = domPublishService.offerNotification(
- toDomNotification(notification), timeout, unit);
+ ListenableFuture<?> offerResult = getDelegate().offerNotification(toDomNotification(notification), timeout,
+ unit);
return DOMNotificationPublishService.REJECTED.equals(offerResult)
? NotificationPublishService.REJECTED
: offerResult;
}
private DOMNotification toDomNotification(final Notification notification) {
- return LazySerializedDOMNotification.create(codecRegistry, notification);
+ return LazySerializedDOMNotification.create(getCodec(), notification);
}
protected static class Builder extends BindingDOMAdapterBuilder<NotificationPublishService> {
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-public class BindingDOMRpcProviderServiceAdapter implements RpcProviderService {
+public class BindingDOMRpcProviderServiceAdapter extends AbstractBindingAdapter<DOMRpcProviderService>
+ implements RpcProviderService {
private static final Set<YangInstanceIdentifier> GLOBAL = ImmutableSet.of(YangInstanceIdentifier.builder().build());
- private final BindingToNormalizedNodeCodec codec;
- private final DOMRpcProviderService domRpcRegistry;
-
public BindingDOMRpcProviderServiceAdapter(final DOMRpcProviderService domRpcRegistry,
final BindingToNormalizedNodeCodec codec) {
- this.codec = codec;
- this.domRpcRegistry = domRpcRegistry;
+ super(codec, domRpcRegistry);
}
@Override
private <S extends RpcService, T extends S> ObjectRegistration<T> register(final Class<S> type,
final T implementation, final Collection<YangInstanceIdentifier> rpcContextPaths) {
- final Map<SchemaPath, Method> rpcs = codec.getRpcMethodToSchemaPath(type).inverse();
+ final Map<SchemaPath, Method> rpcs = getCodec().getRpcMethodToSchemaPath(type).inverse();
final BindingDOMRpcImplementationAdapter adapter = new BindingDOMRpcImplementationAdapter(
- codec.getCodecRegistry(), type, rpcs, implementation);
+ getCodec().getCodecRegistry(), type, rpcs, implementation);
final Set<DOMRpcIdentifier> domRpcs = createDomRpcIdentifiers(rpcs.keySet(), rpcContextPaths);
- final DOMRpcImplementationRegistration<?> domReg = domRpcRegistry.registerRpcImplementation(adapter, domRpcs);
+ final DOMRpcImplementationRegistration<?> domReg = getDelegate().registerRpcImplementation(adapter, domRpcs);
return new BindingRpcAdapterRegistration<>(implementation, domReg);
}
private Collection<YangInstanceIdentifier> toYangInstanceIdentifiers(final Set<InstanceIdentifier<?>> identifiers) {
final Collection<YangInstanceIdentifier> ret = new ArrayList<>(identifiers.size());
for (final InstanceIdentifier<?> binding : identifiers) {
- ret.add(codec.toYangInstanceIdentifierCached(binding));
+ ret.add(getCodec().toYangInstanceIdentifierCached(binding));
}
return ret;
}
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
-
-public class BindingDOMRpcServiceAdapter implements RpcConsumerRegistry {
+public class BindingDOMRpcServiceAdapter extends AbstractBindingAdapter<DOMRpcService> implements RpcConsumerRegistry {
protected static final Factory<RpcConsumerRegistry> BUILDER_FACTORY = Builder::new;
private final LoadingCache<Class<? extends RpcService>, RpcServiceAdapter> proxies = CacheBuilder.newBuilder()
.weakKeys()
.build(new CacheLoader<Class<? extends RpcService>, RpcServiceAdapter>() {
-
- private RpcServiceAdapter createProxy(final Class<? extends RpcService> key) {
- Preconditions.checkArgument(BindingReflections.isBindingClass(key));
- Preconditions.checkArgument(key.isInterface(), "Supplied RPC service type must be interface.");
- return new RpcServiceAdapter(key, codec, domService);
- }
-
@Override
public RpcServiceAdapter load(final Class<? extends RpcService> key) throws Exception {
- return createProxy(key);
+ Preconditions.checkArgument(BindingReflections.isBindingClass(key));
+ Preconditions.checkArgument(key.isInterface(), "Supplied RPC service type must be interface.");
+ return new RpcServiceAdapter(key, getCodec(), getDelegate());
}
-
});
- private final DOMRpcService domService;
- private final BindingToNormalizedNodeCodec codec;
-
public BindingDOMRpcServiceAdapter(final DOMRpcService domService, final BindingToNormalizedNodeCodec codec) {
- this.domService = domService;
- this.codec = codec;
+ super(codec, domService);
}
@SuppressWarnings("unchecked")
}
private static final class Builder extends BindingDOMAdapterBuilder<RpcConsumerRegistry> {
-
@Override
protected RpcConsumerRegistry createInstance(final BindingToNormalizedNodeCodec codec,
final ClassToInstanceMap<DOMService> delegates) {
public Set<? extends Class<? extends DOMService>> getRequiredDelegates() {
return ImmutableSet.of(DOMRpcService.class);
}
-
}
-
}
import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCursorAwareTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteCursor;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
new BindingToNormalizedNodeCodec(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), registry);
final YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.EMPTY;
doReturn(yangInstanceIdentifier).when(registry).toYangInstanceIdentifier(any());
+ doReturn(mock(DOMDataTreeWriteCursor.class)).when(delegate).createCursor(any());
final BindingDOMCursorAwareWriteTransactionAdapter adapter =
new BindingDOMCursorAwareWriteTransactionAdapter<>(delegate, codec);
private DOMDataTreeProducer delegate;
@Before
- public void setUp() throws Exception {
+ public void setUp() {
initMocks(this);
final BindingBrokerTestFactory testFactory = new BindingBrokerTestFactory();
testFactory.setExecutor(MoreExecutors.newDirectExecutorService());
final BindingTestContext testContext = testFactory.getTestContext();
testContext.start();
codec = testContext.getCodec();
- bindingDOMDataTreeProducerAdapter = new BindingDOMDataTreeProducerAdapter(delegate, codec);
+ bindingDOMDataTreeProducerAdapter = new BindingDOMDataTreeProducerAdapter(codec, delegate);
}
@Test
- public void createTransactionTest() throws Exception {
+ public void createTransactionTest() {
doReturn(mock(DOMDataTreeCursorAwareTransaction.class)).when(delegate).createTransaction(true);
assertNotNull(bindingDOMDataTreeProducerAdapter.createTransaction(true));
verify(delegate).createTransaction(true);
}
@Test
- public void createTest() throws Exception {
+ public void createTest() {
assertNotNull(BindingDOMDataTreeProducerAdapter.create(delegate, codec));
}
@Test
- public void createProducerTest() throws Exception {
+ public void createProducerTest() {
doReturn(mock(DOMDataTreeProducer.class)).when(delegate).createProducer(any());
assertNotNull(bindingDOMDataTreeProducerAdapter.createProducer(ImmutableSet.of()));
verify(delegate).createProducer(any());
}
@Test
- public void closeTest() throws Exception {
+ public void closeTest() throws DataTreeProducerException, DOMDataTreeProducerException {
reset(delegate);
bindingDOMDataTreeProducerAdapter.close();
verify(delegate).close();
}
@Test(expected = DataTreeProducerException.class)
- public void closeTestWithException1() throws Exception {
+ public void closeTestWithException1() throws DataTreeProducerException, DOMDataTreeProducerException {
doThrow(new DOMDataTreeProducerBusyException("test")).when(delegate).close();
bindingDOMDataTreeProducerAdapter.close();
}
@Test(expected = DataTreeProducerException.class)
- public void closeTestWithException2() throws Exception {
+ public void closeTestWithException2() throws DataTreeProducerException, DOMDataTreeProducerException {
doThrow(new DOMDataTreeProducerException("test")).when(delegate).close();
bindingDOMDataTreeProducerAdapter.close();
}
Code Review / mdsal.git / commitdiff