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 com.google.common.base.MoreObjects.ToStringHelper;
11 import java.util.ArrayList;
12 import java.util.Collections;
13 import java.util.HashSet;
14 import java.util.List;
15 import java.util.Optional;
17 import org.opendaylight.mdsal.binding.model.api.AbstractType;
18 import org.opendaylight.mdsal.binding.model.api.AnnotationType;
19 import org.opendaylight.mdsal.binding.model.api.Constant;
20 import org.opendaylight.mdsal.binding.model.api.Enumeration;
21 import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
22 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
23 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
24 import org.opendaylight.mdsal.binding.model.api.MethodSignature;
25 import org.opendaylight.mdsal.binding.model.api.Type;
26 import org.opendaylight.mdsal.binding.model.api.TypeComment;
27 import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
28 import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
29 import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
30 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
31 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
32 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
33 import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
35 abstract class AbstractGeneratedType extends AbstractType implements GeneratedType {
36 private final TypeComment comment;
37 private final List<AnnotationType> annotations;
38 private final List<Type> implementsTypes;
39 private final List<Enumeration> enumerations;
40 private final List<Constant> constants;
41 private final List<MethodSignature> methodSignatures;
42 private final List<GeneratedType> enclosedTypes;
43 private final List<GeneratedProperty> properties;
44 private final boolean isAbstract;
45 private final YangSourceDefinition definition;
47 AbstractGeneratedType(final AbstractGeneratedTypeBuilder<?> builder) {
48 super(builder.getIdentifier());
49 this.comment = builder.getComment();
50 this.annotations = toUnmodifiableAnnotations(builder.getAnnotations());
51 this.implementsTypes = makeUnmodifiable(builder.getImplementsTypes());
52 this.constants = makeUnmodifiable(builder.getConstants());
53 this.enumerations = List.copyOf(builder.getEnumerations());
54 this.methodSignatures = toUnmodifiableMethods(builder.getMethodDefinitions());
55 this.enclosedTypes = List.copyOf(builder.getEnclosedTransferObjects());
56 this.properties = toUnmodifiableProperties(builder.getProperties());
57 this.isAbstract = builder.isAbstract();
58 this.definition = builder.getYangSourceDefinition().orElse(null);
61 AbstractGeneratedType(final JavaTypeName identifier, final TypeComment comment,
62 final List<AnnotationTypeBuilder> annotationBuilders, final boolean isAbstract,
63 final List<Type> implementsTypes, final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
64 final List<GeneratedTOBuilder> enclosedGenTOBuilders, final List<EnumBuilder> enumBuilders,
65 final List<Constant> constants, final List<MethodSignatureBuilder> methodBuilders,
66 final List<GeneratedPropertyBuilder> propertyBuilders) {
68 this.comment = comment;
69 this.annotations = toUnmodifiableAnnotations(annotationBuilders);
70 this.implementsTypes = makeUnmodifiable(implementsTypes);
71 this.constants = makeUnmodifiable(constants);
72 this.enumerations = toUnmodifiableEnumerations(enumBuilders);
73 this.methodSignatures = toUnmodifiableMethods(methodBuilders);
74 this.enclosedTypes = toUnmodifiableEnclosedTypes(enclosedGenTypeBuilders, enclosedGenTOBuilders);
75 this.properties = toUnmodifiableProperties(propertyBuilders);
76 this.isAbstract = isAbstract;
77 this.definition = null;
80 protected static final <T> List<T> makeUnmodifiable(final List<T> list) {
81 switch (list.size()) {
83 return Collections.emptyList();
85 return Collections.singletonList(list.get(0));
87 return Collections.unmodifiableList(list);
91 protected static <T> Set<T> makeUnmodifiable(final Set<T> set) {
94 return Collections.emptySet();
96 return Collections.singleton(set.iterator().next());
98 return Collections.unmodifiableSet(set);
102 private static List<GeneratedType> toUnmodifiableEnclosedTypes(
103 final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
104 final List<GeneratedTOBuilder> enclosedGenTOBuilders) {
105 final ArrayList<GeneratedType> enclosedTypesList = new ArrayList<>(enclosedGenTypeBuilders.size()
106 + enclosedGenTOBuilders.size());
107 for (final GeneratedTypeBuilder builder : enclosedGenTypeBuilders) {
108 if (builder != null) {
109 enclosedTypesList.add(builder.build());
113 for (final GeneratedTOBuilder builder : enclosedGenTOBuilders) {
114 if (builder != null) {
115 enclosedTypesList.add(builder.build());
119 return makeUnmodifiable(enclosedTypesList);
122 protected static final List<AnnotationType> toUnmodifiableAnnotations(
123 final List<AnnotationTypeBuilder> annotationBuilders) {
124 final List<AnnotationType> annotationList = new ArrayList<>(annotationBuilders.size());
125 for (final AnnotationTypeBuilder builder : annotationBuilders) {
126 annotationList.add(builder.build());
128 return makeUnmodifiable(annotationList);
131 protected final List<MethodSignature> toUnmodifiableMethods(final List<MethodSignatureBuilder> methodBuilders) {
132 final List<MethodSignature> methods = new ArrayList<>(methodBuilders.size());
133 for (final MethodSignatureBuilder methodBuilder : methodBuilders) {
134 methods.add(methodBuilder.toInstance(this));
136 return makeUnmodifiable(methods);
139 protected final Set<MethodSignature> toUnmodifiableMethods(final Set<MethodSignatureBuilder> getters) {
140 final Set<MethodSignature> methods = new HashSet<>(getters.size());
141 for (final MethodSignatureBuilder methodBuilder : getters) {
142 methods.add(methodBuilder.toInstance(this));
144 return makeUnmodifiable(methods);
147 protected final List<Enumeration> toUnmodifiableEnumerations(final List<EnumBuilder> enumBuilders) {
148 final List<Enumeration> enums = new ArrayList<>(enumBuilders.size());
149 for (final EnumBuilder enumBuilder : enumBuilders) {
150 enums.add(enumBuilder.toInstance());
152 return makeUnmodifiable(enums);
155 protected final List<GeneratedProperty> toUnmodifiableProperties(
156 final List<GeneratedPropertyBuilder> methodBuilders) {
157 final List<GeneratedProperty> methods = new ArrayList<>(methodBuilders.size());
158 for (final GeneratedPropertyBuilder methodBuilder : methodBuilders) {
159 methods.add(methodBuilder.toInstance());
161 return makeUnmodifiable(methods);
165 public final TypeComment getComment() {
170 public final List<AnnotationType> getAnnotations() {
171 return this.annotations;
175 public final boolean isAbstract() {
176 return this.isAbstract;
180 public final List<Type> getImplements() {
181 return this.implementsTypes;
185 public final List<GeneratedType> getEnclosedTypes() {
186 return this.enclosedTypes;
190 public final List<Enumeration> getEnumerations() {
191 return this.enumerations;
195 public final List<Constant> getConstantDefinitions() {
196 return this.constants;
200 public final List<MethodSignature> getMethodDefinitions() {
201 return this.methodSignatures;
205 public final List<GeneratedProperty> getProperties() {
206 return this.properties;
210 public final Optional<YangSourceDefinition> getYangSourceDefinition() {
211 return Optional.ofNullable(definition);
215 protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
216 return super.addToStringAttributes(toStringHelper)
218 .add("comment", comment)
219 .add("annotations", annotations)
220 .add("enclosedTypes", enclosedTypes)
221 .add("enumerations", enumerations)
222 .add("constants", constants)
223 .add("methodSignatures", methodSignatures);