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 String description) {
60 values = LazyCollections.lazyAdd(values, createEnumPair(name, mappedName, value, description));
63 public abstract void setReference(String reference);
65 public abstract void setModuleName(String moduleName);
67 public abstract void setSchemaPath(SchemaPath schemaPath);
69 abstract AbstractPair createEnumPair(String name, String mappedName, int value, String description);
74 * @see java.lang.Object#toString()
77 public final String toString() {
78 final StringBuilder builder = new StringBuilder();
79 builder.append("EnumerationBuilderImpl [packageName=");
80 builder.append(getPackageName());
81 builder.append(", name=");
82 builder.append(getName());
83 builder.append(", values=");
84 builder.append(values);
86 return builder.toString();
90 public final void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef) {
91 final List<EnumPair> enums = enumTypeDef.getValues();
92 final Map<String, String> valueIds = BindingMapping.mapEnumAssignedNames(enums.stream().map(EnumPair::getName)
93 .collect(Collectors.toList()));
95 for (EnumPair enumPair : enums) {
96 addValue(enumPair.getName(), valueIds.get(enumPair.getName()), enumPair.getValue(),
97 enumPair.getDescription().orElse(null));
101 abstract static class AbstractPair implements Enumeration.Pair {
102 private final String name;
103 private final String mappedName;
104 private final int value;
106 AbstractPair(final String name, final String mappedName, final int value) {
107 this.name = requireNonNull(name);
108 this.mappedName = requireNonNull(mappedName);
113 public String getName() {
118 public String getMappedName() {
119 return this.mappedName;
123 public int getValue() {
128 public int hashCode() {
129 final int prime = 31;
131 result = prime * result + Objects.hashCode(this.name);
132 result = prime * result + Objects.hashCode(this.value);
137 public final boolean equals(final Object obj) {
141 if (!(obj instanceof AbstractPair)) {
144 final AbstractPair other = (AbstractPair) obj;
145 return Objects.equals(this.name, other.name) && Objects.equals(this.value, other.value);
149 public final String toString() {
150 final StringBuilder builder = new StringBuilder();
151 builder.append("EnumPair [name=");
152 builder.append(this.name);
153 builder.append(", mappedName=");
154 builder.append(getMappedName());
155 builder.append(", value=");
156 builder.append(this.value);
158 return builder.toString();
162 public final Status getStatus() {
163 // TODO Auto-generated method stub
168 abstract static class AbstractEnumeration extends AbstractBaseType implements Enumeration {
170 private final Type definingType;
171 private final List<Pair> values;
172 private final List<AnnotationType> annotations;
174 public AbstractEnumeration(final AbstractEnumerationBuilder builder, final Type definingType) {
175 super(builder.getPackageName(), builder.getName());
176 this.definingType = definingType;
177 this.values = ImmutableList.copyOf(builder.values);
179 final ArrayList<AnnotationType> a = new ArrayList<>();
180 for (final AnnotationTypeBuilder b : builder.annotationBuilders) {
183 this.annotations = ImmutableList.copyOf(a);
187 public final Type getParentType() {
188 return this.definingType;
192 public final List<Pair> getValues() {
197 public final List<AnnotationType> getAnnotations() {
198 return this.annotations;
202 public final String toFormattedString() {
203 final StringBuilder builder = new StringBuilder();
204 builder.append("public enum");
206 builder.append(getName());
207 builder.append(" {");
208 builder.append("\n");
211 for (final Enumeration.Pair valPair : this.values) {
212 builder.append("\t");
214 builder.append(valPair.getMappedName());
215 builder.append(" (");
216 builder.append(valPair.getValue());
218 if (i == this.values.size() - 1) {
219 builder.append(" );");
221 builder.append(" ),");
225 builder.append("\n}");
226 return builder.toString();
230 public final String toString() {
231 final StringBuilder builder = new StringBuilder();
232 builder.append("Enumeration [packageName=");
233 builder.append(getPackageName());
234 if (this.definingType != null) {
235 builder.append(", definingType=");
236 builder.append(this.definingType.getPackageName());
238 builder.append(this.definingType.getName());
240 builder.append(", definingType= null");
242 builder.append(", name=");
243 builder.append(getName());
244 builder.append(", values=");
245 builder.append(this.values);
247 return builder.toString();
251 public final boolean isAbstract() {
256 public final List<Type> getImplements() {
257 return Collections.emptyList();
261 public final List<GeneratedType> getEnclosedTypes() {
262 return Collections.emptyList();
266 public final List<Enumeration> getEnumerations() {
267 return Collections.emptyList();
271 public final List<Constant> getConstantDefinitions() {
272 return Collections.emptyList();
276 public final List<MethodSignature> getMethodDefinitions() {
277 return Collections.emptyList();
281 public final List<GeneratedProperty> getProperties() {
282 return Collections.emptyList();