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