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.model.util.generated.type.builder;
10 import java.util.ArrayList;
11 import java.util.Collections;
12 import java.util.HashSet;
13 import java.util.List;
14 import java.util.Optional;
16 import org.opendaylight.mdsal.binding.model.api.AbstractBaseType;
17 import org.opendaylight.mdsal.binding.model.api.AnnotationType;
18 import org.opendaylight.mdsal.binding.model.api.Constant;
19 import org.opendaylight.mdsal.binding.model.api.Enumeration;
20 import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
21 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
22 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
23 import org.opendaylight.mdsal.binding.model.api.MethodSignature;
24 import org.opendaylight.mdsal.binding.model.api.Type;
25 import org.opendaylight.mdsal.binding.model.api.TypeComment;
26 import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
27 import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
28 import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
29 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
30 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
31 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
32 import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
34 abstract class AbstractGeneratedType extends AbstractBaseType implements GeneratedType {
36 private final Type parent;
37 private final TypeComment comment;
38 private final List<AnnotationType> annotations;
39 private final List<Type> implementsTypes;
40 private final List<Enumeration> enumerations;
41 private final List<Constant> constants;
42 private final List<MethodSignature> methodSignatures;
43 private final List<GeneratedType> enclosedTypes;
44 private final List<GeneratedProperty> properties;
45 private final boolean isAbstract;
46 private final YangSourceDefinition definition;
48 AbstractGeneratedType(final AbstractGeneratedTypeBuilder<?> builder) {
49 super(builder.getIdentifier());
50 this.parent = builder.getParent();
51 this.comment = builder.getComment();
52 this.annotations = toUnmodifiableAnnotations(builder.getAnnotations());
53 this.implementsTypes = makeUnmodifiable(builder.getImplementsTypes());
54 this.constants = makeUnmodifiable(builder.getConstants());
55 this.enumerations = toUnmodifiableEnumerations(builder.getEnumerations());
56 this.methodSignatures = toUnmodifiableMethods(builder.getMethodDefinitions());
57 this.enclosedTypes = toUnmodifiableEnclosedTypes(builder.getEnclosedTypes(),
58 builder.getEnclosedTransferObjects());
59 this.properties = toUnmodifiableProperties(builder.getProperties());
60 this.isAbstract = builder.isAbstract();
61 this.definition = builder.getYangSourceDefinition().orElse(null);
64 AbstractGeneratedType(final Type parent, final JavaTypeName identifier, final TypeComment comment,
65 final List<AnnotationTypeBuilder> annotationBuilders, final boolean isAbstract,
66 final List<Type> implementsTypes, final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
67 final List<GeneratedTOBuilder> enclosedGenTOBuilders, final List<EnumBuilder> enumBuilders,
68 final List<Constant> constants, final List<MethodSignatureBuilder> methodBuilders,
69 final List<GeneratedPropertyBuilder> propertyBuilders) {
72 this.comment = comment;
73 this.annotations = toUnmodifiableAnnotations(annotationBuilders);
74 this.implementsTypes = makeUnmodifiable(implementsTypes);
75 this.constants = makeUnmodifiable(constants);
76 this.enumerations = toUnmodifiableEnumerations(enumBuilders);
77 this.methodSignatures = toUnmodifiableMethods(methodBuilders);
78 this.enclosedTypes = toUnmodifiableEnclosedTypes(enclosedGenTypeBuilders, enclosedGenTOBuilders);
79 this.properties = toUnmodifiableProperties(propertyBuilders);
80 this.isAbstract = isAbstract;
81 this.definition = null;
84 protected static final <T> List<T> makeUnmodifiable(final List<T> list) {
85 switch (list.size()) {
87 return Collections.emptyList();
89 return Collections.singletonList(list.get(0));
91 return Collections.unmodifiableList(list);
95 protected static <T> Set<T> makeUnmodifiable(final Set<T> set) {
98 return Collections.emptySet();
100 return Collections.singleton(set.iterator().next());
102 return Collections.unmodifiableSet(set);
106 private static List<GeneratedType> toUnmodifiableEnclosedTypes(
107 final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
108 final List<GeneratedTOBuilder> enclosedGenTOBuilders) {
109 final ArrayList<GeneratedType> enclosedTypesList = new ArrayList<>(enclosedGenTypeBuilders.size()
110 + enclosedGenTOBuilders.size());
111 for (final GeneratedTypeBuilder builder : enclosedGenTypeBuilders) {
112 if (builder != null) {
113 enclosedTypesList.add(builder.build());
117 for (final GeneratedTOBuilder builder : enclosedGenTOBuilders) {
118 if (builder != null) {
119 enclosedTypesList.add(builder.build());
123 return makeUnmodifiable(enclosedTypesList);
126 protected static final List<AnnotationType> toUnmodifiableAnnotations(
127 final List<AnnotationTypeBuilder> annotationBuilders) {
128 final List<AnnotationType> annotationList = new ArrayList<>(annotationBuilders.size());
129 for (final AnnotationTypeBuilder builder : annotationBuilders) {
130 annotationList.add(builder.build());
132 return makeUnmodifiable(annotationList);
135 protected final List<MethodSignature> toUnmodifiableMethods(final List<MethodSignatureBuilder> methodBuilders) {
136 final List<MethodSignature> methods = new ArrayList<>(methodBuilders.size());
137 for (final MethodSignatureBuilder methodBuilder : methodBuilders) {
138 methods.add(methodBuilder.toInstance(this));
140 return makeUnmodifiable(methods);
143 protected final Set<MethodSignature> toUnmodifiableMethods(final Set<MethodSignatureBuilder> getters) {
144 final Set<MethodSignature> methods = new HashSet<>(getters.size());
145 for (final MethodSignatureBuilder methodBuilder : getters) {
146 methods.add(methodBuilder.toInstance(this));
148 return makeUnmodifiable(methods);
151 protected final List<Enumeration> toUnmodifiableEnumerations(final List<EnumBuilder> enumBuilders) {
152 final List<Enumeration> enums = new ArrayList<>(enumBuilders.size());
153 for (final EnumBuilder enumBuilder : enumBuilders) {
154 enums.add(enumBuilder.toInstance(this));
156 return makeUnmodifiable(enums);
159 protected final List<GeneratedProperty> toUnmodifiableProperties(
160 final List<GeneratedPropertyBuilder> methodBuilders) {
161 final List<GeneratedProperty> methods = new ArrayList<>(methodBuilders.size());
162 for (final GeneratedPropertyBuilder methodBuilder : methodBuilders) {
163 methods.add(methodBuilder.toInstance(this));
165 return makeUnmodifiable(methods);
169 public final Type getParentType() {
174 public final TypeComment getComment() {
179 public final List<AnnotationType> getAnnotations() {
180 return this.annotations;
184 public final boolean isAbstract() {
185 return this.isAbstract;
189 public final List<Type> getImplements() {
190 return this.implementsTypes;
194 public final List<GeneratedType> getEnclosedTypes() {
195 return this.enclosedTypes;
199 public final List<Enumeration> getEnumerations() {
200 return this.enumerations;
204 public final List<Constant> getConstantDefinitions() {
205 return this.constants;
209 public final List<MethodSignature> getMethodDefinitions() {
210 return this.methodSignatures;
214 public final List<GeneratedProperty> getProperties() {
215 return this.properties;
219 public final Optional<YangSourceDefinition> getYangSourceDefinition() {
220 return Optional.ofNullable(definition);
224 public String toString() {
225 final StringBuilder builder = new StringBuilder();
226 builder.append("GeneratedType [packageName=");
227 builder.append(getPackageName());
228 builder.append(", name=");
229 builder.append(getName());
230 if (this.parent != null) {
231 builder.append(", parent=");
232 builder.append(this.parent.getFullyQualifiedName());
234 builder.append(", parent=null");
236 builder.append(", comment=");
237 builder.append(this.comment);
238 builder.append(", annotations=");
239 builder.append(this.annotations);
240 builder.append(", enclosedTypes=");
241 builder.append(this.enclosedTypes);
242 builder.append(", enumerations=");
243 builder.append(this.enumerations);
244 builder.append(", constants=");
245 builder.append(this.constants);
246 builder.append(", methodSignatures=");
247 builder.append(this.methodSignatures);
249 return builder.toString();