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 List<AnnotationType> getAnnotations() {
 347             return annotations;
 348         }
 349
 350         @Override
 351         public String toFormattedString() {
 352             StringBuilder builder = new StringBuilder();
 353             builder.append("public enum");
 354             builder.append(" ");
 355             builder.append(name);
 356             builder.append(" {");
 357             builder.append("\n");
 358
 359             int i = 0;
 360             for (final Enumeration.Pair valPair : values) {
 361                 builder.append("\t");
 362                 builder.append(" ");
 363                 builder.append(valPair.getName());
 364                 builder.append(" (");
 365                 builder.append(valPair.getValue());
 366
 367                 if (i == (values.size() - 1)) {
 368                     builder.append(" );");
 369                 } else {
 370                     builder.append(" ),");
 371                 }
 372                 ++i;
 373             }
 374             builder.append("\n}");
 375             return builder.toString();
 376         }
 377
 378         /*
 379          * (non-Javadoc)
 380          *
 381          * @see java.lang.Object#hashCode()
 382          */
 383         @Override
 384         public int hashCode() {
 385             final int prime = 31;
 386             int result = 1;
 387             result = prime * result + ((name == null) ? 0 : name.hashCode());
 388             result = prime * result + ((packageName == null) ? 0 : packageName.hashCode());
 389             result = prime * result + ((values == null) ? 0 : values.hashCode());
 390
 391             return result;
 392         }
 393
 394         /*
 395          * (non-Javadoc)
 396          *
 397          * @see java.lang.Object#equals(java.lang.Object)
 398          */
 399         @Override
 400         public boolean equals(final Object obj) {
 401             if (this == obj) {
 402                 return true;
 403             }
 404             if (obj == null) {
 405                 return false;
 406             }
 407             if (getClass() != obj.getClass()) {
 408                 return false;
 409             }
 410             EnumerationImpl other = (EnumerationImpl) obj;
 411             if (name == null) {
 412                 if (other.name != null) {
 413                     return false;
 414                 }
 415             } else if (!name.equals(other.name)) {
 416                 return false;
 417             }
 418             if (packageName == null) {
 419                 if (other.packageName != null) {
 420                     return false;
 421                 }
 422             } else if (!packageName.equals(other.packageName)) {
 423                 return false;
 424             }
 425             if (values == null) {
 426                 if (other.values != null) {
 427                     return false;
 428                 }
 429             } else if (!values.equals(other.values)) {
 430                 return false;
 431             }
 432             return true;
 433         }
 434
 435         /*
 436          * (non-Javadoc)
 437          *
 438          * @see java.lang.Object#toString()
 439          */
 440         @Override
 441         public String toString() {
 442             StringBuilder builder = new StringBuilder();
 443             builder.append("Enumeration [packageName=");
 444             builder.append(packageName);
 445             if (definingType != null) {
 446                 builder.append(", definingType=");
 447                 builder.append(definingType.getPackageName());
 448                 builder.append(".");
 449                 builder.append(definingType.getName());
 450             } else {
 451                 builder.append(", definingType= null");
 452             }
 453             builder.append(", name=");
 454             builder.append(name);
 455             builder.append(", values=");
 456             builder.append(values);
 457             builder.append("]");
 458             return builder.toString();
 459         }
 460
 461         @Override
 462         public String getComment() {
 463             return null;
 464         }
 465
 466         @Override
 467         public boolean isAbstract() {
 468             return false;
 469         }
 470
 471         @Override
 472         public List<Type> getImplements() {
 473             return Collections.emptyList();
 474         }
 475
 476         @Override
 477         public List<GeneratedType> getEnclosedTypes() {
 478             return Collections.emptyList();
 479         }
 480
 481         @Override
 482         public List<Enumeration> getEnumerations() {
 483             return Collections.emptyList();
 484         }
 485
 486         @Override
 487         public List<Constant> getConstantDefinitions() {
 488             return Collections.emptyList();
 489         }
 490
 491         @Override
 492         public List<MethodSignature> getMethodDefinitions() {
 493             // TODO Auto-generated method stub
 494             return Collections.emptyList();
 495         }
 496
 497         @Override
 498         public List<GeneratedProperty> getProperties() {
 499             return Collections.emptyList();
 500         }
 501
 502         @Override
 503         public String getDescription() {
 504             return description;
 505         }
 506
 507         @Override
 508         public String getReference() {
 509             return reference;
 510         }
 511
 512         @Override
 513         public Iterable<QName> getSchemaPath() {
 514             return schemaPath;
 515         }
 516
 517         @Override
 518         public String getModuleName() {
 519             return moduleName;
 520         }
 521     }
 522 }