@import org.opendaylight.mdsal.binding.javav2.java.api.generator.renderers.BuilderRenderer.toListOfNames
@import org.opendaylight.mdsal.binding.javav2.java.api.generator.rangeGenerators.AbstractRangeGenerator
@import org.opendaylight.mdsal.binding.javav2.java.api.generator.rangeGenerators.LengthGenerator
+@import org.opendaylight.mdsal.binding.javav2.util.BindingMapping
+@import org.opendaylight.mdsal.binding.javav2.generator.util.Types
@import org.opendaylight.mdsal.binding.javav2.model.api.ConcreteType
@import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType
+@import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedTypeForBuilder
@import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedTransferObject
@import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedProperty
@import org.opendaylight.mdsal.binding.javav2.model.api.Type
+@import org.opendaylight.mdsal.binding.javav2.model.api.ParameterizedType
@import org.opendaylight.yangtools.concepts.Builder
@(genType: GeneratedType, properties: Set[GeneratedProperty], importedNames: Map[String, String],
ImportedNamesWithProperties: Map[GeneratedProperty, String], augmentField: GeneratedProperty, copyConstructorHelper: String,
-getterMethods: List[String])
+getterMethods: List[String], parentTypeForBuilderName: String, childTreeNode: Boolean, childTreeNodeIdent: Boolean,
+keyTypeName: String, instantiable: Boolean, constants: String)
@if(genType != null) {
@{wrapToDocumentation(formatDataForJavaDocBuilder(importedNames.get("genType")))}
public class @{genType.getName}Builder implements @{getSimpleNameForBuilder} <@{importedNames.get("genType")}> {
@generateFields(false)
+ @{constants}
+
@generateAugmentField(false)
@generateConstructorsFromIfcs()
}
private static final class @{genType.getName}Impl implements @{genType.getName} {
-
+ @if(instantiable) {
@implementedInterfaceGetter()
+ }
@generateFields(true)
}
@generateMethodFieldsFrom() = {
- @if(genType.isInstanceOf[GeneratedType] && !genType.isInstanceOf[GeneratedTransferObject]) {
+ @if(genType.isInstanceOf[GeneratedType] && genType.isInstanceOf[GeneratedTypeForBuilder]
+ && !genType.isInstanceOf[GeneratedTransferObject]) {
@if(hasImplementsFromUses(genType.asInstanceOf[GeneratedType])) {
/**
- *Set fields from given grouping argument. Valid argument is instance of one of following types:
+ * Set fields from given grouping argument. Valid argument is instance of one of following types:
* <ul>
@for(impl <- getAllIfcs(genType.asInstanceOf[GeneratedType])) {
* <li>@{impl.getFullyQualifiedName}</li>
public void fieldsFrom(@{importedNames.get("treeNode")} arg) {
boolean isValidArg = false;
@for(impl <- getAllIfcs(genType.asInstanceOf[GeneratedType])) {
- @if(impl.isInstanceOf[GeneratedType] && !impl.asInstanceOf[GeneratedType].getMethodDefinitions.isEmpty) {
+ @if(impl.isInstanceOf[GeneratedType] && impl.isInstanceOf[GeneratedTypeForBuilder]
+ && !impl.asInstanceOf[GeneratedType].getMethodDefinitions.isEmpty) {
if (arg instanceof @{impl.asInstanceOf[GeneratedType].getFullyQualifiedName}) {
- @if(!impl.isInstanceOf[GeneratedTransferObject]) {
- @for(getter <- genType.asInstanceOf[GeneratedType].getMethodDefinitions) {
+ @if(impl.isInstanceOf[GeneratedType] && impl.isInstanceOf[GeneratedTypeForBuilder]
+ && !impl.isInstanceOf[GeneratedTransferObject]) {
+ @for(getter <- impl.asInstanceOf[GeneratedType].getMethodDefinitions) {
this._@{propertyNameFromGetter(getter)} = ((@{impl.asInstanceOf[GeneratedType].getFullyQualifiedName})arg).@{getter.getName}();
}
}
}
}
}
- if (!isValidArg) {
- throw new IllegalArgumentException(
- "expected one of: @{toListOfNames(getAllIfcs(genType.asInstanceOf[GeneratedType]))} \n" +
- "but was: " + arg
- );
- }
+
+ @{importedNames.get("codeHelpers")}.validValue(isValidArg, arg, "@{toListOfNames(getAllIfcs(genType.asInstanceOf[GeneratedType]))}");
}
}
}
* Generate constructor with argument of given type.
*@
@generateConstructorFromIfc(impl: Type) = {
- @if(impl.isInstanceOf[GeneratedType]) {
+ @if(impl.isInstanceOf[GeneratedType] && impl.isInstanceOf[GeneratedTypeForBuilder]) {
@if(!impl.asInstanceOf[GeneratedType].getMethodDefinitions.isEmpty) {
public @{genType.getName}Builder(
@{impl.getFullyQualifiedName} arg) {
}
}
-
@generateSetters() = {
@for(field <- properties) {
- @if(!field.getReturnType.isInstanceOf[GeneratedType] && getRestrictions(field.getReturnType) != null) {
- @if(getRestrictions(field.getReturnType).getRangeConstraints != null && !getRestrictions(field.getReturnType).getRangeConstraints.isEmpty) {
- @{AbstractRangeGenerator.forType(field.getReturnType).generateRangeChecker(toFirstUpper(field.getName),
- getRestrictions(field.getReturnType).getRangeConstraints)}
- }
- @if(getRestrictions(field.getReturnType).getLengthConstraints != null && !getRestrictions(field.getReturnType).getLengthConstraints.isEmpty) {
- @{LengthGenerator.generateLengthChecker(fieldName(field), field.getReturnType,
- getRestrictions(field.getReturnType).getLengthConstraints)}
- }
- }
- public @{genType.getName}Builder set@{toFirstUpper(field.getName)}(final @{importedNames.get("augmentFieldReturnType")} value) {
- @if(!field.getReturnType.isInstanceOf[GeneratedType] && getRestrictions(field.getReturnType) != null) {
- if (value != null) {
- @if(getRestrictions(field.getReturnType).getRangeConstraints != null && !getRestrictions(field.getReturnType).getRangeConstraints.isEmpty) {
- @if(field.getReturnType.isInstanceOf[ConcreteType]) {
- @{AbstractRangeGenerator.forType(field.getReturnType).generateRangeCheckerCall(toFirstUpper(field.getName), "value")}
- } else {
- @{AbstractRangeGenerator.forType(field.getReturnType).generateRangeCheckerCall(toFirstUpper(field.getName), "value.getValue()")}
- }
- }
- @if(getRestrictions(field.getReturnType).getLengthConstraints != null && !getRestrictions(field.getReturnType).getLengthConstraints.isEmpty) {
- @if(field.getReturnType.isInstanceOf[ConcreteType]) {
- @{LengthGenerator.generateLengthCheckerCall(fieldName(field), "value")}
- } else {
- @{LengthGenerator.generateLengthCheckerCall(fieldName(field), "value.getValue()")}
- }
- }
- }
- }
- this.@{fieldName(field)} = value;
- return this;
+ @if(field.getReturnType.isInstanceOf[ParameterizedType]
+ && field.getReturnType.asInstanceOf[ParameterizedType].getRawType.equals(Types.typeForClass(classOf[List[_]]))) {
+ @generateSetter(field, field.getReturnType.asInstanceOf[ParameterizedType].getActualTypeArguments()(0), true)
+ } else {
+ @generateSetter(field, field.getReturnType, false)
}
}
+
@if(augmentField != null) {
public @{genType.getName}Builder add@{toFirstUpper(augmentField.getName)}(@{importedNames.get("class")}<? extends @{importedNames.get("augmentFieldReturnType")}> augmentationType, @{importedNames.get("augmentFieldReturnType")} augmentation) {
if (augmentation == null) {
}
}
+@generateSetter(field: GeneratedProperty, actualType: Type, isList: Boolean) = {
+ @if(!actualType.isInstanceOf[GeneratedType] && getRestrictions(actualType) != null) {
+ @if(getRestrictions(actualType).getRangeConstraint.isPresent) {
+ @{AbstractRangeGenerator.forType(actualType).generateRangeChecker(toFirstUpper(field.getName),
+ getRestrictions(actualType).getRangeConstraint.get)}
+ }
+ @if(getRestrictions(actualType).getLengthConstraint.isPresent) {
+ @{LengthGenerator.generateLengthChecker(fieldName(field), actualType,
+ getRestrictions(actualType).getLengthConstraint.get)}
+ }
+ }
+
+ @if(isList) {
+ public @{genType.getName}Builder set@{toFirstUpper(field.getName)}(final @{ImportedNamesWithProperties.get(field)} values) {
+ @if(!actualType.isInstanceOf[GeneratedType] && getRestrictions(actualType) != null) {
+ if (values != null) {
+ for (@{actualType.getFullyQualifiedName} value : values) {
+ @checkArgument(field, actualType)
+ }
+ }
+ }
+ this.@{fieldName(field)} = values;
+ return this;
+ }
+ } else {
+ public @{genType.getName}Builder set@{toFirstUpper(field.getName)}(final @{ImportedNamesWithProperties.get(field)} value) {
+ @if(!actualType.isInstanceOf[GeneratedType] && getRestrictions(actualType) != null) {
+ if (value != null) {
+ @checkArgument(field, actualType)
+ }
+ }
+ this.@{fieldName(field)} = value;
+ return this;
+ }
+ }
+}
+
+@checkArgument(field: GeneratedProperty, actualType: Type) = {
+ @if(getRestrictions(actualType).getRangeConstraint.isPresent) {
+ @if(actualType.isInstanceOf[ConcreteType]) {
+ @{AbstractRangeGenerator.forType(actualType).generateRangeCheckerCall(toFirstUpper(field.getName), "value")}
+ } else {
+ @{AbstractRangeGenerator.forType(actualType).generateRangeCheckerCall(toFirstUpper(field.getName), "value.getValue()")}
+ }
+ }
+ @if(getRestrictions(actualType).getLengthConstraint.isPresent) {
+ @if(actualType.isInstanceOf[ConcreteType]) {
+ @{LengthGenerator.generateLengthCheckerCall(fieldName(field), "value")}
+ } else {
+ @{LengthGenerator.generateLengthCheckerCall(fieldName(field), "value.getValue()")}
+ }
+ }
+ @for(currentConstant <- genType.getConstantDefinitions) {
+ @defining(fieldName(field)) { suffix =>
+ @if(currentConstant.getName.startsWith(BindingMapping.PATTERN_CONSTANT_NAME)
+ && suffix.equals(currentConstant.getName.substring(BindingMapping.PATTERN_CONSTANT_NAME.length))) {
+ @{importedNames.get("codeHelpers")}.checkPattern(value, @{BindingMapping.MEMBER_PATTERN_LIST}@{suffix}, @{BindingMapping.MEMBER_REGEX_LIST}@{suffix});
+ }
+ }
+ }
+}
+
@generateGetters(addOverride: Boolean) = {
@if(!getterMethods.isEmpty) {
@for(property <- getterMethods) {
@if(addOverride) {@@Override}
public <E extends @{importedNames.get("augmentation")}<? super @{genType.getName}>> E get@{toFirstUpper(augmentField.getName)}
(@{importedNames.get("class")}<E> augmentationType) {
- if (augmentationType == null) {
- throw new IllegalArgumentException("Augmentation Type reference cannot be NULL!");
- }
- return (E) @{augmentField.getName}.get(augmentationType);
+ return (E) @{augmentField.getName}.get(@{importedNames.get("codeHelpers")}.nonNullValue(augmentationType, "augmentationType"));
}
}
}
}
@generateImplementedMethods() = {
+ @if(childTreeNodeIdent) {
@@Override
- public @{importedNames.get("item")}<@{genType.getParentType.getName}> treeIdentifier() {
- //TODO implement
- return null;
+ public @{importedNames.get("identifiableItem")}<@{genType.getName()}, @{keyTypeName}> treeIdentifier() {
+ return new @{importedNames.get("identifiableItem")}(@{importedNames.get("genType")}.class,_identifier);
}
+ } else {
+ @if(childTreeNode) {
+ @@Override
+ public @{importedNames.get("item")}<@{genType.getName()}> treeIdentifier() {
+ return new @{importedNames.get("item")}(@{importedNames.get("genType")}.class);
+ }
+ }
+ }
+ @if(augmentField != null) {
@@Override
public @{importedNames.get("classInstMap")}<@{importedNames.get("augmentation")}<? super @{genType.getName}>>
augments() {
//TODO implement
return null;
}
+ }
}
@generateEquals() = {
if (!(obj instanceof @{importedNames.get("treeNode")})) {
return false;
}
+ @if(parentTypeForBuilderName != null) {
if (!(obj instanceof @{importedNames.get("instantiable")})) {
return false;
}
.implementedInterface())) {
return false;
}
+ }
@{importedNames.get("genType")} other = (@{importedNames.get("genType")})obj;
@for(property <- properties) {
@if(property.getReturnType.getName.contains("[")) {
return true;
}
}
-}
\ No newline at end of file
+}
Code Review / mdsal.git / blobdiff