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.generator.api.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeGenerator;
import org.opendaylight.mdsal.binding.generator.api.ClassLoadingStrategy;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
});
private final BindingNormalizedNodeCodecRegistry codecRegistry;
private final ClassLoadingStrategy classLoadingStrategy;
+ private final BindingRuntimeGenerator generator;
private final FutureSchema futureSchema;
+
private ListenerRegistration<?> listenerRegistration;
@Inject
- public BindingToNormalizedNodeCodec(final ClassLoadingStrategy classLoadingStrategy,
- final BindingNormalizedNodeCodecRegistry codecRegistry) {
- this(classLoadingStrategy, codecRegistry, false);
+ public BindingToNormalizedNodeCodec(final BindingRuntimeGenerator generator,
+ final ClassLoadingStrategy classLoadingStrategy, final BindingNormalizedNodeCodecRegistry codecRegistry) {
+ this(generator, classLoadingStrategy, codecRegistry, false);
}
- public BindingToNormalizedNodeCodec(final ClassLoadingStrategy classLoadingStrategy,
- final BindingNormalizedNodeCodecRegistry codecRegistry, final boolean waitForSchema) {
+ 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 ClassLoadingStrategy classLoadingStrategy,
- final DOMSchemaService schemaService) {
+ public static BindingToNormalizedNodeCodec newInstance(final BindingRuntimeGenerator generator,
+ final ClassLoadingStrategy classLoadingStrategy, final DOMSchemaService schemaService) {
final BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry();
- BindingToNormalizedNodeCodec instance = new BindingToNormalizedNodeCodec(
- classLoadingStrategy, codecRegistry, true);
+ BindingToNormalizedNodeCodec instance = new BindingToNormalizedNodeCodec(generator, classLoadingStrategy,
+ codecRegistry, true);
instance.listenerRegistration = schemaService.registerSchemaContextListener(instance);
return instance;
}
@Override
public void onGlobalContextUpdated(final SchemaContext context) {
- final BindingRuntimeContext runtimeContext = BindingRuntimeContext.create(classLoadingStrategy, context);
+ final BindingRuntimeContext runtimeContext = BindingRuntimeContext.create(
+ generator.generateTypeMapping(context), classLoadingStrategy);
codecRegistry.onBindingRuntimeContextUpdated(runtimeContext);
futureSchema.onRuntimeContextUpdated(runtimeContext);
}
return codecRegistry.create(context);
}
- @Override
- public final BindingCodecTree create(final SchemaContext context, final Class<?>... bindingClasses) {
- return codecRegistry.create(context, bindingClasses);
- }
-
protected @NonNull Entry<InstanceIdentifier<?>, BindingDataObjectCodecTreeNode<?>> getSubtreeCodec(
final YangInstanceIdentifier domIdentifier) {
import java.util.concurrent.TimeoutException;
import java.util.function.Predicate;
import org.checkerframework.checker.lock.qual.GuardedBy;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.junit.BeforeClass;
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.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yang.gen.v1.urn.odl.actions.norev.Cont;
ctx.addModuleInfos(BindingReflections.loadModuleInfos());
final BindingNormalizedNodeCodecRegistry registry = mock(BindingNormalizedNodeCodecRegistry.class);
- CODEC = new BindingToNormalizedNodeCodec(ctx, registry);
- CODEC.onGlobalContextUpdated(ctx.tryToCreateSchemaContext().get());
+ CODEC = new BindingToNormalizedNodeCodec(new DefaultBindingRuntimeGenerator(), ctx, registry);
+ CODEC.onGlobalContextUpdated(ctx.tryToCreateModelContext().get());
}
@AfterClass
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.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMService;
@Before
public void setUp() {
doReturn(ImmutableClassToInstanceMap.of()).when(domService).getExtensions();
- bindingDOMAdapterLoader = new BindingDOMAdapterLoader(
- new BindingToNormalizedNodeCodec(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
- mockCodecRegistry)) {
+ bindingDOMAdapterLoader = new BindingDOMAdapterLoader(new BindingToNormalizedNodeCodec(
+ new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
+ mockCodecRegistry)) {
@Override
protected DOMService getDelegate(final Class<? extends DOMService> reqDeleg) {
return domService;
import org.junit.Test;
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.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCursorAwareTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class BindingDOMCursorAwareWriteTransactionAdapterTest {
-
@Test
public void basicTest() throws Exception {
final DOMDataTreeCursorAwareTransaction delegate = mock(DOMDataTreeCursorAwareTransaction.class);
final BindingNormalizedNodeCodecRegistry registry = mock(BindingNormalizedNodeCodecRegistry.class);
- final BindingToNormalizedNodeCodec codec =
- new BindingToNormalizedNodeCodec(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), registry);
+ final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
+ new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
+ registry);
final YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.empty();
doReturn(yangInstanceIdentifier).when(registry).toYangInstanceIdentifier(any());
doReturn(mock(DOMDataTreeWriteCursor.class)).when(delegate).createCursor(any());
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.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener;
@Test
public void testRegisterDataTreeChangeListener() {
- final BindingToNormalizedNodeCodec codec =
- new BindingToNormalizedNodeCodec(this.classLoadingStrategy, this.codecRegistry);
+ final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
+ new DefaultBindingRuntimeGenerator(), classLoadingStrategy, codecRegistry);
final DataTreeChangeService service = BindingDOMDataTreeChangeServiceAdapter.create(codec, this.mockDOMService);
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.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.PostCanCommitStep;
public void canCommitTest() throws Exception {
final DataTreeCommitCohort<?> cohort = mock(DataTreeCommitCohort.class);
final BindingNormalizedNodeCodecRegistry registry = mock(BindingNormalizedNodeCodecRegistry.class);
- final BindingToNormalizedNodeCodec codec =
- new BindingToNormalizedNodeCodec(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), registry);
+ final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
+ new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
+ registry);
final BindingDOMDataTreeCommitCohortAdapter<?> adapter =
new BindingDOMDataTreeCommitCohortAdapter<>(codec, cohort);
import org.junit.Test;
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.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteCursor;
InstanceIdentifier.create(DataObject.class));
final DOMDataTreeWriteCursor delegate = mock(DOMDataTreeWriteCursor.class);
final BindingNormalizedNodeCodecRegistry registry = mock(BindingNormalizedNodeCodecRegistry.class);
- final BindingToNormalizedNodeCodec codec =
- new BindingToNormalizedNodeCodec(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), registry);
+ final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
+ new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
+ registry);
final BindingDOMDataTreeWriteCursorAdapter<?> adapter =
new BindingDOMDataTreeWriteCursorAdapter<>(identifier, delegate, codec);
import org.junit.Test;
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.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class BindingDOMMountPointServiceAdapterTest {
-
@Test
public void basicTest() throws Exception {
final BindingNormalizedNodeCodecRegistry registry = mock(BindingNormalizedNodeCodecRegistry.class);
- final BindingToNormalizedNodeCodec codec =
- new BindingToNormalizedNodeCodec(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), registry);
+ final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
+ new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
+ registry);
doReturn(YangInstanceIdentifier.empty()).when(registry).toYangInstanceIdentifier(any());
final DOMMountPointService mountPointService = mock(DOMMountPointService.class);
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.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
doReturn(transactionChain).when(domService).createTransactionChain(any());
doReturn(ImmutableClassToInstanceMap.of()).when(domService).getExtensions();
- BindingDOMAdapterLoader bindingDOMAdapterLoader = new BindingDOMAdapterLoader(
- new BindingToNormalizedNodeCodec(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
- mockCodecRegistry)) {
+ BindingDOMAdapterLoader bindingDOMAdapterLoader = new BindingDOMAdapterLoader(new BindingToNormalizedNodeCodec(
+ new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
+ mockCodecRegistry)) {
@Override
protected DOMService getDelegate(final Class<? extends DOMService> reqDeleg) {
return domService;
import org.junit.Test;
import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
+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 GeneratedClassLoadingStrategy loading = getTCCLClassLoadingStrategy();
- final BindingNormalizedNodeCodecRegistry codecRegistry = mock(BindingNormalizedNodeCodecRegistry.class);
- final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(loading, codecRegistry);
+ 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());
* 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.assertEquals;
import org.junit.Test;
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.generator.impl.GeneratedClassLoadingStrategy;
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;
@Override
protected void setupWithSchema(final SchemaContext schemaContext) {
this.context = schemaContext;
- final BindingNormalizedNodeCodecRegistry registry = new BindingNormalizedNodeCodecRegistry();
- this.codec = new BindingToNormalizedNodeCodec(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
- registry, true);
+ this.codec = new BindingToNormalizedNodeCodec(new DefaultBindingRuntimeGenerator(),
+ GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), new BindingNormalizedNodeCodecRegistry(),
+ true);
}
@Test
import java.util.Map.Entry;
import org.junit.Test;
import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeGenerator;
+import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class BindingToNormalizedNodeCodecTest {
-
/**
* Positive test.
*
final SchemaContext schemaCtx) {
final GeneratedClassLoadingStrategy classLoadingStrategy =
GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy();
- final BindingRuntimeContext ctx = BindingRuntimeContext.create(classLoadingStrategy, schemaCtx);
+ final BindingRuntimeGenerator generator = new DefaultBindingRuntimeGenerator();
+ final BindingRuntimeContext ctx = BindingRuntimeContext.create(
+ generator.generateTypeMapping(schemaCtx), classLoadingStrategy);
final BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry(ctx);
- final BindingToNormalizedNodeCodec codec =
- new BindingToNormalizedNodeCodec(classLoadingStrategy, codecRegistry);
+ 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")));
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.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
public class LazyDataTreeModificationTest {
-
@Test
public void basicTest() throws Exception {
final BindingNormalizedNodeCodecRegistry registry = mock(BindingNormalizedNodeCodecRegistry.class);
- final BindingToNormalizedNodeCodec codec =
- new BindingToNormalizedNodeCodec(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), registry);
+ final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(
+ new DefaultBindingRuntimeGenerator(), GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
+ registry);
final DOMDataTreeCandidate domDataTreeCandidate = mock(DOMDataTreeCandidate.class);
final DOMDataTreeIdentifier domDataTreeIdentifier =
new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.empty());
assertNotNull(LazyDataTreeModification.create(codec, domDataTreeCandidate));
}
-
}
\ No newline at end of file
import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
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.binding.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
public AbstractDataBrokerTestCustomizer() {
this.schemaService = new MockSchemaService();
- final BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry();
- final GeneratedClassLoadingStrategy loading = GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy();
- this.bindingToNormalized = new BindingToNormalizedNodeCodec(loading, codecRegistry);
+ this.bindingToNormalized = new BindingToNormalizedNodeCodec(new DefaultBindingRuntimeGenerator(),
+ GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), new BindingNormalizedNodeCodecRegistry());
this.schemaService.registerSchemaContextListener(this.bindingToNormalized);
this.domNotificationRouter = DOMNotificationRouter.create(16);
}
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.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
@Beta
public class BindingTestContext implements AutoCloseable {
-
-
private BindingToNormalizedNodeCodec codec;
private final ListeningExecutorService executor;
public void startBindingToDomMappingService() {
final BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry();
final GeneratedClassLoadingStrategy loading = GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy();
- codec = new BindingToNormalizedNodeCodec(loading, codecRegistry);
+ codec = new BindingToNormalizedNodeCodec(new DefaultBindingRuntimeGenerator(), loading, codecRegistry);
mockSchemaService.registerSchemaContextListener(codec);
}
*/
package org.opendaylight.mdsal.binding.dom.codec.api;
-import com.google.common.annotations.Beta;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
public interface BindingCodecTreeFactory {
/**
* @return Binding Codec Tree for specified Binding runtime context.
*/
BindingCodecTree create(BindingRuntimeContext context);
-
- /**
- * Creates Binding Codec Tree for specified Binding runtime context.
- *
- * @param context
- * Binding Runtime Context for which Binding codecs should be
- * instantiated.
- * @param bindingClasses
- * Binding Runtime Context will be constructed using bindings
- * which contains specified classes, in order to support
- * deserialization in multi-classloader environment.
- * @return Binding Codec Tree for specified Binding runtime context.
- */
- @Beta
- BindingCodecTree create(SchemaContext context, Class<?>... bindingClasses);
}
package org.opendaylight.mdsal.binding.dom.codec.osgi;
import java.util.EventListener;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
@Deprecated
public interface BindingRuntimeContextListener extends EventListener {
package org.opendaylight.mdsal.binding.dom.codec.osgi;
import com.google.common.annotations.Beta;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
package org.opendaylight.mdsal.binding.dom.codec.osgi.impl;
import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import com.google.common.util.concurrent.ListenableFuture;
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.opendaylight.mdsal.binding.dom.codec.osgi.BindingRuntimeContextListener;
import org.opendaylight.mdsal.binding.dom.codec.osgi.BindingRuntimeContextService;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.generator.api.ClassLoadingStrategy;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
}
void updateBindingRuntimeContext(final SchemaContext schemaContext) {
- final BindingRuntimeContext next = verifyNotNull(BindingRuntimeContext.create(strategy, schemaContext));
+ final BindingRuntimeContext next = BindingRuntimeContext.create(
+ new DefaultBindingRuntimeGenerator().generateTypeMapping(schemaContext), strategy);
final BindingRuntimeContextListener[] listeners;
synchronized (lock) {
import org.opendaylight.mdsal.binding.dom.codec.impl.NodeCodecContext.CodecContextFactory;
import org.opendaylight.mdsal.binding.dom.codec.loader.CodecClassLoader;
import org.opendaylight.mdsal.binding.dom.codec.util.BindingSchemaMapping;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.concepts.Delegator;
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.util.AbstractBindingLazyContainerNode;
-import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
-import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
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.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return new BindingCodecContext(context, this);
}
- @Override
- @SuppressWarnings("checkstyle:illegalCatch")
- public BindingCodecTree create(final SchemaContext context, final Class<?>... bindingClasses) {
- final ModuleInfoBackedContext strategy = ModuleInfoBackedContext.create();
- for (final Class<?> bindingCls : bindingClasses) {
- try {
- strategy.registerModuleInfo(BindingReflections.getModuleInfo(bindingCls));
- } catch (final Exception e) {
- throw new IllegalStateException(
- "Could not create BindingRuntimeContext from class " + bindingCls.getName(), e);
- }
- }
- final BindingRuntimeContext runtimeCtx = BindingRuntimeContext.create(strategy, context);
- return create(runtimeCtx);
- }
-
-
private static final class DeserializeFunction<T> implements Function<Optional<NormalizedNode<?, ?>>, Optional<T>> {
private final DataObjectCodecContext<?,?> ctx;
import org.opendaylight.mdsal.binding.dom.codec.api.MissingClassInLoadingStrategyException;
import org.opendaylight.mdsal.binding.dom.codec.api.MissingSchemaException;
import org.opendaylight.mdsal.binding.dom.codec.api.MissingSchemaForClassException;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.generator.api.ClassLoadingStrategy;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.BindingObject;
import org.opendaylight.yangtools.yang.binding.DataObject;
import static java.util.Objects.requireNonNull;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingIdentityCodec;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.concepts.AbstractIllegalArgumentCodec;
import org.opendaylight.yangtools.yang.binding.BaseIdentity;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
import org.opendaylight.mdsal.binding.dom.codec.loader.CodecClassLoader;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.junit.AfterClass;
import org.junit.BeforeClass;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
public abstract class AbstractBindingRuntimeTest {
-
- private static SchemaContext schemaContext;
+ private static EffectiveModelContext schemaContext;
private static BindingRuntimeContext runtimeContext;
@BeforeClass
public static void beforeClass() {
ModuleInfoBackedContext ctx = ModuleInfoBackedContext.create();
ctx.addModuleInfos(BindingReflections.loadModuleInfos());
- schemaContext = ctx.tryToCreateSchemaContext().get();
- runtimeContext = BindingRuntimeContext.create(ctx, schemaContext);
+ schemaContext = ctx.tryToCreateModelContext().get();
+
+ runtimeContext = BindingRuntimeContext.create(
+ new DefaultBindingRuntimeGenerator().generateTypeMapping(schemaContext), ctx);
}
@AfterClass
runtimeContext = null;
}
- public static final SchemaContext getSchemaContext() {
+ public static final EffectiveModelContext getSchemaContext() {
return schemaContext;
}
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.mdsal.binding.dom.codec.api.MissingClassInLoadingStrategyException;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
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.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* This sets of tests are designed in way, that schema context contains models for all augmentations, but backing class
*/
public class AugmentationClassDiscoveredAfterCodecTest {
- private SchemaContext schemaContext;
+ private EffectiveModelContext schemaContext;
private BindingRuntimeContext runtimeContext;
private ClassExcludingClassLoadingStrategy mockedContext;
private BindingNormalizedNodeCodecRegistry registry;
final ModuleInfoBackedContext ctx = ModuleInfoBackedContext.create();
ctx.addModuleInfos(BindingReflections.loadModuleInfos());
mockedContext = new ClassExcludingClassLoadingStrategy(ctx);
- schemaContext = ctx.tryToCreateSchemaContext().get();
- runtimeContext = BindingRuntimeContext.create(mockedContext, schemaContext);
+ schemaContext = ctx.tryToCreateModelContext().get();
+ runtimeContext = BindingRuntimeContext.create(
+ new DefaultBindingRuntimeGenerator().generateTypeMapping(schemaContext), mockedContext);
registry = new BindingNormalizedNodeCodecRegistry(runtimeContext);
}
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.mdsal.binding.generator.api.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingRuntimeGenerator;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
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.binding.YangModuleInfo;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
public class ExceptionReportingTest {
private static final BindingNormalizedNodeCodecRegistry CODEC_WITHOUT_TOP = codec(LowestLevel1.class);
throw new IllegalStateException(e);
}
}
- final SchemaContext schema = ctx.tryToCreateSchemaContext().get();
- final BindingRuntimeContext runtimeCtx = BindingRuntimeContext.create(ctx, schema);
+ final EffectiveModelContext schema = ctx.tryToCreateModelContext().get();
+ final BindingRuntimeContext runtimeCtx = BindingRuntimeContext.create(
+ new DefaultBindingRuntimeGenerator().generateTypeMapping(schema), ctx);
final BindingNormalizedNodeCodecRegistry registry = new BindingNormalizedNodeCodecRegistry(runtimeCtx);
return registry;
}
<dependencies>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-model-api</artifactId>
+ <artifactId>yang-model-util</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
* 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.generator.util;
+package org.opendaylight.mdsal.binding.generator.api;
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.base.MoreObjects;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
-import java.util.ServiceLoader;
import java.util.Set;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeGenerator;
-import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeTypes;
-import org.opendaylight.mdsal.binding.generator.api.ClassLoadingStrategy;
import org.opendaylight.mdsal.binding.model.api.DefaultType;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.slf4j.LoggerFactory;
/**
- * Runtime Context for Java YANG Binding classes
+ * Runtime Context for Java YANG Binding classes. It provides information derived from the backing effective model,
+ * which is not captured in generated classes (and hence cannot be obtained from {@code BindingReflections}.
*
- * <p>Runtime Context provides additional insight in Java YANG Binding,
- * binding classes and underlying YANG schema, it contains
- * runtime information, which could not be derived from generated
- * classes alone using {@link org.opendaylight.mdsal.binding.spec.reflect.BindingReflections}.
- *
- * <p>Some of this information are for example list of all available
- * children for cases {@link #getChoiceCaseChildren(DataNodeContainer)}, since
- * choices are augmentable and new choices may be introduced by additional models.
- *
- * <p>Same goes for all possible augmentations.
+ * <p>Some of this information are for example list of all available children for cases
+ * {@link #getChoiceCaseChildren(DataNodeContainer)}, since choices are augmentable and new choices may be introduced
+ * by additional models. Same goes for all possible augmentations.
*/
+@Beta
public final class BindingRuntimeContext implements SchemaContextProvider, Immutable {
private static final Logger LOG = LoggerFactory.getLogger(BindingRuntimeContext.class);
- private static final BindingRuntimeGenerator GENERATOR = ServiceLoader.load(BindingRuntimeGenerator.class)
- .findFirst()
- .orElseThrow(() -> new IllegalStateException("No BindingRuntimeGenerator implementation found"));
-
- private final BindingRuntimeTypes runtimeTypes;
- private final ClassLoadingStrategy strategy;
+ private final @NonNull BindingRuntimeTypes runtimeTypes;
+ private final @NonNull ClassLoadingStrategy strategy;
private final LoadingCache<QName, Class<?>> identityClasses = CacheBuilder.newBuilder().weakValues().build(
new CacheLoader<QName, Class<?>>() {
* Creates Binding Runtime Context from supplied class loading strategy and schema context.
*
* @param strategy Class loading strategy to retrieve generated Binding classes
- * @param ctx Schema Context which describes YANG model and to which Binding classes should be mapped
- * @return Instance of BindingRuntimeContext for supplied schema context.
+ * @param runtimeTypes Binding classes to YANG schema mapping
+ * @return A new instance
*/
- public static BindingRuntimeContext create(final ClassLoadingStrategy strategy, final SchemaContext ctx) {
- return new BindingRuntimeContext(GENERATOR.generateTypeMapping(ctx), strategy);
+ public static @NonNull BindingRuntimeContext create(final BindingRuntimeTypes runtimeTypes,
+ final ClassLoadingStrategy strategy) {
+ return new BindingRuntimeContext(runtimeTypes, strategy);
}
/**
*
* @return Class loading strategy.
*/
- public ClassLoadingStrategy getStrategy() {
+ public @NonNull ClassLoadingStrategy getStrategy() {
return strategy;
}
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.checkerframework.checker.lock.qual.Holding;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeGenerator;
import org.opendaylight.mdsal.binding.generator.api.ClassLoadingStrategy;
import org.opendaylight.mdsal.binding.generator.api.ModuleInfoRegistry;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
}
}
+ @Beta
+ public @NonNull BindingRuntimeContext createRuntimeContext(final BindingRuntimeGenerator generator) {
+ return BindingRuntimeContext.create(generator.generateTypeMapping(tryToCreateModelContext().orElseThrow()),
+ this);
+ }
+
// TODO finish schema parsing and expose as SchemaService
// Unite with current SchemaService
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Optional;
-import java.util.ServiceLoader;
import java.util.function.Supplier;
import org.junit.BeforeClass;
-import org.opendaylight.mdsal.binding.generator.api.BindingGenerator;
+import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingGenerator;
import org.opendaylight.mdsal.binding.java.api.generator.GeneratorJavaFile;
import org.opendaylight.mdsal.binding.java.api.generator.YangModuleInfoTemplate;
import org.opendaylight.mdsal.binding.model.api.Type;
public abstract class BaseCompilationTest {
- private static BindingGenerator BINDING_GENERATOR;
-
@BeforeClass
public static void createTestDirs() {
if (CompilationTestUtils.TEST_DIR.exists()) {
}
assertTrue(CompilationTestUtils.GENERATOR_OUTPUT_DIR.mkdirs());
assertTrue(CompilationTestUtils.COMPILER_OUTPUT_DIR.mkdirs());
-
- BINDING_GENERATOR = ServiceLoader.load(BindingGenerator.class).findFirst().orElseThrow();
}
protected static final void generateTestSources(final List<Type> types, final File sourcesOutputDir)
throws IOException, URISyntaxException {
final List<File> sourceFiles = CompilationTestUtils.getSourceFiles(resourceDirPath);
final EffectiveModelContext context = YangParserTestUtils.parseYangFiles(sourceFiles);
- final List<Type> types = BINDING_GENERATOR.generateTypes(context);
+ final List<Type> types = new DefaultBindingGenerator().generateTypes(context);
generateTestSources(types, sourcesOutputDir);
// Also generate YangModuleInfo
import static org.junit.Assert.assertTrue;
import java.util.List;
-import java.util.ServiceLoader;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.generator.api.BindingGenerator;
+import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingGenerator;
import org.opendaylight.mdsal.binding.java.api.generator.TOGenerator;
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
final SchemaContext context = YangParserTestUtils.parseYangResource("/list-composite-key.yang");
assertNotNull(context);
- final BindingGenerator bindingGen = ServiceLoader.load(BindingGenerator.class).findFirst().orElseThrow();
- final List<Type> genTypes = bindingGen.generateTypes(context);
+ final List<Type> genTypes = new DefaultBindingGenerator().generateTypes(context);
assertTrue(genTypes != null);
assertEquals(7, genTypes.size());
<groupId>org.osgi</groupId>
<artifactId>org.osgi.core</artifactId>
</dependency>
+
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-generator-impl</artifactId>
+ <scope>test</scope>
+ </dependency>
</dependencies>
<scm>
<connection>scm:git:http://git.opendaylight.org/gerrit/controller.git</connection>
import org.mockito.MockitoAnnotations;
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.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
DOM_ENTITY.getIdentifier());
this.adapter = new BindingDOMEntityOwnershipServiceAdapter(this.mockDOMService,
- new BindingToNormalizedNodeCodec(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
- this.mockCodecRegistry));
+ new BindingToNormalizedNodeCodec(new DefaultBindingRuntimeGenerator(),
+ GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), mockCodecRegistry));
}
@Test
public void testOwnershipChangeWithException() throws Exception {
final DOMEntityOwnershipListenerAdapter domEntityOwnershipListenerAdapter =
new DOMEntityOwnershipListenerAdapter(mock(EntityOwnershipListener.class),
- new BindingToNormalizedNodeCodec(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(),
- this.mockCodecRegistry));
+ new BindingToNormalizedNodeCodec(new DefaultBindingRuntimeGenerator(),
+ GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), mockCodecRegistry));
final DOMEntityOwnershipChange domOwnershipChange = mock(DOMEntityOwnershipChange.class);
doThrow(IllegalStateException.class).when(domOwnershipChange).getEntity();
domEntityOwnershipListenerAdapter.ownershipChanged(domOwnershipChange);
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.util.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeGenerator;
import org.opendaylight.mdsal.yanglib.api.SchemaContextResolver;
import org.opendaylight.mdsal.yanglib.api.YangLibSupport;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160621.$YangModuleInfoImpl;
private final EffectiveModelContext context;
@Inject
- public YangModuleLibrarySupport(final @Reference YangParserFactory parserFactory)
- throws YangParserException, IOException {
+ public YangModuleLibrarySupport(final @Reference YangParserFactory parserFactory,
+ final @Reference BindingRuntimeGenerator generator) throws YangParserException, IOException {
final YangModuleInfo yangLibModule = $YangModuleInfoImpl.getInstance();
context = parserFactory.createParser()
.addSource(createSource(yangLibModule))
.buildEffectiveModel();
final BindingCodecTree codecTree = new BindingNormalizedNodeCodecRegistry(BindingRuntimeContext.create(
- SimpleStrategy.INSTANCE, context)).getCodecContext();
+ generator.generateTypeMapping(context), SimpleStrategy.INSTANCE)).getCodecContext();
this.codec = verifyNotNull(codecTree.getSubtreeCodec(InstanceIdentifier.create(ModulesState.class)));
}
*/
package org.opendaylight.mdsal.yanglib.rfc7895;
+import static java.util.Objects.requireNonNull;
+
import java.io.IOException;
+import java.util.ServiceLoader;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.kohsuke.MetaInfServices;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeGenerator;
import org.opendaylight.mdsal.yanglib.api.YangLibSupport;
import org.opendaylight.mdsal.yanglib.api.YangLibSupportFactory;
import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
@MetaInfServices
@NonNullByDefault
public final class YangModuleLibrarySupportFactory implements YangLibSupportFactory {
+ private final BindingRuntimeGenerator generator;
+
+ public YangModuleLibrarySupportFactory() {
+ this(ServiceLoader.load(BindingRuntimeGenerator.class).findFirst()
+ .orElseThrow(() -> new IllegalStateException("Failed to find a BindingRuntimeGenerator service")));
+ }
+
+ public YangModuleLibrarySupportFactory(final BindingRuntimeGenerator generator) {
+ this.generator = requireNonNull(generator);
+ }
+
@Override
public YangLibSupport createYangLibSupport(final YangParserFactory parserFactory)
throws YangParserException, IOException {
- return new YangModuleLibrarySupport(parserFactory);
+ return new YangModuleLibrarySupport(parserFactory, generator);
}
}
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.impl.BindingNormalizedNodeCodecRegistry;
-import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeGenerator;
import org.opendaylight.mdsal.yanglib.api.SchemaContextResolver;
import org.opendaylight.mdsal.yanglib.api.YangLibSupport;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.$YangModuleInfoImpl;
private final EffectiveModelContext context;
@Inject
- public YangLibrarySupport(final @Reference YangParserFactory parserFactory)
- throws YangParserException, IOException {
+ public YangLibrarySupport(final @Reference YangParserFactory parserFactory,
+ final @Reference BindingRuntimeGenerator generator) throws YangParserException, IOException {
final YangModuleInfo yangLibModule = $YangModuleInfoImpl.getInstance();
context = parserFactory.createParser()
.addSource(createSource(yangLibModule))
.buildEffectiveModel();
final BindingCodecTree codecTree = new BindingNormalizedNodeCodecRegistry(BindingRuntimeContext.create(
- SimpleStrategy.INSTANCE, context)).getCodecContext();
+ generator.generateTypeMapping(context), SimpleStrategy.INSTANCE)).getCodecContext();
this.identityCodec = codecTree.getIdentityCodec();
this.codec = verifyNotNull(codecTree.getSubtreeCodec(InstanceIdentifier.create(YangLibrary.class)));
*/
package org.opendaylight.mdsal.yanglib.rfc8525;
+import static java.util.Objects.requireNonNull;
+
import java.io.IOException;
+import java.util.ServiceLoader;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.kohsuke.MetaInfServices;
+import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeGenerator;
import org.opendaylight.mdsal.yanglib.api.YangLibSupport;
import org.opendaylight.mdsal.yanglib.api.YangLibSupportFactory;
import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
@MetaInfServices
@NonNullByDefault
public final class YangLibrarySupportFactory implements YangLibSupportFactory {
+ private final BindingRuntimeGenerator generator;
+
+ public YangLibrarySupportFactory() {
+ this(ServiceLoader.load(BindingRuntimeGenerator.class).findFirst()
+ .orElseThrow(() -> new IllegalStateException("Failed to find a BindingRuntimeGenerator service")));
+ }
+
+ public YangLibrarySupportFactory(final BindingRuntimeGenerator generator) {
+ this.generator = requireNonNull(generator);
+ }
+
@Override
public YangLibSupport createYangLibSupport(final YangParserFactory parserFactory)
throws YangParserException, IOException {
- return new YangLibrarySupport(parserFactory);
+ return new YangLibrarySupport(parserFactory, generator);
}
}
Code Review / mdsal.git / commitdiff