binding/mdsal-binding-model-ri/src/main/java/org/opendaylight/mdsal/binding/model/ri/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.ri.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.List;
  16 import java.util.Map;
  17 import java.util.stream.Collectors;
  18 import org.opendaylight.mdsal.binding.model.api.AbstractType;
  19 import org.opendaylight.mdsal.binding.model.api.AnnotationType;
  20 import org.opendaylight.mdsal.binding.model.api.Constant;
  21 import org.opendaylight.mdsal.binding.model.api.Enumeration;
  22 import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
  23 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
  24 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
  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.YangSourceDefinition;
  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.yangtools.util.LazyCollections;
  31 import org.opendaylight.yangtools.yang.binding.contract.Naming;
  32 import org.opendaylight.yangtools.yang.model.api.Status;
  33 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  34 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
  35
  36 // FIXME: public because EnumBuilder does not have setters we are exposing
  37 public abstract class AbstractEnumerationBuilder extends AbstractType implements EnumBuilder {
  38     private List<Enumeration.Pair> values = ImmutableList.of();
  39     private List<AnnotationTypeBuilder> annotationBuilders = ImmutableList.of();
  40
  41     AbstractEnumerationBuilder(final JavaTypeName identifier) {
  42         super(identifier);
  43     }
  44
  45     @Override
  46     public final AnnotationTypeBuilder addAnnotation(final JavaTypeName identifier) {
  47         final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(identifier);
  48         if (!annotationBuilders.contains(builder)) {
  49             annotationBuilders = LazyCollections.lazyAdd(annotationBuilders, builder);
  50             return builder;
  51         }
  52         return null;
  53     }
  54
  55     @VisibleForTesting
  56     final void addValue(final String name, final String mappedName, final int value, final Status status,
  57             final String description, final String reference) {
  58         values = LazyCollections.lazyAdd(values,
  59             createEnumPair(name, mappedName, value, status, description, reference));
  60     }
  61
  62     public abstract void setReference(String reference);
  63
  64     public abstract void setModuleName(String moduleName);
  65
  66     public abstract void setYangSourceDefinition(YangSourceDefinition yangSourceDefinition);
  67
  68     abstract AbstractPair createEnumPair(String name, String mappedName, int value, Status status, String description,
  69             String reference);
  70
  71     @Override
  72     protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
  73         return super.addToStringAttributes(toStringHelper).add("values", values);
  74     }
  75
  76     @Override
  77     public final void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef) {
  78         final List<EnumPair> enums = enumTypeDef.getValues();
  79         final Map<String, String> valueIds = Naming.mapEnumAssignedNames(enums.stream().map(EnumPair::getName)
  80             .collect(Collectors.toList()));
  81
  82         for (EnumPair enumPair : enums) {
  83             addValue(enumPair.getName(), valueIds.get(enumPair.getName()), enumPair.getValue(), enumPair.getStatus(),
  84                 enumPair.getDescription().orElse(null), enumPair.getReference().orElse(null));
  85         }
  86     }
  87
  88     abstract static class AbstractPair implements Enumeration.Pair {
  89         private final String name;
  90         private final String mappedName;
  91         private final int value;
  92
  93         AbstractPair(final String name, final String mappedName, final int value) {
  94             this.name = requireNonNull(name);
  95             this.mappedName = requireNonNull(mappedName);
  96             this.value = value;
  97         }
  98
  99         @Override
 100         public final String getName() {
 101             return name;
 102         }
 103
 104         @Override
 105         public final String getMappedName() {
 106             return mappedName;
 107         }
 108
 109         @Override
 110         public final int getValue() {
 111             return value;
 112         }
 113
 114         @Override
 115         public final int hashCode() {
 116             return name.hashCode() * 31 + value;
 117         }
 118
 119         @Override
 120         public final boolean equals(final Object obj) {
 121             return obj == this || obj instanceof AbstractPair other && name.equals(other.name) && value == other.value;
 122         }
 123
 124         @Override
 125         public final String toString() {
 126             return new StringBuilder().append("EnumPair [name=").append(name)
 127                 .append(", mappedName=").append(getMappedName())
 128                 .append(", value=").append(value)
 129                 .append("]").toString();
 130         }
 131     }
 132
 133     abstract static class AbstractEnumeration extends AbstractType implements Enumeration {
 134         private final List<AnnotationType> annotations;
 135         private final List<Pair> values;
 136
 137         AbstractEnumeration(final AbstractEnumerationBuilder builder) {
 138             super(builder.getIdentifier());
 139             values = ImmutableList.copyOf(builder.values);
 140             annotations = builder.annotationBuilders.stream()
 141                 .map(AnnotationTypeBuilder::build)
 142                 .collect(ImmutableList.toImmutableList());
 143         }
 144
 145         @Override
 146         public final List<Pair> getValues() {
 147             return values;
 148         }
 149
 150         @Override
 151         public final List<AnnotationType> getAnnotations() {
 152             return annotations;
 153         }
 154
 155         @Override
 156         public final String toFormattedString() {
 157             final var sb = new StringBuilder().append("public enum ").append(getName()).append(" {\n");
 158
 159             int offset = 0;
 160             for (var valPair : values) {
 161                 sb.append("\t ").append(valPair.getMappedName()).append(" (").append(valPair.getValue()).append(" )")
 162                     .append(offset == values.size() - 1 ? ';' : ',');
 163                 ++offset;
 164             }
 165             return sb.append("\n}").toString();
 166         }
 167
 168         @Override
 169         protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
 170             return super.addToStringAttributes(toStringHelper).add("values", values);
 171         }
 172
 173         @Override
 174         public final boolean isAbstract() {
 175             return false;
 176         }
 177
 178         @Override
 179         public final List<Type> getImplements() {
 180             return List.of();
 181         }
 182
 183         @Override
 184         public final List<GeneratedType> getEnclosedTypes() {
 185             return List.of();
 186         }
 187
 188         @Override
 189         public final List<Enumeration> getEnumerations() {
 190             return List.of();
 191         }
 192
 193         @Override
 194         public final List<Constant> getConstantDefinitions() {
 195             return List.of();
 196         }
 197
 198         @Override
 199         public final List<MethodSignature> getMethodDefinitions() {
 200             return List.of();
 201         }
 202
 203         @Override
 204         public final List<GeneratedProperty> getProperties() {
 205             return List.of();
 206         }
 207     }
 208 }