<packaging>bundle</packaging>
<dependencies>
- <dependency>
- <groupId>javax.inject</groupId>
- <artifactId>javax.inject</artifactId>
- <optional>true</optional>
- </dependency>
- <dependency>
- <groupId>javax.annotation</groupId>
- <artifactId>javax.annotation-api</artifactId>
- <optional>true</optional>
- </dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-util</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.kohsuke.metainf-services</groupId>
+ <artifactId>metainf-services</artifactId>
+ <optional>true</optional>
+ </dependency>
+ <dependency>
+ <groupId>javax.inject</groupId>
+ <artifactId>javax.inject</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>org.osgi</groupId>
<artifactId>org.osgi.core</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>osgi.cmpn</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
--- /dev/null
+/*
+ * Copyright (c) 2020 PANTHEON.tech, 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 org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.api.ActionProviderService;
+import org.opendaylight.mdsal.binding.api.ActionService;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataTreeService;
+import org.opendaylight.mdsal.binding.api.MountPointService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.opendaylight.mdsal.binding.dom.adapter.spi.AdapterFactory;
+import org.opendaylight.mdsal.dom.api.DOMActionProviderService;
+import org.opendaylight.mdsal.dom.api.DOMActionService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeService;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMNotificationPublishService;
+import org.opendaylight.mdsal.dom.api.DOMNotificationService;
+import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+
+abstract class AbstractAdapterFactory implements AdapterFactory {
+ @Override
+ public final DataBroker createDataBroker(final DOMDataBroker domService) {
+ return new BindingDOMDataBrokerAdapter(context(), domService);
+ }
+
+ @Override
+ public final DataTreeService createDataTreeService(final DOMDataTreeService domService) {
+ return new BindingDOMDataTreeServiceAdapter(context(), domService);
+ }
+
+ @Override
+ public final MountPointService createMountPointService(final DOMMountPointService domService) {
+ return new BindingDOMMountPointServiceAdapter(context(), domService);
+ }
+
+ @Override
+ public final NotificationService createNotificationService(final DOMNotificationService domService) {
+ return new BindingDOMNotificationServiceAdapter(context(), domService);
+ }
+
+ @Override
+ public final NotificationPublishService createNotificationPublishService(
+ final DOMNotificationPublishService domService) {
+ return new BindingDOMNotificationPublishServiceAdapter(context(), domService);
+ }
+
+ @Override
+ public final RpcConsumerRegistry createRpcConsumerRegistry(final DOMRpcService domService) {
+ return new BindingDOMRpcServiceAdapter(context(), domService);
+ }
+
+ @Override
+ public final RpcProviderService createRpcProviderService(final DOMRpcProviderService domService) {
+ return new BindingDOMRpcProviderServiceAdapter(context(), domService);
+ }
+
+ @Override
+ public final ActionService createActionService(final DOMActionService domService) {
+ return new ActionServiceAdapter(context(), domService);
+ }
+
+ @Override
+ public final ActionProviderService createActionProviderService(final DOMActionProviderService domService) {
+ return new ActionProviderServiceAdapter(context(), domService);
+ }
+
+ abstract @NonNull AdapterContext context();
+}
@NonNullByDefault
abstract class AbstractBindingAdapter<T> implements Delegator<T> {
- private final BindingToNormalizedNodeCodec codec;
+ private final AdapterContext adapterContext;
private final T delegate;
- AbstractBindingAdapter(final BindingToNormalizedNodeCodec codec, final T delegate) {
- this.codec = requireNonNull(codec);
+ AbstractBindingAdapter(final AdapterContext adapterContext, final T delegate) {
+ this.adapterContext = requireNonNull(adapterContext);
this.delegate = requireNonNull(delegate);
}
return delegate;
}
- protected final BindingToNormalizedNodeCodec getCodec() {
- return codec;
+ protected final AdapterContext adapterContext() {
+ return adapterContext;
+ }
+
+ protected final CurrentAdapterSerializer currentSerializer() {
+ return adapterContext.currentSerializer();
}
}
}
});
- AbstractBindingLoadingAdapter(final BindingToNormalizedNodeCodec codec, final D delegate) {
- super(codec, delegate);
+ AbstractBindingLoadingAdapter(final AdapterContext adapterContext, final D delegate) {
+ super(adapterContext, delegate);
}
final V getAdapter(final K key) {
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
abstract class AbstractForwardedTransaction<T extends DOMDataTreeTransaction> implements Delegator<T>,
Identifiable<Object> {
- private final @NonNull BindingToNormalizedNodeCodec codec;
+ private final @NonNull AdapterContext adapterContext;
private final @NonNull T delegate;
- AbstractForwardedTransaction(final T delegateTx, final BindingToNormalizedNodeCodec codec) {
+ AbstractForwardedTransaction(final AdapterContext adapterContext, final T delegateTx) {
+ this.adapterContext = requireNonNull(adapterContext, "Codec must not be null");
this.delegate = requireNonNull(delegateTx, "Delegate must not be null");
- this.codec = requireNonNull(codec, "Codec must not be null");
}
@Override
return txType.cast(delegate);
}
- protected final BindingToNormalizedNodeCodec getCodec() {
- return codec;
+ protected final AdapterContext adapterContext() {
+ return adapterContext;
}
protected final <D extends DataObject> @NonNull FluentFuture<Optional<D>> doRead(
final InstanceIdentifier<D> path) {
checkArgument(!path.isWildcarded(), "Invalid read of wildcarded path %s", path);
- return readOps.read(store, codec.toYangInstanceIdentifierBlocking(path))
- .transform(codec.getCodecRegistry().deserializeFunction(path)::apply, MoreExecutors.directExecutor());
+ final CurrentAdapterSerializer codec = adapterContext.currentSerializer();
+ final YangInstanceIdentifier domPath = codec.toYangInstanceIdentifier(path);
+
+ return readOps.read(store, domPath)
+ .transform(optData -> optData.map(domData -> (D) codec.fromNormalizedNode(domPath, domData).getValue()),
+ MoreExecutors.directExecutor());
}
protected final @NonNull FluentFuture<Boolean> doExists(final DOMDataTreeReadOperations readOps,
final LogicalDatastoreType store, final InstanceIdentifier<?> path) {
checkArgument(!path.isWildcarded(), "Invalid exists of wildcarded path %s", path);
- return readOps.exists(store, codec.toYangInstanceIdentifierBlocking(path));
+ return readOps.exists(store, adapterContext.currentSerializer().toYangInstanceIdentifier(path));
}
}
private final NodeIdentifier inputName;
private final SchemaPath schemaPath;
- ActionAdapter(final BindingToNormalizedNodeCodec codec, final DOMActionService delegate,
+ ActionAdapter(final AdapterContext codec, final DOMActionService delegate,
final Class<? extends Action<?, ?, ?>> type) {
super(codec, delegate);
this.type = requireNonNull(type);
- this.schemaPath = getCodec().getActionPath(type);
+ this.schemaPath = currentSerializer().getActionPath(type);
this.inputName = NodeIdentifier.create(operationInputQName(schemaPath.getLastComponent().getModule()));
}
- @Override public @Nullable Object invoke(final @Nullable Object proxy, final @Nullable Method method,
+ @Override
+ public @Nullable Object invoke(final @Nullable Object proxy, final @Nullable Method method,
final Object @Nullable [] args) throws Throwable {
switch (method.getName()) {
case "equals":
if (args.length == 2) {
final InstanceIdentifier<?> path = (InstanceIdentifier<?>) requireNonNull(args[0]);
final RpcInput input = (RpcInput) requireNonNull(args[1]);
+ final CurrentAdapterSerializer serializer = currentSerializer();
final ListenableFuture<? extends DOMActionResult> future = getDelegate().invokeAction(schemaPath,
new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
- getCodec().toYangInstanceIdentifier(path)),
- getCodec().toLazyNormalizedNodeActionInput(type, inputName, input));
+ serializer.toYangInstanceIdentifier(path)),
+ serializer.toLazyNormalizedNodeActionInput(type, inputName, input));
// Invocation returned a future we know about -- return that future instead
if (ENABLE_CODEC_SHORTCUT && future instanceof BindingRpcFutureAware) {
return Futures.transform(future,
dom -> RpcResultUtil.rpcResultFromDOM(dom.getErrors(), dom.getOutput()
- .map(output -> getCodec().fromNormalizedNodeActionOutput(type, output))
- .orElse(null)), MoreExecutors.directExecutor());
+ .map(output -> serializer.fromNormalizedNodeActionOutput(type, output))
+ .orElse(null)),
+ MoreExecutors.directExecutor());
}
break;
default:
*/
package org.opendaylight.mdsal.binding.dom.adapter;
+import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import com.google.common.collect.ClassToInstanceMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.api.ActionProviderService;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMAdapterBuilder.Factory;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMActionImplementation;
import org.opendaylight.mdsal.dom.api.DOMActionProviderService;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-@Beta
@NonNullByDefault
-// FIXME: make this class non-public once the controller user is gone
public final class ActionProviderServiceAdapter extends AbstractBindingAdapter<DOMActionProviderService>
implements ActionProviderService {
private static final class Builder extends BindingDOMAdapterBuilder<ActionProviderService> {
+ Builder(final AdapterContext adapterContext) {
+ super(adapterContext);
+ }
+
@Override
- protected ActionProviderService createInstance(final @Nullable BindingToNormalizedNodeCodec codec,
- final ClassToInstanceMap<DOMService> delegates) {
- final DOMActionProviderService domAction = delegates.getInstance(DOMActionProviderService.class);
- return new ActionProviderServiceAdapter(requireNonNull(codec), domAction);
+ protected ActionProviderService createInstance(final ClassToInstanceMap<DOMService> delegates) {
+ return new ActionProviderServiceAdapter(adapterContext(),
+ delegates.getInstance(DOMActionProviderService.class));
}
@Override
static final Factory<ActionProviderService> BUILDER_FACTORY = Builder::new;
- ActionProviderServiceAdapter(final BindingToNormalizedNodeCodec codec, final DOMActionProviderService delegate) {
- super(codec, delegate);
- }
-
- @Deprecated
- public static ActionProviderServiceAdapter create(final BindingToNormalizedNodeCodec codec,
- final DOMActionProviderService delegate) {
- return new ActionProviderServiceAdapter(codec, delegate);
+ ActionProviderServiceAdapter(final AdapterContext adapterContext, final DOMActionProviderService delegate) {
+ super(adapterContext, delegate);
}
@Override
- public <O extends DataObject, P extends InstanceIdentifier<O>,
- T extends org.opendaylight.yangtools.yang.binding.Action<P, ?, ?>, S extends T>
- ObjectRegistration<S> registerImplementation(final Class<T> actionInterface, final S implementation,
+ public <O extends DataObject, P extends InstanceIdentifier<O>, T extends Action<P, ?, ?>, S extends T>
+ ObjectRegistration<S> registerImplementation(final Class<T> actionInterface, final S implementation,
final LogicalDatastoreType datastore, final Set<DataTreeIdentifier<O>> validNodes) {
- final SchemaPath path = getCodec().getActionPath(actionInterface);
+ final SchemaPath path = currentSerializer().getActionPath(actionInterface);
final ObjectRegistration<DOMActionImplementation> reg = getDelegate().registerActionImplementation(
- new Impl(getCodec(),
+ new Impl(adapterContext(),
NodeIdentifier.create(YangConstants.operationOutputQName(path.getLastComponent().getModule())),
actionInterface, implementation), ImmutableSet.of());
- return new AbstractObjectRegistration<S>(implementation) {
+ return new AbstractObjectRegistration<>(implementation) {
@Override
protected void removeRegistration() {
reg.close();
private static final class Impl implements DOMActionImplementation {
private final Class<? extends Action<?, ?, ?>> actionInterface;
+ private final AdapterContext adapterContext;
private final Action implementation;
- private final BindingNormalizedNodeSerializer codec;
private final NodeIdentifier outputName;
- Impl(final BindingNormalizedNodeSerializer codec, final NodeIdentifier outputName,
+ Impl(final AdapterContext adapterContext, final NodeIdentifier outputName,
final Class<? extends Action<?, ?, ?>> actionInterface, final Action<?, ?, ?> implementation) {
- this.codec = requireNonNull(codec);
+ this.adapterContext = requireNonNull(adapterContext);
this.outputName = requireNonNull(outputName);
this.actionInterface = requireNonNull(actionInterface);
this.implementation = requireNonNull(implementation);
@SuppressWarnings({ "rawtypes", "unchecked" })
public ListenableFuture<? extends DOMActionResult> invokeAction(final SchemaPath type,
final DOMDataTreeIdentifier path, final ContainerNode input) {
+ final CurrentAdapterSerializer codec = adapterContext.currentSerializer();
+
final ListenableFuture<RpcResult<?>> userFuture = implementation.invoke(
- codec.fromYangInstanceIdentifier(path.getRootIdentifier()),
+ verifyNotNull(codec.fromYangInstanceIdentifier(path.getRootIdentifier())),
codec.fromNormalizedNodeActionInput(actionInterface, input));
if (userFuture instanceof BindingOperationFluentFuture) {
// If we are looping back through our future we can skip wrapping. This can happen if application
return (BindingOperationFluentFuture) userFuture;
}
- return new BindingOperationFluentFuture(userFuture, actionInterface, outputName, codec);
+ return new BindingOperationFluentFuture(userFuture, actionInterface, outputName, adapterContext);
}
}
}
import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import com.google.common.collect.ClassToInstanceMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.ListenableFuture;
import java.lang.reflect.Proxy;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.api.ActionService;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMAdapterBuilder.Factory;
import org.opendaylight.yangtools.yang.binding.RpcOutput;
import org.opendaylight.yangtools.yang.common.RpcResult;
-@Beta
@NonNullByDefault
-// FIXME: make this class non-public once the controller user is gone
-public final class ActionServiceAdapter
+final class ActionServiceAdapter
extends AbstractBindingLoadingAdapter<DOMActionService, Class<? extends Action<?, ?, ?>>, ActionAdapter>
implements ActionService {
private static final class Builder extends BindingDOMAdapterBuilder<ActionService> {
- @Override
- protected ActionService createInstance(final @Nullable BindingToNormalizedNodeCodec codec,
- final ClassToInstanceMap<DOMService> delegates) {
- final DOMActionService domAction = delegates.getInstance(DOMActionService.class);
- return new ActionServiceAdapter(requireNonNull(codec), domAction);
+ Builder(final AdapterContext adapterContext) {
+ super(adapterContext);
}
@Override
public Set<? extends Class<? extends DOMService>> getRequiredDelegates() {
return ImmutableSet.of(DOMActionService.class);
}
+
+ @Override
+ protected ActionService createInstance(final ClassToInstanceMap<DOMService> delegates) {
+ return new ActionServiceAdapter(adapterContext(), delegates.getInstance(DOMActionService.class));
+ }
}
private static final class ConstrainedAction implements Delegator<Action<?, ?, ?>>,
static final Factory<ActionService> BUILDER_FACTORY = Builder::new;
- ActionServiceAdapter(final BindingToNormalizedNodeCodec codec, final DOMActionService delegate) {
- super(codec, delegate);
- }
-
- @Deprecated
- public static ActionServiceAdapter create(final BindingToNormalizedNodeCodec codec,
- final DOMActionService delegate) {
- return new ActionServiceAdapter(codec, delegate);
+ ActionServiceAdapter(final AdapterContext adapterContext, final DOMActionService delegate) {
+ super(adapterContext, delegate);
}
@Override
ActionAdapter loadAdapter(final Class<? extends Action<?, ?, ?>> key) {
checkArgument(BindingReflections.isBindingClass(key));
checkArgument(key.isInterface(), "Supplied Action type must be an interface.");
- return new ActionAdapter(getCodec(), getDelegate(), key);
+ return new ActionAdapter(adapterContext(), getDelegate(), key);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2020 PANTHEON.tech, 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 com.google.common.annotations.VisibleForTesting;
+import org.eclipse.jdt.annotation.NonNull;
+
+@VisibleForTesting
+public interface AdapterContext {
+
+ @NonNull CurrentAdapterSerializer currentSerializer();
+}
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
+import java.util.ServiceLoader;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.opendaylight.mdsal.binding.api.ActionProviderService;
-import org.opendaylight.mdsal.binding.api.ActionService;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.DataTreeService;
-import org.opendaylight.mdsal.binding.api.MountPointService;
-import org.opendaylight.mdsal.binding.api.NotificationPublishService;
-import org.opendaylight.mdsal.binding.api.NotificationService;
-import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
-import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.kohsuke.MetaInfServices;
import org.opendaylight.mdsal.binding.dom.adapter.spi.AdapterFactory;
-import org.opendaylight.mdsal.dom.api.DOMActionProviderService;
-import org.opendaylight.mdsal.dom.api.DOMActionService;
-import org.opendaylight.mdsal.dom.api.DOMDataBroker;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeService;
-import org.opendaylight.mdsal.dom.api.DOMMountPointService;
-import org.opendaylight.mdsal.dom.api.DOMNotificationPublishService;
-import org.opendaylight.mdsal.dom.api.DOMNotificationService;
-import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
-import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.yangtools.concepts.Immutable;
/**
* @author Robert Varga
*/
@Beta
+@MetaInfServices(value = AdapterFactory.class)
@NonNullByDefault
@Singleton
-public final class BindingAdapterFactory implements AdapterFactory, Immutable {
- private final BindingToNormalizedNodeCodec codec;
+public final class BindingAdapterFactory extends AbstractAdapterFactory implements Immutable {
+ private final AdapterContext codec;
- @Inject
- public BindingAdapterFactory(final BindingToNormalizedNodeCodec codec) {
- this.codec = requireNonNull(codec);
- }
-
- /**
- * Create a {@link DataBroker} backed by a {@link DOMDataBroker}.
- *
- * @param domService Backing DOMDataBroker
- * @return A DataBroker
- * @throws NullPointerException if {@code domService} is null
- */
- @Override
- public DataBroker createDataBroker(final DOMDataBroker domService) {
- return new BindingDOMDataBrokerAdapter(domService, codec);
- }
-
- /**
- * Create a {@link DataTreeService} backed by a {@link DOMDataTreeService}.
- *
- * @param domService Backing DOMDataTreeService
- * @return A DataTreeService
- * @throws NullPointerException if {@code domService} is null
- */
- @Override
- public DataTreeService createDataTreeService(final DOMDataTreeService domService) {
- return BindingDOMDataTreeServiceAdapter.create(domService, codec);
- }
-
- /**
- * Create a {@link MountPointService} backed by a {@link DOMMountPointService}.
- *
- * @param domService Backing DOMMountPointService
- * @return A MountPointService
- * @throws NullPointerException if {@code domService} is null
- */
- @Override
- public MountPointService createMountPointService(final DOMMountPointService domService) {
- return new BindingDOMMountPointServiceAdapter(domService, codec);
- }
-
- /**
- * Create a {@link DataBroker} backed by a {@link DOMDataBroker}.
- *
- * @param domService Backing DOMDataBroker
- * @return A DataBroker
- * @throws NullPointerException if {@code domService} is null
- */
- @Override
- public NotificationService createNotificationService(final DOMNotificationService domService) {
- return new BindingDOMNotificationServiceAdapter(domService, codec);
- }
-
- /**
- * Create a {@link NotificationPublishService} backed by a {@link DOMNotificationPublishService}.
- *
- * @param domService Backing DOMNotificationPublishService
- * @return A NotificationPublishService
- * @throws NullPointerException if {@code domService} is null
- */
- @Override
- public NotificationPublishService createNotificationPublishService(final DOMNotificationPublishService domService) {
- return new BindingDOMNotificationPublishServiceAdapter(domService, codec);
- }
-
- /**
- * Create a {@link RpcConsumerRegistry} backed by a {@link DOMRpcService}.
- *
- * @param domService Backing DOMRpcService
- * @return A RpcConsumerRegistry
- * @throws NullPointerException if {@code domService} is null
- */
- @Override
- public RpcConsumerRegistry createRpcConsumerRegistry(final DOMRpcService domService) {
- return new BindingDOMRpcServiceAdapter(domService, codec);
+ public BindingAdapterFactory() {
+ this(ServiceLoader.load(AdapterContext.class).findFirst()
+ .orElseThrow(() -> new IllegalStateException("Failed to load BlockingBindingNormalizer")));
}
- /**
- * Create a {@link RpcProviderService} backed by a {@link DOMRpcProviderService}.
- *
- * @param domService Backing DOMRpcProviderService
- * @return A RpcProviderService
- * @throws NullPointerException if {@code domService} is null
- */
- @Override
- public RpcProviderService createRpcProviderService(final DOMRpcProviderService domService) {
- return new BindingDOMRpcProviderServiceAdapter(domService, codec);
- }
-
- @Override
- public ActionService createActionService(final DOMActionService domService) {
- return new ActionServiceAdapter(codec, domService);
+ @Inject
+ public BindingAdapterFactory(final AdapterContext codec) {
+ this.codec = requireNonNull(codec);
}
@Override
- public ActionProviderService createActionProviderService(final DOMActionProviderService domService) {
- return new ActionProviderServiceAdapter(codec, domService);
+ AdapterContext context() {
+ return codec;
}
}
*/
final class BindingClusteredDOMDataTreeChangeListenerAdapter<T extends DataObject>
extends BindingDOMDataTreeChangeListenerAdapter<T> implements ClusteredDOMDataTreeChangeListener {
- BindingClusteredDOMDataTreeChangeListenerAdapter(BindingToNormalizedNodeCodec codec,
- ClusteredDataTreeChangeListener<T> listener, LogicalDatastoreType store) {
+ BindingClusteredDOMDataTreeChangeListenerAdapter(final AdapterContext codec,
+ final ClusteredDataTreeChangeListener<T> listener, final LogicalDatastoreType store) {
super(codec, listener, store);
}
}
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ClassToInstanceMap;
+import static java.util.Objects.requireNonNull;
+
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.BindingService;
import org.opendaylight.mdsal.dom.api.DOMService;
@FunctionalInterface
interface Factory<T extends BindingService> {
- BindingDOMAdapterBuilder<T> newBuilder();
+ @NonNull BindingDOMAdapterBuilder<T> newBuilder(@NonNull AdapterContext adapterContext);
}
- private BindingToNormalizedNodeCodec codec;
+ private final @NonNull AdapterContext adapterContext;
- void setCodec(final BindingToNormalizedNodeCodec codec) {
- this.codec = codec;
+ BindingDOMAdapterBuilder(final AdapterContext adapterContext) {
+ this.adapterContext = requireNonNull(adapterContext);
}
- @Override
- protected final T createInstance(final ClassToInstanceMap<DOMService> delegates) {
- Preconditions.checkState(codec != null);
- return createInstance(codec, delegates);
+ protected final @NonNull AdapterContext adapterContext() {
+ return adapterContext;
}
-
- abstract T createInstance(BindingToNormalizedNodeCodec myCodec,
- @NonNull ClassToInstanceMap<@NonNull DOMService> delegates);
}
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableMap;
import java.util.Map;
import org.opendaylight.mdsal.binding.api.ActionProviderService;
.put(ActionProviderService.class, ActionProviderServiceAdapter.BUILDER_FACTORY)
.build();
- private final BindingToNormalizedNodeCodec codec;
+ private final AdapterContext codec;
- public BindingDOMAdapterLoader(final BindingToNormalizedNodeCodec codec) {
- this.codec = codec;
+ public BindingDOMAdapterLoader(final AdapterContext codec) {
+ this.codec = requireNonNull(codec);
}
@Override
protected final AdapterBuilder<? extends BindingService, DOMService> createBuilder(
final Class<? extends BindingService> key) {
final Factory<?> factory = FACTORIES.get(key);
- Preconditions.checkArgument(factory != null, "Unsupported service type %s", key);
- final BindingDOMAdapterBuilder<?> builder = factory.newBuilder();
- builder.setCodec(codec);
- return builder;
+ checkArgument(factory != null, "Unsupported service type %s", key);
+ return factory.newBuilder(codec);
}
}
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-public class BindingDOMCursorAwareWriteTransactionAdapter<T extends DOMDataTreeCursorAwareTransaction>
+final class BindingDOMCursorAwareWriteTransactionAdapter<T extends DOMDataTreeCursorAwareTransaction>
extends AbstractBindingAdapter<T> implements CursorAwareWriteTransaction {
-
- public BindingDOMCursorAwareWriteTransactionAdapter(final T delegate, final BindingToNormalizedNodeCodec codec) {
- super(codec, delegate);
+ BindingDOMCursorAwareWriteTransactionAdapter(final AdapterContext adapterContext, final T delegate) {
+ super(adapterContext, delegate);
}
@Override
public <P extends DataObject> DataTreeWriteCursor createCursor(final DataTreeIdentifier<P> path) {
- final YangInstanceIdentifier yPath = getCodec().toYangInstanceIdentifier(path.getRootIdentifier());
+ final YangInstanceIdentifier yPath = currentSerializer().toYangInstanceIdentifier(path.getRootIdentifier());
final DOMDataTreeWriteCursor cursor = getDelegate().createCursor(
new DOMDataTreeIdentifier(path.getDatastoreType(), yPath));
- return new BindingDOMDataTreeWriteCursorAdapter<>(path, cursor, getCodec());
+ return new BindingDOMDataTreeWriteCursorAdapter<>(adapterContext(), cursor, path);
}
@Override
*/
package org.opendaylight.mdsal.binding.dom.adapter;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ClassToInstanceMap;
import com.google.common.collect.ImmutableSet;
import java.util.Set;
* Besides this the DataBrokerImpl and it's collaborators also cache data that is already transformed from the binding
* independent to binding aware format.
*/
+@VisibleForTesting
public class BindingDOMDataBrokerAdapter extends AbstractBindingAdapter<@NonNull DOMDataBroker> implements DataBroker,
DataTreeChangeService {
static final Factory<DataBroker> BUILDER_FACTORY = Builder::new;
private final DataTreeChangeService treeChangeService;
- public BindingDOMDataBrokerAdapter(final DOMDataBroker domDataBroker, final BindingToNormalizedNodeCodec codec) {
- super(codec, domDataBroker);
+ public BindingDOMDataBrokerAdapter(final AdapterContext adapterContext, final DOMDataBroker domDataBroker) {
+ super(adapterContext, domDataBroker);
final DOMDataTreeChangeService domTreeChange = domDataBroker.getExtensions()
.getInstance(DOMDataTreeChangeService.class);
- if (domTreeChange != null) {
- treeChangeService = BindingDOMDataTreeChangeServiceAdapter.create(codec, domTreeChange);
- } else {
- treeChangeService = null;
- }
+ treeChangeService = domTreeChange == null ? null
+ : new BindingDOMDataTreeChangeServiceAdapter(adapterContext, domTreeChange);
}
@Override
public ReadTransaction newReadOnlyTransaction() {
- return new BindingDOMReadTransactionAdapter(getDelegate().newReadOnlyTransaction(), getCodec());
+ return new BindingDOMReadTransactionAdapter(adapterContext(), getDelegate().newReadOnlyTransaction());
}
@Override
public WriteTransaction newWriteOnlyTransaction() {
- return new BindingDOMWriteTransactionAdapter<>(getDelegate().newWriteOnlyTransaction(), getCodec());
+ return new BindingDOMWriteTransactionAdapter<>(adapterContext(), getDelegate().newWriteOnlyTransaction());
}
@Override
public ReadWriteTransaction newReadWriteTransaction() {
- return new BindingDOMReadWriteTransactionAdapter(getDelegate().newReadWriteTransaction(), getCodec());
+ return new BindingDOMReadWriteTransactionAdapter(adapterContext(), getDelegate().newReadWriteTransaction());
}
@Override
public TransactionChain createTransactionChain(final TransactionChainListener listener) {
- return new BindingDOMTransactionChainAdapter(getDelegate()::createTransactionChain, getCodec(), listener);
+ return new BindingDOMTransactionChainAdapter(getDelegate()::createTransactionChain, adapterContext(), listener);
}
@Override
public TransactionChain createMergingTransactionChain(final TransactionChainListener listener) {
- return new BindingDOMTransactionChainAdapter(getDelegate()::createMergingTransactionChain, getCodec(),
+ return new BindingDOMTransactionChainAdapter(getDelegate()::createMergingTransactionChain, adapterContext(),
listener);
}
private static class Builder extends BindingDOMAdapterBuilder<DataBroker> {
+ Builder(final AdapterContext adapterContext) {
+ super(adapterContext);
+ }
+
@Override
public Set<? extends Class<? extends DOMService>> getRequiredDelegates() {
return ImmutableSet.of(DOMDataBroker.class);
}
@Override
- protected DataBroker createInstance(final BindingToNormalizedNodeCodec codec,
- final ClassToInstanceMap<DOMService> delegates) {
- final DOMDataBroker domDataBroker = delegates.getInstance(DOMDataBroker.class);
- return new BindingDOMDataBrokerAdapter(domDataBroker, codec);
+ protected DataBroker createInstance(final ClassToInstanceMap<DOMService> delegates) {
+ return new BindingDOMDataBrokerAdapter(adapterContext(), delegates.getInstance(DOMDataBroker.class));
}
}
import java.util.Collection;
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
-import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
import org.opendaylight.yangtools.yang.binding.DataObject;
* and translated DOM events to their Binding equivalent.
*/
class BindingDOMDataTreeChangeListenerAdapter<T extends DataObject> implements DOMDataTreeChangeListener {
-
- private final BindingToNormalizedNodeCodec codec;
+ private final AdapterContext adapterContext;
private final DataTreeChangeListener<T> listener;
private final LogicalDatastoreType store;
- BindingDOMDataTreeChangeListenerAdapter(final BindingToNormalizedNodeCodec codec,
+ BindingDOMDataTreeChangeListenerAdapter(final AdapterContext adapterContext,
final DataTreeChangeListener<T> listener, final LogicalDatastoreType store) {
- this.codec = requireNonNull(codec);
+ this.adapterContext = requireNonNull(adapterContext);
this.listener = requireNonNull(listener);
this.store = requireNonNull(store);
}
@Override
public void onDataTreeChanged(final Collection<DataTreeCandidate> domChanges) {
- final Collection<DataTreeModification<T>> bindingChanges = LazyDataTreeModification.from(codec, domChanges,
- store);
- listener.onDataTreeChanged(bindingChanges);
+ listener.onDataTreeChanged(LazyDataTreeModification.from(adapterContext.currentSerializer(), domChanges,
+ store));
}
@Override
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
* Adapter exposing Binding {@link DataTreeChangeService} and wrapping a {@link DOMDataTreeChangeService} and is
*/
final class BindingDOMDataTreeChangeServiceAdapter extends AbstractBindingAdapter<DOMDataTreeChangeService>
implements DataTreeChangeService {
-
- private BindingDOMDataTreeChangeServiceAdapter(final BindingToNormalizedNodeCodec codec,
- final DOMDataTreeChangeService dataTreeChangeService) {
- super(codec, dataTreeChangeService);
- }
-
- static DataTreeChangeService create(final BindingToNormalizedNodeCodec codec,
+ BindingDOMDataTreeChangeServiceAdapter(final AdapterContext adapterContext,
final DOMDataTreeChangeService dataTreeChangeService) {
- return new BindingDOMDataTreeChangeServiceAdapter(codec, dataTreeChangeService);
+ super(adapterContext, dataTreeChangeService);
}
@Override
final BindingDOMDataTreeChangeListenerAdapter<T> domListener =
listener instanceof ClusteredDataTreeChangeListener
? new BindingClusteredDOMDataTreeChangeListenerAdapter<>(
- getCodec(), (ClusteredDataTreeChangeListener<T>) listener, storeType)
- : new BindingDOMDataTreeChangeListenerAdapter<>(getCodec(), listener, storeType);
+ adapterContext(), (ClusteredDataTreeChangeListener<T>) listener, storeType)
+ : new BindingDOMDataTreeChangeListenerAdapter<>(adapterContext(), listener, storeType);
final ListenerRegistration<BindingDOMDataTreeChangeListenerAdapter<T>> domReg =
getDelegate().registerDataTreeChangeListener(domIdentifier, domListener);
}
private DOMDataTreeIdentifier toDomTreeIdentifier(final DataTreeIdentifier<?> treeId) {
- final YangInstanceIdentifier domPath = getCodec().toYangInstanceIdentifierBlocking(treeId.getRootIdentifier());
- return new DOMDataTreeIdentifier(treeId.getDatastoreType(), domPath);
+ return new DOMDataTreeIdentifier(treeId.getDatastoreType(),
+ currentSerializer().toYangInstanceIdentifier(treeId.getRootIdentifier()));
}
}
* 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.FluentFuture;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-class BindingDOMDataTreeCommitCohortAdapter<T extends DataObject>
+final class BindingDOMDataTreeCommitCohortAdapter<T extends DataObject>
extends AbstractBindingAdapter<DataTreeCommitCohort<T>> implements DOMDataTreeCommitCohort {
-
- BindingDOMDataTreeCommitCohortAdapter(final BindingToNormalizedNodeCodec codec,
- final DataTreeCommitCohort<T> cohort) {
+ BindingDOMDataTreeCommitCohortAdapter(final AdapterContext codec, final DataTreeCommitCohort<T> cohort) {
super(codec, cohort);
}
@Override
public FluentFuture<PostCanCommitStep> canCommit(final Object txId,
final SchemaContext ctx, final Collection<DOMDataTreeCandidate> candidates) {
- final Collection<DataTreeModification<T>> modifications = candidates.stream().map(
- candidate -> LazyDataTreeModification.<T>create(getCodec(), candidate)).collect(Collectors.toList());
+ final Collection<DataTreeModification<T>> modifications = candidates.stream()
+ .map(candidate -> LazyDataTreeModification.<T>create(currentSerializer(), candidate))
+ .collect(Collectors.toList());
return getDelegate().canCommit(txId, modifications);
}
}
* 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 org.opendaylight.mdsal.binding.api.DataTreeCommitCohort;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
-public class BindingDOMDataTreeCommitCohortRegistryAdapter
+final class BindingDOMDataTreeCommitCohortRegistryAdapter
extends AbstractBindingAdapter<DOMDataTreeCommitCohortRegistry> implements DataTreeCommitCohortRegistry {
- BindingDOMDataTreeCommitCohortRegistryAdapter(final BindingToNormalizedNodeCodec codec,
+ BindingDOMDataTreeCommitCohortRegistryAdapter(final AdapterContext codec,
final DOMDataTreeCommitCohortRegistry registry) {
super(codec, registry);
}
- static DataTreeCommitCohortRegistry from(final BindingToNormalizedNodeCodec codec,
- final DOMDataTreeCommitCohortRegistry registry) {
- return new BindingDOMDataTreeCommitCohortRegistryAdapter(codec, registry);
- }
-
@Override
public <D extends DataObject, T extends DataTreeCommitCohort<D>> ObjectRegistration<T> registerCommitCohort(
final DataTreeIdentifier<D> subtree, final T cohort) {
final BindingDOMDataTreeCommitCohortAdapter<D> adapter =
- new BindingDOMDataTreeCommitCohortAdapter<>(getCodec(), cohort);
- final DOMDataTreeIdentifier domPath = getCodec().toDOMDataTreeIdentifier(subtree);
+ new BindingDOMDataTreeCommitCohortAdapter<>(adapterContext(), cohort);
+ final DOMDataTreeIdentifier domPath = currentSerializer().toDOMDataTreeIdentifier(subtree);
final DOMDataTreeCommitCohortRegistration<?> domReg = getDelegate().registerCommitCohort(domPath, adapter);
- return new ObjectRegistration<T>() {
+ return new ObjectRegistration<>() {
@Override
public T getInstance() {
import org.opendaylight.mdsal.binding.api.DataTreeListener;
import org.opendaylight.mdsal.binding.api.DataTreeListeningException;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMDataTreeListener;
private final LogicalDatastoreType store;
- protected BindingDOMDataTreeListenerAdapter(final DataTreeListener delegate,
- final BindingToNormalizedNodeCodec codec, final LogicalDatastoreType store) {
+ protected BindingDOMDataTreeListenerAdapter(final DataTreeListener delegate, final AdapterContext codec,
+ final LogicalDatastoreType store) {
super(codec, delegate);
this.store = requireNonNull(store, "store");
}
@Override
public void onDataTreeChanged(final Collection<DataTreeCandidate> domChanges,
final Map<DOMDataTreeIdentifier, NormalizedNode<?, ?>> domSubtrees) {
-
- final Collection<DataTreeModification<?>> changes = toBinding(domChanges);
- final Map<DataTreeIdentifier<?>, DataObject> subtrees = toBinding(domSubtrees);
-
- getDelegate().onDataTreeChanged(changes, subtrees);
+ final CurrentAdapterSerializer serializer = currentSerializer();
+ getDelegate().onDataTreeChanged(toBinding(serializer, domChanges), toBinding(serializer, domSubtrees));
}
- private Map<DataTreeIdentifier<?>, DataObject> toBinding(
+ private Map<DataTreeIdentifier<?>, DataObject> toBinding(final BindingNormalizedNodeSerializer serializer,
final Map<DOMDataTreeIdentifier, NormalizedNode<?, ?>> domSubtrees) {
// FIXME: Introduce lazy translating map
final Map<DataTreeIdentifier<?>, DataObject> ret = Maps.newHashMapWithExpectedSize(domSubtrees.size());
+
for (final Entry<DOMDataTreeIdentifier, NormalizedNode<?, ?>> domEntry : domSubtrees.entrySet()) {
final Entry<InstanceIdentifier<?>, DataObject> bindingEntry =
- getCodec().fromNormalizedNode(domEntry.getKey().getRootIdentifier(), domEntry.getValue());
+ serializer.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(getCodec(), domChanges, store));
+ private Collection<DataTreeModification<?>> toBinding(final CurrentAdapterSerializer serializer,
+ final Collection<DataTreeCandidate> domChanges) {
+ return Collection.class.cast(LazyDataTreeModification.from(serializer, domChanges, store));
}
@Override
import org.opendaylight.mdsal.dom.api.DOMDataTreeProducer;
import org.opendaylight.mdsal.dom.api.DOMDataTreeProducerException;
-class BindingDOMDataTreeProducerAdapter extends AbstractBindingAdapter<DOMDataTreeProducer>
+final class BindingDOMDataTreeProducerAdapter extends AbstractBindingAdapter<DOMDataTreeProducer>
implements DataTreeProducer {
-
- BindingDOMDataTreeProducerAdapter(final BindingToNormalizedNodeCodec codec, final DOMDataTreeProducer delegate) {
- super(codec, delegate);
+ BindingDOMDataTreeProducerAdapter(final AdapterContext adapterContext, final DOMDataTreeProducer delegate) {
+ super(adapterContext, delegate);
}
@Override
public CursorAwareWriteTransaction createTransaction(final boolean isolated) {
final DOMDataTreeCursorAwareTransaction domTx = getDelegate().createTransaction(isolated);
- return new BindingDOMCursorAwareWriteTransactionAdapter<>(domTx, getCodec());
- }
-
- static DataTreeProducer create(final DOMDataTreeProducer domProducer, final BindingToNormalizedNodeCodec codec) {
- return new BindingDOMDataTreeProducerAdapter(codec, domProducer);
+ return new BindingDOMCursorAwareWriteTransactionAdapter<>(adapterContext(), domTx);
}
@Override
public DataTreeProducer createProducer(final Collection<DataTreeIdentifier<?>> subtrees) {
- final Collection<DOMDataTreeIdentifier> domSubtrees = getCodec().toDOMDataTreeIdentifiers(subtrees);
+ final Collection<DOMDataTreeIdentifier> domSubtrees = currentSerializer().toDOMDataTreeIdentifiers(subtrees);
final DOMDataTreeProducer domChildProducer = getDelegate().createProducer(domSubtrees);
- return BindingDOMDataTreeProducerAdapter.create(domChildProducer, getCodec());
+ return new BindingDOMDataTreeProducerAdapter(adapterContext(), domChildProducer);
}
@Override
import org.opendaylight.mdsal.dom.api.DOMDataTreeService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-public final class BindingDOMDataTreeServiceAdapter extends AbstractBindingAdapter<DOMDataTreeService>
+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(codec, domService);
+ BindingDOMDataTreeServiceAdapter(final AdapterContext adapterContext, final DOMDataTreeService delegate) {
+ super(adapterContext, delegate);
}
@Override
public DataTreeProducer createProducer(final Collection<DataTreeIdentifier<?>> subtrees) {
- final Collection<DOMDataTreeIdentifier> domSubtrees = getCodec().toDOMDataTreeIdentifiers(subtrees);
+ final Collection<DOMDataTreeIdentifier> domSubtrees = currentSerializer().toDOMDataTreeIdentifiers(subtrees);
final DOMDataTreeProducer domChildProducer = getDelegate().createProducer(domSubtrees);
- return BindingDOMDataTreeProducerAdapter.create(domChildProducer, getCodec());
+ return new BindingDOMDataTreeProducerAdapter(adapterContext(), domChildProducer);
}
@Override
* 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.annotations.VisibleForTesting;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public class BindingDOMDataTreeWriteCursorAdapter<T extends DOMDataTreeWriteCursor>
+final class BindingDOMDataTreeWriteCursorAdapter<T extends DOMDataTreeWriteCursor>
extends AbstractBindingAdapter<T> implements DataTreeWriteCursor {
private final Deque<PathArgument> stack = new ArrayDeque<>();
- public BindingDOMDataTreeWriteCursorAdapter(final DataTreeIdentifier<?> path, final T delegate,
- final BindingToNormalizedNodeCodec codec) {
- super(codec, delegate);
+ BindingDOMDataTreeWriteCursorAdapter(final AdapterContext adapterContext, final T delegate,
+ final DataTreeIdentifier<?> path) {
+ super(adapterContext, 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 = getCodec().toYangInstanceIdentifier(iid);
+ final YangInstanceIdentifier ret = currentSerializer().toYangInstanceIdentifier(iid);
stack.pop();
return ret.getLastPathArgument();
}
stack.push(child);
final InstanceIdentifier<?> iid = InstanceIdentifier.create(stack);
@SuppressWarnings({ "unchecked", "rawtypes" })
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = getCodec().toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = currentSerializer().toNormalizedNode(
(InstanceIdentifier) iid, data);
stack.pop();
return entry;
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import java.util.Optional;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.mdsal.binding.api.MountPointService.MountPointListener;
import org.opendaylight.mdsal.dom.api.DOMMountPointListener;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
private final T listener;
private final ListenerRegistration<DOMMountPointListener> registration;
- private final BindingToNormalizedNodeCodec codec;
+ private final AdapterContext adapterContext;
- BindingDOMMountPointListenerAdapter(final T listener, final BindingToNormalizedNodeCodec codec,
+ BindingDOMMountPointListenerAdapter(final T listener, final AdapterContext adapterContext,
final DOMMountPointService mountService) {
- this.listener = listener;
- this.codec = codec;
+ this.listener = requireNonNull(listener);
+ this.adapterContext = requireNonNull(adapterContext);
this.registration = mountService.registerProvisionListener(this);
}
}
}
- private InstanceIdentifier<? extends DataObject> toBinding(final YangInstanceIdentifier path)
- throws DeserializationException {
- final Optional<InstanceIdentifier<? extends DataObject>> instanceIdentifierOptional = codec.toBinding(path);
- if (instanceIdentifierOptional.isPresent()) {
- return instanceIdentifierOptional.get();
- }
-
- throw new DeserializationException("Deserialization unsuccessful, " + instanceIdentifierOptional);
- }
-
@Override
public void onMountPointRemoved(final YangInstanceIdentifier path) {
try {
LOG.error("Unable to translate mountPoint path {}. Omitting event.", path, e);
}
}
+
+ private InstanceIdentifier<? extends DataObject> toBinding(final YangInstanceIdentifier path)
+ throws DeserializationException {
+ final InstanceIdentifier<?> binding;
+ try {
+ binding = adapterContext.currentSerializer().fromYangInstanceIdentifier(path);
+ } catch (IllegalArgumentException e) {
+ throw new DeserializationException("Deserialization unsuccessful, " + path, e);
+ }
+ if (binding == null) {
+ throw new DeserializationException("Deserialization unsuccessful, " + path);
+ }
+ return binding;
+ }
+
+
}
\ No newline at end of file
public class BindingDOMMountPointServiceAdapter
extends AbstractBindingLoadingAdapter<DOMMountPointService, DOMMountPoint, BindingMountPointAdapter>
implements MountPointService {
- public BindingDOMMountPointServiceAdapter(final DOMMountPointService mountService,
- final BindingToNormalizedNodeCodec codec) {
- super(codec, mountService);
+ public BindingDOMMountPointServiceAdapter(final AdapterContext adapterContext,
+ final DOMMountPointService mountService) {
+ super(adapterContext, mountService);
}
@Override
public Optional<MountPoint> getMountPoint(final InstanceIdentifier<?> mountPoint) {
- YangInstanceIdentifier domPath = getCodec().toYangInstanceIdentifierBlocking(mountPoint);
+ YangInstanceIdentifier domPath = currentSerializer().toCachedYangInstanceIdentifier(mountPoint);
Optional<DOMMountPoint> domMount = getDelegate().getMountPoint(domPath);
return domMount.map(this::getAdapter);
}
@Override
public <T extends MountPointListener> ListenerRegistration<T> registerListener(final InstanceIdentifier<?> path,
final T listener) {
- return new BindingDOMMountPointListenerAdapter<>(listener, getCodec(), getDelegate());
+ return new BindingDOMMountPointListenerAdapter<>(listener, adapterContext(), getDelegate());
}
@Override
BindingMountPointAdapter loadAdapter(final DOMMountPoint key) {
- return new BindingMountPointAdapter(getCodec(), key);
+ return new BindingMountPointAdapter(adapterContext(), key);
}
}
*/
package org.opendaylight.mdsal.binding.dom.adapter;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableMap;
import com.google.common.reflect.TypeToken;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Set;
import org.opendaylight.mdsal.binding.dom.adapter.invoke.NotificationListenerInvoker;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.mdsal.dom.api.DOMEvent;
import org.opendaylight.mdsal.dom.api.DOMNotification;
class BindingDOMNotificationListenerAdapter implements DOMNotificationListener {
- private final BindingNormalizedNodeSerializer codec;
+ private final AdapterContext adapterContext;
private final NotificationListener delegate;
private final ImmutableMap<SchemaPath, NotificationListenerInvoker> invokers;
- BindingDOMNotificationListenerAdapter(final BindingNormalizedNodeSerializer codec,
- final NotificationListener delegate) {
- this.codec = codec;
- this.delegate = delegate;
+ BindingDOMNotificationListenerAdapter(final AdapterContext adapterContext, final NotificationListener delegate) {
+ this.adapterContext = requireNonNull(adapterContext);
+ this.delegate = requireNonNull(delegate);
this.invokers = createInvokerMapFor(delegate.getClass());
}
// okay, for now at least.
return ((LazySerializedDOMNotification) notification).getBindingData();
}
- return notification instanceof DOMEvent ? codec.fromNormalizedNodeNotification(notification.getType(),
+
+ final CurrentAdapterSerializer serializer = adapterContext.currentSerializer();
+ return notification instanceof DOMEvent ? serializer.fromNormalizedNodeNotification(notification.getType(),
notification.getBody(), ((DOMEvent) notification).getEventInstant())
- : codec.fromNormalizedNodeNotification(notification.getType(), notification.getBody());
+ : serializer.fromNormalizedNodeNotification(notification.getType(), notification.getBody());
}
private NotificationListenerInvoker getInvoker(final SchemaPath type) {
*/
package org.opendaylight.mdsal.binding.dom.adapter;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ClassToInstanceMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.ListenableFuture;
import org.opendaylight.yangtools.yang.binding.EventInstantAware;
import org.opendaylight.yangtools.yang.binding.Notification;
+@VisibleForTesting
public class BindingDOMNotificationPublishServiceAdapter extends AbstractBindingAdapter<DOMNotificationPublishService>
implements NotificationPublishService {
static final Factory<NotificationPublishService> BUILDER_FACTORY = Builder::new;
- public BindingDOMNotificationPublishServiceAdapter(final DOMNotificationPublishService domPublishService,
- final BindingToNormalizedNodeCodec codec) {
- super(codec, domPublishService);
- }
-
- @Deprecated
- public BindingDOMNotificationPublishServiceAdapter(final BindingToNormalizedNodeCodec codec,
+ public BindingDOMNotificationPublishServiceAdapter(final AdapterContext adapterContext,
final DOMNotificationPublishService domPublishService) {
- this(domPublishService, codec);
- }
-
- public BindingToNormalizedNodeCodec getCodecRegistry() {
- return getCodec();
+ super(adapterContext, domPublishService);
}
public DOMNotificationPublishService getDomPublishService() {
private @NonNull DOMNotification toDomNotification(final Notification notification) {
final Instant instant = notification instanceof EventInstantAware
? ((EventInstantAware) notification).eventInstant() : Instant.now();
- return LazySerializedDOMNotification.create(getCodec(), notification, instant);
+ return LazySerializedDOMNotification.create(currentSerializer(), notification, instant);
}
protected static class Builder extends BindingDOMAdapterBuilder<NotificationPublishService> {
+ Builder(final AdapterContext adapterContext) {
+ super(adapterContext);
+ }
+
@Override
public Set<Class<? extends DOMService>> getRequiredDelegates() {
return ImmutableSet.of(DOMNotificationPublishService.class);
}
@Override
- protected NotificationPublishService createInstance(final BindingToNormalizedNodeCodec codec,
- final ClassToInstanceMap<DOMService> delegates) {
- final DOMNotificationPublishService domPublish = delegates.getInstance(DOMNotificationPublishService.class);
- return new BindingDOMNotificationPublishServiceAdapter(codec, domPublish);
+ protected NotificationPublishService createInstance(final ClassToInstanceMap<DOMService> delegates) {
+ return new BindingDOMNotificationPublishServiceAdapter(adapterContext(),
+ delegates.getInstance(DOMNotificationPublishService.class));
}
}
}
*/
package org.opendaylight.mdsal.binding.dom.adapter;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ClassToInstanceMap;
import com.google.common.collect.ImmutableSet;
import java.util.Set;
import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMAdapterBuilder.Factory;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.dom.api.DOMNotificationService;
import org.opendaylight.mdsal.dom.api.DOMService;
import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
+@VisibleForTesting
public class BindingDOMNotificationServiceAdapter implements NotificationService {
-
public static final Factory<NotificationService> BUILDER_FACTORY = Builder::new;
- private final BindingNormalizedNodeSerializer codec;
+ private final AdapterContext adapterContext;
private final DOMNotificationService domNotifService;
- public BindingDOMNotificationServiceAdapter(final DOMNotificationService domNotifService,
- final BindingNormalizedNodeSerializer codec) {
- this.codec = codec;
- this.domNotifService = domNotifService;
- }
-
- @Deprecated
- public BindingDOMNotificationServiceAdapter(final BindingNormalizedNodeSerializer codec,
+ public BindingDOMNotificationServiceAdapter(final AdapterContext adapterContext,
final DOMNotificationService domNotifService) {
- this(domNotifService, codec);
+ this.adapterContext = requireNonNull(adapterContext);
+ this.domNotifService = domNotifService;
}
@Override
public <T extends NotificationListener> ListenerRegistration<T> registerNotificationListener(final T listener) {
final BindingDOMNotificationListenerAdapter domListener
- = new BindingDOMNotificationListenerAdapter(codec, listener);
+ = new BindingDOMNotificationListenerAdapter(adapterContext, listener);
final ListenerRegistration<BindingDOMNotificationListenerAdapter> domRegistration =
domNotifService.registerNotificationListener(domListener, domListener.getSupportedNotifications());
return new ListenerRegistrationImpl<>(listener, domRegistration);
}
private static class Builder extends BindingDOMAdapterBuilder<NotificationService> {
+ Builder(final AdapterContext adapterContext) {
+ super(adapterContext);
+ }
@Override
- protected NotificationService createInstance(final BindingToNormalizedNodeCodec codec,
- final ClassToInstanceMap<DOMService> delegates) {
+ protected NotificationService createInstance(final ClassToInstanceMap<DOMService> delegates) {
final DOMNotificationService domNotification = delegates.getInstance(DOMNotificationService.class);
- return new BindingDOMNotificationServiceAdapter(codec.getCodecRegistry(), domNotification);
+ return new BindingDOMNotificationServiceAdapter(adapterContext(), domNotification);
}
@Override
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-final class BindingDOMReadTransactionAdapter extends AbstractForwardedTransaction<DOMDataTreeReadTransaction> implements
- ReadTransaction {
-
- protected BindingDOMReadTransactionAdapter(final DOMDataTreeReadTransaction delegate,
- final BindingToNormalizedNodeCodec codec) {
- super(delegate, codec);
+final class BindingDOMReadTransactionAdapter extends AbstractForwardedTransaction<DOMDataTreeReadTransaction>
+ implements ReadTransaction {
+ BindingDOMReadTransactionAdapter(final AdapterContext adapterContext, final DOMDataTreeReadTransaction delegate) {
+ super(adapterContext, delegate);
}
@Override
public void close() {
getDelegate().close();
}
-
}
class BindingDOMReadWriteTransactionAdapter extends BindingDOMWriteTransactionAdapter<DOMDataTreeReadWriteTransaction>
implements ReadWriteTransaction {
-
- BindingDOMReadWriteTransactionAdapter(final DOMDataTreeReadWriteTransaction delegateTx,
- final BindingToNormalizedNodeCodec codec) {
- super(delegateTx, codec);
+ BindingDOMReadWriteTransactionAdapter(final AdapterContext adapterContext,
+ final DOMDataTreeReadWriteTransaction delegateTx) {
+ super(adapterContext, delegateTx);
}
@Override
import java.util.concurrent.ExecutionException;
import org.opendaylight.mdsal.binding.dom.adapter.invoke.RpcServiceInvoker;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingLazyContainerNode;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-public class BindingDOMRpcImplementationAdapter implements DOMRpcImplementation {
+final class BindingDOMRpcImplementationAdapter implements DOMRpcImplementation {
private static final Cache<Class<?>, RpcServiceInvoker> SERVICE_INVOKERS = CacheBuilder.newBuilder().weakKeys()
.build();
// Default implementations are 0, we need to perform some translation, hence we have a slightly higher cost
private static final int COST = 1;
- private final BindingNormalizedNodeSerializer codec;
+ private final AdapterContext adapterContext;
private final RpcServiceInvoker invoker;
private final RpcService delegate;
private final QName inputQname;
- <T extends RpcService> BindingDOMRpcImplementationAdapter(final BindingNormalizedNodeSerializer codec,
+ <T extends RpcService> BindingDOMRpcImplementationAdapter(final AdapterContext adapterContext,
final Class<T> type, final Map<SchemaPath, Method> localNameToMethod, final T delegate) {
try {
this.invoker = SERVICE_INVOKERS.get(type, () -> {
throw new IllegalArgumentException("Failed to create invokers for type " + type, e);
}
- this.codec = requireNonNull(codec);
+ this.adapterContext = requireNonNull(adapterContext);
this.delegate = requireNonNull(delegate);
inputQname = YangConstants.operationInputQName(BindingReflections.getQNameModule(type)).intern();
}
@Override
public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode<?, ?> input) {
final SchemaPath schemaPath = rpc.getType();
- final DataObject bindingInput = input != null ? deserialize(rpc.getType(), input) : null;
+ final CurrentAdapterSerializer serializer = adapterContext.currentSerializer();
+ final DataObject bindingInput = input != null ? deserialize(serializer, schemaPath, input) : null;
final ListenableFuture<RpcResult<?>> bindingResult = invoke(schemaPath, bindingInput);
- return LazyDOMRpcResultFuture.create(codec, bindingResult);
+ return LazyDOMRpcResultFuture.create(serializer, bindingResult);
}
@Override
return COST;
}
- private DataObject deserialize(final SchemaPath rpcPath, final NormalizedNode<?, ?> input) {
+ private DataObject deserialize(final CurrentAdapterSerializer serializer, final SchemaPath rpcPath,
+ final NormalizedNode<?, ?> input) {
if (ENABLE_CODEC_SHORTCUT && input instanceof BindingLazyContainerNode) {
return ((BindingLazyContainerNode<?>) input).getDataObject();
}
final SchemaPath inputSchemaPath = rpcPath.createChild(inputQname);
- return codec.fromNormalizedNodeRpcData(inputSchemaPath, (ContainerNode) input);
+ return serializer.fromNormalizedNodeRpcData(inputSchemaPath, (ContainerNode) input);
}
private ListenableFuture<RpcResult<?>> invoke(final SchemaPath schemaPath, final DataObject input) {
*/
package org.opendaylight.mdsal.binding.dom.adapter;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableSet;
import java.lang.reflect.Method;
import java.util.ArrayList;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@VisibleForTesting
public class BindingDOMRpcProviderServiceAdapter extends AbstractBindingAdapter<DOMRpcProviderService>
implements RpcProviderService {
private static final ImmutableSet<YangInstanceIdentifier> GLOBAL = ImmutableSet.of(YangInstanceIdentifier.empty());
- public BindingDOMRpcProviderServiceAdapter(final DOMRpcProviderService domRpcRegistry,
- final BindingToNormalizedNodeCodec codec) {
- super(codec, domRpcRegistry);
+ public BindingDOMRpcProviderServiceAdapter(final AdapterContext adapterContext,
+ final DOMRpcProviderService domRpcRegistry) {
+ super(adapterContext, 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 = getCodec().getRpcMethodToSchemaPath(type).inverse();
+ final Map<SchemaPath, Method> rpcs = currentSerializer().getRpcMethodToSchemaPath(type).inverse();
- final BindingDOMRpcImplementationAdapter adapter = new BindingDOMRpcImplementationAdapter(
- getCodec().getCodecRegistry(), type, rpcs, implementation);
+ final BindingDOMRpcImplementationAdapter adapter = new BindingDOMRpcImplementationAdapter(adapterContext(),
+ type, rpcs, implementation);
final Set<DOMRpcIdentifier> domRpcs = createDomRpcIdentifiers(rpcs.keySet(), rpcContextPaths);
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());
+ final CurrentAdapterSerializer serializer = currentSerializer();
for (final InstanceIdentifier<?> binding : identifiers) {
- ret.add(getCodec().toYangInstanceIdentifierCached(binding));
+ ret.add(serializer.toCachedYangInstanceIdentifier(binding));
}
return ret;
}
import static com.google.common.base.Preconditions.checkArgument;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ClassToInstanceMap;
import com.google.common.collect.ImmutableSet;
import java.util.Set;
import org.opendaylight.mdsal.dom.api.DOMService;
import org.opendaylight.yangtools.yang.binding.RpcService;
+@VisibleForTesting
public class BindingDOMRpcServiceAdapter
extends AbstractBindingLoadingAdapter<DOMRpcService, Class<? extends RpcService>, RpcServiceAdapter>
implements RpcConsumerRegistry {
+ static final Factory<RpcConsumerRegistry> BUILDER_FACTORY = Builder::new;
- protected static final Factory<RpcConsumerRegistry> BUILDER_FACTORY = Builder::new;
-
- public BindingDOMRpcServiceAdapter(final DOMRpcService domService, final BindingToNormalizedNodeCodec codec) {
- super(codec, domService);
+ public BindingDOMRpcServiceAdapter(final AdapterContext adapterContext, final DOMRpcService domService) {
+ super(adapterContext, domService);
}
@SuppressWarnings("unchecked")
RpcServiceAdapter loadAdapter(final Class<? extends RpcService> key) {
checkArgument(BindingReflections.isBindingClass(key));
checkArgument(key.isInterface(), "Supplied RPC service type must be interface.");
- return new RpcServiceAdapter(key, getCodec(), getDelegate());
+ return new RpcServiceAdapter(key, adapterContext(), getDelegate());
}
private static final class Builder extends BindingDOMAdapterBuilder<RpcConsumerRegistry> {
- @Override
- protected RpcConsumerRegistry createInstance(final BindingToNormalizedNodeCodec codec,
- final ClassToInstanceMap<DOMService> delegates) {
- final DOMRpcService domRpc = delegates.getInstance(DOMRpcService.class);
- return new BindingDOMRpcServiceAdapter(domRpc , codec);
+ Builder(final AdapterContext adapterContext) {
+ super(adapterContext);
}
@Override
public Set<? extends Class<? extends DOMService>> getRequiredDelegates() {
return ImmutableSet.of(DOMRpcService.class);
}
+
+ @Override
+ protected RpcConsumerRegistry createInstance(final ClassToInstanceMap<DOMService> delegates) {
+ return new BindingDOMRpcServiceAdapter(adapterContext(), delegates.getInstance(DOMRpcService.class));
+ }
}
}
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.function.Function;
import java.util.function.Supplier;
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.mdsal.binding.api.TransactionChain;
private static final Logger LOG = LoggerFactory.getLogger(BindingDOMTransactionChainAdapter.class);
private final DOMTransactionChain delegate;
- private final BindingToNormalizedNodeCodec codec;
+ private final AdapterContext adapterContext;
private final DelegateChainListener domListener;
private final TransactionChainListener bindingListener;
BindingDOMTransactionChainAdapter(final Function<DOMTransactionChainListener, DOMTransactionChain> chainFactory,
- final BindingToNormalizedNodeCodec codec, final TransactionChainListener listener) {
+ final AdapterContext codec, final TransactionChainListener listener) {
requireNonNull(chainFactory, "DOM Transaction chain factory must not be null");
this.domListener = new DelegateChainListener();
this.bindingListener = listener;
this.delegate = chainFactory.apply(domListener);
- this.codec = codec;
+ this.adapterContext = requireNonNull(codec);
}
@Override
@Override
public ReadTransaction newReadOnlyTransaction() {
- return new BindingDOMReadTransactionAdapter(createTransaction(delegate::newReadOnlyTransaction), codec);
+ return new BindingDOMReadTransactionAdapter(adapterContext,
+ createTransaction(delegate::newReadOnlyTransaction));
}
@Override
public WriteTransaction newWriteOnlyTransaction() {
final DOMDataTreeWriteTransaction delegateTx = createTransaction(delegate::newWriteOnlyTransaction);
- return new BindingDOMWriteTransactionAdapter<DOMDataTreeWriteTransaction>(delegateTx, codec) {
+ return new BindingDOMWriteTransactionAdapter<>(adapterContext, delegateTx) {
@Override
- public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+ public FluentFuture<? extends CommitInfo> commit() {
return listenForFailure(this, super.commit());
}
};
@Override
public ReadWriteTransaction newReadWriteTransaction() {
final DOMDataTreeReadWriteTransaction delegateTx = createTransaction(delegate::newReadWriteTransaction);
- return new BindingDOMReadWriteTransactionAdapter(delegateTx, codec) {
+ return new BindingDOMReadWriteTransactionAdapter(adapterContext, delegateTx) {
@Override
- public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
+ public FluentFuture<? extends CommitInfo> commit() {
return listenForFailure(this, super.commit());
}
};
* of this transaction chain), instead of DOM transaction
* which is known only to this chain, binding transaction implementation
* and underlying transaction chain.
- *
*/
LOG.debug("Transaction chain {} failed. Failed DOM Transaction {}",this,transaction,cause);
}
class BindingDOMWriteTransactionAdapter<T extends DOMDataTreeWriteTransaction> extends AbstractForwardedTransaction<T>
implements WriteTransaction {
- BindingDOMWriteTransactionAdapter(final T delegateTx, final BindingToNormalizedNodeCodec codec) {
- super(delegateTx, codec);
+ BindingDOMWriteTransactionAdapter(final AdapterContext adapterContext, final T delegateTx) {
+ super(adapterContext, delegateTx);
}
@Override
@Override
public final <U extends DataObject> void mergeParentStructurePut(final LogicalDatastoreType store,
final InstanceIdentifier<U> path, final U data) {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized("put",
- path, data);
- ensureParentsByMerge(store, normalized.getKey(), path);
+ final CurrentAdapterSerializer serializer = adapterContext().currentSerializer();
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized(serializer, "put", path,
+ data);
+ ensureParentsByMerge(serializer, store, normalized.getKey(), path);
getDelegate().put(store, normalized.getKey(), normalized.getValue());
}
@Override
public final <U extends DataObject> void mergeParentStructureMerge(final LogicalDatastoreType store,
final InstanceIdentifier<U> path, final U data) {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized("merge", path, data);
- ensureParentsByMerge(store, normalized.getKey(), path);
+ final CurrentAdapterSerializer serializer = adapterContext().currentSerializer();
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized(serializer, "merge", path,
+ data);
+ ensureParentsByMerge(serializer, store, normalized.getKey(), path);
getDelegate().merge(store, normalized.getKey(), normalized.getValue());
}
@Override
public final void delete(final LogicalDatastoreType store, final InstanceIdentifier<?> path) {
checkArgument(!path.isWildcarded(), "Cannot delete wildcarded path %s", path);
-
- final YangInstanceIdentifier normalized = getCodec().toYangInstanceIdentifierBlocking(path);
- getDelegate().delete(store, normalized);
+ getDelegate().delete(store, adapterContext().currentSerializer().toYangInstanceIdentifier(path));
}
@Override
* @param domPath an instance of YangInstanceIdentifier
* @param path an instance of InstanceIdentifier
*/
- private void ensureParentsByMerge(final LogicalDatastoreType store, final YangInstanceIdentifier domPath,
- final InstanceIdentifier<?> path) {
+ private void ensureParentsByMerge(final CurrentAdapterSerializer serializer, final LogicalDatastoreType store,
+ final YangInstanceIdentifier domPath, final InstanceIdentifier<?> path) {
final YangInstanceIdentifier parentPath = domPath.getParent();
if (parentPath != null && !parentPath.isEmpty()) {
final NormalizedNode<?, ?> parentNode = ImmutableNodes.fromInstanceId(
- getCodec().runtimeContext().getSchemaContext(), parentPath);
+ serializer.getRuntimeContext().getSchemaContext(), parentPath);
getDelegate().merge(store, YangInstanceIdentifier.create(parentNode.getIdentifier()), parentNode);
}
}
private <U extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalized(
final String operation, final InstanceIdentifier<U> path, final U data) {
+ return toNormalized(adapterContext().currentSerializer(), operation, path, data);
+ }
+
+ private static <U extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalized(
+ final CurrentAdapterSerializer serializer, final String operation, final InstanceIdentifier<U> path,
+ final U data) {
checkArgument(!path.isWildcarded(), "Cannot %s data into wildcarded path %s", operation, path);
- return getCodec().toNormalizedNode(path, data);
+ return serializer.toNormalizedNode(path, data);
}
}
private final InstanceIdentifier<?> identifier;
private final LoadingCache<Class<? extends BindingService>, Optional<BindingService>> services;
- BindingMountPointAdapter(final BindingToNormalizedNodeCodec codec, final DOMMountPoint domMountPoint) {
- identifier = codec.fromYangInstanceIdentifier(domMountPoint.getIdentifier());
+ BindingMountPointAdapter(final AdapterContext codec, final DOMMountPoint domMountPoint) {
+ identifier = codec.currentSerializer().fromYangInstanceIdentifier(domMountPoint.getIdentifier());
services = CacheBuilder.newBuilder().build(new BindingDOMAdapterLoader(codec) {
@Override
protected DOMService getDelegate(final Class<? extends DOMService> reqDeleg) {
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.dom.api.DOMActionResult;
import org.opendaylight.mdsal.dom.spi.SimpleDOMActionResult;
import org.opendaylight.yangtools.yang.binding.Action;
private final Class<? extends Action<?, ?, O>> action;
private final NodeIdentifier identifier;
- private BindingNormalizedNodeSerializer codec;
+ private AdapterContext adapterContext;
BindingOperationFluentFuture(final ListenableFuture<RpcResult<O>> userFuture,
final Class<? extends Action<?, ?, O>> action, final NodeIdentifier identifier,
- final BindingNormalizedNodeSerializer codec) {
+ final AdapterContext adapterContext) {
this.userFuture = requireNonNull(userFuture);
this.action = requireNonNull(action);
this.identifier = requireNonNull(identifier);
- this.codec = requireNonNull(codec);
+ this.adapterContext = requireNonNull(adapterContext);
userFuture.addListener(this::userFutureCompleted, MoreExecutors.directExecutor());
}
try {
final RpcResult<O> bindingResult = Futures.getDone(userFuture);
if (bindingResult.getResult() != null) {
- domResult = new SimpleDOMActionResult(
- codec.toLazyNormalizedNodeActionOutput(action, identifier, bindingResult.getResult()),
- bindingResult.getErrors());
+ domResult = new SimpleDOMActionResult(adapterContext.currentSerializer()
+ .toLazyNormalizedNodeActionOutput(action, identifier, bindingResult.getResult()),
+ bindingResult.getErrors());
} else {
domResult = new SimpleDOMActionResult(bindingResult.getErrors());
}
} catch (ExecutionException e) {
- codec = null;
+ adapterContext = null;
setException(e.getCause());
return;
} catch (RuntimeException | Error e) {
- codec = null;
+ adapterContext = null;
setException(e);
return;
}
- codec = null;
+ adapterContext = null;
set(domResult);
}
}
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. 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 com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkState;
-import static java.util.Objects.requireNonNull;
-
-import com.google.common.annotations.Beta;
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
-import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterators;
-import java.lang.reflect.Method;
-import java.time.Instant;
-import java.util.AbstractMap.SimpleEntry;
-import java.util.Collection;
-import java.util.Map.Entry;
-import java.util.Optional;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
-import javax.annotation.PreDestroy;
-import javax.inject.Inject;
-import javax.inject.Singleton;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.binding.runtime.api.BindingRuntimeContext;
-import org.opendaylight.binding.runtime.api.BindingRuntimeGenerator;
-import org.opendaylight.binding.runtime.api.ClassLoadingStrategy;
-import org.opendaylight.binding.runtime.api.DefaultBindingRuntimeContext;
-import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingLazyContainerNode;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
-import org.opendaylight.mdsal.binding.dom.codec.api.MissingSchemaException;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
-import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
-import org.opendaylight.mdsal.dom.api.DOMSchemaService;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.Action;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.binding.Notification;
-import org.opendaylight.yangtools.yang.binding.RpcInput;
-import org.opendaylight.yangtools.yang.binding.RpcOutput;
-import org.opendaylight.yangtools.yang.binding.RpcService;
-import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
-import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * A combinations of {@link BindingCodecTreeFactory} and {@link BindingNormalizedNodeSerializer}, with internal
- * caching of instance identifiers.
- *
- * <p>
- * NOTE: this class is non-final to allow controller adapter migration without duplicated code.
- */
-@Singleton
-public class BindingToNormalizedNodeCodec implements BindingNormalizedNodeSerializer, EffectiveModelContextListener,
- AutoCloseable {
-
- private static final long WAIT_DURATION_SEC = 5;
- private static final Logger LOG = LoggerFactory.getLogger(BindingToNormalizedNodeCodec.class);
-
- private final LoadingCache<InstanceIdentifier<?>, YangInstanceIdentifier> iiCache = CacheBuilder.newBuilder()
- .softValues().build(new CacheLoader<InstanceIdentifier<?>, YangInstanceIdentifier>() {
- @Override
- public YangInstanceIdentifier load(final InstanceIdentifier<?> key) {
- return toYangInstanceIdentifierBlocking(key);
- }
- });
- private final BindingNormalizedNodeCodecRegistry codecRegistry;
- private final ClassLoadingStrategy classLoadingStrategy;
- private final BindingRuntimeGenerator generator;
- private final FutureSchema futureSchema;
-
- private ListenerRegistration<?> listenerRegistration;
-
- @Inject
- public BindingToNormalizedNodeCodec(final BindingRuntimeGenerator generator,
- final ClassLoadingStrategy classLoadingStrategy, final BindingNormalizedNodeCodecRegistry codecRegistry) {
- this(generator, classLoadingStrategy, codecRegistry, false);
- }
-
- @Beta
- public BindingToNormalizedNodeCodec(final BindingRuntimeContext runtimeContext) {
- generator = (final SchemaContext context) -> {
- throw new UnsupportedOperationException("Static context assigned");
- };
- classLoadingStrategy = runtimeContext.getStrategy();
- codecRegistry = new BindingNormalizedNodeCodecRegistry(runtimeContext);
- // TODO: this should have a specialized constructor or not be needed
- futureSchema = FutureSchema.create(0, TimeUnit.SECONDS, false);
- futureSchema.onRuntimeContextUpdated(runtimeContext);
- }
-
- public BindingToNormalizedNodeCodec(final BindingRuntimeGenerator generator,
- final ClassLoadingStrategy classLoadingStrategy, final BindingNormalizedNodeCodecRegistry codecRegistry,
- final boolean waitForSchema) {
- this.generator = requireNonNull(generator, "generator");
- this.classLoadingStrategy = requireNonNull(classLoadingStrategy, "classLoadingStrategy");
- this.codecRegistry = requireNonNull(codecRegistry, "codecRegistry");
- this.futureSchema = FutureSchema.create(WAIT_DURATION_SEC, TimeUnit.SECONDS, waitForSchema);
- }
-
- public static BindingToNormalizedNodeCodec newInstance(final BindingRuntimeGenerator generator,
- final ClassLoadingStrategy classLoadingStrategy, final DOMSchemaService schemaService) {
- final BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry();
- BindingToNormalizedNodeCodec instance = new BindingToNormalizedNodeCodec(generator, classLoadingStrategy,
- codecRegistry, true);
- instance.listenerRegistration = schemaService.registerSchemaContextListener(instance);
- return instance;
- }
-
- protected YangInstanceIdentifier toYangInstanceIdentifierBlocking(
- final InstanceIdentifier<? extends DataObject> binding) {
- try {
- return codecRegistry.toYangInstanceIdentifier(binding);
- } catch (final MissingSchemaException e) {
- waitForSchema(decompose(binding), e);
- return codecRegistry.toYangInstanceIdentifier(binding);
- }
- }
-
- @Override
- public final YangInstanceIdentifier toYangInstanceIdentifier(final InstanceIdentifier<?> binding) {
- return codecRegistry.toYangInstanceIdentifier(binding);
- }
-
- protected YangInstanceIdentifier toYangInstanceIdentifierCached(final InstanceIdentifier<?> binding) {
- return iiCache.getUnchecked(binding);
- }
-
- @Override
- public final <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
- final InstanceIdentifier<T> path, final T data) {
- try {
- return codecRegistry.toNormalizedNode(path, data);
- } catch (final MissingSchemaException e) {
- waitForSchema(decompose(path), e);
- return codecRegistry.toNormalizedNode(path, data);
- }
- }
-
- @Override
- public final Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data) {
- return codecRegistry.fromNormalizedNode(path, data);
- }
-
- @Override
- public final Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data) {
- return codecRegistry.fromNormalizedNodeNotification(path, data);
- }
-
- @Override
- public final Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data,
- final Instant eventInstant) {
- return codecRegistry.fromNormalizedNodeNotification(path, data, eventInstant);
- }
-
- @Override
- public final DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) {
- return codecRegistry.fromNormalizedNodeRpcData(path, data);
- }
-
- @Override
- public <T extends RpcInput> T fromNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
- final ContainerNode input) {
- return codecRegistry.fromNormalizedNodeActionInput(action, input);
- }
-
- @Override
- public <T extends RpcOutput> T fromNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
- final ContainerNode output) {
- return codecRegistry.fromNormalizedNodeActionOutput(action, output);
- }
-
- @Override
- public final <T extends DataObject> InstanceIdentifier<T> fromYangInstanceIdentifier(
- final YangInstanceIdentifier dom) {
- return codecRegistry.fromYangInstanceIdentifier(dom);
- }
-
- @Override
- public final ContainerNode toNormalizedNodeNotification(final Notification data) {
- return codecRegistry.toNormalizedNodeNotification(data);
- }
-
- @Override
- public final ContainerNode toNormalizedNodeRpcData(final DataContainer data) {
- return codecRegistry.toNormalizedNodeRpcData(data);
- }
-
- @Override
- public ContainerNode toNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
- final RpcInput input) {
- return codecRegistry.toNormalizedNodeActionInput(action, input);
- }
-
- @Override
- public ContainerNode toNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
- final RpcOutput output) {
- return codecRegistry.toNormalizedNodeActionOutput(action, output);
- }
-
- @Override
- public BindingLazyContainerNode<RpcInput> toLazyNormalizedNodeActionInput(
- final Class<? extends Action<?, ?, ?>> action, final NodeIdentifier identifier, final RpcInput input) {
- return codecRegistry.toLazyNormalizedNodeActionInput(action, identifier, input);
- }
-
- @Override
- public BindingLazyContainerNode<RpcOutput> toLazyNormalizedNodeActionOutput(
- final Class<? extends Action<?, ?, ?>> action, final NodeIdentifier identifier, final RpcOutput output) {
- return codecRegistry.toLazyNormalizedNodeActionOutput(action, identifier, output);
- }
-
- /**
- * Returns a Binding-Aware instance identifier from normalized
- * instance-identifier if it is possible to create representation.
- *
- * <p>
- * Returns Optional.empty for cases where target is mixin node except
- * augmentation.
- */
- public final Optional<InstanceIdentifier<? extends DataObject>> toBinding(final YangInstanceIdentifier normalized)
- throws DeserializationException {
- try {
- return Optional.ofNullable(codecRegistry.fromYangInstanceIdentifier(normalized));
- } catch (final IllegalArgumentException e) {
- return Optional.empty();
- }
- }
-
- @Override
- public void onModelContextUpdated(final EffectiveModelContext newModelContext) {
- final BindingRuntimeContext runtimeContext = DefaultBindingRuntimeContext.create(
- generator.generateTypeMapping(newModelContext), classLoadingStrategy);
- codecRegistry.onBindingRuntimeContextUpdated(runtimeContext);
- futureSchema.onRuntimeContextUpdated(runtimeContext);
- }
-
- public final BindingNormalizedNodeCodecRegistry getCodecRegistry() {
- return codecRegistry;
- }
-
- @Override
- @PreDestroy
- public void close() {
- if (listenerRegistration != null) {
- listenerRegistration.close();
- }
- }
-
- // FIXME: This should be probably part of Binding Runtime context
- public final ImmutableBiMap<Method, SchemaPath> getRpcMethodToSchemaPath(final Class<? extends RpcService> key) {
- final Module module = getModuleBlocking(key);
- final ImmutableBiMap.Builder<Method, SchemaPath> ret = ImmutableBiMap.builder();
- try {
- for (final RpcDefinition rpcDef : module.getRpcs()) {
- final Method method = findRpcMethod(key, rpcDef);
- ret.put(method, rpcDef.getPath());
- }
- } catch (final NoSuchMethodException e) {
- throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
- }
- return ret.build();
- }
-
- protected ImmutableBiMap<Method, RpcDefinition> getRpcMethodToSchema(final Class<? extends RpcService> key) {
- final Module module = getModuleBlocking(key);
- final ImmutableBiMap.Builder<Method, RpcDefinition> ret = ImmutableBiMap.builder();
- try {
- for (final RpcDefinition rpcDef : module.getRpcs()) {
- final Method method = findRpcMethod(key, rpcDef);
- ret.put(method, rpcDef);
- }
- } catch (final NoSuchMethodException e) {
- throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
- }
- return ret.build();
- }
-
- private Module getModuleBlocking(final Class<?> modeledClass) {
- final QNameModule moduleName = BindingReflections.getQNameModule(modeledClass);
- BindingRuntimeContext localRuntimeContext = runtimeContext();
- Module module = localRuntimeContext == null ? null :
- localRuntimeContext.getSchemaContext().findModule(moduleName).orElse(null);
- if (module == null && futureSchema.waitForSchema(moduleName)) {
- localRuntimeContext = runtimeContext();
- checkState(localRuntimeContext != null, "BindingRuntimeContext is not available.");
- module = localRuntimeContext.getSchemaContext().findModule(moduleName).orElse(null);
- }
- if (module != null) {
- return module;
- }
-
- LOG.debug("Schema for {} is not available; expected module name: {}; BindingRuntimeContext: {}",
- modeledClass, moduleName, localRuntimeContext);
- throw new IllegalStateException(String.format("Schema for %s is not available; expected module name: %s; "
- + "full BindingRuntimeContext available in debug log", modeledClass, moduleName));
- }
-
- private void waitForSchema(final Collection<Class<?>> binding, final MissingSchemaException exception) {
- LOG.warn("Blocking thread to wait for schema convergence updates for {} {}", futureSchema.getDuration(),
- futureSchema.getUnit());
- if (!futureSchema.waitForSchema(binding)) {
- throw exception;
- }
- }
-
- private Method findRpcMethod(final Class<? extends RpcService> key, final RpcDefinition rpcDef)
- throws NoSuchMethodException {
- final String methodName = BindingMapping.getRpcMethodName(rpcDef.getQName());
- final Class<?> inputClz = runtimeContext().getClassForSchema(rpcDef.getInput());
- return key.getMethod(methodName, inputClz);
- }
-
- protected @NonNull Entry<InstanceIdentifier<?>, BindingDataObjectCodecTreeNode<?>> getSubtreeCodec(
- final YangInstanceIdentifier domIdentifier) {
-
- final BindingCodecTree currentCodecTree = codecRegistry.getCodecContext();
- final InstanceIdentifier<?> bindingPath = codecRegistry.fromYangInstanceIdentifier(domIdentifier);
- checkArgument(bindingPath != null);
- /**
- * If we are able to deserialize YANG instance identifier, getSubtreeCodec must
- * return non-null value.
- */
- final BindingDataObjectCodecTreeNode<?> codecContext = currentCodecTree.getSubtreeCodec(bindingPath);
- return new SimpleEntry<>(bindingPath, codecContext);
- }
-
- final SchemaPath getActionPath(final Class<? extends Action<?, ?, ?>> type) {
- final ActionDefinition schema = runtimeContext().getActionDefinition(type);
- checkArgument(schema != null, "Failed to find schema for %s", type);
- return schema.getPath();
- }
-
- final BindingRuntimeContext runtimeContext() {
- return futureSchema.runtimeContext();
- }
-
- private static Collection<Class<?>> decompose(final InstanceIdentifier<?> path) {
- return ImmutableSet.copyOf(Iterators.transform(path.getPathArguments().iterator(), PathArgument::getType));
- }
-
- protected Collection<DOMDataTreeIdentifier> toDOMDataTreeIdentifiers(
- final Collection<DataTreeIdentifier<?>> subtrees) {
- return subtrees.stream().map(this::toDOMDataTreeIdentifier).collect(Collectors.toSet());
- }
-
- protected DOMDataTreeIdentifier toDOMDataTreeIdentifier(final DataTreeIdentifier<?> path) {
- final YangInstanceIdentifier domPath = toYangInstanceIdentifierBlocking(path.getRootIdentifier());
- return new DOMDataTreeIdentifier(path.getDatastoreType(), domPath);
- }
-}
--- /dev/null
+/*
+ * Copyright (c) 2020 PANTHEON.tech, 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 com.google.common.annotations.Beta;
+import java.util.ServiceLoader;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import org.eclipse.jdt.annotation.NonNull;
+import org.kohsuke.MetaInfServices;
+import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
+
+/**
+ * A simple, constant implementation of the BlockingBindingNormalizer contract. This implementation is appropriate
+ * in contexts where the backing context cannot change.
+ */
+@Beta
+@MetaInfServices
+@Singleton
+public final class ConstantAdapterContext implements AdapterContext {
+ private final @NonNull CurrentAdapterSerializer serializer;
+
+ public ConstantAdapterContext() {
+ this(ServiceLoader.load(BindingDOMCodecServices.class).findFirst()
+ .orElseThrow(() -> new IllegalStateException("Cannot load BindingDOMCodecServices")));
+ }
+
+ @Inject
+ public ConstantAdapterContext(final BindingDOMCodecServices codec) {
+ this.serializer = new CurrentAdapterSerializer(codec);
+ }
+
+ @Override
+ public CurrentAdapterSerializer currentSerializer() {
+ return serializer;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2020 PANTHEON.tech, 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 com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.annotations.Beta;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.google.common.collect.ImmutableBiMap;
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.stream.Collectors;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.binding.runtime.api.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
+import org.opendaylight.mdsal.binding.dom.codec.spi.ForwardingBindingDOMCodecServices;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
+import org.opendaylight.yangtools.yang.binding.Action;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.RpcService;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Beta
+@VisibleForTesting
+public final class CurrentAdapterSerializer extends ForwardingBindingDOMCodecServices {
+ private static final Logger LOG = LoggerFactory.getLogger(CurrentAdapterSerializer.class);
+
+ private final LoadingCache<InstanceIdentifier<?>, YangInstanceIdentifier> cache = CacheBuilder.newBuilder()
+ .softValues().build(new CacheLoader<InstanceIdentifier<?>, YangInstanceIdentifier>() {
+ @Override
+ public YangInstanceIdentifier load(final InstanceIdentifier<?> key) {
+ return toYangInstanceIdentifier(key);
+ }
+ });
+
+ private final @NonNull BindingDOMCodecServices delegate;
+
+ public CurrentAdapterSerializer(final BindingDOMCodecServices delegate) {
+ this.delegate = requireNonNull(delegate);
+ }
+
+ @Override
+ protected BindingDOMCodecServices delegate() {
+ return delegate;
+ }
+
+ @NonNull YangInstanceIdentifier toCachedYangInstanceIdentifier(final @NonNull InstanceIdentifier<?> path) {
+ return cache.getUnchecked(path);
+ }
+
+ <T extends DataObject> @NonNull InstanceIdentifier<T> coerceInstanceIdentifier(final YangInstanceIdentifier dom) {
+ return verifyNotNull(fromYangInstanceIdentifier(dom));
+ }
+
+ DOMDataTreeIdentifier toDOMDataTreeIdentifier(final DataTreeIdentifier<?> path) {
+ return new DOMDataTreeIdentifier(path.getDatastoreType(), toYangInstanceIdentifier(path.getRootIdentifier()));
+ }
+
+ Collection<DOMDataTreeIdentifier> toDOMDataTreeIdentifiers(final Collection<DataTreeIdentifier<?>> subtrees) {
+ return subtrees.stream().map(this::toDOMDataTreeIdentifier).collect(Collectors.toSet());
+ }
+
+ @NonNull SchemaPath getActionPath(final @NonNull Class<? extends Action<?, ?, ?>> type) {
+ final ActionDefinition schema = getRuntimeContext().getActionDefinition(type);
+ checkArgument(schema != null, "Failed to find schema for %s", type);
+ return schema.getPath();
+ }
+
+ // FIXME: This should be probably part of Binding Runtime context
+ ImmutableBiMap<Method, RpcDefinition> getRpcMethodToSchema(final Class<? extends RpcService> key) {
+ final Module module = getModule(key);
+ final ImmutableBiMap.Builder<Method, RpcDefinition> ret = ImmutableBiMap.builder();
+ try {
+ for (final RpcDefinition rpcDef : module.getRpcs()) {
+ final Method method = findRpcMethod(key, rpcDef);
+ ret.put(method, rpcDef);
+ }
+ } catch (final NoSuchMethodException e) {
+ throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
+ }
+ return ret.build();
+ }
+
+ // FIXME: This should be probably part of Binding Runtime context
+ ImmutableBiMap<Method, SchemaPath> getRpcMethodToSchemaPath(final Class<? extends RpcService> key) {
+ final Module module = getModule(key);
+ final ImmutableBiMap.Builder<Method, SchemaPath> ret = ImmutableBiMap.builder();
+ try {
+ for (final RpcDefinition rpcDef : module.getRpcs()) {
+ final Method method = findRpcMethod(key, rpcDef);
+ ret.put(method, rpcDef.getPath());
+ }
+ } catch (final NoSuchMethodException e) {
+ throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
+ }
+ return ret.build();
+ }
+
+ private Module getModule(final Class<?> modeledClass) {
+ final QNameModule moduleName = BindingReflections.getQNameModule(modeledClass);
+ final BindingRuntimeContext localRuntimeContext = getRuntimeContext();
+ final Module module = localRuntimeContext.getSchemaContext().findModule(moduleName).orElse(null);
+ if (module != null) {
+ return module;
+ }
+
+ LOG.trace("Schema for {} is not available; expected module name: {}; BindingRuntimeContext: {}",
+ modeledClass, moduleName, localRuntimeContext);
+ throw new IllegalStateException(String.format("Schema for %s is not available; expected module name: %s; "
+ + "full BindingRuntimeContext available in trace log", modeledClass, moduleName));
+ }
+
+ private Method findRpcMethod(final Class<? extends RpcService> key, final RpcDefinition rpcDef)
+ throws NoSuchMethodException {
+ final String methodName = BindingMapping.getRpcMethodName(rpcDef.getQName());
+ final Class<?> inputClz = getRuntimeContext().getClassForSchema(rpcDef.getInput());
+ return key.getMethod(methodName, inputClz);
+ }
+}
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
-import java.util.Map.Entry;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataObjectModification;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCandidate;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
}
@SuppressWarnings({"unchecked", "rawtypes"})
- static <T extends DataObject> DataTreeModification<T> create(final BindingToNormalizedNodeCodec codec,
+ static <T extends DataObject> DataTreeModification<T> create(final CurrentAdapterSerializer serializer,
final DataTreeCandidate domChange, final LogicalDatastoreType datastoreType) {
- final Entry<InstanceIdentifier<?>, BindingDataObjectCodecTreeNode<?>> codecCtx = codec.getSubtreeCodec(
- domChange.getRootPath());
- final DataTreeIdentifier<?> path = DataTreeIdentifier.create(datastoreType, codecCtx.getKey());
- final DataObjectModification<?> modification = LazyDataObjectModification.create(codecCtx.getValue(),
- domChange.getRootNode());
- return new LazyDataTreeModification(path, modification);
+ final InstanceIdentifier<?> bindingPath = serializer.coerceInstanceIdentifier(domChange.getRootPath());
+ final BindingDataObjectCodecTreeNode<?> codec = serializer.getSubtreeCodec(bindingPath);
+ final DataTreeIdentifier<?> path = DataTreeIdentifier.create(datastoreType, bindingPath);
+ return new LazyDataTreeModification(path, LazyDataObjectModification.create(codec, domChange.getRootNode()));
}
@SuppressWarnings({"unchecked", "rawtypes"})
- static <T extends DataObject> DataTreeModification<T> create(final BindingToNormalizedNodeCodec codec,
+ static <T extends DataObject> DataTreeModification<T> create(final CurrentAdapterSerializer serializer,
final DOMDataTreeCandidate candidate) {
- final Entry<InstanceIdentifier<?>, BindingDataObjectCodecTreeNode<?>> codecCtx = codec.getSubtreeCodec(
- candidate.getRootPath().getRootIdentifier());
- final DataTreeIdentifier<?> path = DataTreeIdentifier.create(candidate.getRootPath().getDatastoreType(),
- codecCtx.getKey());
- final DataObjectModification<?> modification = LazyDataObjectModification.create(codecCtx.getValue(),
- candidate.getRootNode());
- return new LazyDataTreeModification(path, modification);
+ final DOMDataTreeIdentifier domRootPath = candidate.getRootPath();
+ final InstanceIdentifier<?> bindingPath = serializer.coerceInstanceIdentifier(domRootPath.getRootIdentifier());
+ final BindingDataObjectCodecTreeNode<?> codec = serializer.getSubtreeCodec(bindingPath);
+ return new LazyDataTreeModification(DataTreeIdentifier.create(domRootPath.getDatastoreType(), bindingPath),
+ LazyDataObjectModification.create(codec, candidate.getRootNode()));
}
static <T extends DataObject> @NonNull Collection<DataTreeModification<T>> from(
- final BindingToNormalizedNodeCodec codec, final Collection<DataTreeCandidate> domChanges,
+ final CurrentAdapterSerializer codec, final Collection<DataTreeCandidate> domChanges,
final LogicalDatastoreType datastoreType) {
final List<DataTreeModification<T>> result = new ArrayList<>(domChanges.size());
for (final DataTreeCandidate domChange : domChanges) {
--- /dev/null
+/*
+ * Copyright (c) 2020 PANTHEON.tech, 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 com.google.common.base.Verify.verifyNotNull;
+
+import com.google.common.annotations.Beta;
+import org.opendaylight.mdsal.binding.dom.adapter.spi.AdapterFactory;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Reference;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Beta
+@Component(immediate = true, service = AdapterFactory.class)
+// TODO: once we have constructor injection, unify this with BindingAdapterFactory
+public final class OSGiBindingAdapterFactory extends AbstractAdapterFactory {
+ private static final Logger LOG = LoggerFactory.getLogger(OSGiBindingAdapterFactory.class);
+
+ @Reference
+ AdapterContext codec = null;
+
+ @Override
+ AdapterContext context() {
+ return verifyNotNull(codec);
+ }
+
+ @Activate
+ @SuppressWarnings("static-method")
+ void activate() {
+ LOG.info("Binding Adapter Factory activated");
+ }
+
+ @Deactivate
+ @SuppressWarnings("static-method")
+ void deactivate() {
+ LOG.info("Binding Adapter Factory deactivated");
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2020 PANTHEON.tech, 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 com.google.common.base.Verify.verifyNotNull;
+
+import com.google.common.annotations.Beta;
+import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Reference;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Beta
+@Component(immediate = true, service = AdapterContext.class)
+public final class OSGiBlockingBindingNormalizer implements AdapterContext {
+ private static final Logger LOG = LoggerFactory.getLogger(OSGiBlockingBindingNormalizer.class);
+
+ @Reference(updated = "update")
+ volatile BindingDOMCodecServices codec = null;
+
+ private volatile CurrentAdapterSerializer serializer;
+
+ @Override
+ public CurrentAdapterSerializer currentSerializer() {
+ return verifyNotNull(serializer);
+ }
+
+ @Activate
+ void activate() {
+ serializer = new CurrentAdapterSerializer(codec);
+ LOG.info("Binding/DOM adapter activated");
+ }
+
+ @Deactivate
+ void deactivate() {
+ serializer = null;
+ LOG.info("Binding/DOM adapter deactivated");
+ }
+
+ void update() {
+ serializer = new CurrentAdapterSerializer(codec);
+ LOG.info("Binding/DOM adapter updated");
+ }
+}
import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.dom.adapter.StaticConfiguration.ENABLE_CODEC_SHORTCUT;
+import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMap.Builder;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
class RpcServiceAdapter implements InvocationHandler {
private final ImmutableMap<Method, RpcInvocationStrategy> rpcNames;
private final Class<? extends RpcService> type;
- private final BindingToNormalizedNodeCodec codec;
+ private final AdapterContext adapterContext;
private final DOMRpcService delegate;
private final RpcService proxy;
- RpcServiceAdapter(final Class<? extends RpcService> type, final BindingToNormalizedNodeCodec codec,
+ RpcServiceAdapter(final Class<? extends RpcService> type, final AdapterContext adapterContext,
final DOMRpcService domService) {
this.type = requireNonNull(type);
- this.codec = requireNonNull(codec);
+ this.adapterContext = requireNonNull(adapterContext);
this.delegate = requireNonNull(domService);
- final ImmutableMap.Builder<Method, RpcInvocationStrategy> rpcBuilder = ImmutableMap.builder();
- for (final Entry<Method, RpcDefinition> rpc : codec.getRpcMethodToSchema(type).entrySet()) {
+
+ final ImmutableBiMap<Method, RpcDefinition> methods = adapterContext.currentSerializer()
+ .getRpcMethodToSchema(type);
+ final Builder<Method, RpcInvocationStrategy> rpcBuilder = ImmutableMap.builderWithExpectedSize(methods.size());
+ for (final Entry<Method, RpcDefinition> rpc : methods.entrySet()) {
rpcBuilder.put(rpc.getKey(), createStrategy(rpc.getKey(), rpc.getValue()));
}
rpcNames = rpcBuilder.build();
}
private abstract class RpcInvocationStrategy {
-
private final SchemaPath rpcName;
- protected RpcInvocationStrategy(final SchemaPath path) {
+ RpcInvocationStrategy(final SchemaPath path) {
rpcName = path;
}
return ((BindingRpcFutureAware) result).getBindingFuture();
}
- return transformFuture(schemaPath, result, codec.getCodecRegistry());
+ return transformFuture(schemaPath, result, adapterContext.currentSerializer());
}
private ListenableFuture<RpcResult<?>> transformFuture(final SchemaPath rpc,
}
private final class NonRoutedStrategy extends RpcInvocationStrategy {
-
- protected NonRoutedStrategy(final SchemaPath path) {
+ NonRoutedStrategy(final SchemaPath path) {
super(path);
}
@Override
ContainerNode serialize(final DataObject input) {
- return LazySerializedContainerNode.create(getRpcName(), input, codec.getCodecRegistry());
+ return LazySerializedContainerNode.create(getRpcName(), input, adapterContext.currentSerializer());
}
-
}
private final class RoutedStrategy extends RpcInvocationStrategy {
-
private final ContextReferenceExtractor refExtractor;
private final NodeIdentifier contextName;
- protected RoutedStrategy(final SchemaPath path, final Method rpcMethod, final QName leafName) {
+ RoutedStrategy(final SchemaPath path, final Method rpcMethod, final QName leafName) {
super(path);
final Optional<Class<? extends DataContainer>> maybeInputType =
BindingReflections.resolveRpcInputClass(rpcMethod);
@Override
ContainerNode serialize(final DataObject input) {
final InstanceIdentifier<?> bindingII = refExtractor.extract(input);
+ final CurrentAdapterSerializer serializer = adapterContext.currentSerializer();
+
if (bindingII != null) {
- final YangInstanceIdentifier yangII = codec.toYangInstanceIdentifierCached(bindingII);
+ final YangInstanceIdentifier yangII = serializer.toCachedYangInstanceIdentifier(bindingII);
final LeafNode<?> contextRef = ImmutableNodes.leafNode(contextName, yangII);
- return LazySerializedContainerNode.withContextRef(getRpcName(), input, contextRef,
- codec.getCodecRegistry());
+ return LazySerializedContainerNode.withContextRef(getRpcName(), input, contextRef, serializer);
}
- return LazySerializedContainerNode.create(getRpcName(), input, codec.getCodecRegistry());
+ return LazySerializedContainerNode.create(getRpcName(), input, serializer);
}
}
import com.google.common.collect.ImmutableList;
import java.util.List;
-import org.checkerframework.checker.lock.qual.GuardedBy;
import org.opendaylight.mdsal.binding.api.ActionProviderService;
import org.opendaylight.mdsal.binding.api.ActionService;
import org.opendaylight.mdsal.binding.api.BindingService;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMService;
import org.osgi.framework.BundleContext;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Reference;
import org.osgi.util.tracker.ServiceTracker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Robert Varga
*/
-public final class DynamicBindingAdapter implements AutoCloseable {
+@Component(immediate = true)
+public final class DynamicBindingAdapter {
private static final Logger LOG = LoggerFactory.getLogger(DynamicBindingAdapter.class);
- @GuardedBy("this")
- private List<AdaptingTracker<?, ?>> trackers;
+ private List<AdaptingTracker<?, ?>> trackers = ImmutableList.of();
- public DynamicBindingAdapter(final AdapterFactory factory, final BundleContext ctx) {
+ @Reference
+ AdapterFactory factory = null;
+
+ @Activate
+ void activate(final BundleContext ctx) {
trackers = ImmutableList.of(
new AdaptingTracker<>(ctx, DOMDataBroker.class, DataBroker.class, factory::createDataBroker),
new AdaptingTracker<>(ctx, DOMDataTreeService.class, DataTreeService.class, factory::createDataTreeService),
LOG.info("{} DOMService trackers started", trackers.size());
}
- @Override
- public void close() {
- final List<AdaptingTracker<?, ?>> toClose;
- synchronized (this) {
- toClose = trackers;
- trackers = ImmutableList.of();
- }
-
- LOG.debug("Stopping {} DOMService trackers", toClose.size());
- if (!toClose.isEmpty()) {
- toClose.forEach(AdaptingTracker::close);
- LOG.info("{} DOMService trackers stopped", toClose.size());
+ @Deactivate
+ void deactivate() {
+ LOG.debug("Stopping {} DOMService trackers", trackers.size());
+ if (!trackers.isEmpty()) {
+ trackers.forEach(AdaptingTracker::close);
+ LOG.info("{} DOMService trackers stopped", trackers.size());
}
+ trackers = ImmutableList.of();
}
}
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
- xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0">
-
- <!-- Runtime binding/normalized mapping service -->
- <reference id="classLoadingStrategy" interface="org.opendaylight.mdsal.binding.generator.api.ClassLoadingStrategy"/>
- <reference id="schemaService" interface="org.opendaylight.mdsal.dom.api.DOMSchemaService" />
-
- <bean id="mappingCodec" class="org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec"
- factory-method="newInstance" destroy-method="close">
- <argument ref="classLoadingStrategy"/>
- <argument ref="schemaService"/>
- </bean>
-
- <!-- Adapter factory based on the codec -->
- <bean id="adapterFactory" class="org.opendaylight.mdsal.binding.dom.adapter.BindingAdapterFactory">
- <argument ref="mappingCodec"/>
- </bean>
-
- <!-- Automatic DOM/Binding adapter instantiation -->
- <bean id="dynamicAdapter" class="org.opendaylight.mdsal.binding.dom.adapter.osgi.DynamicBindingAdapter"
- destroy-method="close">
- <argument ref="adapterFactory"/>
- <argument ref="blueprintBundleContext"/>
- </bean>
-
- <service ref="adapterFactory" interface="org.opendaylight.mdsal.binding.dom.adapter.spi.AdapterFactory"/>
-</blueprint>
import org.opendaylight.mdsal.binding.dom.adapter.test.util.BindingTestContext;
public abstract class AbstractAdapterTest {
- protected BindingToNormalizedNodeCodec codec;
+ protected AdapterContext codec;
@Before
public void before() {
import static org.junit.Assert.assertEquals;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.binding.runtime.spi.BindingRuntimeHelpers;
+import org.opendaylight.mdsal.binding.dom.codec.impl.BindingCodecContext;
import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
import org.opendaylight.yang.gen.v1.urn.odl.actions.norev.Cont;
import org.opendaylight.yang.gen.v1.urn.odl.actions.norev.Grpcont;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public class ActionLookupTest {
- private static BindingToNormalizedNodeCodec CODEC;
-
- @BeforeClass
- public static void beforeClass() {
- CODEC = new BindingToNormalizedNodeCodec(
- BindingRuntimeHelpers.createRuntimeContext(new DefaultBindingRuntimeGenerator()));
- }
-
- @AfterClass
- public static void afterClass() {
- CODEC = null;
- }
-
@Test
public void testActionSchemaPath() {
- assertEquals(SchemaPath.create(true, Cont.QNAME, Foo.QNAME), CODEC.getActionPath(Foo.class));
- assertEquals(SchemaPath.create(true, Grpcont.QNAME, Bar.QNAME), CODEC.getActionPath(Bar.class));
+ CurrentAdapterSerializer codec = new CurrentAdapterSerializer(new BindingCodecContext(
+ BindingRuntimeHelpers.createRuntimeContext(new DefaultBindingRuntimeGenerator())));
+
+ assertEquals(SchemaPath.create(true, Cont.QNAME, Foo.QNAME), codec.getActionPath(Foo.class));
+ assertEquals(SchemaPath.create(true, Grpcont.QNAME, Bar.QNAME), codec.getActionPath(Bar.class));
assertEquals(SchemaPath.create(true, Othercont.QNAME, Bar.QNAME),
- CODEC.getActionPath(org.opendaylight.yang.gen.v1.urn.odl.actions.norev.othercont.Bar.class));
+ codec.getActionPath(org.opendaylight.yang.gen.v1.urn.odl.actions.norev.othercont.Bar.class));
}
}
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.TransactionChainListener;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMService;
@Mock
private DOMDataBroker domService;
-
@Mock
- private BindingNormalizedNodeCodecRegistry mockCodecRegistry;
+ private AdapterContext mockContext;
private BindingDOMAdapterLoader bindingDOMAdapterLoader;
private BindingDOMDataBrokerAdapter bindingDOMDataBrokerAdapter;
@Before
public void setUp() {
doReturn(ImmutableClassToInstanceMap.of()).when(domService).getExtensions();
- bindingDOMAdapterLoader = new BindingDOMAdapterLoader(new BindingToNormalizedNodeCodec(
- new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
- mockCodecRegistry)) {
+ bindingDOMAdapterLoader = new BindingDOMAdapterLoader(mockContext) {
@Override
protected DOMService getDelegate(final Class<? extends DOMService> reqDeleg) {
return domService;
import static org.mockito.Mockito.verify;
import org.junit.Test;
-import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
+import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCursorAwareTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteCursor;
@Test
public void basicTest() throws Exception {
final DOMDataTreeCursorAwareTransaction delegate = mock(DOMDataTreeCursorAwareTransaction.class);
- final BindingNormalizedNodeCodecRegistry registry = mock(BindingNormalizedNodeCodecRegistry.class);
- final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
- new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
- registry);
+ final BindingDOMCodecServices registry = mock(BindingDOMCodecServices.class);
+ final AdapterContext codec = new ConstantAdapterContext(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);
+ final BindingDOMCursorAwareWriteTransactionAdapter<?> adapter =
+ new BindingDOMCursorAwareWriteTransactionAdapter<>(codec, delegate);
assertNotNull(adapter.createCursor(DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.create(DataObject.class))));
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
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.binding.api.DataTreeModification;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
+import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
*
* @author Thomas Pantelis
*/
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class BindingDOMDataTreeChangeServiceAdapterTest {
private static final InstanceIdentifier<Top> TOP_PATH = InstanceIdentifier.create(Top.class);
private GeneratedClassLoadingStrategy classLoadingStrategy;
@Mock
- private BindingNormalizedNodeCodecRegistry codecRegistry;
+ private BindingDOMCodecServices services;
@Mock
private YangInstanceIdentifier mockYangID;
@Before
public void setUp() {
- MockitoAnnotations.initMocks(this);
- doReturn(this.mockYangID).when(this.codecRegistry).toYangInstanceIdentifier(TOP_PATH);
+ doReturn(mockYangID).when(services).toYangInstanceIdentifier(TOP_PATH);
}
@Test
public void testRegisterDataTreeChangeListener() {
- final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
- new DefaultBindingRuntimeGenerator(), classLoadingStrategy, codecRegistry);
+ final AdapterContext codec = new ConstantAdapterContext(services);
- final DataTreeChangeService service = BindingDOMDataTreeChangeServiceAdapter.create(codec, this.mockDOMService);
+ final DataTreeChangeService service = new BindingDOMDataTreeChangeServiceAdapter(codec, mockDOMService);
- doReturn(this.mockDOMReg).when(this.mockDOMService).registerDataTreeChangeListener(
- domDataTreeIdentifier(this.mockYangID),
+ doReturn(mockDOMReg).when(mockDOMService).registerDataTreeChangeListener(
+ domDataTreeIdentifier(mockYangID),
any(DOMDataTreeChangeListener.class));
final DataTreeIdentifier<Top> treeId = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, TOP_PATH);
final TestClusteredDataTreeChangeListener mockClusteredListener = new TestClusteredDataTreeChangeListener();
service.registerDataTreeChangeListener(treeId , mockClusteredListener);
- verify(this.mockDOMService).registerDataTreeChangeListener(domDataTreeIdentifier(this.mockYangID),
+ verify(mockDOMService).registerDataTreeChangeListener(domDataTreeIdentifier(this.mockYangID),
isA(ClusteredDOMDataTreeChangeListener.class));
- reset(this.mockDOMService);
- doReturn(this.mockDOMReg).when(this.mockDOMService).registerDataTreeChangeListener(
- domDataTreeIdentifier(this.mockYangID), any(DOMDataTreeChangeListener.class));
+ reset(mockDOMService);
+ doReturn(mockDOMReg).when(mockDOMService).registerDataTreeChangeListener(
+ domDataTreeIdentifier(mockYangID), any(DOMDataTreeChangeListener.class));
final TestDataTreeChangeListener mockNonClusteredListener = new TestDataTreeChangeListener();
service.registerDataTreeChangeListener(treeId , mockNonClusteredListener);
import java.util.Arrays;
import java.util.Collection;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
-import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.binding.api.DataTreeCommitCohort;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
+import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.PostCanCommitStep;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class BindingDOMDataTreeCommitCohortAdapterTest {
@Test
- public void canCommitTest() throws Exception {
+ public void canCommitTest() {
final DataTreeCommitCohort<?> cohort = mock(DataTreeCommitCohort.class);
- final BindingNormalizedNodeCodecRegistry registry = mock(BindingNormalizedNodeCodecRegistry.class);
- final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
- new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
- registry);
+ final BindingDOMCodecServices registry = mock(BindingDOMCodecServices.class);
+ final AdapterContext codec = new ConstantAdapterContext(registry);
final BindingDOMDataTreeCommitCohortAdapter<?> adapter =
new BindingDOMDataTreeCommitCohortAdapter<>(codec, cohort);
final DOMDataTreeIdentifier domDataTreeIdentifier =
new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.empty());
doReturn(InstanceIdentifier.create(DataObject.class)).when(registry).fromYangInstanceIdentifier(any());
- final BindingCodecTree bindingCodecTree = mock(BindingCodecTree.class);
final BindingDataObjectCodecTreeNode<?> bindingCodecTreeNode = mock(BindingDataObjectCodecTreeNode.class);
- doReturn(bindingCodecTreeNode).when(bindingCodecTree).getSubtreeCodec(any(InstanceIdentifier.class));
- doReturn(bindingCodecTree).when(registry).getCodecContext();
+ doReturn(bindingCodecTreeNode).when(registry).getSubtreeCodec(any(InstanceIdentifier.class));
doReturn(domDataTreeIdentifier).when(domDataTreeCandidate).getRootPath();
doReturn(mock(DataTreeCandidateNode.class)).when(domDataTreeCandidate).getRootNode();
- assertNotNull(LazyDataTreeModification.create(codec, domDataTreeCandidate));
+ assertNotNull(LazyDataTreeModification.create(codec.currentSerializer(), domDataTreeCandidate));
final Object txId = new Object();
package org.opendaylight.mdsal.binding.dom.adapter;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
final BindingDOMDataTreeCommitCohortRegistryAdapter registryAdapter =
new BindingDOMDataTreeCommitCohortRegistryAdapter(bindingTestContext.getCodec(), cohortRegistry);
- assertNotNull(BindingDOMDataTreeCommitCohortRegistryAdapter.from(bindingTestContext.getCodec(),
- cohortRegistry));
-
final DataTreeIdentifier<Top> dataTreeIdentifier = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.create(Top.class));
final DataTreeCommitCohort<Top> dataTreeCommitCohort = mock(DataTreeCommitCohort.class);
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
-import static org.mockito.MockitoAnnotations.initMocks;
import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.MoreExecutors;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.binding.api.DataTreeProducerException;
import org.opendaylight.mdsal.binding.dom.adapter.test.util.BindingBrokerTestFactory;
import org.opendaylight.mdsal.binding.dom.adapter.test.util.BindingTestContext;
import org.opendaylight.mdsal.dom.api.DOMDataTreeProducerBusyException;
import org.opendaylight.mdsal.dom.api.DOMDataTreeProducerException;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class BindingDOMDataTreeProducerAdapterTest {
-
private BindingDOMDataTreeProducerAdapter bindingDOMDataTreeProducerAdapter;
- private BindingToNormalizedNodeCodec codec;
+ private AdapterContext codec;
@Mock
private DOMDataTreeProducer delegate;
@Before
public void setUp() {
- initMocks(this);
final BindingBrokerTestFactory testFactory = new BindingBrokerTestFactory();
testFactory.setExecutor(MoreExecutors.newDirectExecutorService());
final BindingTestContext testContext = testFactory.getTestContext();
verify(delegate).createTransaction(true);
}
- @Test
- public void createTest() {
- assertNotNull(BindingDOMDataTreeProducerAdapter.create(delegate, codec));
- }
-
@Test
public void createProducerTest() {
doReturn(mock(DOMDataTreeProducer.class)).when(delegate).createProducer(any());
initMocks(this);
super.before();
- bindingDOMDataTreeServiceAdapter = BindingDOMDataTreeServiceAdapter.create(delegate, codec);
+ bindingDOMDataTreeServiceAdapter = new BindingDOMDataTreeServiceAdapter(codec, delegate);
}
@Test
import java.util.AbstractMap.SimpleEntry;
import java.util.Deque;
import org.junit.Test;
-import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
+import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteCursor;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public class BindingDOMDataTreeWriteCursorAdapterTest {
-
@Test
public void basicTest() throws Exception {
final DataTreeIdentifier<?> identifier =
DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.create(DataObject.class));
final DOMDataTreeWriteCursor delegate = mock(DOMDataTreeWriteCursor.class);
- final BindingNormalizedNodeCodecRegistry registry = mock(BindingNormalizedNodeCodecRegistry.class);
- final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
- new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
- registry);
+ final BindingDOMCodecServices registry = mock(BindingDOMCodecServices.class);
+ final AdapterContext codec = new ConstantAdapterContext(registry);
final BindingDOMDataTreeWriteCursorAdapter<?> adapter =
- new BindingDOMDataTreeWriteCursorAdapter<>(identifier, delegate, codec);
+ new BindingDOMDataTreeWriteCursorAdapter<>(codec, delegate, identifier);
final PathArgument pathArgument = Item.of(DataObject.class);
final DataObject data = mock(DataObject.class);
public class BindingDOMMountPointListenerAdapterTest {
private BindingDOMMountPointListenerAdapter<?> bindingDOMMountPointListenerAdapter;
- private BindingToNormalizedNodeCodec codec;
+ private AdapterContext codec;
@Mock private MountPointListener listener;
@Mock private DOMMountPointService mountPointService;
import java.util.Optional;
import org.junit.Test;
-import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.binding.api.MountPointService.MountPointListener;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
+import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.yangtools.yang.binding.DataObject;
public class BindingDOMMountPointServiceAdapterTest {
@Test
public void basicTest() throws Exception {
- final BindingNormalizedNodeCodecRegistry registry = mock(BindingNormalizedNodeCodecRegistry.class);
- final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
- new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
- registry);
+ final BindingDOMCodecServices registry = mock(BindingDOMCodecServices.class);
+ final AdapterContext codec = new ConstantAdapterContext(registry);
doReturn(YangInstanceIdentifier.empty()).when(registry).toYangInstanceIdentifier(any());
final DOMMountPointService mountPointService = mock(DOMMountPointService.class);
final BindingDOMMountPointServiceAdapter adapter =
- new BindingDOMMountPointServiceAdapter(mountPointService, codec);
+ new BindingDOMMountPointServiceAdapter(codec, mountPointService);
doReturn(Optional.empty()).when(mountPointService).getMountPoint(any());
assertFalse(adapter.getMountPoint(InstanceIdentifier.create(DataObject.class)).isPresent());
import java.lang.reflect.Method;
import java.net.URI;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
+import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.bi.ba.rpcservice.rev140701.OpendaylightTestRpcServiceService;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
@Test
public void basicTest() throws Exception {
- final BindingNormalizedNodeCodecRegistry registry = mock(BindingNormalizedNodeCodecRegistry.class);
+ final BindingDOMCodecServices registry = mock(BindingDOMCodecServices.class);
final Method testMethod = this.getClass().getDeclaredMethod("testMethod");
final SchemaPath schemaPath = SchemaPath.create(true,
QName.create(QNameModule.create(new URI("tst")), "test"));
- final BindingDOMRpcImplementationAdapter adapter =
- new BindingDOMRpcImplementationAdapter(registry, OpendaylightTestRpcServiceService.class,
- ImmutableMap.of(schemaPath, testMethod), mock(OpendaylightTestRpcServiceService.class));
+ final BindingDOMRpcImplementationAdapter adapter = new BindingDOMRpcImplementationAdapter(
+ new ConstantAdapterContext(registry), OpendaylightTestRpcServiceService.class,
+ ImmutableMap.of(schemaPath, testMethod), mock(OpendaylightTestRpcServiceService.class));
assertNotNull(adapter);
}
biRpcProviderService.registerRpcImplementation((rpc, input) ->
FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult(testContext.getCodec()
- .getCodecRegistry().toNormalizedNodeRpcData(baKnockKnockOutput))),
- DOMRpcIdentifier.create(KNOCK_KNOCK_PATH, testContext.getCodec().toYangInstanceIdentifier(BA_NODE_ID)));
+ .currentSerializer().toNormalizedNodeRpcData(baKnockKnockOutput))),
+ DOMRpcIdentifier.create(KNOCK_KNOCK_PATH, testContext.getCodec().currentSerializer()
+ .toYangInstanceIdentifier(BA_NODE_ID)));
final OpendaylightKnockKnockRpcService baKnockService =
baRpcConsumerService.getRpcService(OpendaylightKnockKnockRpcService.class);
}
private ContainerNode toDOMKnockKnockInput(final KnockKnockInput from) {
- return testContext.getCodec().getCodecRegistry().toNormalizedNodeRpcData(from);
+ return testContext.getCodec().currentSerializer().toNormalizedNodeRpcData(from);
}
private static class OpendaylightKnockKnockRpcServiceImpl implements OpendaylightKnockKnockRpcService {
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.TransactionChainListener;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
+import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
private TransactionChainListener transactionChainListener;
@Mock
- private BindingNormalizedNodeCodecRegistry mockCodecRegistry;
+ private BindingDOMCodecServices mockCodecRegistry;
private BindingDOMTransactionChainAdapter bindingDOMTransactionChainAdapter;
doReturn(transactionChain).when(domService).createTransactionChain(any());
doReturn(ImmutableClassToInstanceMap.of()).when(domService).getExtensions();
- BindingDOMAdapterLoader bindingDOMAdapterLoader = new BindingDOMAdapterLoader(new BindingToNormalizedNodeCodec(
- new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
- mockCodecRegistry)) {
+ BindingDOMAdapterLoader bindingDOMAdapterLoader = new BindingDOMAdapterLoader(
+ new ConstantAdapterContext(mockCodecRegistry)) {
@Override
protected DOMService getDelegate(final Class<? extends DOMService> reqDeleg) {
return domService;
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. 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 org.junit.Assert.assertNull;
-import static org.mockito.Mockito.mock;
-import static org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy;
-
-import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
-import org.opendaylight.mdsal.dom.api.DOMMountPoint;
-
-public class BindingMountPointAdapterTest {
- @Test
- public void basicTest() throws Exception {
- final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
- new DefaultBindingRuntimeGenerator(), getTCCLClassLoadingStrategy(),
- mock(BindingNormalizedNodeCodecRegistry.class));
- final DOMMountPoint domMountPoint = mock(DOMMountPoint.class);
- final BindingMountPointAdapter bindingMountPointAdapter = new BindingMountPointAdapter(codec, domMountPoint);
- assertNull(bindingMountPointAdapter.getIdentifier());
- }
-}
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.SetMultimap;
-import com.google.common.util.concurrent.Uninterruptibles;
import java.lang.reflect.Method;
import java.net.URI;
+import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
import org.junit.Test;
-import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractSchemaAwareTest;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
+import org.opendaylight.mdsal.binding.dom.adapter.test.util.MockAdapterContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.bi.ba.rpcservice.rev140701.OpendaylightTestRpcServiceService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeLeafOnlyAugment;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.AbstractSchemaContext;
private static final YangInstanceIdentifier BI_TOP_LEVEL_LIST = YangInstanceIdentifier.builder().node(Top.QNAME)
.node(TopLevelList.QNAME).nodeWithKey(TopLevelList.QNAME, NAME_QNAME, TOP_FOO_KEY.getName()).build();
- private BindingToNormalizedNodeCodec codec;
+ private MockAdapterContext codec;
private EffectiveModelContext context;
@Override
protected void setupWithSchema(final EffectiveModelContext schemaContext) {
this.context = schemaContext;
- this.codec = new BindingToNormalizedNodeCodec(new DefaultBindingRuntimeGenerator(),
- GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), new BindingNormalizedNodeCodecRegistry(),
- true);
+ this.codec = new MockAdapterContext();
}
@Test
public void testComplexAugmentationSerialization() {
- this.codec.onModelContextUpdated(this.context);
- final PathArgument lastArg = this.codec.toYangInstanceIdentifier(BA_TREE_COMPLEX_USES).getLastPathArgument();
+ codec.onModelContextUpdated(context);
+ final PathArgument lastArg = codec.currentSerializer().toYangInstanceIdentifier(BA_TREE_COMPLEX_USES)
+ .getLastPathArgument();
assertTrue(lastArg instanceof AugmentationIdentifier);
}
-
@Test
public void testLeafOnlyAugmentationSerialization() {
- this.codec.onModelContextUpdated(this.context);
- final PathArgument leafOnlyLastArg = this.codec.toYangInstanceIdentifier(BA_TREE_LEAF_ONLY)
+ codec.onModelContextUpdated(context);
+ final PathArgument leafOnlyLastArg = codec.currentSerializer().toYangInstanceIdentifier(BA_TREE_LEAF_ONLY)
.getLastPathArgument();
assertTrue(leafOnlyLastArg instanceof AugmentationIdentifier);
assertTrue(((AugmentationIdentifier) leafOnlyLastArg).getPossibleChildNames().contains(SIMPLE_VALUE_QNAME));
}
@Test
- @SuppressWarnings("checkstyle:illegalCatch")
- public void testToYangInstanceIdentifierBlocking() {
- this.codec.onModelContextUpdated(new EmptyEffectiveModelContext());
-
- final CountDownLatch done = new CountDownLatch(1);
- final AtomicReference<YangInstanceIdentifier> yangId = new AtomicReference<>();
- final AtomicReference<RuntimeException> error = new AtomicReference<>();
- new Thread(() -> {
- try {
- yangId.set(BindingNormalizedCodecTest.this.codec.toYangInstanceIdentifierBlocking(BA_TOP_LEVEL_LIST));
- } catch (final RuntimeException e) {
- error.set(e);
- } finally {
- done.countDown();
- }
- }).start();
-
- Uninterruptibles.sleepUninterruptibly(500, TimeUnit.MILLISECONDS);
- this.codec.onModelContextUpdated(this.context);
-
- assertTrue("toYangInstanceIdentifierBlocking completed",
- Uninterruptibles.awaitUninterruptibly(done, 3, TimeUnit.SECONDS));
- if (error.get() != null) {
- throw error.get();
- }
-
- assertEquals("toYangInstanceIdentifierBlocking", BI_TOP_LEVEL_LIST, yangId.get());
- }
-
- @Test
- public void testGetRpcMethodToSchemaPathWithNoInitialSchemaContext() {
- testGetRpcMethodToSchemaPath();
- }
-
- @Test
- public void testGetRpcMethodToSchemaPathBlocking() {
- this.codec.onModelContextUpdated(new EmptyEffectiveModelContext());
- testGetRpcMethodToSchemaPath();
- }
-
- @SuppressWarnings("checkstyle:illegalCatch")
- private void testGetRpcMethodToSchemaPath() {
- final CountDownLatch done = new CountDownLatch(1);
- final AtomicReference<ImmutableBiMap<Method, SchemaPath>> retMap = new AtomicReference<>();
- final AtomicReference<RuntimeException> error = new AtomicReference<>();
- new Thread(() -> {
- try {
- retMap.set(BindingNormalizedCodecTest.this.codec.getRpcMethodToSchemaPath(
- OpendaylightTestRpcServiceService.class));
- } catch (final RuntimeException e) {
- error.set(e);
- } finally {
- done.countDown();
- }
- }).start();
-
- Uninterruptibles.sleepUninterruptibly(500, TimeUnit.MILLISECONDS);
- this.codec.onModelContextUpdated(this.context);
-
- assertTrue("getRpcMethodToSchemaPath completed",
- Uninterruptibles.awaitUninterruptibly(done, 3, TimeUnit.SECONDS));
- if (error.get() != null) {
- throw error.get();
- }
-
- for (final Method method : retMap.get().keySet()) {
- if (method.getName().equals("rockTheHouse")) {
- return;
- }
- }
-
- fail("rockTheHouse RPC method not found");
+ public void testGetRpcMethodToSchemaPath() {
+ codec.onModelContextUpdated(context);
+ final List<String> retMap = codec.currentSerializer()
+ .getRpcMethodToSchemaPath(OpendaylightTestRpcServiceService.class).keySet().stream()
+ .map(Method::getName)
+ .collect(Collectors.toList());
+ assertTrue(retMap.contains("rockTheHouse"));
}
static class EmptyEffectiveModelContext extends AbstractSchemaContext implements EffectiveModelContext {
*/
package org.opendaylight.mdsal.binding.dom.adapter;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.fail;
+import static org.junit.Assert.assertThrows;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
-import java.util.ArrayList;
-import java.util.List;
+import java.lang.reflect.Method;
import java.util.Map.Entry;
import org.junit.Test;
-import org.opendaylight.binding.runtime.api.BindingRuntimeContext;
-import org.opendaylight.binding.runtime.api.BindingRuntimeGenerator;
import org.opendaylight.binding.runtime.api.DefaultBindingRuntimeContext;
import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
+import org.opendaylight.mdsal.binding.dom.codec.impl.BindingCodecContext;
import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
-public class BindingToNormalizedNodeCodecTest {
+public class CurrentAdapterSerializerTest {
/**
* Positive test.
*
assertNotNull(value);
final Class<? extends DataObject> iface = value.implementedInterface();
assertEquals("Cont", iface.getSimpleName());
- final Object[] objs = {};
- try {
- iface.getDeclaredMethod("getVlanId").invoke(value, objs);
- fail();
- } catch (final InvocationTargetException e) {
- final Throwable cause = e.getCause();
- assertNotNull(cause);
- assertEquals(cause.getClass(), IllegalArgumentException.class);
- }
+
+ final Method getVlanId = iface.getDeclaredMethod("getVlanId");
+ final InvocationTargetException ex = assertThrows(InvocationTargetException.class,
+ () -> getVlanId.invoke(value));
+ assertThat(ex.getCause(), instanceOf(IllegalArgumentException.class));
}
private static NormalizedNode<?, ?> prepareData(final SchemaContext schemaCtx, final Object value) {
private static Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final NormalizedNode<?, ?> data,
final SchemaContext schemaCtx) {
- final GeneratedClassLoadingStrategy classLoadingStrategy =
- GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy();
- final BindingRuntimeGenerator generator = new DefaultBindingRuntimeGenerator();
- final BindingRuntimeContext ctx = DefaultBindingRuntimeContext.create(
- generator.generateTypeMapping(schemaCtx), classLoadingStrategy);
- final BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry(ctx);
- final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
- generator, classLoadingStrategy, codecRegistry);
- final List<PathArgument> pathArgs = new ArrayList<>();
- pathArgs.add(NodeIdentifier.create(QName.create("urn:test", "2017-01-01", "cont")));
+ final CurrentAdapterSerializer codec = new CurrentAdapterSerializer(new BindingCodecContext(
+ DefaultBindingRuntimeContext.create(new DefaultBindingRuntimeGenerator().generateTypeMapping(schemaCtx),
+ GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy())));
- final YangInstanceIdentifier path = YangInstanceIdentifier.create(pathArgs);
- final Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode = codec.fromNormalizedNode(path, data);
- codec.close();
- return fromNormalizedNode;
+ final YangInstanceIdentifier path = YangInstanceIdentifier.create(NodeIdentifier.create(QName.create(
+ "urn:test", "2017-01-01", "cont")));
+ return codec.fromNormalizedNode(path, data);
}
}
import java.util.concurrent.TimeUnit;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.common.RpcResult;
public class LazyDOMRpcResultFutureTest {
private LazyDOMRpcResultFuture lazyDOMRpcResultFuture;
- private final BindingNormalizedNodeCodecRegistry codec = mock(BindingNormalizedNodeCodecRegistry.class);
+ private final BindingNormalizedNodeSerializer codec = mock(BindingNormalizedNodeSerializer.class);
private final ListenableFuture<RpcResult<?>> future = mock(ListenableFuture.class);
private final RpcResult<?> domRpcResult = mock(RpcResult.class);
import static org.mockito.Mockito.mock;
import org.junit.Test;
-import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
+import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCandidate;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
public class LazyDataTreeModificationTest {
@Test
public void basicTest() throws Exception {
- final BindingNormalizedNodeCodecRegistry registry = mock(BindingNormalizedNodeCodecRegistry.class);
- final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
- new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
- registry);
+ final BindingDOMCodecServices registry = mock(BindingDOMCodecServices.class);
+ final AdapterContext codec = new ConstantAdapterContext(registry);
final DOMDataTreeCandidate domDataTreeCandidate = mock(DOMDataTreeCandidate.class);
final DOMDataTreeIdentifier domDataTreeIdentifier =
new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.empty());
doReturn(InstanceIdentifier.create(DataObject.class)).when(registry).fromYangInstanceIdentifier(any());
- final BindingCodecTree bindingCodecTree = mock(BindingCodecTree.class);
final BindingDataObjectCodecTreeNode<?> bindingCodecTreeNode = mock(BindingDataObjectCodecTreeNode.class);
- doReturn(bindingCodecTreeNode).when(bindingCodecTree).getSubtreeCodec(any(InstanceIdentifier.class));
- doReturn(bindingCodecTree).when(registry).getCodecContext();
+ doReturn(bindingCodecTreeNode).when(registry).getSubtreeCodec(any(InstanceIdentifier.class));
doReturn(domDataTreeIdentifier).when(domDataTreeCandidate).getRootPath();
doReturn(mock(DataTreeCandidateNode.class)).when(domDataTreeCandidate).getRootNode();
- assertNotNull(LazyDataTreeModification.create(codec, domDataTreeCandidate));
+ assertNotNull(LazyDataTreeModification.create(codec.currentSerializer(), domDataTreeCandidate));
}
}
\ No newline at end of file
import org.junit.Test;
import org.opendaylight.mdsal.binding.dom.adapter.test.util.BindingBrokerTestFactory;
import org.opendaylight.mdsal.binding.dom.adapter.test.util.BindingTestContext;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.bi.ba.rpcservice.rev140701.OpendaylightTestRpcServiceService;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public class LazySerializedContainerNodeTest {
-
@Test
public void basicTest() throws Exception {
final SchemaPath rpcName;
final DataObject dataObject = mock(DataObject.class);
- final BindingNormalizedNodeCodecRegistry codec = mock(BindingNormalizedNodeCodecRegistry.class);
+ final BindingNormalizedNodeSerializer codec = mock(BindingNormalizedNodeSerializer.class);
final ContainerNode containerNode = mock(ContainerNode.class);
doReturn(containerNode).when(codec).toNormalizedNodeRpcData(any());
doReturn(Optional.empty()).when(containerNode).getChild(any());
final BindingTestContext bindingTestContext = bindingBrokerTestFactory.getTestContext();
bindingTestContext.start();
- final ImmutableBiMap<?, ?> biMap =
- bindingTestContext.getCodec().getRpcMethodToSchema(OpendaylightTestRpcServiceService.class);
+ final ImmutableBiMap<?, ?> biMap = bindingTestContext.getCodec().currentSerializer()
+ .getRpcMethodToSchema(OpendaylightTestRpcServiceService.class);
rpcName = ((RpcDefinition) biMap.values().iterator().next()).getPath();
final LeafNode<?> leafNode = ImmutableLeafNodeBuilder.create().withNodeIdentifier(NodeIdentifier
.create(QName.create("", "test"))).withValue("").build();
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
-import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMDataBrokerAdapter;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMNotificationPublishServiceAdapter;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMNotificationServiceAdapter;
-import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.test.util.MockAdapterContext;
import org.opendaylight.mdsal.binding.dom.adapter.test.util.MockSchemaService;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
private final DOMNotificationRouter domNotificationRouter;
private final MockSchemaService schemaService;
private ImmutableMap<LogicalDatastoreType, DOMStore> datastores;
- private final BindingToNormalizedNodeCodec bindingToNormalized;
+ private final MockAdapterContext adapterContext;
public ImmutableMap<LogicalDatastoreType, DOMStore> createDatastores() {
return ImmutableMap.<LogicalDatastoreType, DOMStore>builder()
}
public AbstractDataBrokerTestCustomizer() {
- this.schemaService = new MockSchemaService();
- this.bindingToNormalized = new BindingToNormalizedNodeCodec(new DefaultBindingRuntimeGenerator(),
- GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), new BindingNormalizedNodeCodecRegistry());
- this.schemaService.registerSchemaContextListener(this.bindingToNormalized);
- this.domNotificationRouter = DOMNotificationRouter.create(16);
+ schemaService = new MockSchemaService();
+ adapterContext = new MockAdapterContext();
+ schemaService.registerSchemaContextListener(adapterContext);
+ domNotificationRouter = DOMNotificationRouter.create(16);
}
public DOMStore createConfigurationDatastore() {
final InMemoryDOMDataStore store = new InMemoryDOMDataStore("CFG", getDataTreeChangeListenerExecutor());
- this.schemaService.registerSchemaContextListener(store);
+ schemaService.registerSchemaContextListener(store);
return store;
}
public DOMStore createOperationalDatastore() {
final InMemoryDOMDataStore store = new InMemoryDOMDataStore("OPER", getDataTreeChangeListenerExecutor());
- this.schemaService.registerSchemaContextListener(store);
+ schemaService.registerSchemaContextListener(store);
return store;
}
}
public NotificationService createNotificationService() {
- return new BindingDOMNotificationServiceAdapter(this.domNotificationRouter,
- this.bindingToNormalized.getCodecRegistry());
+ return new BindingDOMNotificationServiceAdapter(adapterContext, domNotificationRouter);
}
public NotificationPublishService createNotificationPublishService() {
- return new BindingDOMNotificationPublishServiceAdapter(this.domNotificationRouter, this.bindingToNormalized);
+ return new BindingDOMNotificationPublishServiceAdapter(adapterContext, domNotificationRouter);
}
public abstract ListeningExecutorService getCommitCoordinatorExecutor();
}
public DataBroker createDataBroker() {
- return new BindingDOMDataBrokerAdapter(getDOMDataBroker(), this.bindingToNormalized);
+ return new BindingDOMDataBrokerAdapter(adapterContext, getDOMDataBroker());
}
- public BindingToNormalizedNodeCodec getBindingToNormalized() {
- return this.bindingToNormalized;
+ public AdapterContext getAdapterContext() {
+ return adapterContext;
}
public DOMSchemaService getSchemaService() {
- return this.schemaService;
+ return schemaService;
}
public DOMDataBroker getDOMDataBroker() {
- if (this.domDataBroker == null) {
- this.domDataBroker = createDOMDataBroker();
+ if (domDataBroker == null) {
+ domDataBroker = createDOMDataBroker();
}
- return this.domDataBroker;
+ return domDataBroker;
}
private synchronized ImmutableMap<LogicalDatastoreType, DOMStore> getDatastores() {
- if (this.datastores == null) {
- this.datastores = createDatastores();
+ if (datastores == null) {
+ datastores = createDatastores();
}
- return this.datastores;
+ return datastores;
}
public void updateSchema(final EffectiveModelContext ctx) {
- this.schemaService.changeSchema(ctx);
+ schemaService.changeSchema(ctx);
}
public DOMNotificationRouter getDomNotificationRouter() {
- return this.domNotificationRouter;
+ return domNotificationRouter;
}
}
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.NotificationService;
-import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
import org.opendaylight.mdsal.dom.broker.DOMNotificationRouter;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
public class AbstractNotificationBrokerTest extends AbstractSchemaAwareTest {
- private BindingToNormalizedNodeCodec bindingToNormalizedNodeCodec;
+ private AdapterContext bindingToNormalizedNodeCodec;
private DOMNotificationRouter domNotificationRouter;
private NotificationService notificationService;
private NotificationPublishService notificationPublishService;
domNotificationRouter = testCustomizer.getDomNotificationRouter();
notificationService = testCustomizer.createNotificationService();
notificationPublishService = testCustomizer.createNotificationPublishService();
- bindingToNormalizedNodeCodec = testCustomizer.getBindingToNormalized();
+ bindingToNormalizedNodeCodec = testCustomizer.getAdapterContext();
testCustomizer.updateSchema(context);
}
return domNotificationRouter;
}
- public BindingToNormalizedNodeCodec getBindingToNormalizedNodeCodec() {
+ public AdapterContext getBindingToNormalizedNodeCodec() {
return bindingToNormalizedNodeCodec;
}
}
SwitchOutput baSwitchOutput = new SwitchOutputBuilder().build();
biRpcProviderService.registerRpcImplementation((rpc, input) ->
- FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult(testContext.getCodec()
- .getCodecRegistry().toNormalizedNodeRpcData(baSwitchOutput))),
+ FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult(testContext.getCodec().currentSerializer()
+ .toNormalizedNodeRpcData(baSwitchOutput))),
DOMRpcIdentifier.create(SWITCH_PATH));
final Mdsal500Service baSwitchService =
}
private static ListenableFuture<RpcResult<SwitchOutput>> switchResult(final boolean success) {
- SwitchOutput output = new SwitchOutputBuilder().build();
- RpcResult<SwitchOutput> result = RpcResultBuilder.<SwitchOutput>status(success).withResult(output)
- .build();
- return Futures.immediateFuture(result);
+ return Futures.immediateFuture(RpcResultBuilder.<SwitchOutput>status(success)
+ .withResult(new SwitchOutputBuilder().build())
+ .build());
}
private static SwitchInputBuilder switchBuilder(final String foo) {
- SwitchInputBuilder builder = new SwitchInputBuilder();
- builder.setFoo(foo);
- return builder;
+ return new SwitchInputBuilder().setFoo(foo);
}
private ContainerNode toDOMSwitchInput(final SwitchInput from) {
- return testContext.getCodec().getCodecRegistry().toNormalizedNodeRpcData(from);
+ return testContext.getCodec().currentSerializer().toNormalizedNodeRpcData(from);
}
private static class Mdsal500ServiceImpl implements Mdsal500Service {
}
@Override
- public ListenableFuture<RpcResult<SwitchOutput>> switch$(SwitchInput switchInput) {
+ public ListenableFuture<RpcResult<SwitchOutput>> switch$(final SwitchInput switchInput) {
receivedSwitch.put(switchInput.getFoo(), switchInput);
return switchResult;
}
import com.google.common.util.concurrent.MoreExecutors;
import java.util.Set;
import org.opendaylight.binding.runtime.spi.BindingRuntimeHelpers;
-import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMDataBrokerAdapter;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMMountPointServiceAdapter;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMNotificationPublishServiceAdapter;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMNotificationServiceAdapter;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMRpcProviderServiceAdapter;
import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMRpcServiceAdapter;
-import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
@Beta
public class BindingTestContext implements AutoCloseable {
- private BindingToNormalizedNodeCodec codec;
+ private MockAdapterContext codec;
private final ListeningExecutorService executor;
return newDOMDataBroker;
}
- public BindingToNormalizedNodeCodec getCodec() {
+ public AdapterContext getCodec() {
return codec;
}
public void startNewDataBroker() {
checkState(executor != null, "Executor needs to be set");
checkState(newDOMDataBroker != null, "DOM Data Broker must be set");
- dataBroker = new BindingDOMDataBrokerAdapter(newDOMDataBroker, codec);
+ dataBroker = new BindingDOMDataBrokerAdapter(codec, newDOMDataBroker);
}
public void startNewDomDataBroker() {
public void startBindingBroker() {
checkState(executor != null, "Executor needs to be set");
- baConsumerRpc = new BindingDOMRpcServiceAdapter(getDomRpcInvoker(), codec);
- baProviderRpc = new BindingDOMRpcProviderServiceAdapter(getDomRpcRegistry(), codec);
- final MountPointService mountService = new BindingDOMMountPointServiceAdapter(biMountImpl, codec);
+ baConsumerRpc = new BindingDOMRpcServiceAdapter(codec, getDomRpcInvoker());
+ baProviderRpc = new BindingDOMRpcProviderServiceAdapter(codec, getDomRpcRegistry());
+ final MountPointService mountService = new BindingDOMMountPointServiceAdapter(codec, biMountImpl);
}
public void startForwarding() {
}
public void startBindingToDomMappingService() {
- final BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry();
- final GeneratedClassLoadingStrategy loading = GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy();
- codec = new BindingToNormalizedNodeCodec(new DefaultBindingRuntimeGenerator(), loading, codecRegistry);
+ codec = new MockAdapterContext();
mockSchemaService.registerSchemaContextListener(codec);
}
if (schemaModuleInfos != null) {
updateYangSchema(schemaModuleInfos);
- } else if (this.startWithSchema) {
+ } else if (startWithSchema) {
loadYangSchemaFromClasspath();
}
}
}
public void setSchemaModuleInfos(final Set<YangModuleInfo> moduleInfos) {
- this.schemaModuleInfos = moduleInfos;
+ schemaModuleInfos = moduleInfos;
}
}
--- /dev/null
+/*
+ * Copyright (c) 2020 PANTHEON.tech, 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.test.util;
+
+import static com.google.common.base.Verify.verifyNotNull;
+
+import org.opendaylight.binding.runtime.api.DefaultBindingRuntimeContext;
+import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
+import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
+import org.opendaylight.mdsal.binding.dom.adapter.CurrentAdapterSerializer;
+import org.opendaylight.mdsal.binding.dom.codec.impl.BindingCodecContext;
+import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
+
+public final class MockAdapterContext implements AdapterContext, EffectiveModelContextListener {
+ private volatile CurrentAdapterSerializer serializer = null;
+
+ @Override
+ public CurrentAdapterSerializer currentSerializer() {
+ return verifyNotNull(serializer);
+ }
+
+ @Override
+ public void onModelContextUpdated(final EffectiveModelContext newModelContext) {
+ serializer = new CurrentAdapterSerializer(new BindingCodecContext(DefaultBindingRuntimeContext.create(
+ new DefaultBindingRuntimeGenerator().generateTypeMapping(newModelContext),
+ GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy())));
+ }
+}
import com.google.common.annotations.Beta;
import com.google.common.primitives.UnsignedLong;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingIdentityCodec;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingInstanceIdentifierCodec;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingLazyContainerNode;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeWriterFactory;
import org.opendaylight.mdsal.binding.dom.codec.spi.LazyActionInputContainerNode;
import org.opendaylight.mdsal.binding.dom.codec.spi.LazyActionOutputContainerNode;
import org.opendaylight.yangtools.yang.binding.Action;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcInput;
import org.opendaylight.yangtools.yang.binding.RpcOutput;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
return new LazyActionOutputContainerNode(identifier, output, this, action);
}
- @Override
- public <T extends DataObject> BindingDataObjectCodecTreeNode<T> getSubtreeCodec(final InstanceIdentifier<T> path) {
- return delegate.getSubtreeCodec(path);
- }
-
- @Override
- public BindingCodecTreeNode getSubtreeCodec(final YangInstanceIdentifier path) {
- return delegate.getSubtreeCodec(path);
- }
-
- @Override
- public BindingCodecTreeNode getSubtreeCodec(final Absolute path) {
- return delegate.getSubtreeCodec(path);
- }
-
- @Override
- public BindingIdentityCodec getIdentityCodec() {
- return delegate.getIdentityCodec();
- }
-
- @Override
- public BindingInstanceIdentifierCodec getInstanceIdentifierCodec() {
- return delegate.getInstanceIdentifierCodec();
- }
-
@Override
protected BindingDOMCodecServices delegate() {
return verifyNotNull(delegate);
package org.opendaylight.mdsal.binding.dom.codec.spi;
import com.google.common.annotations.Beta;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.binding.runtime.api.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeWriterFactory;
public interface BindingDOMCodecServices extends BindingNormalizedNodeWriterFactory, BindingNormalizedNodeSerializer,
BindingCodecTree {
+ @NonNull BindingRuntimeContext getRuntimeContext();
}
import com.google.common.collect.ForwardingObject;
import java.time.Instant;
import java.util.Map.Entry;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.binding.runtime.api.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingIdentityCodec;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingInstanceIdentifierCodec;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingLazyContainerNode;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingStreamEventWriter;
import org.opendaylight.yangtools.yang.binding.Action;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
@Beta
public abstract class ForwardingBindingDOMCodecServices extends ForwardingObject implements BindingDOMCodecServices {
@Override
- protected abstract BindingDOMCodecServices delegate();
+ protected abstract @NonNull BindingDOMCodecServices delegate();
@Override
public BindingLazyContainerNode<RpcInput> toLazyNormalizedNodeActionInput(
@Override
public <T extends DataObject> InstanceIdentifier<T> fromYangInstanceIdentifier(final YangInstanceIdentifier dom) {
- return delegate().getInstanceIdentifierCodec().toBinding(dom);
+ return delegate().fromYangInstanceIdentifier(dom);
}
@Override
final NormalizedNodeStreamWriter streamWriter) {
return delegate().newRpcWriter(rpcInputOrOutput,streamWriter);
}
+
+ @Override
+ public <T extends DataObject> BindingDataObjectCodecTreeNode<T> getSubtreeCodec(final InstanceIdentifier<T> path) {
+ return delegate().getSubtreeCodec(path);
+ }
+
+ @Override
+ public BindingCodecTreeNode getSubtreeCodec(final YangInstanceIdentifier path) {
+ return delegate().getSubtreeCodec(path);
+ }
+
+ @Override
+ public BindingCodecTreeNode getSubtreeCodec(final Absolute path) {
+ return delegate().getSubtreeCodec(path);
+ }
+
+ @Override
+ public BindingIdentityCodec getIdentityCodec() {
+ return delegate().getIdentityCodec();
+ }
+
+ @Override
+ public BindingInstanceIdentifierCodec getInstanceIdentifierCodec() {
+ return delegate().getInstanceIdentifierCodec();
+ }
+
+ @Override
+ public BindingRuntimeContext getRuntimeContext() {
+ return delegate().getRuntimeContext();
+ }
}
<configuration>
<instructions>
<Bundle-Name>${project.groupId}.${project.artifactId}</Bundle-Name>
- <Export-Package>
- org.opendaylight.mdsal.binding.dom.codec.impl,
- ;-split-package:=error
- </Export-Package>
<Private-Package>
+ org.opendaylight.mdsal.binding.dom.codec.impl,
org.opendaylight.mdsal.binding.dom.codec.loader,
</Private-Package>
<Import-Package>
import static com.google.common.base.Verify.verify;
import static java.util.Objects.requireNonNull;
+import com.google.common.annotations.Beta;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
+import java.util.ServiceLoader;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
+import javax.inject.Inject;
+import javax.inject.Singleton;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
+import org.kohsuke.MetaInfServices;
import org.opendaylight.binding.runtime.api.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-final class BindingCodecContext extends AbstractBindingNormalizedNodeSerializer implements BindingDOMCodecServices,
- Immutable, CodecContextFactory, DataObjectSerializerRegistry {
+@Beta
+@MetaInfServices(value = BindingDOMCodecServices.class)
+@Singleton
+public final class BindingCodecContext extends AbstractBindingNormalizedNodeSerializer
+ implements BindingDOMCodecServices, Immutable, CodecContextFactory, DataObjectSerializerRegistry {
private final class DataObjectSerializerProxy implements DataObjectSerializer, Delegator<DataObjectStreamer<?>> {
private final @NonNull DataObjectStreamer<?> delegate;
private final @NonNull CodecClassLoader loader = CodecClassLoader.create();
private final @NonNull InstanceIdentifierCodec instanceIdentifierCodec;
private final @NonNull IdentityCodec identityCodec;
- private final BindingRuntimeContext context;
+ private final @NonNull BindingRuntimeContext context;
private final SchemaRootCodecContext<?> root;
- BindingCodecContext(final BindingRuntimeContext context) {
+ public BindingCodecContext() {
+ this(ServiceLoader.load(BindingRuntimeContext.class).findFirst()
+ .orElseThrow(() -> new IllegalStateException("Failed to load BindingRuntimeContext")));
+ }
+
+ @Inject
+ public BindingCodecContext(final BindingRuntimeContext context) {
this.context = requireNonNull(context, "Binding Runtime Context is required.");
this.root = SchemaRootCodecContext.create(this);
this.identityCodec = new IdentityCodec(context);
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. 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.codec.impl;
-
-import static com.google.common.base.Preconditions.checkState;
-
-import java.time.Instant;
-import java.util.Map.Entry;
-import java.util.Optional;
-import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
-import java.util.function.Function;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.binding.runtime.api.BindingRuntimeContext;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeWriterFactory;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingStreamEventWriter;
-import org.opendaylight.mdsal.binding.dom.codec.spi.AbstractBindingNormalizedNodeSerializer;
-import org.opendaylight.yangtools.yang.binding.Action;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.Notification;
-import org.opendaylight.yangtools.yang.binding.RpcInput;
-import org.opendaylight.yangtools.yang.binding.RpcOutput;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class BindingNormalizedNodeCodecRegistry extends AbstractBindingNormalizedNodeSerializer
- implements BindingNormalizedNodeWriterFactory {
- private static final Logger LOG = LoggerFactory.getLogger(BindingNormalizedNodeCodecRegistry.class);
-
- private static final AtomicReferenceFieldUpdater<BindingNormalizedNodeCodecRegistry, BindingCodecContext> UPDATER =
- AtomicReferenceFieldUpdater.newUpdater(BindingNormalizedNodeCodecRegistry.class, BindingCodecContext.class,
- "codecContext");
- private volatile BindingCodecContext codecContext;
-
- public BindingNormalizedNodeCodecRegistry() {
-
- }
-
- public BindingNormalizedNodeCodecRegistry(final BindingRuntimeContext codecContext) {
- this();
- onBindingRuntimeContextUpdated(codecContext);
- }
-
- public BindingCodecTree getCodecContext() {
- return codecContext;
- }
-
- public void onBindingRuntimeContextUpdated(final BindingRuntimeContext context) {
- // BindingCodecContext is a costly resource. Let us not ditch it unless we have to
- final BindingCodecContext current = codecContext;
- if (current != null && context.equals(current.getRuntimeContext())) {
- LOG.debug("Skipping update of runtime context {}", context);
- return;
- }
-
- final BindingCodecContext updated = new BindingCodecContext(context);
- if (!UPDATER.compareAndSet(this, current, updated)) {
- LOG.warn("Concurrent update of runtime context (expected={} current={}) detected at ", current,
- codecContext, new Throwable());
- }
- }
-
- final @NonNull BindingCodecContext codecContext() {
- final BindingCodecContext local = codecContext;
- checkState(local != null, "No context available yet");
- return local;
- }
-
- @Override
- public YangInstanceIdentifier toYangInstanceIdentifier(final InstanceIdentifier<?> binding) {
- return codecContext().toYangInstanceIdentifier(binding);
- }
-
- @Override
- public <T extends DataObject> InstanceIdentifier<T> fromYangInstanceIdentifier(final YangInstanceIdentifier dom) {
- return codecContext().getInstanceIdentifierCodec().toBinding(dom);
- }
-
- @Override
- public <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?,?>> toNormalizedNode(
- final InstanceIdentifier<T> path, final T data) {
- return codecContext().toNormalizedNode(path, data);
- }
-
- @Override
- public ContainerNode toNormalizedNodeNotification(final Notification data) {
- return codecContext().toNormalizedNodeNotification(data);
- }
-
- @Override
- public ContainerNode toNormalizedNodeRpcData(final DataContainer data) {
- return codecContext().toNormalizedNodeRpcData(data);
- }
-
- @Override
- public ContainerNode toNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
- final RpcInput input) {
- return codecContext().toNormalizedNodeActionInput(action, input);
- }
-
- @Override
- public ContainerNode toNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
- final RpcOutput output) {
- return codecContext().toNormalizedNodeActionOutput(action, output);
- }
-
- @Override
- public Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode(final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data) {
- return codecContext().fromNormalizedNode(path, data);
- }
-
- @Override
- public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data) {
- return codecContext().fromNormalizedNodeNotification(path, data);
- }
-
- @Override
- public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data,
- final Instant eventInstant) {
- return codecContext().fromNormalizedNodeNotification(path, data, eventInstant);
- }
-
- @Override
- public DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) {
- return codecContext().fromNormalizedNodeRpcData(path, data);
- }
-
- @Override
- public <T extends RpcInput> T fromNormalizedNodeActionInput(final Class<? extends Action<?, ?, ?>> action,
- final ContainerNode input) {
- return codecContext().fromNormalizedNodeActionInput(action, input);
- }
-
- @Override
- public <T extends RpcOutput> T fromNormalizedNodeActionOutput(final Class<? extends Action<?, ?, ?>> action,
- final ContainerNode output) {
- return codecContext().fromNormalizedNodeActionOutput(action, output);
- }
-
- @Override
- public Entry<YangInstanceIdentifier, BindingStreamEventWriter> newWriterAndIdentifier(
- final InstanceIdentifier<?> path, final NormalizedNodeStreamWriter domWriter) {
- return codecContext().newWriterAndIdentifier(path, domWriter);
- }
-
- @Override
- public BindingStreamEventWriter newWriter(final InstanceIdentifier<?> path,
- final NormalizedNodeStreamWriter domWriter) {
- return codecContext().newWriter(path, domWriter);
- }
-
- @Override
- public BindingStreamEventWriter newNotificationWriter(final Class<? extends Notification> notification,
- final NormalizedNodeStreamWriter streamWriter) {
- return codecContext().newNotificationWriter(notification, streamWriter);
- }
-
- @Override
- public BindingStreamEventWriter newActionInputWriter(final Class<? extends Action<?, ?, ?>> action,
- final NormalizedNodeStreamWriter domWriter) {
- return codecContext().newActionInputWriter(action, domWriter);
- }
-
- @Override
- public BindingStreamEventWriter newActionOutputWriter(final Class<? extends Action<?, ?, ?>> action,
- final NormalizedNodeStreamWriter domWriter) {
- return codecContext().newActionOutputWriter(action, domWriter);
- }
-
- @Override
- public BindingStreamEventWriter newRpcWriter(final Class<? extends DataContainer> rpcInputOrOutput,
- final NormalizedNodeStreamWriter streamWriter) {
- return codecContext().newRpcWriter(rpcInputOrOutput,streamWriter);
- }
-
- public <T extends DataObject> Function<Optional<NormalizedNode<?, ?>>, Optional<T>> deserializeFunction(
- final InstanceIdentifier<T> path) {
- final DataObjectCodecContext<?,?> ctx = (DataObjectCodecContext<?,?>) codecContext().getCodecContextNode(path,
- null);
- return new DeserializeFunction<>(ctx);
- }
-
- private static final class DeserializeFunction<T> implements Function<Optional<NormalizedNode<?, ?>>, Optional<T>> {
- private final DataObjectCodecContext<?,?> ctx;
-
- DeserializeFunction(final DataObjectCodecContext<?,?> ctx) {
- this.ctx = ctx;
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public Optional<T> apply(final Optional<NormalizedNode<?, ?>> input) {
- return input.map(data -> (T) ctx.deserialize(data));
- }
- }
-}
package org.opendaylight.mdsal.binding.dom.codec.impl;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yangtools.yang.binding.DataObject;
/**
* Marker interface for codecs dealing with RPC input being potentially unmapped. We use this interface to mark both
* {@link UnmappedRpcInputCodec} and {@link ContainerNodeCodecContext}, which results in bimorphic invocation in
- * {@link BindingNormalizedNodeCodecRegistry#fromNormalizedNodeRpcData()}.
+ * {@link BindingNormalizedNodeSerializer#fromNormalizedNodeRpcData()}.
*
* <p>
* Without this interface we could end up with megamorphic invocation, as the two implementations cannot share class
import org.junit.BeforeClass;
public abstract class AbstractBindingCodecTest extends AbstractBindingRuntimeTest {
- protected BindingNormalizedNodeCodecRegistry registry;
+ protected BindingCodecContext codecContext;
@BeforeClass
public static void beforeClass() {
@Before
public void before() {
- this.registry = new BindingNormalizedNodeCodecRegistry(getRuntimeContext());
+ this.codecContext = new BindingCodecContext(getRuntimeContext());
}
}
@Test
public void testSerialization() {
- assertEquals(DOM_FOO_INPUT, registry.toLazyNormalizedNodeActionInput(Foo.class, BINDING_FOO_INPUT)
+ assertEquals(DOM_FOO_INPUT, codecContext.toLazyNormalizedNodeActionInput(Foo.class, BINDING_FOO_INPUT)
.getDelegate());
- assertEquals(DOM_BAR_INPUT, registry.toLazyNormalizedNodeActionInput(Bar.class, BINDING_BAR_INPUT)
+ assertEquals(DOM_BAR_INPUT, codecContext.toLazyNormalizedNodeActionInput(Bar.class, BINDING_BAR_INPUT)
.getDelegate());
- assertEquals(DOM_FOO_OUTPUT, registry.toLazyNormalizedNodeActionOutput(Foo.class, BINDING_FOO_OUTPUT)
+ assertEquals(DOM_FOO_OUTPUT, codecContext.toLazyNormalizedNodeActionOutput(Foo.class, BINDING_FOO_OUTPUT)
.getDelegate());
- assertEquals(DOM_BAR_OUTPUT, registry.toLazyNormalizedNodeActionOutput(Bar.class, BINDING_BAR_OUTPUT)
+ assertEquals(DOM_BAR_OUTPUT, codecContext.toLazyNormalizedNodeActionOutput(Bar.class, BINDING_BAR_OUTPUT)
.getDelegate());
}
@Test
public void testKeyedListActionSerialization() {
- assertEquals(DOM_FOOIO_INPUT, registry.toLazyNormalizedNodeActionInput(Fooio.class, BINDING_FOOIO_INPUT)
+ assertEquals(DOM_FOOIO_INPUT, codecContext.toLazyNormalizedNodeActionInput(Fooio.class, BINDING_FOOIO_INPUT)
.getDelegate());
- assertEquals(DOM_FOOIO_OUTPUT, registry.toLazyNormalizedNodeActionOutput(Fooio.class, BINDING_FOOIO_OUTPUT)
+ assertEquals(DOM_FOOIO_OUTPUT, codecContext.toLazyNormalizedNodeActionOutput(Fooio.class, BINDING_FOOIO_OUTPUT)
.getDelegate());
}
@Test
public void testDeserialization() {
- assertEquals(BINDING_FOO_INPUT, registry.fromNormalizedNodeActionInput(Foo.class, DOM_FOO_INPUT));
- assertEquals(BINDING_BAR_INPUT, registry.fromNormalizedNodeActionInput(Bar.class, DOM_FOO_INPUT));
- assertEquals(BINDING_FOO_OUTPUT, registry.fromNormalizedNodeActionOutput(Foo.class, DOM_FOO_OUTPUT));
- assertEquals(BINDING_BAR_OUTPUT, registry.fromNormalizedNodeActionOutput(Bar.class, DOM_FOO_INPUT));
+ assertEquals(BINDING_FOO_INPUT, codecContext.fromNormalizedNodeActionInput(Foo.class, DOM_FOO_INPUT));
+ assertEquals(BINDING_BAR_INPUT, codecContext.fromNormalizedNodeActionInput(Bar.class, DOM_FOO_INPUT));
+ assertEquals(BINDING_FOO_OUTPUT, codecContext.fromNormalizedNodeActionOutput(Foo.class, DOM_FOO_OUTPUT));
+ assertEquals(BINDING_BAR_OUTPUT, codecContext.fromNormalizedNodeActionOutput(Bar.class, DOM_FOO_INPUT));
}
@Test
public void testKeyedListActionDeserialization() {
- assertEquals(BINDING_FOOIO_INPUT, registry.fromNormalizedNodeActionInput(Fooio.class, DOM_FOOIO_INPUT));
- assertEquals(BINDING_FOOIO_OUTPUT, registry.fromNormalizedNodeActionOutput(Fooio.class, DOM_FOOIO_OUTPUT));
+ assertEquals(BINDING_FOOIO_INPUT, codecContext.fromNormalizedNodeActionInput(Fooio.class, DOM_FOOIO_INPUT));
+ assertEquals(BINDING_FOOIO_OUTPUT, codecContext.fromNormalizedNodeActionOutput(Fooio.class, DOM_FOOIO_OUTPUT));
}
}
@Test
public void testAnydataToBinding() {
- final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(
+ final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(
YangInstanceIdentifier.create(CONT_NODE_ID), cont);
assertEquals(InstanceIdentifier.create(Cont.class), entry.getKey());
final DataObject ldo = entry.getValue();
@Test
public void testAnydataFromBinding() {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
InstanceIdentifier.create(Cont.class), new ContBuilder().setContAny(new FakeCont()).build());
assertEquals(YangInstanceIdentifier.create(CONT_NODE_ID), entry.getKey());
assertEquals(cont, entry.getValue());
@Test
public void testAnyxmlToBinding() {
- final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(
+ final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(
YangInstanceIdentifier.create(CONT_NODE_ID), cont);
assertEquals(InstanceIdentifier.create(Cont.class), entry.getKey());
final DataObject ldo = entry.getValue();
@Test
public void testAnyxmlFromBinding() {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
InstanceIdentifier.create(Cont.class), new ContBuilder().setContAny(new FakeCont()).build());
assertEquals(YangInstanceIdentifier.create(CONT_NODE_ID), entry.getKey());
assertEquals(cont, entry.getValue());
import org.opendaylight.binding.runtime.api.ClassLoadingStrategy;
import org.opendaylight.binding.runtime.api.DefaultBindingRuntimeContext;
import org.opendaylight.binding.runtime.spi.BindingRuntimeHelpers;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.binding.dom.codec.api.MissingClassInLoadingStrategyException;
import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugment;
* The idea of this suite is to test that codecs will work even if situation like this happens.
*/
public class AugmentationClassDiscoveredAfterCodecTest {
- private BindingNormalizedNodeCodecRegistry registry;
+ private BindingNormalizedNodeSerializer serializer;
private FilteringClassLoadingStrategy filter;
@Before
// Class loading filter, manipulated by tests
filter = new FilteringClassLoadingStrategy(delegate.getStrategy());
- registry = new BindingNormalizedNodeCodecRegistry(DefaultBindingRuntimeContext.create(delegate.getTypes(),
- filter));
+ serializer = new BindingCodecContext(DefaultBindingRuntimeContext.create(delegate.getTypes(), filter));
}
private static final TopLevelListKey TOP_FOO_KEY = new TopLevelListKey("foo");
@Test(expected = MissingClassInLoadingStrategyException.class)
public void testCorrectExceptionThrown() {
materializeWithExclusions(TreeLeafOnlyAugment.class, TreeComplexUsesAugment.class);
- registry.toYangInstanceIdentifier(BA_TREE_LEAF_ONLY);
+ serializer.toYangInstanceIdentifier(BA_TREE_LEAF_ONLY);
}
@Test
public void testUsingBindingInstanceIdentifier() {
materializeWithExclusions(TreeLeafOnlyAugment.class, TreeComplexUsesAugment.class);
filter.includeClass(TreeLeafOnlyAugment.class);
- final YangInstanceIdentifier domYY = registry.toYangInstanceIdentifier(BA_TREE_LEAF_ONLY);
+ final YangInstanceIdentifier domYY = serializer.toYangInstanceIdentifier(BA_TREE_LEAF_ONLY);
assertNotNull(domYY);
}
.addAugmentation(TreeLeafOnlyAugment.class,
new TreeLeafOnlyAugmentBuilder().setSimpleValue("foo").build()).build();
final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> domData =
- registry.toNormalizedNode(BA_TOP_LEVEL_LIST, data);
+ serializer.toNormalizedNode(BA_TOP_LEVEL_LIST, data);
assertNotNull(domData);
}
for (final Class<?> clz : clzToExclude) {
filter.excludeClass(clz);
}
- registry.toYangInstanceIdentifier(BA_TOP_LEVEL_LIST);
+ serializer.toYangInstanceIdentifier(BA_TOP_LEVEL_LIST);
}
private static final class FilteringClassLoadingStrategy implements ClassLoadingStrategy {
import static org.junit.Assert.assertEquals;
-import java.util.Optional;
+import java.util.Map.Entry;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.RpcComplexUsesAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.RpcComplexUsesAugmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugmentBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeLeafOnlyAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.complex.from.grouping.ContainerWithUsesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelListBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelListKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public class AugmentationSubstitutionTest extends AbstractBindingCodecTest {
-
private static final TopLevelListKey TOP_FOO_KEY = new TopLevelListKey("foo");
private static final InstanceIdentifier<TopLevelList> BA_TOP_LEVEL_LIST = InstanceIdentifier.builder(Top.class)
.child(TopLevelList.class, TOP_FOO_KEY).build();
- private static final InstanceIdentifier<TreeLeafOnlyAugment> BA_TREE_LEAF_ONLY = BA_TOP_LEVEL_LIST
- .augmentation(TreeLeafOnlyAugment.class);
- private static final InstanceIdentifier<TreeComplexUsesAugment> BA_TREE_COMPLEX_USES = BA_TOP_LEVEL_LIST
- .augmentation(TreeComplexUsesAugment.class);
- private static final QName SIMPLE_VALUE_QNAME = QName.create(TreeComplexUsesAugment.QNAME, "simple-value");
@Test
public void augmentationInGroupingSubstituted() {
.addAugmentation(TreeComplexUsesAugment.class, new TreeComplexUsesAugmentBuilder(createComplexData())
.build())
.build();
- final NormalizedNode<?, ?> domTreeEntry = registry.toNormalizedNode(BA_TOP_LEVEL_LIST, baTree).getValue();
- final NormalizedNode<?, ?> domRpcEntry = registry.toNormalizedNode(BA_TOP_LEVEL_LIST, baRpc).getValue();
+ final NormalizedNode<?, ?> domTreeEntry = codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST, baTree).getValue();
+ final NormalizedNode<?, ?> domRpcEntry = codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST, baRpc).getValue();
assertEquals(domTreeEntry, domRpcEntry);
}
.addAugmentation(TreeComplexUsesAugment.class, new TreeComplexUsesAugmentBuilder(createComplexData())
.build())
.build();
- final NormalizedNode<?, ?> domTreeEntry = registry.toNormalizedNode(BA_TOP_LEVEL_LIST, manuallyConstructed)
- .getValue();
- final TopLevelList deserialized = registry.deserializeFunction(BA_TOP_LEVEL_LIST)
- .apply(Optional.of(domTreeEntry)).get();
+
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ BA_TOP_LEVEL_LIST, manuallyConstructed);
+ final TopLevelList deserialized = (TopLevelList) codecContext.fromNormalizedNode(entry.getKey(),
+ entry.getValue()).getValue();
assertEquals(manuallyConstructed, deserialized);
final TopLevelList copiedFromDeserialized = new TopLevelListBuilder(deserialized).build();
assertEquals(manuallyConstructed, copiedFromDeserialized);
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
-import java.util.Optional;
+import java.util.Map.Entry;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.odl.test.binary.key.rev160101.BinaryList;
import org.opendaylight.yang.gen.v1.odl.test.binary.key.rev160101.BinaryListBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public class BinaryKeyTest extends AbstractBindingCodecTest {
}
private BinaryList process(final BinaryList binaryList) {
- final NormalizedNode<?, ?> domTreeEntry = registry.toNormalizedNode(instanceIdentifier, binaryList).getValue();
- return registry.deserializeFunction(instanceIdentifier).apply(Optional.of(domTreeEntry)).get();
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ instanceIdentifier, binaryList);
+ return (BinaryList) codecContext.fromNormalizedNode(entry.getKey(), entry.getValue()).getValue();
}
}
import java.util.Collections;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
import org.opendaylight.yang.gen.v1.urn.test.opendaylight.bug._5524.module1.rev160101.grouping.module1.ListModule11Builder;
import org.opendaylight.yang.gen.v1.urn.test.opendaylight.bug._5524.module1.rev160101.grouping.module1.list.module1._1.ListModule12Builder;
new ContainerManualContainerModule2Builder().build()).build())
.build())).build())).build()).build();
- final BindingCodecTree codecContext = registry.getCodecContext();
final BindingDataObjectCodecTreeNode<Module4Main> subtreeCodec = codecContext.getSubtreeCodec(
InstanceIdentifier.create(Module4Main.class));
final NormalizedNode<?, ?> serialized = subtreeCodec.serialize(module4Main);
import java.util.Collections;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
import org.opendaylight.yang.gen.v1.urn.yang.foo.rev160101.BooleanContainer;
import org.opendaylight.yang.gen.v1.urn.yang.foo.rev160101.BooleanContainerBuilder;
.build()))
.build();
- final BindingCodecTree codecContext = registry.getCodecContext();
final BindingDataObjectCodecTreeNode<BooleanContainer> subtreeCodec = codecContext.getSubtreeCodec(
InstanceIdentifier.create(BooleanContainer.class));
final NormalizedNode<?, ?> serializedInt = subtreeCodec.serialize(booleanContainerInt);
@Before
public void before() {
super.before();
- topNode = registry.getCodecContext().getSubtreeCodec(TOP_PATH);
- contNode = registry.getCodecContext().getSubtreeCodec(CONT_PATH);
+ topNode = codecContext.getSubtreeCodec(TOP_PATH);
+ contNode = codecContext.getSubtreeCodec(CONT_PATH);
}
private static Map<TopLevelListKey, TopLevelList> createList(final int num) {
.withKey(CHOICE_FOO_KEY)
.setChoiceInChoiceList(new ComplexViaUsesBuilder(createComplexData()).build())
.build();
- final NormalizedNode<?, ?> domTreeEntry = registry.toNormalizedNode(BA_CHOICE_LIST, baTree).getValue();
- final NormalizedNode<?, ?> domRpcEntry = registry.toNormalizedNode(BA_CHOICE_LIST, baRpc).getValue();
+ final NormalizedNode<?, ?> domTreeEntry = codecContext.toNormalizedNode(BA_CHOICE_LIST, baTree).getValue();
+ final NormalizedNode<?, ?> domRpcEntry = codecContext.toNormalizedNode(BA_CHOICE_LIST, baRpc).getValue();
assertEquals(domTreeEntry, domRpcEntry);
}
.withKey(TOP_FOO_KEY)
.setChoiceInList(new EmptyLeafBuilder().setEmptyType(Empty.getInstance()).build())
.build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> dom = registry.toNormalizedNode(BA_TOP_LEVEL_LIST,
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> dom = codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST,
withEmptyCase);
- final Entry<InstanceIdentifier<?>, DataObject> readed = registry.fromNormalizedNode(dom.getKey(),
+ final Entry<InstanceIdentifier<?>, DataObject> readed = codecContext.fromNormalizedNode(dom.getKey(),
dom.getValue());
final ChoiceInList list = ((TopLevelList) readed.getValue()).getChoiceInList();
assertTrue(list instanceof EmptyLeaf);
import org.junit.Test;
import org.opendaylight.binding.runtime.spi.BindingRuntimeHelpers;
+import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.binding.dom.codec.api.IncorrectNestingException;
import org.opendaylight.mdsal.binding.dom.codec.api.MissingSchemaException;
import org.opendaylight.mdsal.binding.dom.codec.api.MissingSchemaForClassException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class ExceptionReportingTest {
- private static final BindingNormalizedNodeCodecRegistry CODEC_WITHOUT_TOP = codec(LowestLevel1.class);
- private static final BindingNormalizedNodeCodecRegistry ONLY_TOP_CODEC = codec(Top.class);
- private static final BindingNormalizedNodeCodecRegistry FULL_CODEC = codec(TreeComplexUsesAugment.class);
+ private static final BindingNormalizedNodeSerializer CODEC_WITHOUT_TOP = codec(LowestLevel1.class);
+ private static final BindingNormalizedNodeSerializer ONLY_TOP_CODEC = codec(Top.class);
+ private static final BindingNormalizedNodeSerializer FULL_CODEC = codec(TreeComplexUsesAugment.class);
private static final TopLevelListKey TOP_FOO_KEY = new TopLevelListKey("foo");
private static final InstanceIdentifier<TopLevelList> BA_TOP_LEVEL_LIST = InstanceIdentifier
(Class) TreeComplexUsesAugment.class));
}
- @SuppressWarnings("checkstyle:illegalCatch")
- private static BindingNormalizedNodeCodecRegistry codec(final Class<?>... classes) {
- return new BindingNormalizedNodeCodecRegistry(BindingRuntimeHelpers.createRuntimeContext(
+ private static BindingNormalizedNodeSerializer codec(final Class<?>... classes) {
+ return new BindingCodecContext(BindingRuntimeHelpers.createRuntimeContext(
new DefaultBindingRuntimeGenerator(), classes));
}
}
@Test
public void testYangIIToBindingAwareII() {
- final InstanceIdentifier<?> instanceIdentifier = registry.fromYangInstanceIdentifier(BI_TOP_PATH);
+ final InstanceIdentifier<?> instanceIdentifier = codecContext.fromYangInstanceIdentifier(BI_TOP_PATH);
assertEquals(Top.class, instanceIdentifier.getTargetType());
}
@Test
public void testYangIIToBindingAwareIIListWildcarded() {
- final InstanceIdentifier<?> instanceIdentifier = registry.fromYangInstanceIdentifier(BI_TOP_LEVEL_LIST_PATH);
+ final InstanceIdentifier<?> instanceIdentifier = codecContext.fromYangInstanceIdentifier(
+ BI_TOP_LEVEL_LIST_PATH);
assertNull(instanceIdentifier);
}
@Test
public void testYangIIToBindingAwareIIListWithKey() {
- final InstanceIdentifier<?> instanceIdentifier = registry.fromYangInstanceIdentifier(BI_TOP_LEVEL_LIST_1_PATH);
+ final InstanceIdentifier<?> instanceIdentifier = codecContext.fromYangInstanceIdentifier(
+ BI_TOP_LEVEL_LIST_1_PATH);
final InstanceIdentifier.PathArgument last = Iterables.getLast(instanceIdentifier.getPathArguments());
assertEquals(TopLevelList.class, instanceIdentifier.getTargetType());
assertFalse(instanceIdentifier.isWildcarded());
@Test
public void testBindingAwareIIToYangIContainer() {
- final YangInstanceIdentifier yangInstanceIdentifier = registry.toYangInstanceIdentifier(
+ final YangInstanceIdentifier yangInstanceIdentifier = codecContext.toYangInstanceIdentifier(
InstanceIdentifier.create(Top.class).child(TopLevelList.class));
final PathArgument lastPathArgument = yangInstanceIdentifier.getLastPathArgument();
assertTrue(lastPathArgument instanceof NodeIdentifier);
@Test
public void testBindingAwareIIToYangIIWildcard() {
- final YangInstanceIdentifier yangInstanceIdentifier = registry.toYangInstanceIdentifier(
+ final YangInstanceIdentifier yangInstanceIdentifier = codecContext.toYangInstanceIdentifier(
InstanceIdentifier.create(Top.class).child(TopLevelList.class));
final PathArgument lastPathArgument = yangInstanceIdentifier.getLastPathArgument();
assertTrue(lastPathArgument instanceof NodeIdentifier);
@Test
public void testBindingAwareIIToYangIIListWithKey() {
- final YangInstanceIdentifier yangInstanceIdentifier = registry.toYangInstanceIdentifier(
+ final YangInstanceIdentifier yangInstanceIdentifier = codecContext.toYangInstanceIdentifier(
InstanceIdentifier.create(Top.class).child(TopLevelList.class, TOP_FOO_KEY));
final PathArgument lastPathArgument = yangInstanceIdentifier.getLastPathArgument();
assertTrue(lastPathArgument instanceof NodeIdentifierWithPredicates);
@Test
public void testBindingAwareIIToYangIIAugmentation() {
- final PathArgument lastArg = registry.toYangInstanceIdentifier(BA_TREE_COMPLEX_USES).getLastPathArgument();
+ final PathArgument lastArg = codecContext.toYangInstanceIdentifier(BA_TREE_COMPLEX_USES).getLastPathArgument();
assertTrue(lastArg instanceof AugmentationIdentifier);
}
@Test
public void testBindingAwareIIToYangIILeafOnlyAugmentation() {
- final PathArgument leafOnlyLastArg = registry.toYangInstanceIdentifier(BA_TREE_LEAF_ONLY).getLastPathArgument();
+ final PathArgument leafOnlyLastArg = codecContext.toYangInstanceIdentifier(BA_TREE_LEAF_ONLY)
+ .getLastPathArgument();
assertTrue(leafOnlyLastArg instanceof AugmentationIdentifier);
assertTrue(((AugmentationIdentifier) leafOnlyLastArg).getPossibleChildNames().contains(SIMPLE_VALUE_QNAME));
}
@Test
public void testChoiceCaseGroupingFromBinding() {
- final YangInstanceIdentifier contBase = registry.toYangInstanceIdentifier(
+ final YangInstanceIdentifier contBase = codecContext.toYangInstanceIdentifier(
InstanceIdentifier.builder(Cont.class).child(ContBase.class, GrpCont.class).build());
assertEquals(YangInstanceIdentifier.create(NodeIdentifier.create(Cont.QNAME),
NodeIdentifier.create(ContChoice.QNAME), NodeIdentifier.create(GrpCont.QNAME)), contBase);
- final YangInstanceIdentifier contAug = registry.toYangInstanceIdentifier(
+ final YangInstanceIdentifier contAug = codecContext.toYangInstanceIdentifier(
InstanceIdentifier.builder(Cont.class).child(ContAug.class, GrpCont.class).build());
assertEquals(YangInstanceIdentifier.create(NodeIdentifier.create(Cont.QNAME),
NodeIdentifier.create(ContChoice.QNAME),
// Legacy: downcast the child to Class, losing type safety but still working. Faced with ambiguity, it will
// select the lexically-lower class
assertEquals(1, ContBase.class.getCanonicalName().compareTo(ContAug.class.getCanonicalName()));
- final YangInstanceIdentifier contAugLegacy = registry.toYangInstanceIdentifier(
+ final YangInstanceIdentifier contAugLegacy = codecContext.toYangInstanceIdentifier(
InstanceIdentifier.builder(Cont.class).child((Class) GrpCont.class).build());
assertEquals(contAug, contAugLegacy);
- final YangInstanceIdentifier rootBase = registry.toYangInstanceIdentifier(
+ final YangInstanceIdentifier rootBase = codecContext.toYangInstanceIdentifier(
InstanceIdentifier.builder(RootBase.class, GrpCont.class).build());
assertEquals(YangInstanceIdentifier.create(NodeIdentifier.create(Root.QNAME),
NodeIdentifier.create(GrpCont.QNAME)), rootBase);
- final YangInstanceIdentifier rootAug = registry.toYangInstanceIdentifier(
+ final YangInstanceIdentifier rootAug = codecContext.toYangInstanceIdentifier(
InstanceIdentifier.builder(RootAug.class, GrpCont.class).build());
assertEquals(YangInstanceIdentifier.create(NodeIdentifier.create(Root.QNAME),
NodeIdentifier.create(GrpCont.QNAME.withModule(RootAug.QNAME.getModule()))), rootAug);
@Test
public void testChoiceCaseGroupingToBinding() {
- final InstanceIdentifier<?> contBase = registry.fromYangInstanceIdentifier(
+ final InstanceIdentifier<?> contBase = codecContext.fromYangInstanceIdentifier(
YangInstanceIdentifier.create(NodeIdentifier.create(Cont.QNAME),
NodeIdentifier.create(ContChoice.QNAME), NodeIdentifier.create(GrpCont.QNAME)));
assertEquals(InstanceIdentifier.builder(Cont.class).child(ContBase.class, GrpCont.class).build(), contBase);
- final InstanceIdentifier<?> contAug = registry.fromYangInstanceIdentifier(
+ final InstanceIdentifier<?> contAug = codecContext.fromYangInstanceIdentifier(
YangInstanceIdentifier.create(NodeIdentifier.create(Cont.QNAME), NodeIdentifier.create(ContChoice.QNAME),
NodeIdentifier.create(GrpCont.QNAME.withModule(ContAug.QNAME.getModule()))));
assertEquals(InstanceIdentifier.builder(Cont.class).child(ContAug.class, GrpCont.class).build(), contAug);
- final InstanceIdentifier<?> rootBase = registry.fromYangInstanceIdentifier(
+ final InstanceIdentifier<?> rootBase = codecContext.fromYangInstanceIdentifier(
YangInstanceIdentifier.create(NodeIdentifier.create(Root.QNAME), NodeIdentifier.create(GrpCont.QNAME)));
assertEquals(InstanceIdentifier.builder(RootBase.class, GrpCont.class).build(), rootBase);
- final InstanceIdentifier<?> rootAug = registry.fromYangInstanceIdentifier(
+ final InstanceIdentifier<?> rootAug = codecContext.fromYangInstanceIdentifier(
YangInstanceIdentifier.create(NodeIdentifier.create(Root.QNAME),
NodeIdentifier.create(GrpCont.QNAME.withModule(RootAug.QNAME.getModule()))));
assertEquals(InstanceIdentifier.builder(RootAug.class, GrpCont.class).build(), rootAug);
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
public class InstanceIdentifierTest extends AbstractBindingCodecTest {
-
private static final TopLevelListKey TOP_FOO_KEY = new TopLevelListKey("foo");
private static final InstanceIdentifier<TopLevelList> BA_TOP_LEVEL_LIST = InstanceIdentifier.builder(Top.class)
.child(TopLevelList.class, TOP_FOO_KEY).build();
@Test
public void testComplexAugmentationSerialization() {
- final YangInstanceIdentifier yangII = registry.toYangInstanceIdentifier(BA_TREE_COMPLEX_USES);
+ final YangInstanceIdentifier yangII = codecContext.toYangInstanceIdentifier(BA_TREE_COMPLEX_USES);
final PathArgument lastArg = yangII.getLastPathArgument();
assertTrue("Last argument should be AugmentationIdentifier", lastArg instanceof AugmentationIdentifier);
- final InstanceIdentifier<?> bindingII = registry.fromYangInstanceIdentifier(yangII);
+ final InstanceIdentifier<?> bindingII = codecContext.fromYangInstanceIdentifier(yangII);
assertEquals(BA_TREE_COMPLEX_USES, bindingII);
}
@Test
public void testLeafOnlyAugmentationSerialization() {
- final PathArgument leafOnlyLastArg = registry.toYangInstanceIdentifier(BA_TREE_LEAF_ONLY).getLastPathArgument();
+ final PathArgument leafOnlyLastArg = codecContext.toYangInstanceIdentifier(BA_TREE_LEAF_ONLY)
+ .getLastPathArgument();
assertTrue("Last argument should be AugmentationIdentifier", leafOnlyLastArg instanceof AugmentationIdentifier);
assertTrue(((AugmentationIdentifier) leafOnlyLastArg).getPossibleChildNames().contains(SIMPLE_VALUE_QNAME));
}
@Test
public void testCamelCaseKeys() {
- final InstanceIdentifier<?> result = registry.fromYangInstanceIdentifier(YangInstanceIdentifier.create(
+ final InstanceIdentifier<?> result = codecContext.fromYangInstanceIdentifier(YangInstanceIdentifier.create(
NodeIdentifier.create(OspfStatLsdbBrief.QNAME),
NodeIdentifierWithPredicates.of(OspfStatLsdbBrief.QNAME, ImmutableMap.of(
QName.create(OspfStatLsdbBrief.QNAME, "AreaIndex"), 1,
@Test
public void testFromBinding() {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> domDef = registry.toNormalizedNode(DEF_IID, DEF);
- Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(domDef.getKey(),
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> domDef = codecContext.toNormalizedNode(DEF_IID, DEF);
+ Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(domDef.getKey(),
domDef.getValue());
assertEquals(DEF_IID, entry.getKey());
final Def codecDef = (Def) entry.getValue();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> domUse = registry.toNormalizedNode(USE_IID, USE);
- entry = registry.fromNormalizedNode(domUse.getKey(), domUse.getValue());
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> domUse = codecContext.toNormalizedNode(USE_IID, USE);
+ entry = codecContext.fromNormalizedNode(domUse.getKey(), domUse.getValue());
assertEquals(USE_IID, entry.getKey());
final Use codecUse = (Use) entry.getValue();
Use copiedUse = new UseBuilder(DEF).build();
assertEquals(USE, copiedUse);
- assertEquals(domUse.getValue(), registry.toNormalizedNode(USE_IID, copiedUse).getValue());
+ assertEquals(domUse.getValue(), codecContext.toNormalizedNode(USE_IID, copiedUse).getValue());
copiedUse = new UseBuilder(codecDef).build();
assertEquals(USE, copiedUse);
- assertEquals(domUse.getValue(), registry.toNormalizedNode(USE_IID, copiedUse).getValue());
+ assertEquals(domUse.getValue(), codecContext.toNormalizedNode(USE_IID, copiedUse).getValue());
copiedUse = new UseBuilder(codecUse).build();
assertEquals(USE, copiedUse);
- assertEquals(domUse.getValue(), registry.toNormalizedNode(USE_IID, copiedUse).getValue());
+ assertEquals(domUse.getValue(), codecContext.toNormalizedNode(USE_IID, copiedUse).getValue());
}
}
.setSchemaUnawareUnion(new Int32StringUnion("foo"))
.setSchemaUnawareUnionRef(new Int32StringUnion(10))
.build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> dom = registry.toNormalizedNode(BA_TOP_LEVEL_LIST,
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> dom = codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST,
binding);
- final Entry<InstanceIdentifier<?>, DataObject> readed = registry.fromNormalizedNode(dom.getKey(),
+ final Entry<InstanceIdentifier<?>, DataObject> readed = codecContext.fromNormalizedNode(dom.getKey(),
dom.getValue());
final TreeComplexLeaves readedAugment = (TreeComplexLeaves) readed.getValue();
@Test
public void listReferenceTest() {
final YangInstanceIdentifier contYII = YangInstanceIdentifier.builder().node(Cont.QNAME).build();
- final InstanceIdentifier<?> fromYangInstanceIdentifier = this.registry.fromYangInstanceIdentifier(contYII);
+ final InstanceIdentifier<?> fromYangInstanceIdentifier = this.codecContext.fromYangInstanceIdentifier(contYII);
assertNotNull(fromYangInstanceIdentifier);
final InstanceIdentifier<Cont> BA_II_CONT = InstanceIdentifier.builder(Cont.class).build();
final Ref refVal = new Ref("myvalue");
final Cont data = new ContBuilder().setRef(refVal).build();
final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedNode =
- this.registry.toNormalizedNode(BA_II_CONT, data);
+ this.codecContext.toNormalizedNode(BA_II_CONT, data);
assertNotNull(normalizedNode);
final Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode =
- this.registry.fromNormalizedNode(contYII, normalizedNode.getValue());
+ this.codecContext.fromNormalizedNode(contYII, normalizedNode.getValue());
assertNotNull(fromNormalizedNode);
final Cont value = (Cont) fromNormalizedNode.getValue();
assertEquals(refVal, value.getRef());
@Test
public void uint32LeafrefTest() {
final YangInstanceIdentifier contYII = YangInstanceIdentifier.builder().node(ContInt32.QNAME).build();
- final InstanceIdentifier<?> fromYangInstanceIdentifier = this.registry.fromYangInstanceIdentifier(contYII);
+ final InstanceIdentifier<?> fromYangInstanceIdentifier = this.codecContext.fromYangInstanceIdentifier(contYII);
assertNotNull(fromYangInstanceIdentifier);
final InstanceIdentifier<ContInt32> BA_II_CONT = InstanceIdentifier.builder(ContInt32.class).build();
final RefUnionInt32 refVal = new RefUnionInt32(Uint32.valueOf(5));
final ContInt32 data = new ContInt32Builder().setRefUnionInt32(refVal).build();
final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedNode =
- this.registry.toNormalizedNode(BA_II_CONT, data);
+ this.codecContext.toNormalizedNode(BA_II_CONT, data);
assertNotNull(normalizedNode);
final Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode =
- this.registry.fromNormalizedNode(contYII, normalizedNode.getValue());
+ this.codecContext.fromNormalizedNode(contYII, normalizedNode.getValue());
assertNotNull(fromNormalizedNode);
final ContInt32 value = (ContInt32) fromNormalizedNode.getValue();
assertEquals(refVal, value.getRefUnionInt32());
@Test
public void containerToNormalized() {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
InstanceIdentifier.create(Top.class), top());
final ContainerNode topNormalized = getEmptyTop();
assertEquals(topNormalized, entry.getValue());
@Test
public void containerFromNormalized() {
final ContainerNode topNormalized = getEmptyTop();
- final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH, topNormalized);
+ final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(BI_TOP_PATH,
+ topNormalized);
assertEquals(top(), entry.getValue());
}
.build());
final ContainerNode topNormalized = getEmptyTop();
- final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH, topNormalized);
- final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = registry.fromNormalizedNode(BI_TOP_PATH,
+ final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(BI_TOP_PATH,
+ topNormalized);
+ final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = codecContext.fromNormalizedNode(BI_TOP_PATH,
topNormalizedWithAugments);
// Equals on other with no augmentation should be false
.withChild(ImmutableNodes.leafNode(AUGMENT_INT_Q, AUGMENT_INT_VALUE))
.build());
- final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = registry.fromNormalizedNode(BI_TOP_PATH,
+ final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = codecContext.fromNormalizedNode(BI_TOP_PATH,
topNormalizedWithAugments);
Map<Class<? extends Augmentation<Top>>, Augmentation<Top>> augments = new HashMap<>();
augments.put(Top1.class, new Top1Builder().setAugmentedString(AUGMENT_STRING_VALUE).build());
@Test
public void listWithKeysToNormalized() {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(BA_TOP_LEVEL_LIST,
- topLevelList(TOP_LEVEL_LIST_FOO_KEY));
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ BA_TOP_LEVEL_LIST, topLevelList(TOP_LEVEL_LIST_FOO_KEY));
final MapEntryNode topLevelListNormalized = ImmutableMapEntryNodeBuilder.create()
.withNodeIdentifier(NodeIdentifierWithPredicates.of(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME,
TOP_LEVEL_LIST_FOO_KEY_VALUE))
TOP_LEVEL_LIST_FOO_KEY_VALUE))
.withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
.build();
- final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_LEVEL_LIST_FOO_PATH,
- topLevelListNormalized);
+ final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(
+ BI_TOP_LEVEL_LIST_FOO_PATH, topLevelListNormalized);
assertEquals(topLevelList(TOP_LEVEL_LIST_FOO_KEY), entry.getValue());
}
@Test
public void leafOnlyAugmentationToNormalized() {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(BA_TREE_LEAF_ONLY,
- new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build());
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
+ BA_TREE_LEAF_ONLY, new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build());
final Set<QName> augmentationChildren = new HashSet<>();
augmentationChildren.add(SIMPLE_VALUE_QNAME);
final AugmentationNode augmentationNode = ImmutableAugmentationNodeBuilder.create()
.withNodeIdentifier(new AugmentationIdentifier(augmentationChildren))
.withChild(leafNode(SIMPLE_VALUE_QNAME, "simpleValue"))
.build();
- final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(
+ final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(
BI_TOP_LEVEL_LIST_FOO_PATH.node(new AugmentationIdentifier(augmentationChildren)),
augmentationNode);
assertEquals(new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build(), entry.getValue());
topLevelLeafList.add("foo");
Top top = new TopBuilder().setTopLevelOrderedLeafList(topLevelLeafList).build();
- Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
+ Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
InstanceIdentifier.create(Top.class), top);
ContainerNode containerNode = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
topLevelLeafList.add("foo");
final Top top = new TopBuilder().setTopLevelLeafList(topLevelLeafList).build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
InstanceIdentifier.create(Top.class), top);
final ContainerNode containerNode = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
.withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_LEAF_LIST_QNAME, "foo"))
.withValue("foo").build()).build())
.build();
- final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH,
+ final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(BI_TOP_PATH,
topWithLeafList);
final List<String> topLevelLeafList = new ArrayList<>();
topLevelLeafList.add("foo");
new NodeWithValue<>(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME, "foo")).withValue("foo").build())
.build())
.build();
- Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH, topWithLeafList);
+ Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(BI_TOP_PATH, topWithLeafList);
List<String> topLevelLeafList = new ArrayList<>();
topLevelLeafList.add("foo");
Top top = new TopBuilder().setTopLevelOrderedLeafList(topLevelLeafList).build();
public void choiceToNormalized() {
final ChoiceContainer choiceContainerBA = new ChoiceContainerBuilder().setIdentifier(new ExtendedBuilder()
.setExtendedId(new ExtendedIdBuilder().setId("identifier_value").build()).build()).build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(
InstanceIdentifier.create(ChoiceContainer.class), choiceContainerBA);
final ContainerNode choiceContainer = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new NodeIdentifier(CHOICE_CONTAINER_QNAME))
.withChild(leafNode(nestedContainerLeafOuterQname, "bar"))
.build())
.build();
- final Entry<InstanceIdentifier<?>, DataObject> entryContainer = registry.fromNormalizedNode(
+ final Entry<InstanceIdentifier<?>, DataObject> entryContainer = codecContext.fromNormalizedNode(
yangInstanceIdentifierOuter, containerNodeOuter);
assertNotNull(entryContainer.getValue());
assertNotNull(entryContainer.getKey());
.build())
.build();
try {
- registry.fromNormalizedNode(yangInstanceIdentifierValid, containerNodeValid);
+ codecContext.fromNormalizedNode(yangInstanceIdentifierValid, containerNodeValid);
fail("Incorect YangInstanceIdentifier should fail");
} catch (IllegalStateException e) {
// Expected
.build())
.build();
try {
- registry.fromNormalizedNode(yangInstanceIdentifier4798, containerNode4798);
+ codecContext.fromNormalizedNode(yangInstanceIdentifier4798, containerNode4798);
fail("Incorect YangInstanceIdentifier should fail");
} catch (IllegalStateException e) {
// Expected
.withNodeIdentifier(new NodeIdentifier(EXTENDED_ID_QNAME))
.withChild(leafNode(CHOICE_IDENTIFIER_ID_QNAME, "identifier_value")).build()).build())
.build();
- final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_CHOICE_CONTAINER_PATH,
+ final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(BI_CHOICE_CONTAINER_PATH,
choiceContainerBI);
final ChoiceContainer choiceContainerBA = new ChoiceContainerBuilder().setIdentifier(new ExtendedBuilder()
.setExtendedId(new ExtendedIdBuilder().setId("identifier_value").build()).build()).build();
nestedLists.add(new NestedListBuilder().withKey(new NestedListKey("bar")).build());
final TopLevelList topLevelList = new TopLevelListBuilder().withKey(TOP_LEVEL_LIST_FOO_KEY).setNestedList(
nestedLists).build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(ii, topLevelList);
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = codecContext.toNormalizedNode(ii,
+ topLevelList);
final MapEntryNode foo = mapEntryBuilder().withNodeIdentifier(NodeIdentifierWithPredicates.of(
TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
.withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
.withNodeIdentifier(new NodeIdentifier(NESTED_LIST_QNAME))
.withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "foo"))
.withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "bar")).build()).build();
- final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_LEVEL_LIST_FOO_PATH,
- foo);
+ final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(
+ BI_TOP_LEVEL_LIST_FOO_PATH, foo);
final List<NestedList> nestedLists = new ArrayList<>();
nestedLists.add(new NestedListBuilder().withKey(new NestedListKey("foo")).build());
nestedLists.add(new NestedListBuilder().withKey(new NestedListKey("bar")).build());
tBuilder.addAugmentation(TopChoiceAugment1.class, tca1Builder.build());
final Top top = tBuilder.build();
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> biResult = registry.toNormalizedNode(
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> biResult = codecContext.toNormalizedNode(
InstanceIdentifier.create(Top.class), top);
final NormalizedNode<?, ?> topNormalized =
assertEquals(BI_TOP_PATH, biResult.getKey());
assertEquals(topNormalized, biResult.getValue());
- final Entry<InstanceIdentifier<?>, DataObject> baResult = registry.fromNormalizedNode(BI_TOP_PATH,
+ final Entry<InstanceIdentifier<?>, DataObject> baResult = codecContext.fromNormalizedNode(BI_TOP_PATH,
topNormalized);
assertEquals(InstanceIdentifier.create(Top.class), baResult.getKey());
@Test
public void testNotificationToNormalized() {
- final ContainerNode dom = registry.toNormalizedNodeNotification(createTestBindingData());
+ final ContainerNode dom = codecContext.toNormalizedNodeNotification(createTestBindingData());
assertEquals(createTestDomData(), dom);
}
@Test
public void testNormalizedToNotification() {
- final Notification bindingDeserialized = registry.fromNormalizedNodeNotification(SchemaPath.ROOT.createChild(
+ final Notification bindingDeserialized = codecContext.fromNormalizedNodeNotification(SchemaPath.create(true,
TwoLevelListChanged.QNAME), createTestDomData());
assertTrue(bindingDeserialized instanceof TwoLevelListChanged);
assertEquals(createTestBindingData(), bindingDeserialized);
@Test
public void testNormalizedToNotificationWithInstant() {
final Instant instant = Instant.now();
- final Notification bindingDeserialized = registry.fromNormalizedNodeNotification(SchemaPath.ROOT.createChild(
+ final Notification bindingDeserialized = codecContext.fromNormalizedNodeNotification(SchemaPath.create(true,
TwoLevelListChanged.QNAME), createTestDomData(), instant);
assertTrue(bindingDeserialized instanceof TwoLevelListChanged);
assertEquals(createTestBindingData(), bindingDeserialized);
@Test
public void testNormalizedToNotificationWithNull() {
- final Notification bindingDeserialized = registry.fromNormalizedNodeNotification(SchemaPath.ROOT.createChild(
+ final Notification bindingDeserialized = codecContext.fromNormalizedNodeNotification(SchemaPath.create(true,
TwoLevelListChanged.QNAME), createTestDomData(), null);
assertTrue(bindingDeserialized instanceof TwoLevelListChanged);
assertEquals(createTestBindingData(), bindingDeserialized);
final PutTopInput bindingOriginal = new PutTopInputBuilder()
.setTopLevelList(ImmutableMap.of(LIST_KEY, new TopLevelListBuilder().withKey(LIST_KEY).build()))
.build();
- final ContainerNode dom = registry.toNormalizedNodeRpcData(bindingOriginal);
+ final ContainerNode dom = codecContext.toNormalizedNodeRpcData(bindingOriginal);
assertNotNull(dom);
assertEquals(PutTopInput.QNAME, dom.getIdentifier().getNodeType());
- final DataObject bindingDeserialized = registry.fromNormalizedNodeRpcData(PUT_TOP_INPUT, dom);
+ final DataObject bindingDeserialized = codecContext.fromNormalizedNodeRpcData(PUT_TOP_INPUT, dom);
assertEquals(bindingOriginal, bindingDeserialized);
}
final GetTopOutput bindingOriginal = new GetTopOutputBuilder()
.setTopLevelList(ImmutableMap.of(LIST_KEY, new TopLevelListBuilder().withKey(LIST_KEY).build()))
.build();
- final ContainerNode dom = registry.toNormalizedNodeRpcData(bindingOriginal);
+ final ContainerNode dom = codecContext.toNormalizedNodeRpcData(bindingOriginal);
assertNotNull(dom);
assertEquals(GetTopOutput.QNAME, dom.getIdentifier().getNodeType());
- final DataObject bindingDeserialized = registry.fromNormalizedNodeRpcData(GET_TOP_OUTPUT, dom);
+ final DataObject bindingDeserialized = codecContext.fromNormalizedNodeRpcData(GET_TOP_OUTPUT, dom);
assertEquals(bindingOriginal, bindingDeserialized);
}
}
@Test
public void testBindingToDomFirst() {
- final YangInstanceIdentifier yangII = registry.toYangInstanceIdentifier(TOP_LEVEL_CONTAINER_FROM_USES);
+ final YangInstanceIdentifier yangII = codecContext.toYangInstanceIdentifier(TOP_LEVEL_CONTAINER_FROM_USES);
final PathArgument lastArg = yangII.getLastPathArgument();
assertEquals(ContainerTop.QNAME, lastArg.getNodeType());
}
@Test
public void testDomToBindingFirst() {
final YangInstanceIdentifier yangII = YangInstanceIdentifier.of(ContainerTop.QNAME);
- InstanceIdentifier<?> bindingII = registry.fromYangInstanceIdentifier(yangII);
+ InstanceIdentifier<?> bindingII = codecContext.fromYangInstanceIdentifier(yangII);
assertEquals(TOP_LEVEL_CONTAINER_FROM_USES, bindingII);
}
.setAction3(true)
.build();
final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> dom =
- registry.toNormalizedNode(BA_DEFAULT_POLICY, binding);
+ codecContext.toNormalizedNode(BA_DEFAULT_POLICY, binding);
final Entry<InstanceIdentifier<?>, DataObject> readed =
- registry.fromNormalizedNode(dom.getKey(),dom.getValue());
+ codecContext.fromNormalizedNode(dom.getKey(),dom.getValue());
assertEquals(binding,readed.getValue());
.setEmptyLeaf3(Empty.getInstance())
.build();
final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> dom =
- registry.toNormalizedNode(BA_TEST_CONT, binding);
+ codecContext.toNormalizedNode(BA_TEST_CONT, binding);
final Entry<InstanceIdentifier<?>, DataObject> readed =
- registry.fromNormalizedNode(dom.getKey(),dom.getValue());
+ codecContext.fromNormalizedNode(dom.getKey(),dom.getValue());
assertEquals(binding,readed.getValue());
* 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.codec.impl;
import static org.junit.Assert.assertEquals;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
public class UnionTypeTest extends AbstractBindingCodecTest {
-
private static final String TEST_STRING = "testtesttest";
-
- public static final QName WRAPPER_QNAME = QName.create("urn:opendaylight:params:xml:ns:yang:yangtools:test:union",
+ private static final QName WRAPPER_QNAME = QName.create("urn:opendaylight:params:xml:ns:yang:yangtools:test:union",
"2015-01-21", "wrapper");
- public static final QName WRAP_LEAF_QNAME = QName.create(WRAPPER_QNAME, "wrap");
+ private static final QName WRAP_LEAF_QNAME = QName.create(WRAPPER_QNAME, "wrap");
@Test
public void unionTest() {
TopLevel topLevel = TopLevelBuilder.getDefaultInstance(TEST_STRING);
Wrapper wrapper = new WrapperBuilder().setWrap(topLevel).build();
- NormalizedNode<?, ?> topLevelEntry = registry.toNormalizedNode(InstanceIdentifier.create(Wrapper.class),
+ NormalizedNode<?, ?> topLevelEntry = codecContext.toNormalizedNode(InstanceIdentifier.create(Wrapper.class),
wrapper).getValue();
ContainerNode containerNode = ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(WRAPPER_QNAME))
+ .withNodeIdentifier(new NodeIdentifier(WRAPPER_QNAME))
.withChild(ImmutableNodes.leafNode(WRAP_LEAF_QNAME, TEST_STRING))
.build();
Assert.assertEquals(topLevelEntry, containerNode);
public void bug5446Test() {
IpAddressBinary ipAddress = IpAddressBinaryBuilder.getDefaultInstance("fwAAAQ==");
Root root = new RootBuilder().setIpAddress(ipAddress).build();
- NormalizedNode<?, ?> rootNode = registry.toNormalizedNode(InstanceIdentifier.builder(Root.class).build(), root)
+ NormalizedNode<?, ?> rootNode = codecContext.toNormalizedNode(InstanceIdentifier.create(Root.class), root)
.getValue();
- Entry<InstanceIdentifier<?>, DataObject> rootEntry = registry.fromNormalizedNode(
+ Entry<InstanceIdentifier<?>, DataObject> rootEntry = codecContext.fromNormalizedNode(
YangInstanceIdentifier.of(rootNode.getNodeType()), rootNode);
DataObject rootObj = rootEntry.getValue();
private DataObject createValueNode(final String valueString) {
UnionType unionType = UnionTypeBuilder.getDefaultInstance(valueString);
UnionNode unionNode = new UnionNodeBuilder().setValue(unionType).build();
- NormalizedNode<?, ?> normalizedUnionNode = registry
+ NormalizedNode<?, ?> normalizedUnionNode = codecContext
.toNormalizedNode(InstanceIdentifier.builder(UnionNode.class).build(), unionNode)
.getValue();
- Entry<InstanceIdentifier<?>, DataObject> unionNodeEntry = registry.fromNormalizedNode(
+ Entry<InstanceIdentifier<?>, DataObject> unionNodeEntry = codecContext.fromNormalizedNode(
YangInstanceIdentifier.of(normalizedUnionNode.getNodeType()), normalizedUnionNode);
DataObject unionNodeObj = unionNodeEntry.getValue();
assertTrue(unionNodeObj instanceof UnionNode);
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListener;
*/
public class BindingDOMEntityOwnershipServiceAdapter implements EntityOwnershipService, AutoCloseable {
private final @NonNull DOMEntityOwnershipService domService;
- private final @NonNull BindingNormalizedNodeSerializer conversionCodec;
+ private final @NonNull AdapterContext adapterContext;
public BindingDOMEntityOwnershipServiceAdapter(final @NonNull DOMEntityOwnershipService domService,
- @NonNull final BindingNormalizedNodeSerializer conversionCodec) {
+ final @NonNull AdapterContext adapterContext) {
this.domService = requireNonNull(domService);
- this.conversionCodec = requireNonNull(conversionCodec);
+ this.adapterContext = requireNonNull(adapterContext);
}
@Override
public EntityOwnershipListenerRegistration registerListener(final String entityType,
final EntityOwnershipListener listener) {
return new BindingEntityOwnershipListenerRegistration(entityType, listener,
- domService.registerListener(entityType, new DOMEntityOwnershipListenerAdapter(listener, conversionCodec)));
+ domService.registerListener(entityType, new DOMEntityOwnershipListenerAdapter(listener, adapterContext)));
}
@Override
}
private @NonNull DOMEntity toDOMEntity(final Entity entity) {
- return new DOMEntity(entity.getType(), conversionCodec.toYangInstanceIdentifier(entity.getIdentifier()));
+ return new DOMEntity(entity.getType(),
+ adapterContext.currentSerializer().toYangInstanceIdentifier(entity.getIdentifier()));
}
@Override
import static java.util.Objects.requireNonNull;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+import org.opendaylight.mdsal.binding.dom.adapter.AdapterContext;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListener;
*
* @author Thomas Pantelis
*/
-class DOMEntityOwnershipListenerAdapter implements DOMEntityOwnershipListener {
+final class DOMEntityOwnershipListenerAdapter implements DOMEntityOwnershipListener {
private static final Logger LOG = LoggerFactory.getLogger(DOMEntityOwnershipListenerAdapter.class);
- private final BindingNormalizedNodeSerializer conversionCodec;
private final EntityOwnershipListener bindingListener;
+ private final AdapterContext adapterContext;
DOMEntityOwnershipListenerAdapter(final EntityOwnershipListener bindingListener,
- final BindingNormalizedNodeSerializer conversionCodec) {
+ final AdapterContext adapterContext) {
this.bindingListener = requireNonNull(bindingListener);
- this.conversionCodec = requireNonNull(conversionCodec);
+ this.adapterContext = requireNonNull(adapterContext);
}
@Override
final YangInstanceIdentifier domId = domEntity.getIdentifier();
final InstanceIdentifier<?> bindingId;
try {
- bindingId = verifyNotNull(conversionCodec.fromYangInstanceIdentifier(domId));
+ bindingId = verifyNotNull(adapterContext.currentSerializer().fromYangInstanceIdentifier(domId));
} catch (RuntimeException e) {
LOG.error("Error converting DOM entity ID {} to binding InstanceIdentifier", domId, e);
return;
<reference id="domEntityOwnershipService" interface="org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipService"/>
- <reference id="conversionCodec" interface="org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer"/>
+ <reference id="conversionCodec" interface="org.opendaylight.mdsal.binding.dom.adapter.AdapterContext"/>
<bean id="bindingEntityOwnershipService" class="org.opendaylight.mdsal.eos.binding.dom.adapter.BindingDOMEntityOwnershipServiceAdapter"
destroy-method="close">
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.opendaylight.binding.runtime.spi.GeneratedClassLoadingStrategy;
-import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
-import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.dom.adapter.ConstantAdapterContext;
+import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
*
* @author Thomas Pantelis
*/
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class BindingDOMEntityOwnershipServiceAdapterTest {
static Entity BINDING_ENTITY = new Entity("foo", "bar");
static DOMEntity DOM_ENTITY = new DOMEntity("foo", "bar");
@Mock
- private BindingNormalizedNodeCodecRegistry mockCodecRegistry;
+ private BindingDOMCodecServices mockCodecRegistry;
@Mock
private DOMEntityOwnershipService mockDOMService;
@Before
public void setup() {
- MockitoAnnotations.initMocks(this);
-
- doReturn(DOM_ENTITY.getIdentifier()).when(this.mockCodecRegistry).toYangInstanceIdentifier(
+ doReturn(DOM_ENTITY.getIdentifier()).when(mockCodecRegistry).toYangInstanceIdentifier(
BINDING_ENTITY.getIdentifier());
- doReturn(BINDING_ENTITY.getIdentifier()).when(this.mockCodecRegistry).fromYangInstanceIdentifier(
+ doReturn(BINDING_ENTITY.getIdentifier()).when(mockCodecRegistry).fromYangInstanceIdentifier(
DOM_ENTITY.getIdentifier());
- this.adapter = new BindingDOMEntityOwnershipServiceAdapter(this.mockDOMService,
- new BindingToNormalizedNodeCodec(new DefaultBindingRuntimeGenerator(),
- GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), mockCodecRegistry));
+ this.adapter = new BindingDOMEntityOwnershipServiceAdapter(mockDOMService,
+ new ConstantAdapterContext(mockCodecRegistry));
}
@Test
assertEquals("isCandidateRegistered", true, this.adapter.isCandidateRegistered(BINDING_ENTITY));
}
- @Test(expected = IllegalStateException.class)
- public void testOwnershipChangeWithException() throws Exception {
+ public void testOwnershipChangeWithException() {
final DOMEntityOwnershipListenerAdapter domEntityOwnershipListenerAdapter =
new DOMEntityOwnershipListenerAdapter(mock(EntityOwnershipListener.class),
- new BindingToNormalizedNodeCodec(new DefaultBindingRuntimeGenerator(),
- GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), mockCodecRegistry));
+ new ConstantAdapterContext(mockCodecRegistry));
final DOMEntityOwnershipChange domOwnershipChange = mock(DOMEntityOwnershipChange.class);
doThrow(IllegalStateException.class).when(domOwnershipChange).getEntity();
- domEntityOwnershipListenerAdapter.ownershipChanged(domOwnershipChange);
+ assertThrows(IllegalStateException.class,
+ () -> domEntityOwnershipListenerAdapter.ownershipChanged(domOwnershipChange));
}
}
Code Review / mdsal.git / commitdiff