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