binding2/mdsal-binding2-generator-util/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/util/generated/type/builder/AnnotationTypeBuilderImpl.java

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