import java.lang.reflect.Method;
import java.util.concurrent.Callable;
import org.opendaylight.mdsal.binding.dom.codec.impl.ValueTypeCodec.SchemaUnawareCodec;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
/**
* Derived YANG types are just immutable value holders for simple value
static Callable<EncapsulatedValueCodec> loader(final Class<?> typeClz, final TypeDefinition<?> typeDef) {
return () -> {
- final Method m;
- if (typeDef instanceof BooleanTypeDefinition) {
- m = typeClz.getMethod("isValue");
- } else {
- m = typeClz.getMethod("getValue");
- }
+ final Method m = typeClz.getMethod(BindingMapping.SCALAR_TYPE_OBJECT_GET_VALUE_NAME);
final MethodHandle getter = LOOKUP.unreflect(m).asType(OBJ_METHOD);
final Class<?> valueType = m.getReturnType();
-
final MethodHandle constructor = LOOKUP.findConstructor(typeClz,
MethodType.methodType(void.class, valueType)).asType(OBJ_METHOD);
return new EncapsulatedValueCodec(typeClz, constructor, getter, valueType);
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
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.AbstractEnumerationBuilder;
genTOBuilder.setRestrictions(BindingGeneratorUtil.getRestrictions(typedef));
final GeneratedPropertyBuilder genPropBuilder = genTOBuilder.addProperty(TypeConstants.VALUE_PROP);
genPropBuilder.setReturnType(javaType);
+
genTOBuilder.addEqualsIdentity(genPropBuilder);
genTOBuilder.addHashIdentity(genPropBuilder);
genTOBuilder.addToStringProperty(genPropBuilder);
- genTOBuilder.addImplementsType(TYPE_OBJECT);
+ genTOBuilder.addImplementsType(BindingTypes.scalarTypeObject(javaType));
if (typedef.getStatus() == Status.DEPRECATED) {
genTOBuilder.addAnnotation("java.lang", "Deprecated");
}
import org.junit.Test;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
+import org.opendaylight.mdsal.binding.model.util.Types;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
assertNotNull(((GeneratedType) typedefType).getImplements());
Type objectType = ((GeneratedType) typedefType).getImplements().stream()
.filter(type -> type.getFullyQualifiedName()
- .equals("org.opendaylight.yangtools.yang.binding.TypeObject")).findAny().get();
- assertEquals(TYPE_OBJECT, objectType);
+ .equals("org.opendaylight.yangtools.yang.binding.ScalarTypeObject")).findAny().get();
+ assertEquals(BindingTypes.scalarTypeObject(Types.BYTE_ARRAY), objectType);
}
@Test
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
+import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
private static final Comparator<Type> SUID_NAME_COMPARATOR = Comparator.comparing(Type::getFullyQualifiedName);
+ private static final ImmutableSet<?> IGNORED_INTERFACES =
+ ImmutableSet.of(BindingTypes.TYPE_OBJECT, BindingTypes.SCALAR_TYPE_OBJECT);
+
/**
* Converts <code>parameterName</code> to valid JAVA parameter name. If the <code>parameterName</code> is one
* of the JAVA reserved words then it is prefixed with underscore character.
}
private static Collection<Type> filteredImplementsTypes(final GeneratedTypeBuilderBase<?> to) {
- return Collections2.filter(to.getImplementsTypes(), item -> !BindingTypes.TYPE_OBJECT.equals(item));
+ return Collections2.filter(to.getImplementsTypes(), item -> !IGNORED_INTERFACES.contains(item));
}
private static <T extends Optional<?>> T currentOrEmpty(final T current, final T base) {
public static final ConcreteType RPC_INPUT = typeForClass(RpcInput.class);
public static final ConcreteType RPC_OUTPUT = typeForClass(RpcOutput.class);
public static final ConcreteType RPC_SERVICE = typeForClass(RpcService.class);
+ public static final ConcreteType SCALAR_TYPE_OBJECT = typeForClass(ScalarTypeObject.class);
// This is an annotation, we are current just referencing the type
public static final JavaTypeName ROUTING_CONTEXT = JavaTypeName.create(RoutingContext.class);
private static final ConcreteType KEYED_LIST_NOTIFICATION = typeForClass(KeyedListNotification.class);
private static final ConcreteType OPAQUE_OBJECT = typeForClass(OpaqueObject.class);
private static final ConcreteType RPC_RESULT = typeForClass(RpcResult.class);
- private static final ConcreteType SCALAR_TYPE_OBJECT = typeForClass(ScalarTypeObject.class);
private BindingTypes() {
import org.opendaylight.yangtools.yang.common.Uint64
import org.opendaylight.yangtools.yang.common.Uint8
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition
+import org.opendaylight.mdsal.binding.model.util.BindingTypes
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping
/**
* Template for generating JAVA class.
«defaultInstance»
- «FOR field : properties SEPARATOR "\n"»
- «field.getterMethod»
- «IF !field.readOnly»
- «field.setterMethod»
- «ENDIF»
- «ENDFOR»
+ «propertyMethods»
«IF (genTO.isTypedef() && genTO.getBaseType instanceof BitsTypeDefinition)»
«generateGetValueForBitsTypeDef»
'''
+ def private propertyMethods() {
+ if (properties.empty) {
+ return ""
+ }
+ isScalarTypeObject ? scalarTypeObjectValue(properties.get(0)) : defaultProperties
+ }
+
+ def private isScalarTypeObject() {
+ for (impl : genTO.implements) {
+ if (BindingTypes.SCALAR_TYPE_OBJECT.identifier.equals(impl.identifier)) {
+ return true
+ }
+ }
+ return false
+ }
+
+ def private defaultProperties() '''
+ «FOR field : properties SEPARATOR "\n"»
+ «field.getterMethod»
+ «IF !field.readOnly»
+ «field.setterMethod»
+ «ENDIF»
+ «ENDFOR»
+ '''
+
+ def private scalarTypeObjectValue(GeneratedProperty field) '''
+ @«OVERRIDE.importedName»
+ public «field.returnType.importedName» «BindingMapping.SCALAR_TYPE_OBJECT_GET_VALUE_NAME»() {
+ return «field.fieldName»«IF field.returnType.name.endsWith("[]")».clone()«ENDIF»;
+ }
+ '''
+
/**
* Template method which generates the method <code>getValue()</code> for typedef,
* which base type is BitsDefinition.
CompilationTestUtils.assertContainsMethod(int32Ext1Class, Integer.class, GET_VAL);
defInst = CompilationTestUtils.assertContainsMethod(int32Ext1Class, int32Ext1Class, "getDefaultInstance",
String.class);
- assertEquals(6, int32Ext1Class.getDeclaredMethods().length);
+ assertEquals(7, int32Ext1Class.getDeclaredMethods().length);
List<Range<Integer>> rangeConstraints = new ArrayList<>();
rangeConstraints.add(Range.closed(2, 2147483647));
defInst = CompilationTestUtils.assertContainsMethod(stringExt1Class, stringExt1Class, "getDefaultInstance",
String.class);
CompilationTestUtils.assertContainsDefaultMethods(stringExt1Class);
- assertEquals(6, stringExt1Class.getDeclaredMethods().length);
+ assertEquals(7, stringExt1Class.getDeclaredMethods().length);
List<Range<Integer>> lengthConstraints = new ArrayList<>();
lengthConstraints.add(Range.closed(5, 11));
CompilationTestUtils.assertContainsDefaultMethods(myDecimalTypeClass);
defInst = CompilationTestUtils.assertContainsMethod(myDecimalTypeClass, myDecimalTypeClass,
"getDefaultInstance", String.class);
- assertEquals(6, myDecimalTypeClass.getDeclaredMethods().length);
+ assertEquals(7, myDecimalTypeClass.getDeclaredMethods().length);
List<Range<BigDecimal>> decimalRangeConstraints = new ArrayList<>();
decimalRangeConstraints.add(Range.closed(new BigDecimal("1.5"), new BigDecimal("5.5")));
CompilationTestUtils.assertContainsDefaultMethods(myDecimalType2Class);
defInst = CompilationTestUtils.assertContainsMethod(myDecimalType2Class, myDecimalType2Class,
"getDefaultInstance", String.class);
- assertEquals(6, myDecimalType2Class.getDeclaredMethods().length);
+ assertEquals(7, myDecimalType2Class.getDeclaredMethods().length);
List<Range<BigDecimal>> decimal2RangeConstraints = new ArrayList<>();
decimal2RangeConstraints.add(Range.closed(new BigDecimal("0"), new BigDecimal("1")));
package org.opendaylight.mdsal.binding.testutils;
import ch.vorburger.xtendbeans.AssertBeans;
+import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.yangtools.test.union.rev150121.LowestLevel2;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.yangtools.test.union.rev150121.UnionTestType;
*/
public class UnionTest {
+ // Has random failures based on method order due to https://github.com/vorburger/xtendbeans/pull/33
+ @Ignore
@Test
public void testUnionType() {
AssertBeans.assertEqualByText(