2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.yangtools.binding.generator.util.generated.type.builder;
10 import org.opendaylight.yangtools.binding.generator.util.AbstractBaseType;
11 import org.opendaylight.yangtools.sal.binding.model.api.*;
12 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.*;
14 import java.util.ArrayList;
15 import java.util.Collections;
16 import java.util.List;
18 abstract class AbstractGeneratedType extends AbstractBaseType implements GeneratedType {
20 private final Type parent;
21 private final String comment;
22 private final List<AnnotationType> annotations;
23 private final List<Type> implementsTypes;
24 private final List<Enumeration> enumerations;
25 private final List<Constant> constants;
26 private final List<MethodSignature> methodSignatures;
27 private final List<GeneratedType> enclosedTypes;
28 private final List<GeneratedProperty> properties;
29 private final boolean isAbstract;
31 public AbstractGeneratedType(AbstractGeneratedTypeBuilder builder) {
32 super(builder.getPackageName(), builder.getName());
33 this.parent = builder.getParent();
34 this.comment = builder.getComment();
35 this.annotations = toUnmodifiableAnnotations(builder.getAnnotations());
36 this.implementsTypes = Collections.unmodifiableList(builder.getImplementsTypes());
37 this.constants = Collections.unmodifiableList(builder.getConstants());
38 this.enumerations = toUnmodifiableEnumerations(builder.getEnumerations());
39 this.methodSignatures = toUnmodifiableMethods(builder.getMethodDefinitions());
40 this.enclosedTypes = toUnmodifiableEnclosedTypes(builder.getEnclosedTypes(),
41 builder.getEnclosedTransferObjects());
42 this.properties = toUnmodifiableProperties(builder.getProperties());
43 this.isAbstract = builder.isAbstract();
46 public AbstractGeneratedType(final Type parent, final String packageName, final String name, final String comment,
47 final List<AnnotationTypeBuilder> annotationBuilders, final boolean isAbstract,
48 final List<Type> implementsTypes, final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
49 final List<GeneratedTOBuilder> enclosedGenTOBuilders, final List<EnumBuilder> enumBuilders,
50 final List<Constant> constants, final List<MethodSignatureBuilder> methodBuilders,
51 final List<GeneratedPropertyBuilder> propertyBuilders) {
52 super(packageName, name);
54 this.comment = comment;
55 this.annotations = toUnmodifiableAnnotations(annotationBuilders);
56 this.implementsTypes = Collections.unmodifiableList(implementsTypes);
57 this.constants = Collections.unmodifiableList(constants);
58 this.enumerations = toUnmodifiableEnumerations(enumBuilders);
59 this.methodSignatures = toUnmodifiableMethods(methodBuilders);
60 this.enclosedTypes = toUnmodifiableEnclosedTypes(enclosedGenTypeBuilders, enclosedGenTOBuilders);
61 this.properties = toUnmodifiableProperties(propertyBuilders);
62 this.isAbstract = isAbstract;
66 private List<GeneratedType> toUnmodifiableEnclosedTypes(final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
67 final List<GeneratedTOBuilder> enclosedGenTOBuilders) {
68 final List<GeneratedType> enclosedTypes = new ArrayList<>();
69 for (final GeneratedTypeBuilder builder : enclosedGenTypeBuilders) {
70 if (builder != null) {
71 enclosedTypes.add(builder.toInstance());
75 for (final GeneratedTOBuilder builder : enclosedGenTOBuilders) {
76 if (builder != null) {
77 enclosedTypes.add(builder.toInstance());
83 protected final List<AnnotationType> toUnmodifiableAnnotations(final List<AnnotationTypeBuilder> annotationBuilders) {
84 final List<AnnotationType> annotationList = new ArrayList<>();
85 for (final AnnotationTypeBuilder builder : annotationBuilders) {
86 annotationList.add(builder.toInstance());
88 return Collections.unmodifiableList(annotationList);
91 protected final List<MethodSignature> toUnmodifiableMethods(List<MethodSignatureBuilder> methodBuilders) {
92 final List<MethodSignature> methods = new ArrayList<>();
93 for (final MethodSignatureBuilder methodBuilder : methodBuilders) {
94 methods.add(methodBuilder.toInstance(this));
96 return Collections.unmodifiableList(methods);
99 protected final List<Enumeration> toUnmodifiableEnumerations(List<EnumBuilder> enumBuilders) {
100 final List<Enumeration> enums = new ArrayList<>();
101 for (final EnumBuilder enumBuilder : enumBuilders) {
102 enums.add(enumBuilder.toInstance(this));
104 return Collections.unmodifiableList(enums);
107 protected final List<GeneratedProperty> toUnmodifiableProperties(List<GeneratedPropertyBuilder> methodBuilders) {
108 final List<GeneratedProperty> methods = new ArrayList<>();
109 for (final GeneratedPropertyBuilder methodBuilder : methodBuilders) {
110 methods.add(methodBuilder.toInstance(this));
112 return Collections.unmodifiableList(methods);
116 public final Type getParentType() {
121 public final String getComment() {
126 public final List<AnnotationType> getAnnotations() {
131 public final boolean isAbstract() {
136 public final List<Type> getImplements() {
137 return implementsTypes;
141 public final List<GeneratedType> getEnclosedTypes() {
142 return enclosedTypes;
146 public final List<Enumeration> getEnumerations() {
151 public final List<Constant> getConstantDefinitions() {
156 public final List<MethodSignature> getMethodDefinitions() {
157 return methodSignatures;
160 public final List<GeneratedProperty> getProperties() {
165 public String toString() {
166 StringBuilder builder = new StringBuilder();
167 builder.append("GeneratedType [packageName=");
168 builder.append(getPackageName());
169 builder.append(", name=");
170 builder.append(getName());
171 if (parent != null) {
172 builder.append(", parent=");
173 builder.append(parent.getFullyQualifiedName());
175 builder.append(", parent=null");
177 builder.append(", comment=");
178 builder.append(comment);
179 builder.append(", annotations=");
180 builder.append(annotations);
181 builder.append(", enclosedTypes=");
182 builder.append(enclosedTypes);
183 builder.append(", enumerations=");
184 builder.append(enumerations);
185 builder.append(", constants=");
186 builder.append(constants);
187 builder.append(", methodSignatures=");
188 builder.append(methodSignatures);
190 return builder.toString();