private static class TestDataObject1 implements DataObject {
@Override
+ @Deprecated
public Class<? extends DataContainer> getImplementedInterface() {
- return null;
+ return DataObject.class;
+ }
+
+ @Override
+ public Class<? extends DataObject> implementedInterface() {
+ return DataObject.class;
}
}
private static class TestDataObject2 implements DataObject {
@Override
+ @Deprecated
public Class<? extends DataContainer> getImplementedInterface() {
- return null;
+ return DataObject.class;
+ }
+
+ @Override
+ public Class<? extends DataObject> implementedInterface() {
+ return DataObject.class;
}
}
-}
\ No newline at end of file
+}
}
static DOMNotification create(final BindingNormalizedNodeSerializer codec, final Notification data) {
- final SchemaPath type = SchemaPath.create(true, BindingReflections.findQName(data.getImplementedInterface()));
+ final SchemaPath type = SchemaPath.create(true, BindingReflections.findQName(data.implementedInterface()));
return new LazySerializedDOMNotification(codec, data, type);
}
final DataObject value = fromNormalizedNode.getValue();
assertNotNull(value);
- assertEquals("Cont", value.getImplementedInterface().getSimpleName());
+ final Class<? extends DataObject> iface = value.implementedInterface();
+ assertEquals("Cont", iface.getSimpleName());
final Object[] objs = {};
- final Object invoked = value.getImplementedInterface().getDeclaredMethods()[0].invoke(value, objs);
+ final Object invoked = iface.getDeclaredMethod("getVlanId").invoke(value, objs);
final Field declaredField = invoked.getClass().getDeclaredField("_id");
declaredField.setAccessible(true);
final Object id = declaredField.get(invoked);
final Entry<InstanceIdentifier<?>, DataObject> fromNormalizedNode = fromNormalizedNode(data, schemaCtx);
final DataObject value = fromNormalizedNode.getValue();
assertNotNull(value);
- assertEquals("Cont", value.getImplementedInterface().getSimpleName());
+ final Class<? extends DataObject> iface = value.implementedInterface();
+ assertEquals("Cont", iface.getSimpleName());
final Object[] objs = {};
try {
- value.getImplementedInterface().getDeclaredMethods()[0].invoke(value, objs);
+ iface.getDeclaredMethod("getVlanId").invoke(value, objs);
fail();
} catch (final InvocationTargetException e) {
final Throwable cause = e.getCause();
private static final Transitive TEST_GROUPING = new Transitive() {
@Override
+ @Deprecated
public Class<? extends DataContainer> getImplementedInterface() {
return Transitive.class;
}
+ @Override
+ public Class<? extends Transitive> implementedInterface() {
+ return Transitive.class;
+ }
+
@Override
public EncapsulatedRoute getRoute() {
return new EncapsulatedRoute(TEST_ROUTE);
final NormalizedNodeResult result = new NormalizedNodeResult();
// We create DOM stream writer which produces normalized nodes
final NormalizedNodeStreamWriter domWriter = ImmutableNormalizedNodeStreamWriter.from(result);
+ final Class<? extends DataObject> type = data.implementedInterface();
@SuppressWarnings("unchecked")
- final Class<? extends DataObject> type = (Class<? extends DataObject>) data.getImplementedInterface();
final BindingStreamEventWriter writer = newWriter.apply((Class<T>)type, domWriter);
try {
getSerializer(type).serialize(data, writer);
*/
@Override
public NormalizedNode<?, ?> serialize(final DataObject input) {
- final BindingNormalizedNodeCache cachingSerializer = getCacheSerializer(input.getImplementedInterface());
+ final BindingNormalizedNodeCache cachingSerializer = getCacheSerializer(input.implementedInterface());
if (cachingSerializer != null) {
final NormalizedNode<?, ?> domData = cachingSerializer.get(input);
domWriter.addChild(domData);
import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.AUGMENTABLE_AUGMENTATION_NAME;
import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.DATA_CONTAINER_GET_IMPLEMENTED_INTERFACE_NAME;
+import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
final String methodName = method.getName();
switch (methodName) {
case DATA_CONTAINER_GET_IMPLEMENTED_INTERFACE_NAME:
+ case DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME:
return context.getBindingClass();
case TO_STRING:
return bindingToString();
import static java.util.Objects.requireNonNull;
import java.io.IOException;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.binding.BindingStreamEventWriter;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.slf4j.LoggerFactory;
public final class ChoiceDispatchSerializer implements DataObjectSerializerImplementation {
-
private static final Logger LOG = LoggerFactory.getLogger(ChoiceDispatchSerializer.class);
- @SuppressWarnings("rawtypes")
- private final Class choiceClass;
+ private final @NonNull Class<? extends DataContainer> choiceClass;
- @SuppressWarnings("rawtypes")
- private ChoiceDispatchSerializer(final Class choiceClass) {
+ private ChoiceDispatchSerializer(final Class<? extends DataContainer> choiceClass) {
this.choiceClass = requireNonNull(choiceClass);
}
- public static ChoiceDispatchSerializer from(final Class<? extends DataContainer> choiceClass) {
+ public static @NonNull ChoiceDispatchSerializer from(final Class<? extends DataContainer> choiceClass) {
return new ChoiceDispatchSerializer(choiceClass);
}
@Override
- @SuppressWarnings("unchecked")
public void serialize(final DataObjectSerializerRegistry reg, final DataObject obj,
final BindingStreamEventWriter stream) throws IOException {
- @SuppressWarnings("rawtypes")
- Class cazeClass = obj.getImplementedInterface();
+ Class<? extends DataObject> cazeClass = obj.implementedInterface();
stream.startChoiceNode(choiceClass, BindingStreamEventWriter.UNKNOWN_SIZE);
DataObjectSerializer caseSerializer = reg.getSerializer(cazeClass);
if (caseSerializer != null) {
import static org.opendaylight.mdsal.binding.model.util.BindingTypes.keyedListAction;
import static org.opendaylight.mdsal.binding.model.util.BindingTypes.rpcResult;
import static org.opendaylight.mdsal.binding.model.util.Types.BOOLEAN;
+import static org.opendaylight.mdsal.binding.model.util.Types.STRING;
+import static org.opendaylight.mdsal.binding.model.util.Types.augmentationTypeFor;
+import static org.opendaylight.mdsal.binding.model.util.Types.classType;
import static org.opendaylight.mdsal.binding.model.util.Types.listTypeFor;
import static org.opendaylight.mdsal.binding.model.util.Types.listenableFutureTypeFor;
+import static org.opendaylight.mdsal.binding.model.util.Types.primitiveVoidType;
import static org.opendaylight.mdsal.binding.model.util.Types.typeForClass;
+import static org.opendaylight.mdsal.binding.model.util.Types.wildcardTypeFor;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findNodeInSchemaContext;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil;
import org.opendaylight.mdsal.binding.model.util.ReferencedTypeImpl;
import org.opendaylight.mdsal.binding.model.util.TypeConstants;
-import org.opendaylight.mdsal.binding.model.util.Types;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.GeneratedPropertyBuilderImpl;
import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.binding.yang.types.AbstractTypeProvider;
return null;
}
final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, node, baseInterface);
+ defaultImplementedInterace(genType);
annotateDeprecatedIfNecessary(node.getStatus(), genType);
final Module module = context.module();
addImplementedInterfaceFromUses(schema, outType);
outType.addImplementsType(type);
outType.addImplementsType(augmentable(outType));
+ defaultImplementedInterace(outType);
annotateDeprecatedIfNecessary(rpc.getStatus(), outType);
resolveDataSchemaNodes(context, outType, outType, schema.getChildNodes());
context.addChildNodeType(schema, outType);
final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition(
context.modulePackageName(), notification, DATA_OBJECT, context);
+ defaultImplementedInterace(notificationInterface);
annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface);
notificationInterface.addImplementsType(NOTIFICATION);
context.addChildNodeType(notification, notificationInterface);
addComment(listenerInterface.addMethod("on" + notificationInterface.getName())
.setAccessModifier(AccessModifier.PUBLIC).addParameter(notificationInterface, "notification")
- .setReturnType(Types.primitiveVoidType()), notification);
+ .setReturnType(primitiveVoidType()), notification);
}
}
// Converts individual grouping to GeneratedType. Firstly generated type builder is created and every child
// node of grouping is resolved to the method.
final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, grouping);
+ narrowImplementedInterface(genType);
annotateDeprecatedIfNecessary(grouping.getStatus(), genType);
context.addGroupingType(grouping, genType);
resolveDataSchemaNodes(context, genType, genType, grouping.getChildNodes());
JavaTypeName.create(augmentPackageName, augTypeName));
augTypeBuilder.addImplementsType(DATA_OBJECT);
- augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));
+ defaultImplementedInterace(augTypeBuilder);
+
+ augTypeBuilder.addImplementsType(augmentationTypeFor(targetTypeRef));
annotateDeprecatedIfNecessary(augSchema.getStatus(), augTypeBuilder);
addImplementedInterfaceFromUses(augSchema, augTypeBuilder);
if (caseNode != null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {
final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode);
caseTypeBuilder.addImplementsType(refChoiceType);
+ defaultImplementedInterace(caseTypeBuilder);
annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder);
context.addCaseType(caseNode.getPath(), caseTypeBuilder);
context.addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
if (caseNode != null) {
final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode);
caseTypeBuilder.addImplementsType(targetType);
+ defaultImplementedInterace(caseTypeBuilder);
CaseSchemaNode node = null;
final String caseLocalName = caseNode.getQName().getLocalName();
final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
method.setReturnType(returnType);
- method.addParameter(Types.STRING, "defaultValue");
+ method.addParameter(STRING, "defaultValue");
method.setAccessModifier(AccessModifier.PUBLIC);
method.setStatic(true);
}
final GeneratedTypeBuilder it = addRawInterfaceDefinition(name, schemaNode);
-
it.addImplementsType(baseInterface);
if (!(schemaNode instanceof GroupingDefinition)) {
it.addImplementsType(augmentable(it));
builder.addAnnotation(DEPRECATED_ANNOTATION);
}
}
+
+ private static void narrowImplementedInterface(final GeneratedTypeBuilder typeBuilder) {
+ defineImplementedInterfaceMethod(typeBuilder, wildcardTypeFor(typeBuilder.getIdentifier()));
+ }
+
+ private static void defaultImplementedInterace(final GeneratedTypeBuilder typeBuilder) {
+ defineImplementedInterfaceMethod(typeBuilder, new ReferencedTypeImpl(typeBuilder.getIdentifier()))
+ .setDefault(true);
+ }
+
+ private static MethodSignatureBuilder defineImplementedInterfaceMethod(final GeneratedTypeBuilder typeBuilder,
+ final Type classType) {
+ final MethodSignatureBuilder ret = typeBuilder
+ .addMethod(BindingMapping.DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME)
+ .setAccessModifier(AccessModifier.PUBLIC)
+ .setReturnType(classType(classType));
+ ret.addAnnotation(OVERRIDE_ANNOTATION);
+ return ret;
+ }
}
assertNotNull("Generated Interface cannot contain NULL reference for Method Signature Definitions!", methods);
- assertEquals("Expected count of method signature definitions is 15", 15, methods.size());
+ assertEquals("Expected count of method signature definitions is 16", 16, methods.size());
Enumeration ianaIfType = null;
for (final MethodSignature method : methods) {
if (method.getName().equals("getType")) {
Type operStatus = null;
final List<MethodSignature> methods = genInterface.getMethodDefinitions();
assertNotNull("Generated Type Interface cannot contain NULL reference to Enumeration types!", methods);
- assertEquals("Generated Type Interface MUST contain 5 Methods ", 5, methods.size());
+ assertEquals("Generated Type Interface MUST contain 6 Methods ", 6, methods.size());
for (final MethodSignature method : methods) {
if (method.getName().equals("getLinkUpDownTrapEnable")) {
linkUpDownTrapEnable = method.getReturnType();
}
assertNotNull(simpleContainer);
assertNotNull(nestedContainer);
- assertEquals(3, simpleContainer.getMethodDefinitions().size());
- assertEquals(2, nestedContainer.getMethodDefinitions().size());
+ assertEquals(4, simpleContainer.getMethodDefinitions().size());
+ assertEquals(3, nestedContainer.getMethodDefinitions().size());
int getFooMethodCounter = 0;
int getBarMethodCounter = 0;
}
assertNotNull(simpleContainer);
assertNotNull(nestedContainer);
- assertEquals(3, simpleContainer.getMethodDefinitions().size());
- assertEquals(2, nestedContainer.getMethodDefinitions().size());
+ assertEquals(4, simpleContainer.getMethodDefinitions().size());
+ assertEquals(3, nestedContainer.getMethodDefinitions().size());
int getFooMethodCounter = 0;
int getBarMethodCounter = 0;
String getBarMethodReturnTypeName = "";
String getNestedContainerReturnTypeName = "";
for (final MethodSignature method : simpleContainer.getMethodDefinitions()) {
+ if (method.isDefault()) {
+ continue;
+ }
if (method.getName().equals("getFoo")) {
getFooMethodCounter++;
getFooMethodReturnTypeName = method.getReturnType().getName();
}
}
- assertEquals(2, listParentContainerMethodsCount);
- assertEquals(1, listChildContainerMethodsCount);
+ assertEquals(3, listParentContainerMethodsCount);
+ assertEquals(2, listChildContainerMethodsCount);
assertEquals(1, getSimpleListKeyMethodCount);
assertEquals(1, listKeyClassCount);
assertEquals(0, setSimpleLeafListMethodCount);
assertEquals(1, getBarMethodCount);
- assertEquals(6, simpleListMethodsCount);
+ assertEquals(7, simpleListMethodsCount);
}
@Test
package org.opendaylight.mdsal.binding.generator.impl;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import com.google.common.collect.Iterables;
+import java.util.Iterator;
import java.util.List;
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
assertNotNull(bar1);
assertTrue(bar1.isUnionType());
- final MethodSignature getBar = Iterables.getOnlyElement(foo.getMethodDefinitions());
+ final Iterator<MethodSignature> it = foo.getMethodDefinitions().iterator();
+ assertTrue(it.hasNext());
+ final MethodSignature getImplIface = it.next();
+ assertEquals("implementedInterface", getImplIface.getName());
+ assertTrue(getImplIface.isDefault());
+ assertTrue(it.hasNext());
+
+ final MethodSignature getBar = it.next();
+ assertFalse(it.hasNext());
final Type getBarType = getBar.getReturnType();
assertTrue(getBarType instanceof GeneratedTransferObject);
final GeneratedTransferObject getBarTO = (GeneratedTransferObject) getBarType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
import static org.opendaylight.mdsal.binding.generator.impl.SupportTestUtil.containsInterface;
import static org.opendaylight.mdsal.binding.generator.impl.SupportTestUtil.containsMethods;
"org.opendaylight.yang.gen.v1.urn.grouping.uses._case.rev130718", groupingCaseTest.getPackageName());
containsInterface("GroupingCaseTest", caseC);
- assertTrue("Case C shouldn't contain any method.", caseC.getMethodDefinitions().isEmpty());
+ assertEquals("Case C shouldn't contain any method.", 1, caseC.getMethodDefinitions().size());
- assertEquals("Number of method in GroupingCaseTest is incorrect", 1, groupingCaseTest.getMethodDefinitions()
+ assertEquals("Number of method in GroupingCaseTest is incorrect", 2, groupingCaseTest.getMethodDefinitions()
.size());
containsMethods(groupingCaseTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingCaseTest1",
"String"));
containsInterface("GroupingContainerTest", containerTest);
- assertEquals("Number of method in GroupingContainerTestis incorrect", 2, groupingContainerTest
+ assertEquals("Number of method in GroupingContainerTestis incorrect", 3, groupingContainerTest
.getMethodDefinitions().size());
- assertEquals("Number of method in ContainerTest is incorrect", 1, containerTest.getMethodDefinitions().size());
+ assertEquals("Number of method in ContainerTest is incorrect", 2, containerTest.getMethodDefinitions().size());
containsMethods(groupingContainerTest.getMethodDefinitions(), new NameTypePattern(
"getLeafGroupingContainerTest1", "String"), new NameTypePattern("getLeafGroupingContainerTest2",
containsInterface("GroupingGroupingTest", groupingTest);
- assertEquals("Number of method in GroupingGroupingTest is incorrect", 1, groupingGroupingTest
+ assertEquals("Number of method in GroupingGroupingTest is incorrect", 2, groupingGroupingTest
.getMethodDefinitions().size());
- assertEquals("Number of method in GroupingTest is incorrect", 1, groupingTest.getMethodDefinitions().size());
+ assertEquals("Number of method in GroupingTest is incorrect", 2, groupingTest.getMethodDefinitions().size());
containsMethods(groupingGroupingTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingGrouping",
"String"));
containsInterface("GroupingListTest", listTest);
- assertEquals("Number of method in GroupingListTest is incorrect", 5, groupingListTest.getMethodDefinitions()
+ assertEquals("Number of method in GroupingListTest is incorrect", 6, groupingListTest.getMethodDefinitions()
.size());
- assertEquals("Number of method in ListTest is incorrect", 1, listTest.getMethodDefinitions().size());
- assertEquals("Number of method in ContainerGroupingListTest is incorrect", 1, containerGroupingListTest
+ assertEquals("Number of method in ListTest is incorrect", 2, listTest.getMethodDefinitions().size());
+ assertEquals("Number of method in ContainerGroupingListTest is incorrect", 2, containerGroupingListTest
.getMethodDefinitions().size());
- assertEquals("Number of method in ListGroupingListTest is incorrect", 1, listGroupingListTest
+ assertEquals("Number of method in ListGroupingListTest is incorrect", 2, listGroupingListTest
.getMethodDefinitions().size());
containsMethods(groupingListTest.getMethodDefinitions(), new NameTypePattern("getContainerGroupingListTest",
assertEquals("Number of method in GroupingUsesModulData is incorrect", 0, groupingUsesModulData
.getMethodDefinitions().size());
- assertEquals("Number of method in GroupingModulTest is incorrect", 2, groupingModulTest.getMethodDefinitions()
+ assertEquals("Number of method in GroupingModulTest is incorrect", 3, groupingModulTest.getMethodDefinitions()
.size());
containsMethods(groupingModulTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingModulTest",
containsInterface("GroupingRpcInputTest", rpcTestInput);
containsInterface("GroupingRpcOutputTest", rpcTestOutput);
- assertEquals("Number of method in RpcTestInput is incorrect", 0, rpcTestInput.getMethodDefinitions().size());
- assertEquals("Number of method in RpcTestOutput is incorrect", 0, rpcTestOutput.getMethodDefinitions().size());
- assertEquals("Number of method in GroupingRpcInputTest is incorrect", 2, groupingRpcInputTest
+ assertEquals("Number of method in RpcTestInput is incorrect", 1, rpcTestInput.getMethodDefinitions().size());
+ assertEquals("Number of method in RpcTestOutput is incorrect", 1, rpcTestOutput.getMethodDefinitions().size());
+ assertEquals("Number of method in GroupingRpcInputTest is incorrect", 3, groupingRpcInputTest
.getMethodDefinitions().size());
- assertEquals("Number of method in GroupingRpcOutputTest is incorrect", 1, groupingRpcOutputTest
+ assertEquals("Number of method in GroupingRpcOutputTest is incorrect", 2, groupingRpcOutputTest
.getMethodDefinitions().size());
- assertEquals("Number of method in ContainerGroupingRpcInputTest is incorrect", 1, containerGroupingRpcInputTest
+ assertEquals("Number of method in ContainerGroupingRpcInputTest is incorrect", 2, containerGroupingRpcInputTest
.getMethodDefinitions().size());
containsMethods(groupingRpcInputTest.getMethodDefinitions(), new NameTypePattern(
containsInterface("GroupingAugmentTest", containerAugment1);
- assertEquals("Number of method in GroupingCaseTest is incorrect", 0, containerAugment1.getMethodDefinitions()
+ assertEquals("Number of method in GroupingCaseTest is incorrect", 1, containerAugment1.getMethodDefinitions()
.size());
- assertEquals("Number of method in ContainerAugment1 is incorrect", 0, containerAugment1.getMethodDefinitions()
+ assertEquals("Number of method in ContainerAugment1 is incorrect", 1, containerAugment1.getMethodDefinitions()
.size());
- assertEquals("Number of method in GroupingCaseTest is incorrect", 1, groupingAugmentTest.getMethodDefinitions()
+ assertEquals("Number of method in GroupingCaseTest is incorrect", 2, groupingAugmentTest.getMethodDefinitions()
.size());
containsMethods(groupingAugmentTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingAugmentTest",
containsInterface("GroupingNotificationTest", notificationTest);
- assertEquals("Number of method in NotificationTest is incorrect", 1, notificationTest.getMethodDefinitions()
+ assertEquals("Number of method in NotificationTest is incorrect", 2, notificationTest.getMethodDefinitions()
.size());
- assertEquals("Number of method in GroupingNotificationTest is incorrect", 2, groupingNotificationTest
+ assertEquals("Number of method in GroupingNotificationTest is incorrect", 3, groupingNotificationTest
.getMethodDefinitions().size());
- assertEquals("Number of method in ContainerGroupingNotificationTest is incorrect", 1,
+ assertEquals("Number of method in ContainerGroupingNotificationTest is incorrect", 2,
containerGroupingNotificationTest.getMethodDefinitions().size());
containsMethods(notificationTest.getMethodDefinitions(), new NameTypePattern("getLeafNotificationTest",
import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.AUGMENTATION_FIELD
import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.AUGMENTABLE_AUGMENTATION_NAME
+import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME
import com.google.common.collect.ImmutableMap
import java.util.List
«generateCopyConstructor(builderType, type)»
+ @«Deprecated.importedName»
@«Override.importedName»
public «Class.importedName»<«targetType.importedName»> getImplementedInterface() {
return «targetType.importedName».class;
if (!(obj instanceof «DataObject.importedName»)) {
return false;
}
- if (!«targetType.importedName».class.equals(((«DataObject.importedName»)obj).getImplementedInterface())) {
+ if (!«targetType.importedName».class.equals(((«DataObject.importedName»)obj).«DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME»())) {
return false;
}
«targetType.importedName» other = («targetType.importedName»)obj;
type.methodDefinitions.filter([def | !def.isDefault])
}
}
-
*/
package org.opendaylight.mdsal.binding.java.api.generator
+import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME
import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.getGetterMethodForNonnull
import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.isGetterMethodName
import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.isNonnullMethodName
def private generateDefaultMethod(MethodSignature method) {
if (method.name.isNonnullMethodName) {
- return generateNonnullMethod(method)
+ generateNonnullMethod(method)
+ } else {
+ switch method.name {
+ case DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME : generateDefaultImplementedInterface
+ }
}
}
«nullableType(ret)» «method.name»();
'''
+ def private generateDefaultImplementedInterface() '''
+ @«Override.importedName»
+ default «Class.importedName»<«type.fullyQualifiedName»> «DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME»() {
+ return «type.fullyQualifiedName».class;
+ }
+ '''
+
def private generateNonnullMethod(MethodSignature method) '''
«val ret = method.returnType»
«val name = method.name»
assertTrue(keyArgsClass.isInterface());
CompilationTestUtils.assertContainsMethod(keyArgsClass, String.class, "getName");
CompilationTestUtils.assertContainsMethod(keyArgsClass, Integer.class, "getSize");
- assertEquals(2, abstractMethods(keyArgsClass).size());
+ assertEquals(3, abstractMethods(keyArgsClass).size());
// Test generated 'list links'
assertTrue(linksClass.isInterface());
/**
* Name of {@link DataContainer#getImplementedInterface()}.
*/
+ // FIXME: 4.0.0: remove this constant
public static final String DATA_CONTAINER_GET_IMPLEMENTED_INTERFACE_NAME = "getImplementedInterface";
+ /**
+ * Name of {@link DataContainer#implementedInterface()}.
+ */
+ public static final String DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME = "implementedInterface";
+
/**
* Prefix for getter methods working on top of boolean.
*/
/**
* Find data hierarchy parent from concrete Data class. This method is shorthand which gets DataObject class by
- * invoking {@link DataObject#getImplementedInterface()} and uses {@link #findHierarchicalParent(Class)}.
+ * invoking {@link DataObject#implementedInterface()} and uses {@link #findHierarchicalParent(Class)}.
*
* @param child
* Child object for which the parent needs to be located.
*/
public static Class<?> findHierarchicalParent(final DataObject child) {
if (child instanceof ChildOf) {
- return ClassLoaderUtils.findFirstGenericArgument(child.getImplementedInterface(), ChildOf.class);
+ return ClassLoaderUtils.findFirstGenericArgument(child.implementedInterface(), ChildOf.class);
}
return null;
}
public static <T extends DataObject> Optional<T> readData(final DataObject source, final Class<T> child) {
checkArgument(source != null, "Object should not be null.");
checkArgument(child != null, "Child type should not be null");
- Class<? extends DataContainer> parentClass = source.getImplementedInterface();
+ Class<? extends DataContainer> parentClass = source.implementedInterface();
@SuppressWarnings("unchecked")
T potential = (T) resolveReadStrategy(parentClass, child).read(source, child);
final InstanceIdentifier parentPath, final PathArgument child) {
checkArgument(parent != null, "Object should not be null.");
checkArgument(child != null, "Child argument should not be null");
- Class<? extends DataContainer> parentClass = parent.getImplementedInterface();
+ Class<? extends DataContainer> parentClass = parent.implementedInterface();
return resolveReadStrategy(parentClass, child.getType()).readUsingPathArgument(parent, child, parentPath);
}
assertNull(findHierarchicalParent(mock(DataObject.class)));
assertEquals(GroupingFoo.class, BindingReflections.findHierarchicalParent(FooChild.class));
final ChildOf<?> childOf = mock(FooChild.class);
- doReturn(FooChild.class).when(childOf).getImplementedInterface();
+ doReturn(FooChild.class).when(childOf).implementedInterface();
assertEquals(GroupingFoo.class, BindingReflections.findHierarchicalParent(childOf));
assertTrue(BindingReflections.isRpcMethod(TestImplementation.class.getDeclaredMethod("rpcMethodTest")));
assertEquals(TestImplementation.class, BindingReflections.findAugmentationTarget(TestImplementation.class));
@Test
public void testReadData() throws Exception {
final Nodes nodes = mock(Nodes.class);
- doReturn(Nodes.class).when(nodes).getImplementedInterface();
+ doReturn(Nodes.class).when(nodes).implementedInterface();
doReturn(null).when(nodes).getNode();
entry = ImmutableMap.<InstanceIdentifier<? extends DataObject>, DataObject>builder()
.put(path, nodes).build().entrySet().iterator().next();
*/
package org.opendaylight.yangtools.yang.binding;
+import org.eclipse.jdt.annotation.NonNull;
+
/**
* Data Container - object contains structured data. Marker interface which must be implemented by all interfaces
* generated for YANG:
* </ul>
*/
public interface DataContainer {
-
+ /**
+ * Return the interface implemented by this object. This method differs from {@link Object#getClass()} in that it
+ * returns the interface contract, not a concrete implementation class.
+ *
+ * @return Implemented contract
+ * @deprecated Use {@link #implementedInterface()} instead.
+ */
+ // FIXME: 4.0.0: MDSAL-395: remove this method
+ @Deprecated
Class<? extends DataContainer> getImplementedInterface();
+
+ @NonNull Class<? extends DataContainer> implementedInterface();
}
* @author Tony Tkacik
*/
public interface DataObject extends DataContainer, BindingObject {
-
-
+ @Override
+ Class<? extends DataObject> implementedInterface();
}
public interface Notification extends DataContainer {
}
-
* statement.
*/
public interface RpcInput extends DataObject {
-
+ @Override
+ Class<? extends RpcInput> implementedInterface();
}
*/
@Beta
public interface RpcOutput extends DataObject {
-
+ @Override
+ Class<? extends RpcOutput> implementedInterface();
}
import org.apache.commons.lang3.SerializationUtils;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
static class TestDataObject1 implements DataObject {
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
- return null;
+ @Deprecated
+ public Class<? extends DataObject> getImplementedInterface() {
+ return DataObject.class;
+ }
+
+ @Override
+ public Class<? extends DataObject> implementedInterface() {
+ return DataObject.class;
}
}
static class TestDataObject2 implements DataObject {
@Override
- public Class<? extends DataContainer> getImplementedInterface() {
- return null;
+ @Deprecated
+ public Class<? extends DataObject> getImplementedInterface() {
+ return DataObject.class;
+ }
+
+ @Override
+ public Class<? extends DataObject> implementedInterface() {
+ return DataObject.class;
}
}
}