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