code-generator/binding-generator-util/src/main/java/org/opendaylight/yangtools/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.yangtools.binding.generator.util.generated.type.builder;
   9
  10 import com.google.common.collect.ImmutableList;
  11
  12 import java.util.ArrayList;
  13 import java.util.Collections;
  14 import java.util.List;
  15
  16 import org.opendaylight.yangtools.binding.generator.util.AbstractBaseType;
  17 import org.opendaylight.yangtools.sal.binding.model.api.AnnotationType;
  18 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.AnnotationTypeBuilder;
  19 import org.opendaylight.yangtools.util.LazyCollections;
  20
  21 final class AnnotationTypeBuilderImpl extends AbstractBaseType implements AnnotationTypeBuilder {
  22
  23     private final String packageName;
  24     private final String name;
  25     private List<AnnotationTypeBuilder> annotationBuilders = Collections.emptyList();
  26     private List<AnnotationType.Parameter> parameters = Collections.emptyList();
  27
  28     public AnnotationTypeBuilderImpl(final String packageName, final String name) {
  29         super(packageName, name);
  30         this.packageName = packageName;
  31         this.name = name;
  32     }
  33
  34     @Override
  35     public AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
  36         if (packageName != null && name != null) {
  37             final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(packageName, name);
  38             if (!annotationBuilders.contains(builder)) {
  39                 annotationBuilders = LazyCollections.lazyAdd(annotationBuilders, builder);
  40                 return builder;
  41             }
  42         }
  43         return null;
  44     }
  45
  46     private boolean addParameter(final ParameterImpl param) {
  47         if (!parameters.contains(param)) {
  48             parameters = LazyCollections.lazyAdd(parameters, param);
  49             return true;
  50         } else {
  51             return false;
  52         }
  53     }
  54
  55     @Override
  56     public boolean addParameter(final String paramName, final String value) {
  57         if (paramName != null && value != null) {
  58             final ParameterImpl param = new ParameterImpl(paramName, value);
  59             return addParameter(param);
  60         }
  61         return false;
  62     }
  63
  64     @Override
  65     public boolean addParameters(final String paramName, final List<String> values) {
  66         if (paramName != null && values != null) {
  67             final ParameterImpl param = new ParameterImpl(paramName, values);
  68             return addParameter(param);
  69         }
  70         return false;
  71     }
  72
  73     @Override
  74     public AnnotationType toInstance() {
  75         return new AnnotationTypeImpl(packageName, name, annotationBuilders, parameters);
  76     }
  77
  78     @Override
  79     public int hashCode() {
  80         final int prime = 31;
  81         int result = 1;
  82         result = prime * result + ((name == null) ? 0 : name.hashCode());
  83         result = prime * result
  84                 + ((packageName == null) ? 0 : packageName.hashCode());
  85         return result;
  86     }
  87
  88     @Override
  89     public boolean equals(final Object obj) {
  90         if (this == obj) {
  91             return true;
  92         }
  93         if (obj == null) {
  94             return false;
  95         }
  96         if (getClass() != obj.getClass()) {
  97             return false;
  98         }
  99         AnnotationTypeBuilderImpl other = (AnnotationTypeBuilderImpl) obj;
 100         if (name == null) {
 101             if (other.name != null) {
 102                 return false;
 103             }
 104         } else if (!name.equals(other.name)) {
 105             return false;
 106         }
 107         if (packageName == null) {
 108             if (other.packageName != null) {
 109                 return false;
 110             }
 111         } else if (!packageName.equals(other.packageName)) {
 112             return false;
 113         }
 114         return true;
 115     }
 116
 117     @Override
 118     public String toString() {
 119         StringBuilder builder = new StringBuilder();
 120         builder.append("AnnotationTypeBuilder [packageName=");
 121         builder.append(packageName);
 122         builder.append(", name=");
 123         builder.append(name);
 124         builder.append(", annotationBuilders=");
 125         builder.append(annotationBuilders);
 126         builder.append(", parameters=");
 127         builder.append(parameters);
 128         builder.append("]");
 129         return builder.toString();
 130     }
 131
 132     private static final class AnnotationTypeImpl implements AnnotationType {
 133
 134         private final String packageName;
 135         private final String name;
 136         private final List<AnnotationType> annotations;
 137         private final List<AnnotationType.Parameter> parameters;
 138         private final List<String> paramNames;
 139
 140         public AnnotationTypeImpl(final String packageName, final String name,
 141                 final List<AnnotationTypeBuilder> annotationBuilders,
 142                 final List<AnnotationType.Parameter> parameters) {
 143             super();
 144             this.packageName = packageName;
 145             this.name = name;
 146
 147             final List<AnnotationType> a = new ArrayList<>();
 148             for (final AnnotationTypeBuilder builder : annotationBuilders) {
 149                 a.add(builder.toInstance());
 150             }
 151             this.annotations = ImmutableList.copyOf(a);
 152
 153             final List<String> p = new ArrayList<>();
 154             for (final AnnotationType.Parameter parameter : parameters) {
 155                 p.add(parameter.getName());
 156             }
 157             this.paramNames = ImmutableList.copyOf(p);
 158
 159             this.parameters = parameters.isEmpty() ? Collections.<AnnotationType.Parameter>emptyList()
 160                     : Collections.unmodifiableList(parameters);
 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(final 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(final String name, final String value) {
 272             super();
 273             this.name = name;
 274             this.value = value;
 275             this.values = Collections.emptyList();
 276         }
 277
 278         public ParameterImpl(final String name, final 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(final 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 }