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