2 * Copyright (c) 2016 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
9 package org.opendaylight.mdsal.binding2.generator.util.generated.type.builder;
11 import com.google.common.annotations.Beta;
12 import com.google.common.collect.ImmutableList;
13 import java.util.ArrayList;
14 import java.util.Collections;
15 import java.util.List;
16 import java.util.stream.Collectors;
17 import org.opendaylight.mdsal.binding2.generator.util.AbstractBaseType;
18 import org.opendaylight.mdsal.binding2.model.api.AnnotationType;
19 import org.opendaylight.mdsal.binding2.model.api.Constant;
20 import org.opendaylight.mdsal.binding2.model.api.Enumeration;
21 import org.opendaylight.mdsal.binding2.model.api.GeneratedProperty;
22 import org.opendaylight.mdsal.binding2.model.api.GeneratedType;
23 import org.opendaylight.mdsal.binding2.model.api.MethodSignature;
24 import org.opendaylight.mdsal.binding2.model.api.Type;
25 import org.opendaylight.mdsal.binding2.model.api.type.builder.AnnotationTypeBuilder;
26 import org.opendaylight.mdsal.binding2.model.api.type.builder.EnumBuilder;
27 import org.opendaylight.mdsal.binding2.model.api.type.builder.GeneratedPropertyBuilder;
28 import org.opendaylight.mdsal.binding2.model.api.type.builder.GeneratedTOBuilder;
29 import org.opendaylight.mdsal.binding2.model.api.type.builder.GeneratedTypeBuilder;
30 import org.opendaylight.mdsal.binding2.model.api.type.builder.MethodSignatureBuilder;
33 abstract class AbstractGeneratedType extends AbstractBaseType implements GeneratedType {
35 private final Type parent;
36 private final String 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;
46 public AbstractGeneratedType(final AbstractGeneratedTypeBuilder<?> builder) {
47 super(builder.getPackageName(), builder.getName());
48 this.parent = builder.getParent();
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 = toUnmodifiableEnumerations(builder.getEnumerations());
54 this.methodSignatures = toUnmodifiableMethods(builder.getMethodDefinitions());
55 this.enclosedTypes = toUnmodifiableEnclosedTypes(builder.getEnclosedTypes(),
56 builder.getEnclosedTransferObjects());
57 this.properties = toUnmodifiableProperties(builder.getProperties());
58 this.isAbstract = builder.isAbstract();
61 public AbstractGeneratedType(final Type parent, final String packageName, final String name, final String 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) {
67 super(packageName, name);
69 this.comment = comment;
70 this.annotations = toUnmodifiableAnnotations(annotationBuilders);
71 this.implementsTypes = makeUnmodifiable(implementsTypes);
72 this.constants = makeUnmodifiable(constants);
73 this.enumerations = toUnmodifiableEnumerations(enumBuilders);
74 this.methodSignatures = toUnmodifiableMethods(methodBuilders);
75 this.enclosedTypes = toUnmodifiableEnclosedTypes(enclosedGenTypeBuilders, enclosedGenTOBuilders);
76 this.properties = toUnmodifiableProperties(propertyBuilders);
77 this.isAbstract = isAbstract;
80 protected static final <T> List<T> makeUnmodifiable(final List<T> list) {
81 switch (list.size()) {
83 return ImmutableList.of();
85 return Collections.singletonList(list.get(0));
87 return Collections.unmodifiableList(list);
91 private static List<GeneratedType> toUnmodifiableEnclosedTypes(final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
92 final List<GeneratedTOBuilder> enclosedGenTOBuilders) {
93 final ArrayList<GeneratedType> enclosedTypesList = new ArrayList<>(enclosedGenTypeBuilders.size() + enclosedGenTOBuilders.size());
94 enclosedTypesList.addAll(enclosedGenTypeBuilders.stream().filter(builder -> builder != null).map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
96 enclosedTypesList.addAll(enclosedGenTOBuilders.stream().filter(builder -> builder != null).map(GeneratedTOBuilder::toInstance).collect(Collectors.toList()));
98 return makeUnmodifiable(enclosedTypesList);
101 protected static final List<AnnotationType> toUnmodifiableAnnotations(final List<AnnotationTypeBuilder> annotationBuilders) {
102 final List<AnnotationType> annotationList = new ArrayList<>(annotationBuilders.size());
103 annotationList.addAll(annotationBuilders.stream().map(AnnotationTypeBuilder::toInstance).collect(Collectors.toList()));
104 return makeUnmodifiable(annotationList);
107 protected final List<MethodSignature> toUnmodifiableMethods(final List<MethodSignatureBuilder> methodBuilders) {
108 final List<MethodSignature> methods = new ArrayList<>(methodBuilders.size());
109 methods.addAll(methodBuilders.stream().map(methodBuilder -> methodBuilder.toInstance(this)).collect(Collectors.toList()));
110 return makeUnmodifiable(methods);
113 protected final List<Enumeration> toUnmodifiableEnumerations(final List<EnumBuilder> enumBuilders) {
114 final List<Enumeration> enums = new ArrayList<>(enumBuilders.size());
115 enums.addAll(enumBuilders.stream().map(enumBuilder -> enumBuilder.toInstance(this)).collect(Collectors.toList()));
116 return makeUnmodifiable(enums);
119 protected final List<GeneratedProperty> toUnmodifiableProperties(final List<GeneratedPropertyBuilder> methodBuilders) {
120 final List<GeneratedProperty> methods = new ArrayList<>(methodBuilders.size());
121 methods.addAll(methodBuilders.stream().map(methodBuilder -> methodBuilder.toInstance(this)).collect(Collectors.toList()));
122 return makeUnmodifiable(methods);
126 public Type getParentType() {
131 public String getComment() {
136 public List<AnnotationType> getAnnotations() {
141 public boolean isAbstract() {
146 public List<Type> getImplements() {
147 return implementsTypes;
151 public List<GeneratedType> getEnclosedTypes() {
152 return enclosedTypes;
156 public List<Enumeration> getEnumerations() {
161 public List<Constant> getConstantDefinitions() {
166 public List<MethodSignature> getMethodDefinitions() {
167 return methodSignatures;
171 public List<GeneratedProperty> getProperties() {
176 public String toString() {
177 StringBuilder builder = new StringBuilder();
178 builder.append("GeneratedType [packageName=");
179 builder.append(getPackageName());
180 builder.append(", name=");
181 builder.append(getName());
182 if (parent != null) {
183 builder.append(", parent=");
184 builder.append(parent.getFullyQualifiedName());
186 builder.append(", parent=null");
188 builder.append(", comment=");
189 builder.append(comment);
190 builder.append(", annotations=");
191 builder.append(annotations);
192 builder.append(", enclosedTypes=");
193 builder.append(enclosedTypes);
194 builder.append(", enumerations=");
195 builder.append(enumerations);
196 builder.append(", constants=");
197 builder.append(constants);
198 builder.append(", methodSignatures=");
199 builder.append(methodSignatures);
201 return builder.toString();