binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/AbstractEnumerationBuilder.java

   1 /*
   2  * Copyright (c) 2018 Pantheon Technologies, s.r.o. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.mdsal.binding.model.util.generated.type.builder;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.annotations.VisibleForTesting;
  13 import com.google.common.base.MoreObjects.ToStringHelper;
  14 import com.google.common.collect.ImmutableList;
  15 import java.util.ArrayList;
  16 import java.util.Collections;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.Objects;
  20 import java.util.stream.Collectors;
  21 import org.opendaylight.mdsal.binding.model.api.AbstractType;
  22 import org.opendaylight.mdsal.binding.model.api.AnnotationType;
  23 import org.opendaylight.mdsal.binding.model.api.Constant;
  24 import org.opendaylight.mdsal.binding.model.api.Enumeration;
  25 import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
  26 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
  27 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
  28 import org.opendaylight.mdsal.binding.model.api.MethodSignature;
  29 import org.opendaylight.mdsal.binding.model.api.Type;
  30 import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
  31 import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
  32 import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
  33 import org.opendaylight.yangtools.util.LazyCollections;
  34 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  35 import org.opendaylight.yangtools.yang.model.api.Status;
  36 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  37 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
  38
  39 // FIXME: public because EnumBuilder does not have setters we are exposing
  40 public abstract class AbstractEnumerationBuilder extends AbstractType implements EnumBuilder {
  41     private List<Enumeration.Pair> values = ImmutableList.of();
  42     private List<AnnotationTypeBuilder> annotationBuilders = ImmutableList.of();
  43
  44     AbstractEnumerationBuilder(final JavaTypeName identifier) {
  45         super(identifier);
  46     }
  47
  48     @Override
  49     public final AnnotationTypeBuilder addAnnotation(final JavaTypeName identifier) {
  50         final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(identifier);
  51         if (!annotationBuilders.contains(builder)) {
  52             annotationBuilders = LazyCollections.lazyAdd(annotationBuilders, builder);
  53             return builder;
  54         }
  55         return null;
  56     }
  57
  58     @VisibleForTesting
  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));
  63     }
  64
  65     public abstract void setReference(String reference);
  66
  67     public abstract void setModuleName(String moduleName);
  68
  69     public abstract void setSchemaPath(SchemaPath schemaPath);
  70
  71     abstract AbstractPair createEnumPair(String name, String mappedName, int value, Status status, String description,
  72             String reference);
  73
  74     @Override
  75     protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
  76         return super.addToStringAttributes(toStringHelper).add("values", values);
  77     }
  78
  79     @Override
  80     public final void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef) {
  81         final List<EnumPair> enums = enumTypeDef.getValues();
  82         final Map<String, String> valueIds = BindingMapping.mapEnumAssignedNames(enums.stream().map(EnumPair::getName)
  83             .collect(Collectors.toList()));
  84
  85         for (EnumPair enumPair : enums) {
  86             addValue(enumPair.getName(), valueIds.get(enumPair.getName()), enumPair.getValue(), enumPair.getStatus(),
  87                 enumPair.getDescription().orElse(null), enumPair.getReference().orElse(null));
  88         }
  89     }
  90
  91     abstract static class AbstractPair implements Enumeration.Pair {
  92         private final String name;
  93         private final String mappedName;
  94         private final int value;
  95
  96         AbstractPair(final String name, final String mappedName, final int value) {
  97             this.name = requireNonNull(name);
  98             this.mappedName = requireNonNull(mappedName);
  99             this.value = value;
 100         }
 101
 102         @Override
 103         public final String getName() {
 104             return this.name;
 105         }
 106
 107         @Override
 108         public final String getMappedName() {
 109             return this.mappedName;
 110         }
 111
 112         @Override
 113         public final int getValue() {
 114             return this.value;
 115         }
 116
 117         @Override
 118         public final int hashCode() {
 119             final int prime = 31;
 120             int result = 1;
 121             result = prime * result + Objects.hashCode(this.name);
 122             result = prime * result + Objects.hashCode(this.value);
 123             return result;
 124         }
 125
 126         @Override
 127         public final boolean equals(final Object obj) {
 128             if (this == obj) {
 129                 return true;
 130             }
 131             if (!(obj instanceof AbstractPair)) {
 132                 return false;
 133             }
 134             final AbstractPair other = (AbstractPair) obj;
 135             return Objects.equals(this.name, other.name) && Objects.equals(this.value, other.value);
 136         }
 137
 138         @Override
 139         public final String toString() {
 140             final StringBuilder builder = new StringBuilder();
 141             builder.append("EnumPair [name=");
 142             builder.append(this.name);
 143             builder.append(", mappedName=");
 144             builder.append(getMappedName());
 145             builder.append(", value=");
 146             builder.append(this.value);
 147             builder.append("]");
 148             return builder.toString();
 149         }
 150     }
 151
 152     abstract static class AbstractEnumeration extends AbstractType implements Enumeration {
 153         private final List<AnnotationType> annotations;
 154         private final List<Pair> values;
 155
 156         AbstractEnumeration(final AbstractEnumerationBuilder builder) {
 157             super(builder.getIdentifier());
 158             this.values = ImmutableList.copyOf(builder.values);
 159
 160             final ArrayList<AnnotationType> a = new ArrayList<>();
 161             for (final AnnotationTypeBuilder b : builder.annotationBuilders) {
 162                 a.add(b.build());
 163             }
 164             this.annotations = ImmutableList.copyOf(a);
 165         }
 166
 167         @Override
 168         public final List<Pair> getValues() {
 169             return this.values;
 170         }
 171
 172         @Override
 173         public final List<AnnotationType> getAnnotations() {
 174             return this.annotations;
 175         }
 176
 177         @Override
 178         public final String toFormattedString() {
 179             final StringBuilder builder = new StringBuilder();
 180             builder.append("public enum");
 181             builder.append(" ");
 182             builder.append(getName());
 183             builder.append(" {");
 184             builder.append("\n");
 185
 186             int offset = 0;
 187             for (final Enumeration.Pair valPair : this.values) {
 188                 builder.append("\t ");
 189                 builder.append(valPair.getMappedName());
 190                 builder.append(" (");
 191                 builder.append(valPair.getValue());
 192
 193                 if (offset == this.values.size() - 1) {
 194                     builder.append(" );");
 195                 } else {
 196                     builder.append(" ),");
 197                 }
 198                 ++offset;
 199             }
 200             builder.append("\n}");
 201             return builder.toString();
 202         }
 203
 204         @Override
 205         protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
 206             return super.addToStringAttributes(toStringHelper).add("values", values);
 207         }
 208
 209         @Override
 210         public final boolean isAbstract() {
 211             return false;
 212         }
 213
 214         @Override
 215         public final List<Type> getImplements() {
 216             return Collections.emptyList();
 217         }
 218
 219         @Override
 220         public final List<GeneratedType> getEnclosedTypes() {
 221             return Collections.emptyList();
 222         }
 223
 224         @Override
 225         public final List<Enumeration> getEnumerations() {
 226             return Collections.emptyList();
 227         }
 228
 229         @Override
 230         public final List<Constant> getConstantDefinitions() {
 231             return Collections.emptyList();
 232         }
 233
 234         @Override
 235         public final List<MethodSignature> getMethodDefinitions() {
 236             return Collections.emptyList();
 237         }
 238
 239         @Override
 240         public final List<GeneratedProperty> getProperties() {
 241             return Collections.emptyList();
 242         }
 243     }
 244 }