import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
+import org.opendaylight.mdsal.binding.model.api.MethodSignature.ValueMechanics;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.TypeMemberComment;
import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotableTypeBuilder;
return;
}
- constructGetter(builder, methodReturnType(builderFactory));
+ final Type returnType = methodReturnType(builderFactory);
+ constructGetter(builder, returnType);
+ constructRequire(builder, returnType);
}
MethodSignatureBuilder constructGetter(final GeneratedTypeBuilderBase<?> builder, final Type returnType) {
- final MethodSignatureBuilder getMethod = builder
- .addMethod(BindingMapping.getGetterMethodName(localName().getLocalName()))
- .setReturnType(returnType);
+ return constructGetter(builder, returnType, BindingMapping.getGetterMethodName(localName().getLocalName()));
+ }
+
+ final MethodSignatureBuilder constructGetter(final GeneratedTypeBuilderBase<?> builder,
+ final Type returnType, final String methodName) {
+ final MethodSignatureBuilder getMethod = builder.addMethod(methodName).setReturnType(returnType);
annotateDeprecatedIfNecessary(getMethod);
return getMethod;
}
+ void constructRequire(final GeneratedTypeBuilderBase<?> builder, final Type returnType) {
+ // No-op in most cases
+ }
+
+ final void constructRequireImpl(final GeneratedTypeBuilderBase<?> builder, final Type returnType) {
+ constructGetter(builder, returnType, BindingMapping.getRequireMethodName(localName().getLocalName()))
+ .setDefault(true)
+ .setMechanics(ValueMechanics.NONNULL);
+ }
+
void addAsGetterMethodOverride(final @NonNull GeneratedTypeBuilderBase<?> builder,
final @NonNull TypeBuilderFactory builderFactory) {
// No-op for most cases
return ret;
}
+
+ @Override
+ void constructRequire(final GeneratedTypeBuilderBase<?> builder, final Type returnType) {
+ constructRequireImpl(builder, returnType);
+ }
}
return ret;
}
+
+ @Override
+ void constructRequire(final GeneratedTypeBuilderBase<?> builder, final Type returnType) {
+ // No-op
+ }
}
package org.opendaylight.mdsal.binding.generator.impl.reactor;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
import org.opendaylight.mdsal.binding.model.util.BindingTypes;
import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
return builder.build();
}
+
+ @Override
+ void constructRequire(final GeneratedTypeBuilderBase<?> builder, final Type returnType) {
+ constructRequireImpl(builder, returnType);
+ }
}
final List<MethodSignature> gtInterfaceMethods = gtInterface.getMethodDefinitions();
assertNotNull("Interface methods are null", gtInterfaceMethods);
- assertEquals(7, gtInterfaceMethods.size());
+ assertEquals(9, gtInterfaceMethods.size());
MethodSignature getIfcKeyMethod = null;
for (final MethodSignature method : gtInterfaceMethods) {
final List<MethodSignature> tunnelMethods = gtTunnel.getMethodDefinitions();
assertNotNull("Tunnel methods are null", tunnelMethods);
- assertEquals(6, tunnelMethods.size());
+ assertEquals(7, tunnelMethods.size());
MethodSignature getTunnelKeyMethod = null;
for (MethodSignature method : tunnelMethods) {
assertNotNull("Generated Interface cannot contain NULL reference for Method Signature Definitions!", methods);
// FIXME: split this into getter/default/static asserts
- assertEquals(19, methods.size());
+ assertEquals(32, methods.size());
Enumeration ianaIfType = null;
for (final MethodSignature method : methods) {
if (method.getName().equals("getType")) {
assertNotNull("Generated Type Interface cannot contain NULL reference to Enumeration types!", methods);
// FIXME: split this into getter/default/static asserts
- assertEquals(9, methods.size());
+ assertEquals(13, methods.size());
for (final MethodSignature method : methods) {
if (method.getName().equals("getLinkUpDownTrapEnable")) {
linkUpDownTrapEnable = method.getReturnType();
assertNotNull(simpleContainer);
assertNotNull(nestedContainer);
// FIXME: split this into getter/default/static asserts
- assertEquals(7, simpleContainer.getMethodDefinitions().size());
+ assertEquals(9, simpleContainer.getMethodDefinitions().size());
// FIXME: split this into getter/default/static asserts
- assertEquals(6, nestedContainer.getMethodDefinitions().size());
+ assertEquals(8, nestedContainer.getMethodDefinitions().size());
int getFooMethodCounter = 0;
int getBarMethodCounter = 0;
assertNotNull(simpleContainer);
assertNotNull(nestedContainer);
// FIXME: split this into getter/default/static asserts
- assertEquals(7, simpleContainer.getMethodDefinitions().size());
+ assertEquals(9, simpleContainer.getMethodDefinitions().size());
// FIXME: split this into getter/default/static asserts
- assertEquals(6, nestedContainer.getMethodDefinitions().size());
+ assertEquals(8, nestedContainer.getMethodDefinitions().size());
int getFooMethodCounter = 0;
int getBarMethodCounter = 0;
// FIXME: split this into getter/default/static asserts
assertEquals(6, listParentContainerMethodsCount);
// FIXME: split this into getter/default/static asserts
- assertEquals(5, listChildContainerMethodsCount);
+ assertEquals(6, listChildContainerMethodsCount);
assertEquals(1, getSimpleListKeyMethodCount);
assertEquals(1, listKeyClassCount);
assertEquals(1, getBarMethodCount);
// FIXME: split this into getter/default/static asserts
- assertEquals(10, simpleListMethodsCount);
+ assertEquals(14, simpleListMethodsCount);
}
@Test
.orElseThrow();
List<MethodSignature> methodSignatures = moduleGenType.getMethodDefinitions();
- assertEquals(1, methodSignatures.size());
+ assertEquals(2, methodSignatures.size());
MethodSignature methodSignature = methodSignatures.get(0);
assertEquals("getLf", methodSignature.getName());
+ assertEquals("requireLf", methodSignatures.get(1).getName());
Type returnType = methodSignature.getReturnType();
assertThat(returnType, instanceOf(ParameterizedType.class));
package org.opendaylight.mdsal.binding.generator.impl;
import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
assertEquals(BindingMapping.BINDING_EQUALS_NAME, bindingEquals.getName());
final MethodSignature bindingToString = it.next();
assertEquals(BindingMapping.BINDING_TO_STRING_NAME, bindingToString.getName());
-
final MethodSignature getBar = it.next();
- assertFalse(it.hasNext());
final Type getBarType = getBar.getReturnType();
assertTrue(getBarType instanceof GeneratedTransferObject);
final GeneratedTransferObject getBarTO = (GeneratedTransferObject) getBarType;
assertTrue(getBarTO.isUnionType());
assertEquals(bar, getBarTO);
+ final MethodSignature requireBar = it.next();
+ assertThat(requireBar.getName(), startsWith(BindingMapping.REQUIRE_PREFIX));
+ assertFalse(it.hasNext());
final GeneratedProperty bar1Prop = bar.getProperties().stream().filter(prop -> "bar$1".equals(prop.getName()))
.findFirst().get();
// FIXME: split this into getter/default/static asserts
assertEquals(4, caseC.getMethodDefinitions().size());
- assertEquals("Number of method in GroupingCaseTest is incorrect", 2, groupingCaseTest.getMethodDefinitions()
+ assertEquals("Number of method in GroupingCaseTest is incorrect", 3, groupingCaseTest.getMethodDefinitions()
.size());
- containsMethods(groupingCaseTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingCaseTest1",
- "String"));
+ containsMethods(groupingCaseTest.getMethodDefinitions(),
+ new NameTypePattern("getLeafGroupingCaseTest1", "String"),
+ new NameTypePattern("requireLeafGroupingCaseTest1", "String"));
}
@Test
containsInterface("GroupingContainerTest", containerTest);
- assertEquals("Number of method in GroupingContainerTestis incorrect", 3, groupingContainerTest
+ assertEquals("Number of method in GroupingContainerTestis incorrect", 5, groupingContainerTest
.getMethodDefinitions().size());
// FIXME: split this into getter/default/static asserts
- assertEquals(5, containerTest.getMethodDefinitions().size());
+ assertEquals(6, containerTest.getMethodDefinitions().size());
- containsMethods(groupingContainerTest.getMethodDefinitions(), new NameTypePattern(
- "getLeafGroupingContainerTest1", "String"), new NameTypePattern("getLeafGroupingContainerTest2",
- "Uint8"));
+ containsMethods(groupingContainerTest.getMethodDefinitions(),
+ new NameTypePattern("getLeafGroupingContainerTest1", "String"),
+ new NameTypePattern("requireLeafGroupingContainerTest1", "String"),
+ new NameTypePattern("getLeafGroupingContainerTest2", "Uint8"),
+ new NameTypePattern("requireLeafGroupingContainerTest2", "Uint8"));
- containsMethods(containerTest.getMethodDefinitions(), new NameTypePattern("getContainerLeafTest", "String"));
+ containsMethods(containerTest.getMethodDefinitions(),
+ new NameTypePattern("getContainerLeafTest", "String"),
+ new NameTypePattern("requireContainerLeafTest", "String"));
}
@Test
containsInterface("GroupingGroupingTest", groupingTest);
- assertEquals("Number of method in GroupingGroupingTest is incorrect", 2, groupingGroupingTest
+ assertEquals("Number of method in GroupingGroupingTest is incorrect", 3, groupingGroupingTest
.getMethodDefinitions().size());
- assertEquals("Number of method in GroupingTest is incorrect", 2, groupingTest.getMethodDefinitions().size());
+ assertEquals("Number of method in GroupingTest is incorrect", 3, groupingTest.getMethodDefinitions().size());
- containsMethods(groupingGroupingTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingGrouping",
- "String"));
+ containsMethods(groupingGroupingTest.getMethodDefinitions(),
+ new NameTypePattern("getLeafGroupingGrouping", "String"),
+ new NameTypePattern("requireLeafGroupingGrouping", "String"));
- containsMethods(groupingTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingTest", "Byte"));
+ containsMethods(groupingTest.getMethodDefinitions(),
+ new NameTypePattern("getLeafGroupingTest", "Byte"),
+ new NameTypePattern("requireLeafGroupingTest", "Byte"));
}
@Test
containsInterface("GroupingListTest", listTest);
- assertEquals("Number of method in GroupingListTest is incorrect", 6, groupingListTest.getMethodDefinitions()
+ assertEquals("Number of method in GroupingListTest is incorrect", 8, groupingListTest.getMethodDefinitions()
.size());
// FIXME: split this into getter/default/static asserts
- assertEquals(5, listTest.getMethodDefinitions().size());
+ assertEquals(6, listTest.getMethodDefinitions().size());
// FIXME: split this into getter/default/static asserts
- assertEquals(5, containerGroupingListTest.getMethodDefinitions().size());
+ assertEquals(6, containerGroupingListTest.getMethodDefinitions().size());
// FIXME: split this into getter/default/static asserts
- assertEquals(5, listGroupingListTest.getMethodDefinitions().size());
-
- containsMethods(groupingListTest.getMethodDefinitions(), new NameTypePattern("getContainerGroupingListTest",
- "ContainerGroupingListTest"), new NameTypePattern("getLeafGroupingListTest", "String"),
- new NameTypePattern("getLeaffllistGroupingListTest", "List<String>"), new NameTypePattern(
- "getListGroupingListTest", "List<ListGroupingListTest>"));
+ assertEquals(6, listGroupingListTest.getMethodDefinitions().size());
+
+ containsMethods(groupingListTest.getMethodDefinitions(),
+ new NameTypePattern("getContainerGroupingListTest", "ContainerGroupingListTest"),
+ new NameTypePattern("getLeafGroupingListTest", "String"),
+ new NameTypePattern("requireLeafGroupingListTest", "String"),
+ new NameTypePattern("getLeaffllistGroupingListTest", "List<String>"),
+ new NameTypePattern("requireLeaffllistGroupingListTest", "List<String>"),
+ new NameTypePattern("getListGroupingListTest", "List<ListGroupingListTest>"));
containsMethods(listTest.getMethodDefinitions(), new NameTypePattern("getListLeafTest", "String"));
containsMethods(containerGroupingListTest.getMethodDefinitions(), new NameTypePattern(
"getLeafContainerGroupingListTest", "Uint8"));
assertEquals("Number of method in GroupingUsesModulData is incorrect", 0, groupingUsesModulData
.getMethodDefinitions().size());
- assertEquals("Number of method in GroupingModulTest is incorrect", 3, groupingModulTest.getMethodDefinitions()
+ assertEquals("Number of method in GroupingModulTest is incorrect", 5, groupingModulTest.getMethodDefinitions()
.size());
- containsMethods(groupingModulTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingModulTest",
- "String"), new NameTypePattern("getLeafGroupingModulTest2", "Uint8"));
+ containsMethods(groupingModulTest.getMethodDefinitions(),
+ new NameTypePattern("getLeafGroupingModulTest", "String"),
+ new NameTypePattern("requireLeafGroupingModulTest", "String"),
+ new NameTypePattern("getLeafGroupingModulTest2", "Uint8"),
+ new NameTypePattern("requireLeafGroupingModulTest2", "Uint8"));
}
@Test
assertEquals(4, rpcTestInput.getMethodDefinitions().size());
// FIXME: split this into getter/default/static asserts
assertEquals(4, rpcTestOutput.getMethodDefinitions().size());
- assertEquals("Number of method in GroupingRpcInputTest is incorrect", 3, groupingRpcInputTest
+ assertEquals("Number of method in GroupingRpcInputTest is incorrect", 4, groupingRpcInputTest
.getMethodDefinitions().size());
- assertEquals("Number of method in GroupingRpcOutputTest is incorrect", 2, groupingRpcOutputTest
+ assertEquals("Number of method in GroupingRpcOutputTest is incorrect", 3, groupingRpcOutputTest
.getMethodDefinitions().size());
// FIXME: split this into getter/default/static asserts
- assertEquals(5, containerGroupingRpcInputTest.getMethodDefinitions().size());
-
- containsMethods(groupingRpcInputTest.getMethodDefinitions(), new NameTypePattern(
- "getContainerGroupingRpcInputTest", "ContainerGroupingRpcInputTest"), new NameTypePattern(
- "getLeaflistGroupingRpcInputTest", "List<Uint8>"));
- containsMethods(groupingRpcOutputTest.getMethodDefinitions(), new NameTypePattern(
- "getLeafGroupingRpcOutputTest", "Byte"));
- containsMethods(containerGroupingRpcInputTest.getMethodDefinitions(), new NameTypePattern(
- "getLeafContainerGroupingRpcInputTest", "String"));
+ assertEquals(6, containerGroupingRpcInputTest.getMethodDefinitions().size());
+
+ containsMethods(groupingRpcInputTest.getMethodDefinitions(),
+ new NameTypePattern("getContainerGroupingRpcInputTest", "ContainerGroupingRpcInputTest"),
+ new NameTypePattern("getLeaflistGroupingRpcInputTest", "List<Uint8>"),
+ new NameTypePattern("requireLeaflistGroupingRpcInputTest", "List<Uint8>"));
+ containsMethods(groupingRpcOutputTest.getMethodDefinitions(),
+ new NameTypePattern("getLeafGroupingRpcOutputTest", "Byte"));
+ containsMethods(containerGroupingRpcInputTest.getMethodDefinitions(),
+ new NameTypePattern("getLeafContainerGroupingRpcInputTest", "String"));
}
@Test
assertEquals(4, containerAugment1.getMethodDefinitions().size());
// FIXME: split this into getter/default/static asserts
assertEquals(4, containerAugment1.getMethodDefinitions().size());
- assertEquals("Number of method in GroupingCaseTest is incorrect", 2, groupingAugmentTest.getMethodDefinitions()
+ assertEquals("Number of method in GroupingCaseTest is incorrect", 3, groupingAugmentTest.getMethodDefinitions()
.size());
- containsMethods(groupingAugmentTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingAugmentTest",
- "String"));
+ containsMethods(groupingAugmentTest.getMethodDefinitions(),
+ new NameTypePattern("getLeafGroupingAugmentTest", "String"),
+ new NameTypePattern("requireLeafGroupingAugmentTest", "String"));
}
@Test
containsInterface("GroupingNotificationTest", notificationTest);
// FIXME: split this into getter/default/static asserts
- assertEquals(5, notificationTest.getMethodDefinitions().size());
- assertEquals("Number of method in GroupingNotificationTest is incorrect", 3, groupingNotificationTest
+ assertEquals(6, notificationTest.getMethodDefinitions().size());
+ assertEquals("Number of method in GroupingNotificationTest is incorrect", 4, groupingNotificationTest
.getMethodDefinitions().size());
// FIXME: split this into getter/default/static asserts
- assertEquals(5, containerGroupingNotificationTest.getMethodDefinitions().size());
-
- containsMethods(notificationTest.getMethodDefinitions(), new NameTypePattern("getLeafNotificationTest",
- "String"));
- containsMethods(groupingNotificationTest.getMethodDefinitions(), new NameTypePattern(
- "getContainerGroupingNotificationTest", "ContainerGroupingNotificationTest"), new NameTypePattern(
- "getLeaffllistGroupingNotificationTest", "List<String>"));
- containsMethods(containerGroupingNotificationTest.getMethodDefinitions(), new NameTypePattern(
- "getLeafContainerGroupingNotificationTest", "Uint32"));
+ assertEquals(6, containerGroupingNotificationTest.getMethodDefinitions().size());
+
+ containsMethods(notificationTest.getMethodDefinitions(),
+ new NameTypePattern("getLeafNotificationTest", "String"));
+ containsMethods(groupingNotificationTest.getMethodDefinitions(),
+ new NameTypePattern("getContainerGroupingNotificationTest", "ContainerGroupingNotificationTest"),
+ new NameTypePattern("getLeaffllistGroupingNotificationTest", "List<String>"),
+ new NameTypePattern("requireLeaffllistGroupingNotificationTest", "List<String>"));
+ containsMethods(containerGroupingNotificationTest.getMethodDefinitions(),
+ new NameTypePattern("getLeafContainerGroupingNotificationTest", "Uint32"),
+ new NameTypePattern("requireLeafContainerGroupingNotificationTest", "Uint32"));
}
}
package org.opendaylight.mdsal.binding.java.api.generator
import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.getGetterMethodForNonnull
+import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.getGetterMethodForRequire
import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.isGetterMethodName
import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.isNonnullMethodName
+import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.isRequireMethodName
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.spec.naming.BindingMapping.REQUIRE_PREFIX
import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.AUGMENTATION_FIELD
import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.BINDING_EQUALS_NAME
import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.BINDING_HASHCODE_NAME
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects
import java.util.List
+import java.util.Locale
import java.util.Map.Entry
import java.util.Set
import org.gaul.modernizer_maven_annotations.SuppressModernizer
import org.opendaylight.mdsal.binding.model.api.Constant
import org.opendaylight.mdsal.binding.model.api.Enumeration
import org.opendaylight.mdsal.binding.model.api.GeneratedType
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName
import org.opendaylight.mdsal.binding.model.api.MethodSignature
import org.opendaylight.mdsal.binding.model.api.Type
import org.opendaylight.mdsal.binding.model.util.Types
def private generateDefaultMethod(MethodSignature method) {
if (method.name.isNonnullMethodName) {
generateNonnullMethod(method)
+ } else if (method.name.isRequireMethodName) {
+ generateRequireMethod(method)
} else {
switch method.name {
case DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME : generateDefaultImplementedInterface
'''
def private accessorJavadoc(MethodSignature method, String orString) {
- val reference = method.comment?.referenceDescription
- val propReturn = method.propertyNameFromGetter + ", or " + orString + " if it is not present."
+ accessorJavadoc(method, orString, null)
+ }
+
+ def private accessorJavadoc(MethodSignature method, String orString, JavaTypeName exception) {
+ val propName = method.propertyNameFromGetter
+ val propReturn = propName + orString
return wrapToDocumentation('''
Return «propReturn»
- «reference.formatReference»
+ «method.comment?.referenceDescription.formatReference»
@return {@code «method.returnType.importedName»} «propReturn»
+ «IF exception !== null»
+ @throws «exception.importedName» if «propName» is not present
+ «ENDIF»
''')
}
def private generateAccessorMethod(MethodSignature method) {
return '''
- «accessorJavadoc(method, "{@code null}")»
+ «accessorJavadoc(method, ", or {@code null} if it is not present.")»
«method.generateAccessorAnnotations»
«method.returnType.nullableType» «method.name»();
'''
def private generateNonnullMethod(MethodSignature method) '''
«val ret = method.returnType»
«val name = method.name»
- «accessorJavadoc(method, "an empty list")»
+ «accessorJavadoc(method, ", or an empty list if it is not present.")»
«method.annotations.generateAnnotations»
default «ret.importedNonNull» «name»() {
return «CODEHELPERS.importedName».nonnull(«name.getGetterMethodForNonnull»());
}
'''
+ def private generateRequireMethod(MethodSignature method) '''
+ «val ret = method.returnType»
+ «val name = method.name»
+ «val fieldName = name.toLowerCase(Locale.ROOT).replace(REQUIRE_PREFIX, "")»
+ «accessorJavadoc(method, ", guaranteed to be non-null.", NSEE)»
+ default «ret.importedNonNull» «name»() {
+ return «CODEHELPERS.importedName».require(«getGetterMethodForRequire(name)»(), "«fieldName»");
+ }
+ '''
+
def private String nullableType(Type type) {
if (type.isObject && (Types.isMapType(type) || Types.isListType(type))) {
return type.importedNullable
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
+import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
* {@code java.lang.NullPointerException} as a JavaTypeName.
*/
static final @NonNull JavaTypeName NPE = JavaTypeName.create(NullPointerException.class);
+ /**
+ * {@code java.lang.NoSuchElementException} as a JavaTypeName.
+ */
+ static final @NonNull JavaTypeName NSEE = JavaTypeName.create(NoSuchElementException.class);
/**
* {@code java.lang.Override} as a JavaTypeName.
*/
prefix = BindingMapping.GETTER_PREFIX;
} else if (BindingMapping.isNonnullMethodName(getterName)) {
prefix = BindingMapping.NONNULL_PREFIX;
+ } else if (BindingMapping.isRequireMethodName(getterName)) {
+ prefix = BindingMapping.REQUIRE_PREFIX;
} else {
throw new IllegalArgumentException(getterName + " is not a getter");
}
assertTrue(linksClass.isInterface());
CompilationTestUtils.assertImplementsIfc(linksClass, keyArgsClass);
assertEquals(7, abstractMethods(linksClass).size());
+ CompilationTestUtils.assertContainsMethod(linksClass,
+ "org.opendaylight.yang.gen.v1.urn.opendaylight.test.rev131008.links.Text", "getText", loader);
+ CompilationTestUtils.assertContainsMethod(linksClass,
+ "org.opendaylight.yang.gen.v1.urn.opendaylight.test.rev131008.links.Text", "requireText", loader);
// Test list key constructor arguments ordering
CompilationTestUtils.assertContainsConstructor(linksKeyClass, Byte.class, String.class, Integer.class);
*/
public static final @NonNull String NONNULL_PREFIX = "nonnull";
+ /**
+ * Prefix for require default wrapper methods. These methods always wrap a corresponding normal getter
+ * of leaf objects.
+ */
+ public static final @NonNull String REQUIRE_PREFIX = "require";
public static final @NonNull String RPC_INPUT_SUFFIX = "Input";
public static final @NonNull String RPC_OUTPUT_SUFFIX = "Output";
return methodName.startsWith(NONNULL_PREFIX);
}
+ public static @NonNull String getGetterMethodForRequire(final String methodName) {
+ checkArgument(isRequireMethodName(methodName));
+ return GETTER_PREFIX + methodName.substring(REQUIRE_PREFIX.length());
+ }
+
+ public static @NonNull String getRequireMethodName(final String localName) {
+ return REQUIRE_PREFIX + toFirstUpper(getPropertyName(localName));
+ }
+
+ public static boolean isRequireMethodName(final String methodName) {
+ return methodName.startsWith(REQUIRE_PREFIX);
+ }
+
public static @NonNull String getGetterSuffix(final QName name) {
final String candidate = toFirstUpper(toCamelCase(name.getLocalName()));
return "Class".equals(candidate) ? "XmlClass" : candidate;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
+import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.regex.Pattern;
import org.eclipse.jdt.annotation.NonNull;
checkArgument(expression, "expected one of: %s \n%but was: %s", options, value);
}
+ /**
+ * Return value and check whether specified value is null and if so throws exception. This method supports
+ * require default getter methods.
+ *
+ * @param value Value itself
+ * @param name Name of the value
+ * @return Non-null value
+ * @throws NoSuchElementException if value is null
+ */
+ public static <T> @NonNull T require(final @Nullable T value, final @NonNull String name) {
+ if (value == null) {
+ throw new NoSuchElementException("Value of " + name + " is not present");
+ }
+ return value;
+ }
+
/**
* A shortcut for {@code Preconditions.checkNotNull(value, "Key component \"%s\" must not be null", name)}.
*