binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/yangtools/binding/generator/util/generated/type/builder/EnumerationBuilderImpl.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. 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.yangtools.binding.generator.util.generated.type.builder;
   9
  10 import com.google.common.collect.ImmutableList;
  11 import java.util.ArrayList;
  12 import java.util.Collections;
  13 import java.util.List;
  14 import org.opendaylight.yangtools.binding.generator.util.AbstractBaseType;
  15 import org.opendaylight.yangtools.sal.binding.model.api.AnnotationType;
  16 import org.opendaylight.yangtools.sal.binding.model.api.Constant;
  17 import org.opendaylight.yangtools.sal.binding.model.api.Enumeration;
  18 import org.opendaylight.yangtools.sal.binding.model.api.Enumeration.Pair;
  19 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedProperty;
  20 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;
  21 import org.opendaylight.yangtools.sal.binding.model.api.MethodSignature;
  22 import org.opendaylight.yangtools.sal.binding.model.api.Type;
  23 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.AnnotationTypeBuilder;
  24 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.EnumBuilder;
  25 import org.opendaylight.yangtools.util.LazyCollections;
  26 import org.opendaylight.yangtools.yang.binding.BindingMapping;
  27 import org.opendaylight.yangtools.yang.common.QName;
  28 import org.opendaylight.yangtools.yang.model.api.Status;
  29 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  30 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
  31
  32 public final class EnumerationBuilderImpl extends AbstractBaseType implements EnumBuilder {
  33     private final String packageName;
  34     private final String name;
  35     private List<Enumeration.Pair> values = Collections.emptyList();
  36     private List<AnnotationTypeBuilder> annotationBuilders = Collections.emptyList();
  37     private List<Pair> unmodifiableValues  = Collections.emptyList();
  38     private String description;
  39     private String reference;
  40     private String moduleName;
  41     private Iterable<QName> schemaPath;
  42
  43     public EnumerationBuilderImpl(final String packageName, final String name) {
  44         super(packageName, name);
  45         this.packageName = packageName;
  46         this.name = name;
  47     }
  48
  49     public void setReference(final String reference) {
  50         this.reference = reference;
  51     }
  52
  53     public void setModuleName(final String moduleName) {
  54         this.moduleName = moduleName;
  55     }
  56
  57     public void setSchemaPath(final Iterable<QName> schemaPath) {
  58         this.schemaPath = schemaPath;
  59     }
  60
  61     @Override
  62     public void setDescription(String description) {
  63         this.description = description;
  64
  65     }
  66
  67     @Override
  68     public AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
  69         if (packageName != null && name != null) {
  70             final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(packageName, name);
  71             if (!annotationBuilders.contains(builder)) {
  72                 annotationBuilders = LazyCollections.lazyAdd(annotationBuilders, builder);
  73                 return builder;
  74             }
  75         }
  76         return null;
  77     }
  78
  79     @Override
  80     public void addValue(final String name, final Integer value, final String description) {
  81         final EnumPairImpl p = new EnumPairImpl(name, value, description);
  82         values = LazyCollections.lazyAdd(values, p);
  83         unmodifiableValues = Collections.unmodifiableList(values);
  84     }
  85
  86     @Override
  87     public Enumeration toInstance(final Type definingType) {
  88         return new EnumerationImpl(definingType, annotationBuilders, packageName, name, unmodifiableValues,
  89                 description, reference, moduleName, schemaPath);
  90     }
  91
  92     /*
  93      * (non-Javadoc)
  94      *
  95      * @see java.lang.Object#toString()
  96      */
  97     @Override
  98     public String toString() {
  99         StringBuilder builder = new StringBuilder();
 100         builder.append("EnumerationBuilderImpl [packageName=");
 101         builder.append(packageName);
 102         builder.append(", name=");
 103         builder.append(name);
 104         builder.append(", values=");
 105         builder.append(values);
 106         builder.append("]");
 107         return builder.toString();
 108     }
 109
 110     @Override
 111     public void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef) {
 112         final List<EnumPair> enums = enumTypeDef.getValues();
 113         if (enums != null) {
 114             int listIndex = 0;
 115             for (final EnumPair enumPair : enums) {
 116                 if (enumPair != null) {
 117                     final String enumPairName = BindingMapping.getClassName(enumPair.getName());
 118                     Integer enumPairValue = enumPair.getValue();
 119
 120                     if (enumPairValue == null) {
 121                         enumPairValue = listIndex;
 122                     }
 123                     else {
 124                         listIndex = enumPairValue;
 125                     }
 126
 127                     this.addValue(enumPairName, enumPairValue, enumPair.getDescription());
 128                     listIndex++;
 129                 }
 130             }
 131         }
 132
 133     }
 134
 135     private static final class EnumPairImpl implements Enumeration.Pair {
 136
 137         private final String name;
 138         private final Integer value;
 139         private final String description;
 140
 141         public EnumPairImpl(final String name, final Integer value, final String description) {
 142             super();
 143             this.name = name;
 144             this.value = value;
 145             this.description = description;
 146         }
 147
 148         @Override
 149         public String getName() {
 150             return name;
 151         }
 152
 153         @Override
 154         public Integer getValue() {
 155             return value;
 156         }
 157
 158         /*
 159          * (non-Javadoc)
 160          *
 161          * @see java.lang.Object#hashCode()
 162          */
 163         @Override
 164         public int hashCode() {
 165             final int prime = 31;
 166             int result = 1;
 167             result = prime * result + ((name == null) ? 0 : name.hashCode());
 168             result = prime * result + ((value == null) ? 0 : value.hashCode());
 169             return result;
 170         }
 171
 172         /*
 173          * (non-Javadoc)
 174          *
 175          * @see java.lang.Object#equals(java.lang.Object)
 176          */
 177         @Override
 178         public boolean equals(final Object obj) {
 179             if (this == obj) {
 180                 return true;
 181             }
 182             if (obj == null) {
 183                 return false;
 184             }
 185             if (getClass() != obj.getClass()) {
 186                 return false;
 187             }
 188             EnumPairImpl other = (EnumPairImpl) obj;
 189             if (name == null) {
 190                 if (other.name != null) {
 191                     return false;
 192                 }
 193             } else if (!name.equals(other.name)) {
 194                 return false;
 195             }
 196             if (value == null) {
 197                 if (other.value != null) {
 198                     return false;
 199                 }
 200             } else if (!value.equals(other.value)) {
 201                 return false;
 202             }
 203             return true;
 204         }
 205
 206         /*
 207          * (non-Javadoc)
 208          *
 209          * @see java.lang.Object#toString()
 210          */
 211         @Override
 212         public String toString() {
 213             StringBuilder builder = new StringBuilder();
 214             builder.append("EnumPair [name=");
 215             builder.append(name);
 216             builder.append(", value=");
 217             builder.append(value);
 218             builder.append("]");
 219             return builder.toString();
 220         }
 221
 222         @Override
 223         public String getDescription() {
 224             return description;
 225         }
 226
 227         @Override
 228         public String getReference() {
 229             return null;
 230         }
 231
 232         @Override
 233         public Status getStatus() {
 234             // TODO Auto-generated method stub
 235             return null;
 236         }
 237
 238     }
 239
 240     private static final class EnumerationImpl extends AbstractBaseType implements Enumeration {
 241
 242         private final Type definingType;
 243         private final String description;
 244         private final String reference;
 245         private final String moduleName;
 246         private final Iterable<QName> schemaPath;
 247         private final List<Pair> values;
 248         private final List<AnnotationType> annotations;
 249
 250         public EnumerationImpl(final Type definingType, final List<AnnotationTypeBuilder> annotationBuilders,
 251                 final String packageName, final String name, final List<Pair> values, final String description,
 252                 final String reference, final String moduleName, final Iterable<QName> schemaPath) {
 253             super(packageName, name);
 254             this.definingType = definingType;
 255             this.values = values;
 256             this.description = description;
 257             this.moduleName = moduleName;
 258             this.schemaPath = schemaPath;
 259             this.reference = reference;
 260
 261             final ArrayList<AnnotationType> a = new ArrayList<>();
 262             for (final AnnotationTypeBuilder builder : annotationBuilders) {
 263                 a.add(builder.toInstance());
 264             }
 265             this.annotations = ImmutableList.copyOf(a);
 266         }
 267
 268         @Override
 269         public Type getParentType() {
 270             return definingType;
 271         }
 272
 273         @Override
 274         public List<Pair> getValues() {
 275             return values;
 276         }
 277
 278         @Override
 279         public List<AnnotationType> getAnnotations() {
 280             return annotations;
 281         }
 282
 283         @Override
 284         public String toFormattedString() {
 285             StringBuilder builder = new StringBuilder();
 286             builder.append("public enum");
 287             builder.append(" ");
 288             builder.append(getName());
 289             builder.append(" {");
 290             builder.append("\n");
 291
 292             int i = 0;
 293             for (final Enumeration.Pair valPair : values) {
 294                 builder.append("\t");
 295                 builder.append(" ");
 296                 builder.append(valPair.getName());
 297                 builder.append(" (");
 298                 builder.append(valPair.getValue());
 299
 300                 if (i == (values.size() - 1)) {
 301                     builder.append(" );");
 302                 } else {
 303                     builder.append(" ),");
 304                 }
 305                 ++i;
 306             }
 307             builder.append("\n}");
 308             return builder.toString();
 309         }
 310
 311         /*
 312          * (non-Javadoc)
 313          *
 314          * @see java.lang.Object#toString()
 315          */
 316         @Override
 317         public String toString() {
 318             StringBuilder builder = new StringBuilder();
 319             builder.append("Enumeration [packageName=");
 320             builder.append(getPackageName());
 321             if (definingType != null) {
 322                 builder.append(", definingType=");
 323                 builder.append(definingType.getPackageName());
 324                 builder.append(".");
 325                 builder.append(definingType.getName());
 326             } else {
 327                 builder.append(", definingType= null");
 328             }
 329             builder.append(", name=");
 330             builder.append(getName());
 331             builder.append(", values=");
 332             builder.append(values);
 333             builder.append("]");
 334             return builder.toString();
 335         }
 336
 337         @Override
 338         public String getComment() {
 339             return null;
 340         }
 341
 342         @Override
 343         public boolean isAbstract() {
 344             return false;
 345         }
 346
 347         @Override
 348         public List<Type> getImplements() {
 349             return Collections.emptyList();
 350         }
 351
 352         @Override
 353         public List<GeneratedType> getEnclosedTypes() {
 354             return Collections.emptyList();
 355         }
 356
 357         @Override
 358         public List<Enumeration> getEnumerations() {
 359             return Collections.emptyList();
 360         }
 361
 362         @Override
 363         public List<Constant> getConstantDefinitions() {
 364             return Collections.emptyList();
 365         }
 366
 367         @Override
 368         public List<MethodSignature> getMethodDefinitions() {
 369             // TODO Auto-generated method stub
 370             return Collections.emptyList();
 371         }
 372
 373         @Override
 374         public List<GeneratedProperty> getProperties() {
 375             return Collections.emptyList();
 376         }
 377
 378         @Override
 379         public String getDescription() {
 380             return description;
 381         }
 382
 383         @Override
 384         public String getReference() {
 385             return reference;
 386         }
 387
 388         @Override
 389         public Iterable<QName> getSchemaPath() {
 390             return schemaPath;
 391         }
 392
 393         @Override
 394         public String getModuleName() {
 395             return moduleName;
 396         }
 397     }
 398 }