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.AbstractBaseType;
21 import org.opendaylight.mdsal.binding.model.api.AnnotationType;
22 import org.opendaylight.mdsal.binding.model.api.Constant;
23 import org.opendaylight.mdsal.binding.model.api.Enumeration;
24 import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
25 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
26 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
27 import org.opendaylight.mdsal.binding.model.api.MethodSignature;
28 import org.opendaylight.mdsal.binding.model.api.Type;
29 import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
30 import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
31 import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
32 import org.opendaylight.yangtools.util.LazyCollections;
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,
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 {
165 private final List<AnnotationType> annotations;
166 private final List<Pair> values;
168 AbstractEnumeration(final AbstractEnumerationBuilder builder) {
169 super(builder.getIdentifier());
170 this.values = ImmutableList.copyOf(builder.values);
172 final ArrayList<AnnotationType> a = new ArrayList<>();
173 for (final AnnotationTypeBuilder b : builder.annotationBuilders) {
176 this.annotations = ImmutableList.copyOf(a);
180 public final List<Pair> getValues() {
185 public final List<AnnotationType> getAnnotations() {
186 return this.annotations;
190 public final String toFormattedString() {
191 final StringBuilder builder = new StringBuilder();
192 builder.append("public enum");
194 builder.append(getName());
195 builder.append(" {");
196 builder.append("\n");
199 for (final Enumeration.Pair valPair : this.values) {
200 builder.append("\t ");
201 builder.append(valPair.getMappedName());
202 builder.append(" (");
203 builder.append(valPair.getValue());
205 if (offset == this.values.size() - 1) {
206 builder.append(" );");
208 builder.append(" ),");
212 builder.append("\n}");
213 return builder.toString();
217 public final String toString() {
218 final StringBuilder builder = new StringBuilder();
219 builder.append("Enumeration [packageName=");
220 builder.append(getPackageName());
221 builder.append(", name=");
222 builder.append(getName());
223 builder.append(", values=");
224 builder.append(this.values);
226 return builder.toString();
230 public final boolean isAbstract() {
235 public final List<Type> getImplements() {
236 return Collections.emptyList();
240 public final List<GeneratedType> getEnclosedTypes() {
241 return Collections.emptyList();
245 public final List<Enumeration> getEnumerations() {
246 return Collections.emptyList();
250 public final List<Constant> getConstantDefinitions() {
251 return Collections.emptyList();
255 public final List<MethodSignature> getMethodDefinitions() {
256 return Collections.emptyList();
260 public final List<GeneratedProperty> getProperties() {
261 return Collections.emptyList();