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