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.mdsal.binding.generator.util.generated.type.builder;
10 import java.util.ArrayList;
11 import java.util.Collections;
12 import java.util.List;
13 import org.opendaylight.mdsal.binding.generator.util.AbstractBaseType;
14 import org.opendaylight.mdsal.binding.model.api.AnnotationType;
15 import org.opendaylight.mdsal.binding.model.api.Constant;
16 import org.opendaylight.mdsal.binding.model.api.Enumeration;
17 import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
18 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
19 import org.opendaylight.mdsal.binding.model.api.MethodSignature;
20 import org.opendaylight.mdsal.binding.model.api.Type;
21 import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
22 import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
23 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
24 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
25 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
26 import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
28 abstract class AbstractGeneratedType extends AbstractBaseType implements GeneratedType {
30 private final Type parent;
31 private final String comment;
32 private final List<AnnotationType> annotations;
33 private final List<Type> implementsTypes;
34 private final List<Enumeration> enumerations;
35 private final List<Constant> constants;
36 private final List<MethodSignature> methodSignatures;
37 private final List<GeneratedType> enclosedTypes;
38 private final List<GeneratedProperty> properties;
39 private final boolean isAbstract;
41 public AbstractGeneratedType(final AbstractGeneratedTypeBuilder<?> builder) {
42 super(builder.getPackageName(), builder.getName());
43 this.parent = builder.getParent();
44 this.comment = builder.getComment();
45 this.annotations = toUnmodifiableAnnotations(builder.getAnnotations());
46 this.implementsTypes = makeUnmodifiable(builder.getImplementsTypes());
47 this.constants = makeUnmodifiable(builder.getConstants());
48 this.enumerations = toUnmodifiableEnumerations(builder.getEnumerations());
49 this.methodSignatures = toUnmodifiableMethods(builder.getMethodDefinitions());
50 this.enclosedTypes = toUnmodifiableEnclosedTypes(builder.getEnclosedTypes(),
51 builder.getEnclosedTransferObjects());
52 this.properties = toUnmodifiableProperties(builder.getProperties());
53 this.isAbstract = builder.isAbstract();
56 public AbstractGeneratedType(final Type parent, final String packageName, final String name, final String comment,
57 final List<AnnotationTypeBuilder> annotationBuilders, final boolean isAbstract,
58 final List<Type> implementsTypes, final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
59 final List<GeneratedTOBuilder> enclosedGenTOBuilders, final List<EnumBuilder> enumBuilders,
60 final List<Constant> constants, final List<MethodSignatureBuilder> methodBuilders,
61 final List<GeneratedPropertyBuilder> propertyBuilders) {
62 super(packageName, name);
64 this.comment = comment;
65 this.annotations = toUnmodifiableAnnotations(annotationBuilders);
66 this.implementsTypes = makeUnmodifiable(implementsTypes);
67 this.constants = makeUnmodifiable(constants);
68 this.enumerations = toUnmodifiableEnumerations(enumBuilders);
69 this.methodSignatures = toUnmodifiableMethods(methodBuilders);
70 this.enclosedTypes = toUnmodifiableEnclosedTypes(enclosedGenTypeBuilders, enclosedGenTOBuilders);
71 this.properties = toUnmodifiableProperties(propertyBuilders);
72 this.isAbstract = isAbstract;
75 protected static final <T> List<T> makeUnmodifiable(final List<T> list) {
76 switch (list.size()) {
78 return Collections.emptyList();
80 return Collections.singletonList(list.get(0));
82 return Collections.unmodifiableList(list);
86 private static List<GeneratedType> toUnmodifiableEnclosedTypes(final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
87 final List<GeneratedTOBuilder> enclosedGenTOBuilders) {
88 final ArrayList<GeneratedType> enclosedTypesList = new ArrayList<>(enclosedGenTypeBuilders.size() + enclosedGenTOBuilders.size());
89 for (final GeneratedTypeBuilder builder : enclosedGenTypeBuilders) {
90 if (builder != null) {
91 enclosedTypesList.add(builder.toInstance());
95 for (final GeneratedTOBuilder builder : enclosedGenTOBuilders) {
96 if (builder != null) {
97 enclosedTypesList.add(builder.toInstance());
101 return makeUnmodifiable(enclosedTypesList);
104 protected static final List<AnnotationType> toUnmodifiableAnnotations(final List<AnnotationTypeBuilder> annotationBuilders) {
105 final List<AnnotationType> annotationList = new ArrayList<>(annotationBuilders.size());
106 for (final AnnotationTypeBuilder builder : annotationBuilders) {
107 annotationList.add(builder.toInstance());
109 return makeUnmodifiable(annotationList);
112 protected final List<MethodSignature> toUnmodifiableMethods(final List<MethodSignatureBuilder> methodBuilders) {
113 final List<MethodSignature> methods = new ArrayList<>(methodBuilders.size());
114 for (final MethodSignatureBuilder methodBuilder : methodBuilders) {
115 methods.add(methodBuilder.toInstance(this));
117 return makeUnmodifiable(methods);
120 protected final List<Enumeration> toUnmodifiableEnumerations(final List<EnumBuilder> enumBuilders) {
121 final List<Enumeration> enums = new ArrayList<>(enumBuilders.size());
122 for (final EnumBuilder enumBuilder : enumBuilders) {
123 enums.add(enumBuilder.toInstance(this));
125 return makeUnmodifiable(enums);
128 protected final List<GeneratedProperty> toUnmodifiableProperties(final List<GeneratedPropertyBuilder> methodBuilders) {
129 final List<GeneratedProperty> methods = new ArrayList<>(methodBuilders.size());
130 for (final GeneratedPropertyBuilder methodBuilder : methodBuilders) {
131 methods.add(methodBuilder.toInstance(this));
133 return makeUnmodifiable(methods);
137 public final Type getParentType() {
142 public final String getComment() {
147 public final List<AnnotationType> getAnnotations() {
148 return this.annotations;
152 public final boolean isAbstract() {
153 return this.isAbstract;
157 public final List<Type> getImplements() {
158 return this.implementsTypes;
162 public final List<GeneratedType> getEnclosedTypes() {
163 return this.enclosedTypes;
167 public final List<Enumeration> getEnumerations() {
168 return this.enumerations;
172 public final List<Constant> getConstantDefinitions() {
173 return this.constants;
177 public final List<MethodSignature> getMethodDefinitions() {
178 return this.methodSignatures;
182 public final List<GeneratedProperty> getProperties() {
183 return this.properties;
187 public String toString() {
188 final StringBuilder builder = new StringBuilder();
189 builder.append("GeneratedType [packageName=");
190 builder.append(getPackageName());
191 builder.append(", name=");
192 builder.append(getName());
193 if (this.parent != null) {
194 builder.append(", parent=");
195 builder.append(this.parent.getFullyQualifiedName());
197 builder.append(", parent=null");
199 builder.append(", comment=");
200 builder.append(this.comment);
201 builder.append(", annotations=");
202 builder.append(this.annotations);
203 builder.append(", enclosedTypes=");
204 builder.append(this.enclosedTypes);
205 builder.append(", enumerations=");
206 builder.append(this.enumerations);
207 builder.append(", constants=");
208 builder.append(this.constants);
209 builder.append(", methodSignatures=");
210 builder.append(this.methodSignatures);
212 return builder.toString();