opendaylight/sal/yang-prototype/code-generator/binding-generator-util/src/main/java/org/opendaylight/controller/binding/generator/util/generated/type/builder/AnnotationTypeBuilderImpl.java

   1 package org.opendaylight.controller.binding.generator.util.generated.type.builder;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collections;
   5 import java.util.List;
   6
   7 import org.opendaylight.controller.sal.binding.model.api.AnnotationType;
   8 import org.opendaylight.controller.sal.binding.model.api.type.builder.AnnotationTypeBuilder;
   9
  10 final class AnnotationTypeBuilderImpl implements AnnotationTypeBuilder {
  11
  12     private final String packageName;
  13     private final String name;
  14     private final List<AnnotationTypeBuilder> annotationBuilders;
  15     private final List<AnnotationType.Parameter> parameters;
  16
  17     public AnnotationTypeBuilderImpl(final String packageName, final String name) {
  18         super();
  19         this.packageName = packageName;
  20         this.name = name;
  21
  22         annotationBuilders = new ArrayList<AnnotationTypeBuilder>();
  23         parameters = new ArrayList<AnnotationType.Parameter>();
  24     }
  25
  26     @Override
  27     public String getPackageName() {
  28         return packageName;
  29     }
  30
  31     @Override
  32     public String getName() {
  33         return name;
  34     }
  35
  36     @Override
  37     public AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
  38         if (packageName != null && name != null) {
  39             final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(packageName, name);
  40             if (annotationBuilders.add(builder)) {
  41                 return builder;
  42             }
  43         }
  44         return null;
  45     }
  46
  47     @Override
  48     public boolean addParameter(String paramName, String value) {
  49         if ((paramName != null) && (value != null)) {
  50             return parameters.add(new ParameterImpl(paramName, value));
  51         }
  52         return false;
  53     }
  54
  55     @Override
  56     public boolean addParameters(String paramName, List<String> values) {
  57         if ((paramName != null) && (values != null)) {
  58             return parameters.add(new ParameterImpl(paramName, values));
  59         }
  60         return false;
  61     }
  62
  63     @Override
  64     public AnnotationType toInstance() {
  65         return new AnnotationTypeImpl(packageName, name, annotationBuilders, parameters);
  66     }
  67
  68     @Override
  69     public int hashCode() {
  70         final int prime = 31;
  71         int result = 1;
  72         result = prime * result + ((name == null) ? 0 : name.hashCode());
  73         result = prime * result
  74                 + ((packageName == null) ? 0 : packageName.hashCode());
  75         return result;
  76     }
  77
  78     @Override
  79     public boolean equals(Object obj) {
  80         if (this == obj) {
  81             return true;
  82         }
  83         if (obj == null) {
  84             return false;
  85         }
  86         if (getClass() != obj.getClass()) {
  87             return false;
  88         }
  89         AnnotationTypeBuilderImpl other = (AnnotationTypeBuilderImpl) obj;
  90         if (name == null) {
  91             if (other.name != null) {
  92                 return false;
  93             }
  94         } else if (!name.equals(other.name)) {
  95             return false;
  96         }
  97         if (packageName == null) {
  98             if (other.packageName != null) {
  99                 return false;
 100             }
 101         } else if (!packageName.equals(other.packageName)) {
 102             return false;
 103         }
 104         return true;
 105     }
 106
 107     @Override
 108     public String toString() {
 109         StringBuilder builder = new StringBuilder();
 110         builder.append("AnnotationTypeBuilder [packageName=");
 111         builder.append(packageName);
 112         builder.append(", name=");
 113         builder.append(name);
 114         builder.append(", annotationBuilders=");
 115         builder.append(annotationBuilders);
 116         builder.append(", parameters=");
 117         builder.append(parameters);
 118         builder.append("]");
 119         return builder.toString();
 120     }
 121
 122     private static final class AnnotationTypeImpl implements AnnotationType {
 123
 124         private final String packageName;
 125         private final String name;
 126         private List<AnnotationType> annotations;
 127         private final List<AnnotationType.Parameter> parameters;
 128         private List<String> paramNames;
 129
 130         public AnnotationTypeImpl(String packageName, String name,
 131                 List<AnnotationTypeBuilder> annotationBuilders,
 132                 List<AnnotationType.Parameter> parameters) {
 133             super();
 134             this.packageName = packageName;
 135             this.name = name;
 136
 137             this.annotations = new ArrayList<AnnotationType>();
 138             for (final AnnotationTypeBuilder builder : annotationBuilders) {
 139                 annotations.add(builder.toInstance());
 140             }
 141
 142             this.annotations = Collections.unmodifiableList(annotations);
 143             this.parameters = Collections.unmodifiableList(parameters);
 144
 145             paramNames = new ArrayList<String>();
 146             for (final AnnotationType.Parameter parameter : parameters) {
 147                 paramNames.add(parameter.getName());
 148             }
 149             this.paramNames = Collections.unmodifiableList(paramNames);
 150         }
 151
 152         @Override
 153         public String getPackageName() {
 154             return packageName;
 155         }
 156
 157         @Override
 158         public String getName() {
 159             return name;
 160         }
 161
 162         @Override
 163         public List<AnnotationType> getAnnotations() {
 164             return annotations;
 165         }
 166
 167         @Override
 168         public Parameter getParameter(final String paramName) {
 169             if (paramName != null) {
 170                 for (final AnnotationType.Parameter parameter : parameters) {
 171                     if (parameter.getName().equals(paramName)) {
 172                         return parameter;
 173                     }
 174                 }
 175             }
 176             return null;
 177         }
 178
 179         @Override
 180         public List<Parameter> getParameters() {
 181             return parameters;
 182         }
 183
 184         @Override
 185         public List<String> getParameterNames() {
 186             return paramNames;
 187         }
 188
 189         @Override
 190         public boolean containsParameters() {
 191             return !parameters.isEmpty();
 192         }
 193
 194         @Override
 195         public int hashCode() {
 196             final int prime = 31;
 197             int result = 1;
 198             result = prime * result + ((name == null) ? 0 : name.hashCode());
 199             result = prime * result
 200                     + ((packageName == null) ? 0 : packageName.hashCode());
 201             return result;
 202         }
 203
 204         @Override
 205         public boolean equals(Object obj) {
 206             if (this == obj) {
 207                 return true;
 208             }
 209             if (obj == null) {
 210                 return false;
 211             }
 212             if (getClass() != obj.getClass()) {
 213                 return false;
 214             }
 215             AnnotationTypeImpl other = (AnnotationTypeImpl) obj;
 216             if (name == null) {
 217                 if (other.name != null) {
 218                     return false;
 219                 }
 220             } else if (!name.equals(other.name)) {
 221                 return false;
 222             }
 223             if (packageName == null) {
 224                 if (other.packageName != null) {
 225                     return false;
 226                 }
 227             } else if (!packageName.equals(other.packageName)) {
 228                 return false;
 229             }
 230             return true;
 231         }
 232
 233         @Override
 234         public String toString() {
 235             StringBuilder builder = new StringBuilder();
 236             builder.append("AnnotationType [packageName=");
 237             builder.append(packageName);
 238             builder.append(", name=");
 239             builder.append(name);
 240             builder.append(", annotations=");
 241             builder.append(annotations);
 242             builder.append(", parameters=");
 243             builder.append(parameters);
 244             builder.append("]");
 245             return builder.toString();
 246         }
 247     }
 248
 249     private static final class ParameterImpl implements AnnotationType.Parameter {
 250
 251         private final String name;
 252         private final String value;
 253         private final List<String> values;
 254
 255         public ParameterImpl(String name, String value) {
 256             super();
 257             this.name = name;
 258             this.value = value;
 259             this.values = Collections.emptyList();
 260         }
 261
 262         public ParameterImpl(String name, List<String> values) {
 263             super();
 264             this.name = name;
 265             this.values = values;
 266             this.value = null;
 267         }
 268
 269         @Override
 270         public String getName() {
 271             return name;
 272         }
 273
 274         @Override
 275         public String getValue() {
 276             return value;
 277         }
 278
 279         @Override
 280         public List<String> getValues() {
 281             return values;
 282         }
 283
 284         @Override
 285         public int hashCode() {
 286             final int prime = 31;
 287             int result = 1;
 288             result = prime * result + ((name == null) ? 0 : name.hashCode());
 289             return result;
 290         }
 291
 292         @Override
 293         public boolean equals(Object obj) {
 294             if (this == obj) {
 295                 return true;
 296             }
 297             if (obj == null) {
 298                 return false;
 299             }
 300             if (getClass() != obj.getClass()) {
 301                 return false;
 302             }
 303             ParameterImpl other = (ParameterImpl) obj;
 304             if (name == null) {
 305                 if (other.name != null) {
 306                     return false;
 307                 }
 308             } else if (!name.equals(other.name)) {
 309                 return false;
 310             }
 311             return true;
 312         }
 313
 314         @Override
 315         public String toString() {
 316             StringBuilder builder = new StringBuilder();
 317             builder.append("ParameterImpl [name=");
 318             builder.append(name);
 319             builder.append(", value=");
 320             builder.append(value);
 321             builder.append(", values=");
 322             builder.append(values);
 323             builder.append("]");
 324             return builder.toString();
 325         }
 326     }
 327 }