Constraints are generated only once (by double-checked locking) and stored as immutable static variable.
BigInteger and BigDecimal values 0, 1 and 10 are represented as Big*.ZERO, ONE or TEN.
BigInteger values are created via BigInteger.valueOf(long) call.
Change-Id: Idb54d841fe64fd5a32af38b30126a314d6bc7a0d
Signed-off-by: Martin Vitez <mvitez@cisco.com>
import com.google.common.base.Splitter
import org.opendaylight.yangtools.sal.binding.model.api.MethodSignature
import com.google.common.collect.Range
-import java.util.ArrayList
import java.util.List
import org.opendaylight.yangtools.sal.binding.model.api.ConcreteType
import org.opendaylight.yangtools.sal.binding.model.api.Restrictions
import java.util.Collection
import java.util.Arrays
import java.util.HashMap
+import com.google.common.collect.ImmutableList
+import java.math.BigInteger
+import java.math.BigDecimal
abstract class BaseTemplate {
-
protected val GeneratedType type;
protected val Map<String, String> importMap;
static val paragraphSplitter = Splitter.on("\n\n").omitEmptyStrings();
}
def generateRestrictions(Type type, String paramName, Type returnType) '''
- «val boolean isArray = returnType.name.contains("[")»
- «processRestrictions(type, paramName, returnType, isArray)»
- '''
-
- def generateRestrictions(GeneratedProperty field, String paramName) '''
- «val Type type = field.returnType»
- «IF type instanceof ConcreteType»
- «processRestrictions(type, paramName, field.returnType, type.name.contains("["))»
- «ELSEIF type instanceof GeneratedTransferObject»
- «processRestrictions(type, paramName, field.returnType, isArrayType(type as GeneratedTransferObject))»
- «ENDIF»
- '''
-
-
- private def processRestrictions(Type type, String paramName, Type returnType, boolean isArray) '''
«val restrictions = type.getRestrictions»
«IF restrictions !== null»
+ «val boolean isNestedType = !(returnType instanceof ConcreteType)»
«IF !restrictions.lengthConstraints.empty»
- «generateLengthRestriction(type, restrictions, paramName, isArray,
- !(returnType instanceof ConcreteType))»
+ «generateLengthRestriction(returnType, restrictions, paramName, isNestedType)»
«ENDIF»
- «IF !restrictions.rangeConstraints.empty &&
- ("java.lang".equals(returnType.packageName) || "java.math".equals(returnType.packageName))»
- «generateRangeRestriction(type, returnType, restrictions, paramName,
- !(returnType instanceof ConcreteType))»
+ «IF !restrictions.rangeConstraints.empty»
+ «generateRangeRestriction(returnType, restrictions, paramName, isNestedType)»
«ENDIF»
«ENDIF»
'''
- def generateLengthRestriction(Type type, Restrictions restrictions, String paramName, boolean isArray,
- boolean isNestedType) '''
+ def private generateLengthRestriction(Type returnType, Restrictions restrictions, String paramName, boolean isNestedType) '''
+ «val clazz = restrictions.lengthConstraints.iterator.next.min.class»
if («paramName» != null) {
+ «printLengthConstraint(returnType, clazz, paramName, isNestedType, returnType.name.contains("["))»
boolean isValidLength = false;
- «List.importedName»<«Range.importedName»<«Integer.importedName»>> lengthConstraints = new «ArrayList.
- importedName»<>();
- «FOR r : restrictions.lengthConstraints»
- lengthConstraints.add(«Range.importedName».closed(«r.min», «r.max»));
- «ENDFOR»
- for («Range.importedName»<«Integer.importedName»> r : lengthConstraints) {
- «IF isArray»
- «IF isNestedType»
- if (r.contains(«paramName».getValue().length)) {
- «ELSE»
- if (r.contains(«paramName».length)) {
- «ENDIF»
- «ELSE»
- «IF isNestedType»
- if (r.contains(«paramName».getValue().length())) {
- «ELSE»
- if (r.contains(«paramName».length())) {
- «ENDIF»
- «ENDIF»
- isValidLength = true;
+ for («Range.importedName»<«clazz.importedNumber»> r : «IF isNestedType»«returnType.importedName».«ENDIF»length()) {
+ if (r.contains(_constraint)) {
+ isValidLength = true;
}
}
if (!isValidLength) {
- throw new IllegalArgumentException(String.format("Invalid length: %s, expected: %s.", «paramName», lengthConstraints));
+ throw new IllegalArgumentException(String.format("Invalid length: %s, expected: %s.", «paramName», «IF isNestedType»«returnType.importedName».«ENDIF»length()));
}
}
'''
- def generateRangeRestriction(Type type, Type returnType, Restrictions restrictions, String paramName,
- boolean isNestedType) '''
- «val javaType = Class.forName(returnType.fullyQualifiedName)»
+ def private generateRangeRestriction(Type returnType, Restrictions restrictions, String paramName, boolean isNestedType) '''
+ «val clazz = restrictions.rangeConstraints.iterator.next.min.class»
if («paramName» != null) {
+ «printRangeConstraint(returnType, clazz, paramName, isNestedType)»
boolean isValidRange = false;
- «List.importedName»<«Range.importedName»<«javaType.importedName»>> rangeConstraints = new «ArrayList.
- importedName»<>();
- «FOR r : restrictions.rangeConstraints»
- rangeConstraints.add(«Range.importedName».closed(new «javaType.importedName»(«r.min.toQuote»), new «javaType.
- importedName»(«r.max.toQuote»)));
- «ENDFOR»
- for («Range.importedName»<«javaType.importedName»> r : rangeConstraints) {
- «IF isNestedType»
- if (r.contains(«paramName».getValue())) {
- «ELSE»
- if (r.contains(«paramName»)) {
- «ENDIF»
- isValidRange = true;
+ for («Range.importedName»<«clazz.importedNumber»> r : «IF isNestedType»«returnType.importedName».«ENDIF»range()) {
+ if (r.contains(_constraint)) {
+ isValidRange = true;
}
}
if (!isValidRange) {
- throw new IllegalArgumentException(String.format("Invalid range: %s, expected: %s.", «paramName», rangeConstraints));
+ throw new IllegalArgumentException(String.format("Invalid range: %s, expected: %s.", «paramName», «IF isNestedType»«returnType.importedName».«ENDIF»range()));
}
}
'''
+ /**
+ * Print length constraint.
+ * This should always be a BigInteger (only string and binary can have length restriction)
+ */
+ def printLengthConstraint(Type returnType, Class<? extends Number> clazz, String paramName, boolean isNestedType, boolean isArray) '''
+ «clazz.importedNumber» _constraint = «clazz.importedNumber».valueOf(«paramName»«IF isNestedType».getValue()«ENDIF».length«IF !isArray»()«ENDIF»);
+ '''
+
+ def printRangeConstraint(Type returnType, Class<? extends Number> clazz, String paramName, boolean isNestedType) '''
+ «IF clazz.canonicalName.equals(BigDecimal.canonicalName)»
+ «clazz.importedNumber» _constraint = new «clazz.importedNumber»(«paramName»«IF isNestedType».getValue()«ENDIF».toString());
+ «ELSE»
+ «IF isNestedType»
+ «val propReturnType = findProperty(returnType as GeneratedTransferObject, "value").returnType»
+ «IF propReturnType.fullyQualifiedName.equals(BigInteger.canonicalName)»
+ «clazz.importedNumber» _constraint = «paramName».getValue();
+ «ELSE»
+ «clazz.importedNumber» _constraint = «clazz.importedNumber».valueOf(«paramName».getValue());
+ «ENDIF»
+ «ELSE»
+ «IF returnType.fullyQualifiedName.equals(BigInteger.canonicalName)»
+ «clazz.importedNumber» _constraint = «paramName»;
+ «ELSE»
+ «clazz.importedNumber» _constraint = «clazz.importedNumber».valueOf(«paramName»);
+ «ENDIF»
+ «ENDIF»
+ «ENDIF»
+ '''
+
def protected generateToString(Collection<GeneratedProperty> properties) '''
«IF !properties.empty»
@Override
def boolean isArrayType(GeneratedTransferObject type) {
var isArray = false
- val GeneratedTransferObject superType = type.findSuperType
- val GeneratedProperty value = superType.getPropByName("value")
+ val GeneratedProperty value = findProperty(type, "value")
if (value != null && value.returnType.name.contains("[")) {
isArray = true
}
return isArray
}
- def GeneratedTransferObject findSuperType(GeneratedTransferObject gto) {
- var GeneratedTransferObject base = gto
- var GeneratedTransferObject superType = base.superType
- while (superType !== null) {
- base = superType
- superType = base.superType
- }
- return base;
- }
-
def String toQuote(Object obj) {
return "\"" + obj.toString + "\"";
}
ENDIF
»'''
+ def protected generateLengthMethod(String methodName, Type type, String className, String varName) '''
+ «val Restrictions restrictions = type.restrictions»
+ «IF restrictions != null && !(restrictions.lengthConstraints.empty)»
+ «val numberClass = restrictions.lengthConstraints.iterator.next.min.class»
+ public static «List.importedName»<«Range.importedName»<«numberClass.importedNumber»>> «methodName»() {
+ «IF numberClass.equals(typeof(BigDecimal))»
+ «lengthMethodBody(restrictions, numberClass, className, varName)»
+ «ELSE»
+ «lengthMethodBody(restrictions, typeof(BigInteger), className, varName)»
+ «ENDIF»
+ }
+ «ENDIF»
+ '''
+
+ def private lengthMethodBody(Restrictions restrictions, Class<? extends Number> numberClass, String className, String varName) '''
+ if («varName» == null) {
+ synchronized («className».class) {
+ if («varName» == null) {
+ «ImmutableList.importedName».Builder<«Range.importedName»<«numberClass.importedName»>> builder = «ImmutableList.importedName».builder();
+ «FOR r : restrictions.lengthConstraints»
+ builder.add(«Range.importedName».closed(«numericValue(numberClass, r.min)», «numericValue(numberClass, r.max)»));
+ «ENDFOR»
+ «varName» = builder.build();
+ }
+ }
+ }
+ return «varName»;
+ '''
+
+ def protected generateRangeMethod(String methodName, Type type, String className, String varName) '''
+ «val Restrictions restrictions = type.restrictions»
+ «IF restrictions != null && !(restrictions.rangeConstraints.empty)»
+ «val numberClass = restrictions.rangeConstraints.iterator.next.min.class»
+ public static «List.importedName»<«Range.importedName»<«numberClass.importedNumber»>> «methodName»() {
+ «IF numberClass.equals(typeof(BigDecimal))»
+ «rangeMethodBody(restrictions, numberClass, className, varName)»
+ «ELSE»
+ «rangeMethodBody(restrictions, typeof(BigInteger), className, varName)»
+ «ENDIF»
+ }
+ «ENDIF»
+ '''
+
+ def private rangeMethodBody(Restrictions restrictions, Class<? extends Number> numberClass, String className, String varName) '''
+ if («varName» == null) {
+ synchronized («className».class) {
+ if («varName» == null) {
+ «ImmutableList.importedName».Builder<«Range.importedName»<«numberClass.importedName»>> builder = «ImmutableList.importedName».builder();
+ «FOR r : restrictions.rangeConstraints»
+ builder.add(«Range.importedName».closed(«numericValue(numberClass, r.min)», «numericValue(numberClass, r.max)»));
+ «ENDFOR»
+ «varName» = builder.build();
+ }
+ }
+ }
+ return «varName»;
+ '''
+
+ def protected String importedNumber(Class<? extends Number> clazz) {
+ if (clazz.equals(typeof(BigDecimal))) {
+ return BigDecimal.importedName
+ }
+ return BigInteger.importedName
+ }
+
+ def private String numericValue(Class<? extends Number> clazz, Object numberValue) {
+ val number = clazz.importedName;
+ val value = numberValue.toString
+ if (clazz.equals(typeof(BigInteger)) || clazz.equals(typeof(BigDecimal))) {
+ if (value.equals("0")) {
+ return number + ".ZERO"
+ } else if (value.equals("1")) {
+ return number + ".ONE"
+ } else if (value.equals("10")) {
+ return number + ".TEN"
+ } else {
+ try {
+ val Long longVal = Long.valueOf(value)
+ return number + ".valueOf(" + longVal + "L)"
+ } catch (NumberFormatException e) {
+ if (clazz.equals(typeof(BigDecimal))) {
+ try {
+ val Double doubleVal = Double.valueOf(value);
+ return number + ".valueOf(" + doubleVal + ")"
+ } catch (NumberFormatException e2) {
+ }
+ }
+ }
+ }
+ }
+ return "new " + number + "(\"" + value + "\")"
+ }
+
+ def private GeneratedProperty findProperty(GeneratedTransferObject gto, String name) {
+ val props = gto.properties
+ for (prop : props) {
+ if (prop.name.equals(name)) {
+ return prop
+ }
+ }
+ val GeneratedTransferObject parent = gto.superType
+ if (parent != null) {
+ return findProperty(parent, name)
+ }
+ return null
+ }
+
}
import java.util.HashSet
import java.util.Collection
import org.opendaylight.yangtools.yang.binding.Identifiable
+import com.google.common.collect.Range
+import org.opendaylight.yangtools.sal.binding.model.api.ConcreteType
/**
* Template for generating JAVA builder classes.
* @param set of method signature instances which should be transformed to list of properties
* @return set of generated property instances which represents the getter <code>methods</code>
*/
- def private propertiesFromMethods(Set<MethodSignature> methods) {
+ def private propertiesFromMethods(Collection<MethodSignature> methods) {
if (methods == null || methods.isEmpty()) {
return Collections.emptySet
}
return names
}
- /**
- * Template method which generates class attributes.
- *
- * @param boolean value which specify whether field is|isn't final
- * @return string with class attributes and their types
- */
+ /**
+ * Template method which generates class attributes.
+ *
+ * @param boolean value which specify whether field is|isn't final
+ * @return string with class attributes and their types
+ */
def private generateFields(boolean _final) '''
- «IF !properties.empty»
+ «IF properties !== null»
«FOR f : properties»
private«IF _final» final«ENDIF» «f.returnType.importedName» «f.fieldName»;
+ «val restrictions = f.returnType.restrictions»
+ «IF !_final && restrictions != null»
+ «IF !(restrictions.lengthConstraints.empty)»
+ «val clazz = restrictions.lengthConstraints.iterator.next.min.class»
+ private static «List.importedName»<«Range.importedName»<«clazz.importedNumber»>> «f.fieldName»_length;
+ «ENDIF»
+ «IF !(restrictions.rangeConstraints.empty)»
+ «val clazz = restrictions.rangeConstraints.iterator.next.min.class»
+ private static «List.importedName»<«Range.importedName»<«clazz.importedNumber»>> «f.fieldName»_range;
+ «ENDIF»
+ «ENDIF»
«ENDFOR»
«ENDIF»
'''
«ENDIF»
'''
- /**
- * Template method which generates setter methods
- *
- * @return string with the setter methods
- */
+ /**
+ * Template method which generates setter methods
+ *
+ * @return string with the setter methods
+ */
def private generateSetters() '''
«FOR field : properties SEPARATOR '\n'»
+ «val length = field.fieldName + "_length"»
+ «val range = field.fieldName + "_range"»
public «type.name»«BUILDER» set«field.name.toFirstUpper»(«field.returnType.importedName» value) {
- «generateRestrictions(field, "value")»
-
+ «generateRestrictions(field, "value", length, range)»
this.«field.fieldName» = value;
return this;
}
+ «generateLengthMethod(length, field.returnType, type.name+BUILDER, length)»
+ «generateRangeMethod(range, field.returnType, type.name+BUILDER, range)»
«ENDFOR»
«IF augmentField != null»
«ENDIF»
'''
+ def generateRestrictions(GeneratedProperty field, String paramName, String lengthGetter, String rangeGetter) '''
+ «val Type type = field.returnType»
+ «IF type instanceof ConcreteType»
+ «createRestrictions(type, paramName, type.name.contains("["), lengthGetter, rangeGetter)»
+ «ELSEIF type instanceof GeneratedTransferObject»
+ «createRestrictions(type, paramName, isArrayType(type as GeneratedTransferObject), lengthGetter, rangeGetter)»
+ «ENDIF»
+ '''
+
+ def private createRestrictions(Type type, String paramName, boolean isArray, String lengthGetter, String rangeGetter) '''
+ «val restrictions = type.getRestrictions»
+ «IF restrictions !== null»
+ «val boolean isNestedType = !(type instanceof ConcreteType)»
+ «IF !restrictions.lengthConstraints.empty»
+ «generateLengthRestriction(type, paramName, lengthGetter, isNestedType, isArray)»
+ «ENDIF»
+ «IF !restrictions.rangeConstraints.empty»
+ «generateRangeRestriction(type, paramName, rangeGetter, isNestedType, isArray)»
+ «ENDIF»
+ «ENDIF»
+ '''
+
+ def private generateLengthRestriction(Type type, String paramName, String getterName, boolean isNestedType, boolean isArray) '''
+ «val restrictions = type.getRestrictions»
+ if («paramName» != null) {
+ «val clazz = restrictions.lengthConstraints.iterator.next.min.class»
+ «printLengthConstraint(type, clazz, paramName, isNestedType, isArray)»
+ boolean isValidLength = false;
+ for («Range.importedName»<«clazz.importedNumber»> r : «getterName»()) {
+ if (r.contains(_constraint)) {
+ isValidLength = true;
+ }
+ }
+ if (!isValidLength) {
+ throw new IllegalArgumentException(String.format("Invalid length: %s, expected: %s.", «paramName», «getterName»));
+ }
+ }
+ '''
+
+ def private generateRangeRestriction(Type type, String paramName, String getterName, boolean isNestedType, boolean isArray) '''
+ «val restrictions = type.getRestrictions»
+ if («paramName» != null) {
+ «val clazz = restrictions.rangeConstraints.iterator.next.min.class»
+ «printRangeConstraint(type, clazz, paramName, isNestedType)»
+ boolean isValidRange = false;
+ for («Range.importedName»<«clazz.importedNumber»> r : «getterName»()) {
+ if (r.contains(_constraint)) {
+ isValidRange = true;
+ }
+ }
+ if (!isValidRange) {
+ throw new IllegalArgumentException(String.format("Invalid range: %s, expected: %s.", «paramName», «getterName»));
+ }
+ }
+ '''
+
/**
* Template method which generate constructor for IMPL class.
*
«generateToString(genTO.toStringIdentifiers)»
- «generateGetLength»
+ «generateLengthMethod("length", genTO, genTO.importedName, "_length")»
- «generateGetRange»
+ «generateRangeMethod("range", genTO, genTO.importedName, "_range")»
}
'''
«parentConstructor»
«ENDIF»
'''
-
+
def protected allValuesConstructor() '''
«IF genTO.typedef && !allProperties.empty && allProperties.size == 1 && allProperties.get(0).name.equals("value")»
@«ConstructorProperties.importedName»("value")
* @return string with the class attributes in JAVA format
*/
def protected generateFields() '''
+ «IF restrictions != null»
+ «IF !(restrictions.lengthConstraints.empty)»
+ «val numberClass = restrictions.lengthConstraints.iterator.next.min.class»
+ private static «List.importedName»<«Range.importedName»<«numberClass.importedNumber»>> _length;
+ «ENDIF»
+ «IF !(restrictions.rangeConstraints.empty)»
+ «val numberClass = restrictions.rangeConstraints.iterator.next.min.class»
+ private static «List.importedName»<«Range.importedName»<«numberClass.importedNumber»>> _range;
+ «ENDIF»
+ «ENDIF»
«IF !properties.empty»
«FOR f : properties»
«IF f.readOnly»final«ENDIF» private «f.returnType.importedName» «f.fieldName»;
«ENDIF»
'''
- def private generateGetLength() '''
- «IF restrictions != null && !(restrictions.lengthConstraints.empty)»
- «val clazz = restrictions.lengthConstraints.iterator.next.min.class»
- public static «List.importedName»<«Range.importedName»<«clazz.importedName»>> length() {
- final «List.importedName»<«Range.importedName»<«clazz.importedName»>> result = new «ArrayList.importedName»<>();
- «FOR r : restrictions.lengthConstraints»
- result.add(«Range.importedName».closed(new «clazz.importedName»("«r.min»"), new «clazz.importedName»("«r.max»")));
- «ENDFOR»
- return result;
- }
- «ENDIF»
- '''
-
- def private generateGetRange() '''
- «IF restrictions != null && !(restrictions.rangeConstraints.empty)»
- «val clazz = restrictions.rangeConstraints.iterator.next.min.class»
- public static «List.importedName»<«Range.importedName»<«clazz.importedName»>> range() {
- final «List.importedName»<«Range.importedName»<«clazz.importedName»>> result = new «ArrayList.importedName»<>();
- «FOR r : restrictions.rangeConstraints»
- result.add(«Range.importedName».closed(new «clazz.importedName»("«r.min»"), new «clazz.importedName»("«r.max»")));
- «ENDFOR»
- return result;
- }
- «ENDIF»
- '''
-
}
private static final String VAL = "_value";
private static final String GET_VAL = "getValue";
private static final String UNITS = "_UNITS";
+ private static final String LENGTH = "_length";
+ private static final String RANGE = "_range";
@Test
public void test() throws Exception {
// typedef int32-ext1
assertFalse(int32Ext1Class.isInterface());
assertContainsField(int32Ext1Class, VAL, Integer.class);
+ assertContainsField(int32Ext1Class, RANGE, List.class);
assertContainsFieldWithValue(int32Ext1Class, "serialVersionUID", Long.TYPE, 5351634010010233292L, Integer.class);
- assertEquals(2, int32Ext1Class.getDeclaredFields().length);
+ assertEquals(3, int32Ext1Class.getDeclaredFields().length);
expectedConstructor = assertContainsConstructor(int32Ext1Class, Integer.class);
assertContainsConstructor(int32Ext1Class, int32Ext1Class);
assertEquals(2, int32Ext1Class.getConstructors().length);
// typedef int32-ext2
assertFalse(int32Ext2Class.isInterface());
+ assertContainsField(int32Ext1Class, RANGE, List.class);
assertContainsFieldWithValue(int32Ext2Class, UNITS, String.class, "mile", Integer.class);
assertContainsFieldWithValue(int32Ext2Class, "serialVersionUID", Long.TYPE, 317831889060130988L, Integer.class);
- assertEquals(2, int32Ext2Class.getDeclaredFields().length);
+ assertEquals(3, int32Ext2Class.getDeclaredFields().length);
expectedConstructor = assertContainsConstructor(int32Ext2Class, Integer.class);
assertContainsConstructor(int32Ext2Class, int32Ext2Class);
assertContainsConstructor(int32Ext2Class, int32Ext1Class);
// typedef string-ext1
assertFalse(stringExt1Class.isInterface());
assertContainsField(stringExt1Class, VAL, String.class);
+ assertContainsField(stringExt1Class, LENGTH, List.class);
assertContainsField(stringExt1Class, "patterns", List.class);
assertContainsField(stringExt1Class, "PATTERN_CONSTANTS", List.class);
assertContainsFieldWithValue(stringExt1Class, "serialVersionUID", Long.TYPE, 6943827552297110991L, String.class);
- assertEquals(4, stringExt1Class.getDeclaredFields().length);
+ assertEquals(5, stringExt1Class.getDeclaredFields().length);
expectedConstructor = assertContainsConstructor(stringExt1Class, String.class);
assertContainsConstructor(stringExt1Class, stringExt1Class);
assertEquals(2, stringExt1Class.getDeclaredConstructors().length);
// typedef string-ext2
assertFalse(stringExt2Class.isInterface());
+ assertContainsField(stringExt2Class, LENGTH, List.class);
assertContainsFieldWithValue(stringExt2Class, "serialVersionUID", Long.TYPE, 8100233177432072092L, String.class);
- assertEquals(1, stringExt2Class.getDeclaredFields().length);
+ assertEquals(2, stringExt2Class.getDeclaredFields().length);
expectedConstructor = assertContainsConstructor(stringExt2Class, String.class);
assertContainsConstructor(stringExt2Class, stringExt2Class);
assertContainsConstructor(stringExt2Class, stringExt1Class);
// typedef my-decimal-type
assertFalse(myDecimalTypeClass.isInterface());
assertContainsField(myDecimalTypeClass, VAL, BigDecimal.class);
+ assertContainsField(myDecimalTypeClass, RANGE, List.class);
assertContainsFieldWithValue(myDecimalTypeClass, "serialVersionUID", Long.TYPE, 3143735729419861095L, BigDecimal.class);
- assertEquals(2, myDecimalTypeClass.getDeclaredFields().length);
+ assertEquals(3, myDecimalTypeClass.getDeclaredFields().length);
assertContainsMethod(myDecimalTypeClass, BigDecimal.class, "getValue");
expectedConstructor = assertContainsConstructor(myDecimalTypeClass, BigDecimal.class);
assertContainsConstructor(myDecimalTypeClass, myDecimalTypeClass);
import org.opendaylight.yangtools.sal.binding.model.api.AccessModifier;
import org.opendaylight.yangtools.sal.binding.model.api.ConcreteType;
import org.opendaylight.yangtools.sal.binding.model.api.Enumeration;
+import org.opendaylight.yangtools.sal.binding.model.api.GeneratedProperty;
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.yangtools.sal.binding.model.api.Restrictions;
import org.opendaylight.yangtools.sal.binding.model.api.Type;
final Restrictions r) {
Type returnType = null;
Preconditions.checkArgument(typeDefinition != null, "Type Definition cannot be NULL!");
- if (typeDefinition.getQName() == null) {
- throw new IllegalArgumentException(
- "Type Definition cannot have non specified QName (QName cannot be NULL!)");
- }
- Preconditions.checkArgument(typeDefinition.getQName().getLocalName() != null,
+ Preconditions.checkArgument(typeDefinition.getQName() != null,
+ "Type Definition cannot have non specified QName (QName cannot be NULL!)");
+ String typedefName = typeDefinition.getQName().getLocalName();
+ Preconditions.checkArgument(typedefName != null,
"Type Definitions Local Name cannot be NULL!");
if (typeDefinition instanceof ExtendedType) {
returnType = javaTypeForExtendedType(typeDefinition);
+ if (r != null && returnType instanceof GeneratedTransferObject) {
+ GeneratedTransferObject gto = (GeneratedTransferObject) returnType;
+ Module module = findParentModule(schemaContext, parentNode);
+ String basePackageName = moduleNamespaceToPackageName(module);
+ String packageName = packageNameForGeneratedType(basePackageName, typeDefinition.getPath());
+ String genTOName = BindingMapping.getClassName(typedefName);
+ String name = packageName + "." + genTOName;
+ if (!(returnType.getFullyQualifiedName().equals(name))) {
+ returnType = shadedTOWithRestrictions(gto, r);
+ }
+ }
} else {
returnType = javaTypeForLeafrefOrIdentityRef(typeDefinition, parentNode);
if (returnType == null) {
return returnType;
}
+ private GeneratedTransferObject shadedTOWithRestrictions(GeneratedTransferObject gto, Restrictions r) {
+ GeneratedTOBuilder gtob = new GeneratedTOBuilderImpl(gto.getPackageName(), gto.getName());
+ GeneratedTransferObject parent = gto.getSuperType();
+ if (parent != null) {
+ gtob.setExtendsType(parent);
+ }
+ gtob.setRestrictions(r);
+ for (GeneratedProperty gp : gto.getProperties()) {
+ GeneratedPropertyBuilder gpb = gtob.addProperty(gp.getName());
+ gpb.setValue(gp.getValue());
+ gpb.setReadOnly(gp.isReadOnly());
+ gpb.setAccessModifier(gp.getAccessModifier());
+ gpb.setReturnType(gp.getReturnType());
+ gpb.setFinal(gp.isFinal());
+ gpb.setStatic(gp.isStatic());
+ }
+ return gtob.toInstance();
+ }
+
/**
* Returns JAVA <code>Type</code> for instances of the type
* <code>LeafrefTypeDefinition</code> or
final String moduleName = module.getName();
final Date moduleRevision = module.getRevision();
if ((basePackageName != null) && (moduleName != null) && (typedef != null) && (typedef.getQName() != null)) {
-
final String typedefName = typedef.getQName().getLocalName();
final TypeDefinition<?> innerTypeDefinition = typedef.getBaseType();
if (!(innerTypeDefinition instanceof LeafrefTypeDefinition)
import static com.google.common.base.Preconditions.checkState;
+import com.google.common.base.Optional;
import java.math.BigDecimal;
+import java.math.BigInteger;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Stack;
-
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public final class ParserListenerUtils {
private static final Logger LOG = LoggerFactory.getLogger(ParserListenerUtils.class);
if (value.contains(".")) {
result = new BigDecimal(value);
} else {
- result = Long.valueOf(value);
+ result = new BigInteger(value);
}
} catch (NumberFormatException e) {
throw new YangParseException(moduleName, line, "Unable to parse range value '" + value + "'.", e);
import static org.junit.Assert.assertTrue;
import java.io.File;
+import java.math.BigInteger;
import java.net.URI;
import java.util.List;
import java.util.Set;
List<LengthConstraint> lengths = type.getLengthConstraints();
assertEquals(1, lengths.size());
LengthConstraint length = type.getLengthConstraints().get(0);
- assertEquals(1L, length.getMin());
- assertEquals(253L, length.getMax());
+ assertEquals(BigInteger.ONE, length.getMin());
+ assertEquals(BigInteger.valueOf(253), length.getMax());
}
@Test
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
+import java.math.BigInteger;
import java.net.URI;
import java.text.DateFormat;
import java.text.ParseException;
List<RangeConstraint> ranges = leafType.getRangeConstraints();
assertEquals(1, ranges.size());
RangeConstraint range = ranges.get(0);
- assertEquals(12L, range.getMin());
- assertEquals(20L, range.getMax());
+ assertEquals(BigInteger.valueOf(12), range.getMin());
+ assertEquals(BigInteger.valueOf(20), range.getMax());
ExtendedType baseType = (ExtendedType) leafType.getBaseType();
QName baseTypeQName = baseType.getQName();
List<RangeConstraint> baseTypeRanges = baseType.getRangeConstraints();
assertEquals(2, baseTypeRanges.size());
RangeConstraint baseTypeRange1 = baseTypeRanges.get(0);
- assertEquals(3L, baseTypeRange1.getMin());
- assertEquals(9L, baseTypeRange1.getMax());
+ assertEquals(BigInteger.valueOf(3), baseTypeRange1.getMin());
+ assertEquals(BigInteger.valueOf(9), baseTypeRange1.getMax());
RangeConstraint baseTypeRange2 = baseTypeRanges.get(1);
- assertEquals(11L, baseTypeRange2.getMin());
- assertEquals(20L, baseTypeRange2.getMax());
+ assertEquals(BigInteger.valueOf(11), baseTypeRange2.getMin());
+ assertEquals(BigInteger.valueOf(20), baseTypeRange2.getMax());
ExtendedType base = (ExtendedType) baseType.getBaseType();
QName baseQName = base.getQName();
List<RangeConstraint> baseRanges = base.getRangeConstraints();
assertEquals(1, baseRanges.size());
RangeConstraint baseRange = baseRanges.get(0);
- assertEquals(2L, baseRange.getMin());
- assertEquals(20L, baseRange.getMax());
+ assertEquals(BigInteger.valueOf(2), baseRange.getMin());
+ assertEquals(BigInteger.valueOf(20), baseRange.getMax());
assertTrue(base.getBaseType() instanceof Int32);
}
List<LengthConstraint> baseType2Lengths = baseType2.getLengthConstraints();
assertEquals(1, baseType2Lengths.size());
LengthConstraint length = baseType2Lengths.get(0);
- assertEquals(6L, length.getMin());
- assertEquals(10L, length.getMax());
+ assertEquals(BigInteger.valueOf(6), length.getMin());
+ assertEquals(BigInteger.TEN, length.getMax());
assertTrue(baseType2.getRangeConstraints().isEmpty());
ExtendedType baseType3 = (ExtendedType) baseType2.getBaseType();
List<LengthConstraint> baseType3Lengths = baseType3.getLengthConstraints();
assertEquals(1, baseType3Lengths.size());
length = baseType3Lengths.get(0);
- assertEquals(5L, length.getMin());
- assertEquals(11L, length.getMax());
+ assertEquals(BigInteger.valueOf(5), length.getMin());
+ assertEquals(BigInteger.valueOf(11), length.getMax());
assertTrue(baseType3.getRangeConstraints().isEmpty());
assertTrue(baseType3.getBaseType() instanceof StringType);
List<LengthConstraint> typeLengths = type.getLengthConstraints();
assertEquals(1, typeLengths.size());
LengthConstraint length = typeLengths.get(0);
- assertEquals(7L, length.getMin());
- assertEquals(10L, length.getMax());
+ assertEquals(BigInteger.valueOf(7), length.getMin());
+ assertEquals(BigInteger.TEN, length.getMax());
assertTrue(type.getRangeConstraints().isEmpty());
ExtendedType baseType1 = (ExtendedType) type.getBaseType();
List<LengthConstraint> baseType2Lengths = baseType1.getLengthConstraints();
assertEquals(1, baseType2Lengths.size());
length = baseType2Lengths.get(0);
- assertEquals(6L, length.getMin());
- assertEquals(10L, length.getMax());
+ assertEquals(BigInteger.valueOf(6), length.getMin());
+ assertEquals(BigInteger.TEN, length.getMax());
assertTrue(baseType1.getRangeConstraints().isEmpty());
ExtendedType baseType2 = (ExtendedType) baseType1.getBaseType();
List<LengthConstraint> baseType3Lengths = baseType2.getLengthConstraints();
assertEquals(1, baseType3Lengths.size());
length = baseType3Lengths.get(0);
- assertEquals(5L, length.getMin());
- assertEquals(11L, length.getMax());
+ assertEquals(BigInteger.valueOf(5), length.getMin());
+ assertEquals(BigInteger.valueOf(11), length.getMax());
assertTrue(baseType2.getRangeConstraints().isEmpty());
assertTrue(baseType2.getBaseType() instanceof StringType);
List<RangeConstraint> ranges = unionType1.getRangeConstraints();
assertEquals(1, ranges.size());
RangeConstraint range = ranges.get(0);
- assertEquals(1L, range.getMin());
- assertEquals(100L, range.getMax());
+ assertEquals(BigInteger.ONE, range.getMin());
+ assertEquals(BigInteger.valueOf(100), range.getMax());
assertTrue(unionType1.getBaseType() instanceof Int16);
assertTrue(unionTypes.get(1) instanceof Int32);
List<RangeConstraint> ranges = int16Ext.getRangeConstraints();
assertEquals(1, ranges.size());
RangeConstraint range = ranges.get(0);
- assertEquals(1L, range.getMin());
- assertEquals(100L, range.getMax());
+ assertEquals(BigInteger.ONE, range.getMin());
+ assertEquals(BigInteger.valueOf(100), range.getMax());
assertTrue(int16Ext.getBaseType() instanceof Int16);
}
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
+import java.math.BigInteger;
import java.net.URI;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
List<RangeConstraint> ranges = dscpExt.getRangeConstraints();
assertEquals(1, ranges.size());
RangeConstraint range = ranges.get(0);
- assertEquals(0L, range.getMin());
- assertEquals(63L, range.getMax());
+ assertEquals(BigInteger.ZERO, range.getMin());
+ assertEquals(BigInteger.valueOf(63), range.getMax());
}
@Test
Code Review / yangtools.git / commitdiff