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.type.builder.AnnotationTypeBuilder;
28 import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
29 import org.opendaylight.mdsal.binding.model.util.AbstractBaseType;
30 import org.opendaylight.yangtools.util.LazyCollections;
31 import org.opendaylight.yangtools.yang.binding.BindingMapping;
32 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
33 import org.opendaylight.yangtools.yang.model.api.Status;
34 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
35 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
37 // FIXME: public because EnumBuilder does not have setters we are exposing
38 public abstract class AbstractEnumerationBuilder extends AbstractBaseType implements EnumBuilder {
39 private List<Enumeration.Pair> values = ImmutableList.of();
40 private List<AnnotationTypeBuilder> annotationBuilders = ImmutableList.of();
42 AbstractEnumerationBuilder(final String packageName, final String name) {
43 super(packageName, name);
47 public final AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
48 if (packageName != null && name != null) {
49 final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(packageName, name);
50 if (!annotationBuilders.contains(builder)) {
51 annotationBuilders = LazyCollections.lazyAdd(annotationBuilders, builder);
59 final void addValue(final String name, final String mappedName, final int value, final Status status,
60 final String description, final String reference) {
61 values = LazyCollections.lazyAdd(values,
62 createEnumPair(name, mappedName, value, status, description, reference));
65 public abstract void setReference(String reference);
67 public abstract void setModuleName(String moduleName);
69 public abstract void setSchemaPath(SchemaPath schemaPath);
71 abstract AbstractPair createEnumPair(String name, String mappedName, int value, Status status, String description,
72 final String reference);
77 * @see java.lang.Object#toString()
80 public final String toString() {
81 final StringBuilder builder = new StringBuilder();
82 builder.append("EnumerationBuilderImpl [packageName=");
83 builder.append(getPackageName());
84 builder.append(", name=");
85 builder.append(getName());
86 builder.append(", values=");
87 builder.append(values);
89 return builder.toString();
93 public final void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef) {
94 final List<EnumPair> enums = enumTypeDef.getValues();
95 final Map<String, String> valueIds = BindingMapping.mapEnumAssignedNames(enums.stream().map(EnumPair::getName)
96 .collect(Collectors.toList()));
98 for (EnumPair enumPair : enums) {
99 addValue(enumPair.getName(), valueIds.get(enumPair.getName()), enumPair.getValue(), enumPair.getStatus(),
100 enumPair.getDescription().orElse(null), enumPair.getReference().orElse(null));
104 abstract static class AbstractPair implements Enumeration.Pair {
105 private final String name;
106 private final String mappedName;
107 private final int value;
109 AbstractPair(final String name, final String mappedName, final int value) {
110 this.name = requireNonNull(name);
111 this.mappedName = requireNonNull(mappedName);
116 public final String getName() {
121 public final String getMappedName() {
122 return this.mappedName;
126 public final int getValue() {
131 public final int hashCode() {
132 final int prime = 31;
134 result = prime * result + Objects.hashCode(this.name);
135 result = prime * result + Objects.hashCode(this.value);
140 public final boolean equals(final Object obj) {
144 if (!(obj instanceof AbstractPair)) {
147 final AbstractPair other = (AbstractPair) obj;
148 return Objects.equals(this.name, other.name) && Objects.equals(this.value, other.value);
152 public final String toString() {
153 final StringBuilder builder = new StringBuilder();
154 builder.append("EnumPair [name=");
155 builder.append(this.name);
156 builder.append(", mappedName=");
157 builder.append(getMappedName());
158 builder.append(", value=");
159 builder.append(this.value);
161 return builder.toString();
165 abstract static class AbstractEnumeration extends AbstractBaseType implements Enumeration {
167 private final Type definingType;
168 private final List<Pair> values;
169 private final List<AnnotationType> annotations;
171 public AbstractEnumeration(final AbstractEnumerationBuilder builder, final Type definingType) {
172 super(builder.getPackageName(), builder.getName());
173 this.definingType = definingType;
174 this.values = ImmutableList.copyOf(builder.values);
176 final ArrayList<AnnotationType> a = new ArrayList<>();
177 for (final AnnotationTypeBuilder b : builder.annotationBuilders) {
180 this.annotations = ImmutableList.copyOf(a);
184 public final Type getParentType() {
185 return this.definingType;
189 public final List<Pair> getValues() {
194 public final List<AnnotationType> getAnnotations() {
195 return this.annotations;
199 public final String toFormattedString() {
200 final StringBuilder builder = new StringBuilder();
201 builder.append("public enum");
203 builder.append(getName());
204 builder.append(" {");
205 builder.append("\n");
208 for (final Enumeration.Pair valPair : this.values) {
209 builder.append("\t");
211 builder.append(valPair.getMappedName());
212 builder.append(" (");
213 builder.append(valPair.getValue());
215 if (i == this.values.size() - 1) {
216 builder.append(" );");
218 builder.append(" ),");
222 builder.append("\n}");
223 return builder.toString();
227 public final String toString() {
228 final StringBuilder builder = new StringBuilder();
229 builder.append("Enumeration [packageName=");
230 builder.append(getPackageName());
231 if (this.definingType != null) {
232 builder.append(", definingType=");
233 builder.append(this.definingType.getPackageName());
235 builder.append(this.definingType.getName());
237 builder.append(", definingType= null");
239 builder.append(", name=");
240 builder.append(getName());
241 builder.append(", values=");
242 builder.append(this.values);
244 return builder.toString();
248 public final boolean isAbstract() {
253 public final List<Type> getImplements() {
254 return Collections.emptyList();
258 public final List<GeneratedType> getEnclosedTypes() {
259 return Collections.emptyList();
263 public final List<Enumeration> getEnumerations() {
264 return Collections.emptyList();
268 public final List<Constant> getConstantDefinitions() {
269 return Collections.emptyList();
273 public final List<MethodSignature> getMethodDefinitions() {
274 return Collections.emptyList();
278 public final List<GeneratedProperty> getProperties() {
279 return Collections.emptyList();