binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/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.binding.model.util.generated.type.builder;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.collect.ImmutableList;
  13 import java.util.ArrayList;
  14 import java.util.Collections;
  15 import java.util.List;
  16 import java.util.Objects;
  17 import org.opendaylight.mdsal.binding.model.api.AnnotationType;
  18 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
  19 import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
  20 import org.opendaylight.mdsal.binding.model.util.AbstractBaseType;
  21 import org.opendaylight.yangtools.util.LazyCollections;
  22
  23 final class AnnotationTypeBuilderImpl extends AbstractBaseType implements AnnotationTypeBuilder {
  24
  25     private List<AnnotationTypeBuilder> annotationBuilders = Collections.emptyList();
  26     private List<AnnotationType.Parameter> parameters = Collections.emptyList();
  27
  28     AnnotationTypeBuilderImpl(final JavaTypeName identifier) {
  29         super(identifier);
  30     }
  31
  32     @Override
  33     public AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
  34         if (packageName != null && name != null) {
  35             final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(JavaTypeName.create(packageName, name));
  36             if (!this.annotationBuilders.contains(builder)) {
  37                 this.annotationBuilders = LazyCollections.lazyAdd(this.annotationBuilders, builder);
  38                 return builder;
  39             }
  40         }
  41         return null;
  42     }
  43
  44     private boolean addParameter(final ParameterImpl param) {
  45         if (parameters.contains(param)) {
  46             return false;
  47         }
  48         parameters = LazyCollections.lazyAdd(parameters, param);
  49         return true;
  50     }
  51
  52     @Override
  53     public boolean addParameter(final String paramName, final String value) {
  54         if (paramName != null && value != null) {
  55             final ParameterImpl param = new ParameterImpl(paramName, value);
  56             return addParameter(param);
  57         }
  58         return false;
  59     }
  60
  61     @Override
  62     public boolean addParameters(final String paramName, final List<String> values) {
  63         if (paramName != null && values != null) {
  64             final ParameterImpl param = new ParameterImpl(paramName, values);
  65             return addParameter(param);
  66         }
  67         return false;
  68     }
  69
  70     @Override
  71     public AnnotationType build() {
  72         return new AnnotationTypeImpl(getIdentifier(), this.annotationBuilders, this.parameters);
  73     }
  74
  75     @Override
  76     public boolean equals(final Object obj) {
  77         if (this == obj) {
  78             return true;
  79         }
  80         if (obj == null || getClass() != obj.getClass()) {
  81             return false;
  82         }
  83         return getIdentifier().equals(((AnnotationTypeBuilderImpl) obj).getIdentifier());
  84     }
  85
  86     @Override
  87     public String toString() {
  88         final StringBuilder builder = new StringBuilder();
  89         builder.append("AnnotationTypeBuilder [packageName=");
  90         builder.append(getPackageName());
  91         builder.append(", name=");
  92         builder.append(getName());
  93         builder.append(", annotationBuilders=");
  94         builder.append(this.annotationBuilders);
  95         builder.append(", parameters=");
  96         builder.append(this.parameters);
  97         builder.append("]");
  98         return builder.toString();
  99     }
 100
 101     private static final class AnnotationTypeImpl implements AnnotationType {
 102         private final JavaTypeName identifier;
 103         private final List<AnnotationType> annotations;
 104         private final List<AnnotationType.Parameter> parameters;
 105         private final List<String> paramNames;
 106
 107         AnnotationTypeImpl(final JavaTypeName identifier, final List<AnnotationTypeBuilder> annotationBuilders,
 108                 final List<AnnotationType.Parameter> parameters) {
 109             this.identifier = requireNonNull(identifier);
 110
 111             final List<AnnotationType> a = new ArrayList<>();
 112             for (final AnnotationTypeBuilder builder : annotationBuilders) {
 113                 a.add(builder.build());
 114             }
 115             this.annotations = ImmutableList.copyOf(a);
 116
 117             final List<String> p = new ArrayList<>();
 118             for (final AnnotationType.Parameter parameter : parameters) {
 119                 p.add(parameter.getName());
 120             }
 121             this.paramNames = ImmutableList.copyOf(p);
 122
 123             this.parameters = parameters.isEmpty() ? Collections.<AnnotationType.Parameter>emptyList()
 124                     : Collections.unmodifiableList(parameters);
 125         }
 126
 127         @Override
 128         public JavaTypeName getIdentifier() {
 129             return identifier;
 130         }
 131
 132         @Override
 133         public List<AnnotationType> getAnnotations() {
 134             return this.annotations;
 135         }
 136
 137         @Override
 138         public Parameter getParameter(final String paramName) {
 139             if (paramName != null) {
 140                 for (final AnnotationType.Parameter parameter : this.parameters) {
 141                     if (parameter.getName().equals(paramName)) {
 142                         return parameter;
 143                     }
 144                 }
 145             }
 146             return null;
 147         }
 148
 149         @Override
 150         public List<Parameter> getParameters() {
 151             return this.parameters;
 152         }
 153
 154         @Override
 155         public List<String> getParameterNames() {
 156             return this.paramNames;
 157         }
 158
 159         @Override
 160         public boolean containsParameters() {
 161             return !this.parameters.isEmpty();
 162         }
 163
 164         @Override
 165         public int hashCode() {
 166             return identifier.hashCode();
 167         }
 168
 169         @Override
 170         public boolean equals(final Object obj) {
 171             if (this == obj) {
 172                 return true;
 173             }
 174             if (obj == null || getClass() != obj.getClass()) {
 175                 return false;
 176             }
 177             final AnnotationTypeImpl other = (AnnotationTypeImpl) obj;
 178             return identifier.equals(other.identifier);
 179         }
 180
 181         @Override
 182         public String toString() {
 183             final StringBuilder builder = new StringBuilder();
 184             builder.append("AnnotationType [packageName=");
 185             builder.append(getPackageName());
 186             builder.append(", name=");
 187             builder.append(getName());
 188             builder.append(", annotations=");
 189             builder.append(this.annotations);
 190             builder.append(", parameters=");
 191             builder.append(this.parameters);
 192             builder.append("]");
 193             return builder.toString();
 194         }
 195     }
 196
 197     private static final class ParameterImpl implements AnnotationType.Parameter {
 198
 199         private final String name;
 200         private final String value;
 201         private final List<String> values;
 202
 203         public ParameterImpl(final String name, final String value) {
 204             this.name = name;
 205             this.value = value;
 206             this.values = Collections.emptyList();
 207         }
 208
 209         public ParameterImpl(final String name, final List<String> values) {
 210             this.name = name;
 211             this.values = values;
 212             this.value = null;
 213         }
 214
 215         @Override
 216         public String getName() {
 217             return this.name;
 218         }
 219
 220         @Override
 221         public String getValue() {
 222             return this.value;
 223         }
 224
 225         @Override
 226         public List<String> getValues() {
 227             return this.values;
 228         }
 229
 230         @Override
 231         public int hashCode() {
 232             final int prime = 31;
 233             int result = 1;
 234             result = prime * result + Objects.hashCode(this.name);
 235             return result;
 236         }
 237
 238         @Override
 239         public boolean equals(final Object obj) {
 240             if (this == obj) {
 241                 return true;
 242             }
 243             if (obj == null) {
 244                 return false;
 245             }
 246             if (getClass() != obj.getClass()) {
 247                 return false;
 248             }
 249             final ParameterImpl other = (ParameterImpl) obj;
 250             return Objects.equals(this.name, other.name);
 251         }
 252
 253         @Override
 254         public String toString() {
 255             final StringBuilder builder = new StringBuilder();
 256             builder.append("ParameterImpl [name=");
 257             builder.append(this.name);
 258             builder.append(", value=");
 259             builder.append(this.value);
 260             builder.append(", values=");
 261             builder.append(this.values);
 262             builder.append("]");
 263             return builder.toString();
 264         }
 265     }
 266 }