2 * Copyright (c) 2018 Pantheon Technologies, s.r.o. 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 static java.util.Objects.requireNonNull;
12 import com.google.common.annotations.VisibleForTesting;
13 import com.google.common.collect.ImmutableList;
14 import java.util.ArrayList;
15 import java.util.Collections;
16 import java.util.List;
18 import java.util.Objects;
19 import java.util.stream.Collectors;
20 import org.opendaylight.mdsal.binding.model.api.AnnotationType;
21 import org.opendaylight.mdsal.binding.model.api.Constant;
22 import org.opendaylight.mdsal.binding.model.api.Enumeration;
23 import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
24 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
25 import org.opendaylight.mdsal.binding.model.api.MethodSignature;
26 import org.opendaylight.mdsal.binding.model.api.Type;
27 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
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.util.AbstractBaseType;
31 import org.opendaylight.yangtools.util.LazyCollections;
32 import org.opendaylight.yangtools.yang.binding.BindingMapping;
33 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
34 import org.opendaylight.yangtools.yang.model.api.Status;
35 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
36 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
38 // FIXME: public because EnumBuilder does not have setters we are exposing
39 public abstract class AbstractEnumerationBuilder extends AbstractBaseType implements EnumBuilder {
40 private List<Enumeration.Pair> values = ImmutableList.of();
41 private List<AnnotationTypeBuilder> annotationBuilders = ImmutableList.of();
43 AbstractEnumerationBuilder(final JavaTypeName identifier) {
48 public final AnnotationTypeBuilder addAnnotation(final JavaTypeName identifier) {
49 final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(identifier);
50 if (!annotationBuilders.contains(builder)) {
51 annotationBuilders = LazyCollections.lazyAdd(annotationBuilders, builder);
58 final void addValue(final String name, final String mappedName, final int value, final Status status,
59 final String description, final String reference) {
60 values = LazyCollections.lazyAdd(values,
61 createEnumPair(name, mappedName, value, status, description, reference));
64 public abstract void setReference(String reference);
66 public abstract void setModuleName(String moduleName);
68 public abstract void setSchemaPath(SchemaPath schemaPath);
70 abstract AbstractPair createEnumPair(String name, String mappedName, int value, Status status, String description,
71 final String reference);
76 * @see java.lang.Object#toString()
79 public final String toString() {
80 final StringBuilder builder = new StringBuilder();
81 builder.append("EnumerationBuilderImpl [packageName=");
82 builder.append(getPackageName());
83 builder.append(", name=");
84 builder.append(getName());
85 builder.append(", values=");
86 builder.append(values);
88 return builder.toString();
92 public final void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef) {
93 final List<EnumPair> enums = enumTypeDef.getValues();
94 final Map<String, String> valueIds = BindingMapping.mapEnumAssignedNames(enums.stream().map(EnumPair::getName)
95 .collect(Collectors.toList()));
97 for (EnumPair enumPair : enums) {
98 addValue(enumPair.getName(), valueIds.get(enumPair.getName()), enumPair.getValue(), enumPair.getStatus(),
99 enumPair.getDescription().orElse(null), enumPair.getReference().orElse(null));
103 abstract static class AbstractPair implements Enumeration.Pair {
104 private final String name;
105 private final String mappedName;
106 private final int value;
108 AbstractPair(final String name, final String mappedName, final int value) {
109 this.name = requireNonNull(name);
110 this.mappedName = requireNonNull(mappedName);
115 public final String getName() {
120 public final String getMappedName() {
121 return this.mappedName;
125 public final int getValue() {
130 public final int hashCode() {
131 final int prime = 31;
133 result = prime * result + Objects.hashCode(this.name);
134 result = prime * result + Objects.hashCode(this.value);
139 public final boolean equals(final Object obj) {
143 if (!(obj instanceof AbstractPair)) {
146 final AbstractPair other = (AbstractPair) obj;
147 return Objects.equals(this.name, other.name) && Objects.equals(this.value, other.value);
151 public final String toString() {
152 final StringBuilder builder = new StringBuilder();
153 builder.append("EnumPair [name=");
154 builder.append(this.name);
155 builder.append(", mappedName=");
156 builder.append(getMappedName());
157 builder.append(", value=");
158 builder.append(this.value);
160 return builder.toString();
164 abstract static class AbstractEnumeration extends AbstractBaseType implements Enumeration {
166 private final Type definingType;
167 private final List<Pair> values;
168 private final List<AnnotationType> annotations;
170 AbstractEnumeration(final AbstractEnumerationBuilder builder, final Type definingType) {
171 super(builder.getIdentifier());
172 this.definingType = definingType;
173 this.values = ImmutableList.copyOf(builder.values);
175 final ArrayList<AnnotationType> a = new ArrayList<>();
176 for (final AnnotationTypeBuilder b : builder.annotationBuilders) {
179 this.annotations = ImmutableList.copyOf(a);
183 public final Type getParentType() {
184 return this.definingType;
188 public final List<Pair> getValues() {
193 public final List<AnnotationType> getAnnotations() {
194 return this.annotations;
198 public final String toFormattedString() {
199 final StringBuilder builder = new StringBuilder();
200 builder.append("public enum");
202 builder.append(getName());
203 builder.append(" {");
204 builder.append("\n");
207 for (final Enumeration.Pair valPair : this.values) {
208 builder.append("\t");
210 builder.append(valPair.getMappedName());
211 builder.append(" (");
212 builder.append(valPair.getValue());
214 if (i == this.values.size() - 1) {
215 builder.append(" );");
217 builder.append(" ),");
221 builder.append("\n}");
222 return builder.toString();
226 public final String toString() {
227 final StringBuilder builder = new StringBuilder();
228 builder.append("Enumeration [packageName=");
229 builder.append(getPackageName());
230 if (this.definingType != null) {
231 builder.append(", definingType=");
232 builder.append(this.definingType.getPackageName());
234 builder.append(this.definingType.getName());
236 builder.append(", definingType= null");
238 builder.append(", name=");
239 builder.append(getName());
240 builder.append(", values=");
241 builder.append(this.values);
243 return builder.toString();
247 public final boolean isAbstract() {
252 public final List<Type> getImplements() {
253 return Collections.emptyList();
257 public final List<GeneratedType> getEnclosedTypes() {
258 return Collections.emptyList();
262 public final List<Enumeration> getEnumerations() {
263 return Collections.emptyList();
267 public final List<Constant> getConstantDefinitions() {
268 return Collections.emptyList();
272 public final List<MethodSignature> getMethodDefinitions() {
273 return Collections.emptyList();
277 public final List<GeneratedProperty> getProperties() {
278 return Collections.emptyList();