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 java.util.ArrayList;
11 import java.util.Collections;
12 import java.util.List;
14 import org.opendaylight.yangtools.binding.generator.util.AbstractBaseType;
15 import org.opendaylight.yangtools.sal.binding.model.api.AnnotationType;
16 import org.opendaylight.yangtools.sal.binding.model.api.Constant;
17 import org.opendaylight.yangtools.sal.binding.model.api.Enumeration;
18 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedProperty;
19 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;
20 import org.opendaylight.yangtools.sal.binding.model.api.MethodSignature;
21 import org.opendaylight.yangtools.sal.binding.model.api.Type;
22 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.AnnotationTypeBuilder;
23 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.EnumBuilder;
24 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedPropertyBuilder;
25 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;
26 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder;
27 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.MethodSignatureBuilder;
29 abstract class AbstractGeneratedType extends AbstractBaseType implements GeneratedType {
31 private final Type parent;
32 private final String comment;
33 private final List<AnnotationType> annotations;
34 private final List<Type> implementsTypes;
35 private final List<Enumeration> enumerations;
36 private final List<Constant> constants;
37 private final List<MethodSignature> methodSignatures;
38 private final List<GeneratedType> enclosedTypes;
39 private final List<GeneratedProperty> properties;
40 private final boolean isAbstract;
42 public AbstractGeneratedType(AbstractGeneratedTypeBuilder<?> builder) {
43 super(builder.getPackageName(), builder.getName());
44 this.parent = builder.getParent();
45 this.comment = builder.getComment();
46 this.annotations = toUnmodifiableAnnotations(builder.getAnnotations());
47 this.implementsTypes = Collections.unmodifiableList(builder.getImplementsTypes());
48 this.constants = Collections.unmodifiableList(builder.getConstants());
49 this.enumerations = toUnmodifiableEnumerations(builder.getEnumerations());
50 this.methodSignatures = toUnmodifiableMethods(builder.getMethodDefinitions());
51 this.enclosedTypes = toUnmodifiableEnclosedTypes(builder.getEnclosedTypes(),
52 builder.getEnclosedTransferObjects());
53 this.properties = toUnmodifiableProperties(builder.getProperties());
54 this.isAbstract = builder.isAbstract();
57 public AbstractGeneratedType(final Type parent, final String packageName, final String name, final String comment,
58 final List<AnnotationTypeBuilder> annotationBuilders, final boolean isAbstract,
59 final List<Type> implementsTypes, final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
60 final List<GeneratedTOBuilder> enclosedGenTOBuilders, final List<EnumBuilder> enumBuilders,
61 final List<Constant> constants, final List<MethodSignatureBuilder> methodBuilders,
62 final List<GeneratedPropertyBuilder> propertyBuilders) {
63 super(packageName, name);
65 this.comment = comment;
66 this.annotations = toUnmodifiableAnnotations(annotationBuilders);
67 this.implementsTypes = Collections.unmodifiableList(implementsTypes);
68 this.constants = Collections.unmodifiableList(constants);
69 this.enumerations = toUnmodifiableEnumerations(enumBuilders);
70 this.methodSignatures = toUnmodifiableMethods(methodBuilders);
71 this.enclosedTypes = toUnmodifiableEnclosedTypes(enclosedGenTypeBuilders, enclosedGenTOBuilders);
72 this.properties = toUnmodifiableProperties(propertyBuilders);
73 this.isAbstract = isAbstract;
77 private List<GeneratedType> toUnmodifiableEnclosedTypes(final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
78 final List<GeneratedTOBuilder> enclosedGenTOBuilders) {
79 final List<GeneratedType> enclosedTypesList = new ArrayList<>();
80 for (final GeneratedTypeBuilder builder : enclosedGenTypeBuilders) {
81 if (builder != null) {
82 enclosedTypesList.add(builder.toInstance());
86 for (final GeneratedTOBuilder builder : enclosedGenTOBuilders) {
87 if (builder != null) {
88 enclosedTypesList.add(builder.toInstance());
91 return enclosedTypesList;
94 protected final List<AnnotationType> toUnmodifiableAnnotations(final List<AnnotationTypeBuilder> annotationBuilders) {
95 final List<AnnotationType> annotationList = new ArrayList<>();
96 for (final AnnotationTypeBuilder builder : annotationBuilders) {
97 annotationList.add(builder.toInstance());
99 return Collections.unmodifiableList(annotationList);
102 protected final List<MethodSignature> toUnmodifiableMethods(List<MethodSignatureBuilder> methodBuilders) {
103 final List<MethodSignature> methods = new ArrayList<>();
104 for (final MethodSignatureBuilder methodBuilder : methodBuilders) {
105 methods.add(methodBuilder.toInstance(this));
107 return Collections.unmodifiableList(methods);
110 protected final List<Enumeration> toUnmodifiableEnumerations(List<EnumBuilder> enumBuilders) {
111 final List<Enumeration> enums = new ArrayList<>();
112 for (final EnumBuilder enumBuilder : enumBuilders) {
113 enums.add(enumBuilder.toInstance(this));
115 return Collections.unmodifiableList(enums);
118 protected final List<GeneratedProperty> toUnmodifiableProperties(List<GeneratedPropertyBuilder> methodBuilders) {
119 final List<GeneratedProperty> methods = new ArrayList<>();
120 for (final GeneratedPropertyBuilder methodBuilder : methodBuilders) {
121 methods.add(methodBuilder.toInstance(this));
123 return Collections.unmodifiableList(methods);
127 public final Type getParentType() {
132 public final String getComment() {
137 public final List<AnnotationType> getAnnotations() {
142 public final boolean isAbstract() {
147 public final List<Type> getImplements() {
148 return implementsTypes;
152 public final List<GeneratedType> getEnclosedTypes() {
153 return enclosedTypes;
157 public final List<Enumeration> getEnumerations() {
162 public final List<Constant> getConstantDefinitions() {
167 public final List<MethodSignature> getMethodDefinitions() {
168 return methodSignatures;
172 public final List<GeneratedProperty> getProperties() {
177 public String toString() {
178 StringBuilder builder = new StringBuilder();
179 builder.append("GeneratedType [packageName=");
180 builder.append(getPackageName());
181 builder.append(", name=");
182 builder.append(getName());
183 if (parent != null) {
184 builder.append(", parent=");
185 builder.append(parent.getFullyQualifiedName());
187 builder.append(", parent=null");
189 builder.append(", comment=");
190 builder.append(comment);
191 builder.append(", annotations=");
192 builder.append(annotations);
193 builder.append(", enclosedTypes=");
194 builder.append(enclosedTypes);
195 builder.append(", enumerations=");
196 builder.append(enumerations);
197 builder.append(", constants=");
198 builder.append(constants);
199 builder.append(", methodSignatures=");
200 builder.append(methodSignatures);
202 return builder.toString();