binding2/mdsal-binding2-generator-util/src/main/java/org/opendaylight/mdsal/binding2/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.mdsal.binding2.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.binding2.generator.util.AbstractBaseType;
  19 import org.opendaylight.mdsal.binding2.model.api.AnnotationType;
  20 import org.opendaylight.mdsal.binding2.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     public AnnotationTypeBuilderImpl(final String packageName, final String name) {
  32         super(packageName, name);
  33         this.packageName = packageName;
  34         this.name = name;
  35     }
  36
  37     @Override
  38     public AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
  39         if (packageName != null && name != null) {
  40             final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(packageName, name);
  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         public AnnotationTypeImpl(final String packageName, final String name,
 129                 final List<AnnotationTypeBuilder> annotationBuilders,
 130                 final List<AnnotationType.Parameter> parameters) {
 131             super();
 132             this.packageName = packageName;
 133             this.name = name;
 134
 135             final List<AnnotationType> a = new ArrayList<>();
 136             for (final AnnotationTypeBuilder builder : annotationBuilders) {
 137                 a.add(builder.toInstance());
 138             }
 139             this.annotations = ImmutableList.copyOf(a);
 140
 141             final List<String> p = new ArrayList<>();
 142             for (final AnnotationType.Parameter parameter : parameters) {
 143                 p.add(parameter.getName());
 144             }
 145             this.paramNames = ImmutableList.copyOf(p);
 146
 147             this.parameters = parameters.isEmpty() ? ImmutableList.of()
 148                     : Collections.unmodifiableList(parameters);
 149         }
 150
 151         @Override
 152         public String getPackageName() {
 153             return packageName;
 154         }
 155
 156         @Override
 157         public String getName() {
 158             return name;
 159         }
 160
 161         @Override
 162         public String getFullyQualifiedName() {
 163             return packageName + "." + name;
 164         }
 165
 166         @Override
 167         public List<AnnotationType> getAnnotations() {
 168             return annotations;
 169         }
 170
 171         @Override
 172         public Parameter getParameter(final String paramName) {
 173             if (paramName != null) {
 174                 for (final AnnotationType.Parameter parameter : parameters) {
 175                     if (parameter.getName().equals(paramName)) {
 176                         return parameter;
 177                     }
 178                 }
 179             }
 180             return null;
 181         }
 182
 183         @Override
 184         public List<Parameter> getParameters() {
 185             return parameters;
 186         }
 187
 188         @Override
 189         public List<String> getParameterNames() {
 190             return paramNames;
 191         }
 192
 193         @Override
 194         public boolean containsParameters() {
 195             return !parameters.isEmpty();
 196         }
 197
 198         @Override
 199         public int hashCode() {
 200             return Objects.hash(name, packageName);
 201         }
 202
 203         @Override
 204         public int compareTo(AnnotationType other) {
 205             return ComparisonChain.start()
 206                     .compare(this.name, other.getName())
 207                     .compare(this.packageName, other.getPackageName())
 208                     //FIXME: what is natural ordering for AnnotationType?
 209                     .compare(this.annotations, other.getAnnotations(), 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         public ParameterImpl(final String name, final String value) {
 256             super();
 257             this.name = name;
 258             this.value = value;
 259             this.values = ImmutableList.of();
 260         }
 261
 262         public ParameterImpl(final String name, final 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 getSingleValue() {
 276             return value;
 277         }
 278
 279         @Override
 280         public List<String> getValues() {
 281             return values;
 282         }
 283
 284         @Override
 285         public int hashCode() {
 286            return Objects.hash(name);
 287         }
 288
 289         @Override
 290         public boolean equals(final Object obj) {
 291             if (this == obj) {
 292                 return true;
 293             }
 294             if (obj == null) {
 295                 return false;
 296             }
 297             if (getClass() != obj.getClass()) {
 298                 return false;
 299             }
 300             if (!(obj instanceof ParameterImpl)) {
 301                 return false;
 302             }
 303             ParameterImpl other = (ParameterImpl) obj;
 304             return Objects.equals(name, other.name);
 305         }
 306
 307         @Override
 308         public String toString() {
 309             StringBuilder builder = new StringBuilder();
 310             builder.append("ParameterImpl [name=");
 311             builder.append(name);
 312             builder.append(", value=");
 313             builder.append(value);
 314             builder.append(", values=");
 315             builder.append(values);
 316             builder.append("]");
 317             return builder.toString();
 318         }
 319     }
 320 }