*/
List<GeneratedProperty> getProperties();
+ /**
+ * Returns parent type for data schema node builder
+ */
+ Type getParentTypeForBuilder();
}
import com.google.common.annotations.Beta;
import java.util.List;
-import org.opendaylight.mdsal.binding.javav2.model.api.Type;
import org.opendaylight.mdsal.binding.javav2.model.api.Constant;
+import org.opendaylight.mdsal.binding.javav2.model.api.Type;
import org.opendaylight.yangtools.yang.common.QName;
@Beta
*/
EnumBuilder addEnumeration(String name);
+ /**
+ * Sets parent type for data schema node node builder
+ *
+ * @param type generated parent type
+ * @return generated type
+ */
+ Type setParentTypeForBuilder(Type type);
+
List<MethodSignatureBuilder> getMethodDefinitions();
/**
genType.setModuleName(module.getName());
genType.setReference(node.getReference());
genType.setSchemaPath((List) node.getPath().getPathFromRoot());
+ genType.setParentTypeForBuilder(childOf);
if (node instanceof DataNodeContainer) {
genCtx.get(module).addChildNodeType(node, genType);
genCtx = groupingsToGenTypes(module, ((DataNodeContainer) node).getGroupings(), genCtx, schemaContext,
abstract class AbstractGeneratedType extends AbstractBaseType implements GeneratedType {
private final Type parent;
+ private final Type parentTypeForBuilder;
private final String comment;
private final List<AnnotationType> annotations;
private final List<Type> implementsTypes;
public AbstractGeneratedType(final AbstractGeneratedTypeBuilder<?> builder) {
super(builder.getPackageName(), builder.getName(), true);
this.parent = builder.getParent();
+ this.parentTypeForBuilder = builder.getParentTypeForBuilder();
this.comment = builder.getComment();
this.annotations = toUnmodifiableAnnotations(builder.getAnnotations());
this.implementsTypes = makeUnmodifiable(builder.getImplementsTypes());
final List<Type> implementsTypes, final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
final List<GeneratedTOBuilder> enclosedGenTOBuilders, final List<EnumBuilder> enumBuilders,
final List<Constant> constants, final List<MethodSignatureBuilder> methodBuilders,
- final List<GeneratedPropertyBuilder> propertyBuilders) {
+ final List<GeneratedPropertyBuilder> propertyBuilders, final Type parentTypeForBuilder) {
super(packageName, name);
this.parent = parent;
+ this.parentTypeForBuilder = parentTypeForBuilder;
this.comment = comment;
this.annotations = toUnmodifiableAnnotations(annotationBuilders);
this.implementsTypes = makeUnmodifiable(implementsTypes);
return this.parent;
}
+ @Override
+ public Type getParentTypeForBuilder() {
+ return this.parentTypeForBuilder;
+ }
+
@Override
public String getComment() {
return this.comment;
private List<GeneratedPropertyBuilder> properties = ImmutableList.of();
private String comment = "";
private boolean isAbstract;
+ private Type parentTypeForBuilder;
protected AbstractGeneratedTypeBuilder(final String packageName, final String name) {
super(packageName, name);
return constant;
}
+ @Override
+ public Type setParentTypeForBuilder(Type type) {
+ return this.parentTypeForBuilder = type;
+ }
+
public boolean containsConstant(final String name) {
Preconditions.checkArgument(name != null, "Parameter name can't be null");
for (Constant constant : constants) {
return null;
}
+ public Type getParentTypeForBuilder() {
+ return parentTypeForBuilder;
+ }
+
@Override
public List<GeneratedPropertyBuilder> getProperties() {
return properties;
public List<GeneratedProperty> getProperties() {
return ImmutableList.of();
}
+
+ @Override
+ public Type getParentTypeForBuilder() {
+ return null;
+ }
}
}
@Override
protected String body() {
+ String parentTypeForBuilderName;
importedNames.put("genType", importedName(getType()));
importedNames.put("objects", importedName(Objects.class));
importedNames.put("object", importedName(Object.class));
importedNames.put("item", importedName(Item.class));
if (getType().getParentType() != null) {
importedNames.put("parent", importedName(getType().getParentType()));
+ parentTypeForBuilderName = getType().getParentType().getName();
} else {
- //TODO implement - get module as type
+ importedNames.put("parentTypeForBuilder", importedName(getType().getParentTypeForBuilder()));
+ parentTypeForBuilderName = getType().getParentTypeForBuilder().getName();
}
importedNames.put("augmentation", importedName(Augmentation.class));
importedNames.put("classInstMap", importedName(ClassToInstanceMap.class));
List<String> getterMethods = new ArrayList<>(Collections2.transform(properties, this::getterMethod));
return builderTemplate.render(getType(), properties, importedNames, importedNamesForProperties, augmentField,
- copyConstructorHelper, getterMethods)
+ copyConstructorHelper, getterMethods, parentTypeForBuilderName)
.body();
}
@(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)
@if(genType != null) {
@{wrapToDocumentation(formatDataForJavaDocBuilder(importedNames.get("genType")))}
public class @{genType.getName}Builder implements @{getSimpleNameForBuilder} <@{importedNames.get("genType")}> {
@generateImplementedMethods() = {
@@Override
- public @{importedNames.get("item")}<@{genType.getParentType.getName}> treeIdentifier() {
+ public @{importedNames.get("item")}<@{parentTypeForBuilderName}> treeIdentifier() {
//TODO implement
return null;
}